Matplotlib and Seaborn visualization

Overview

Data visualization transforms numerical arrays into visual insights. Matplotlib is Python's foundational plotting library (MATLAB-like API), while Seaborn is a statistical visualization layer built on top of Matplotlib with better defaults and statistical functions.

Core Concepts

Matplotlib Fundamentals

The Object-Oriented Pattern (WHY/HOW)

WHY use the OO interface?

Explicit control: You know which Axes you're drawing on (critical for subplots)
Reproducibility: No hidden global state
Composability: Functions can accept ax as an argument

HOW the anatomy works:

import matplotlib.pyplot as plt
import numpy as np
 
# Create container and plot area
fig, ax = plt.subplots(figsize=(8, 6))  # figure size in inches
 
# Generate data
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
 
# Plot on the Axes object
ax.plot(x, y, label='sin(x)', color='blue', linewidth=2)
 
# Customize the Axes
ax.set_xlabel('Radians', fontsize=12)
ax.set_ylabel('Amplitude', fontsize=12)
ax.set_title('Sine Wave Demonstration', fontsize=14, fontweight='bold')
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)
 
plt.tight_layout()  # Prevent label clipping
plt.show()

Why this step?

fig, ax = plt.subplots(): Unpacks a Figure and a single Axes. For 2×2 grid: fig, axes = plt.subplots(2, 2) gives you axes[0,0], axes[0,1], etc.
ax.plot(): Draws on this specific Axes, not some global state
tight_layout(): Auto-adjusts spacing so labels don't overlap

Formula Coordinate Systems in Matplotlib

Matplotlib uses multiple coordinate systems:

Data coordinates: The actual x, y values (e.g., radians, amplitude)
Axes coordinates: Normalized [0,1] × [0,1] within the Axes box
Figure coordinates: Normalized [0,1] × [0,1] within entire Figure
Display coordinates: Pixels on screen

Transforms convert between them: $\text{display} = T_{\text{data→display}} \cdot \text{data}$ Why it matters: To place text at "20% from left, 80% from bottom" regardless of data range:

ax.text(0.2, 0.8, 'Fixed position', transform=ax.transAxes)

Without transform=ax.transAxes, the text would be at data coordinates (0.2, 0.8), which might be off-screen.

Worked example Plot Types and When to Use Them

1. Line plot (ax.plot): Time series, continuous functions

fig, ax = plt.subplots()
epochs = np.arange(1, 51)
train_loss = 2.5 * np.exp(-epochs/10) + 0.1  # Simulated decay
val_loss = 2.5 * np.exp(-epochs/10) + 0.2+ 0.05*np.random.randn(50)
ax.plot(epochs, train_loss, label='Train Loss', marker='o', markersize=3)
ax.plot(epochs, val_loss, label='Val Loss', marker='s', markersize=3)
ax.set_xlabel('Epoch')
ax.set_ylabel('Loss')
ax.set_yscale('log')  # Log scale for loss
ax.legend()
ax.grid(True, which='both', alpha=0.3)

Why log scale? Loss often decreases exponentially—log scale makes the tail visible.

2. Scatter plot (ax.scatter): Correlation, clusters, outliers

fig, ax = plt.subplots()
np.random.seed(42)
x = np.random.randn(200)
y = 2*x + np.random.randn(200)*0.5  # Linear with noise
colors = x + y  # Color by sum
 
scatter = ax.scatter(x, y, c=colors, cmap='viridis', alpha=0.6, edgecolors='k')
fig.colorbar(scatter, ax=ax, label='x + y')
ax.set_xlabel('Feature 1')
ax.set_ylabel('Feature 2')
ax.set_title('Feature Correlation with Color Encoding')

Why colorbar? Third dimension of information (e.g., prediction confidence, density).

3. Histogram (ax.hist): Distribution of a single variable

fig, ax = plt.subplots()
data = np.random.normal(100, 15, 1000)  # Mean=100, std=15
ax.hist(data, bins=30, edgecolor='black', alpha=0.7, density=True)
ax.set_xlabel('Test Score')
ax.set_ylabel('Probability Density')
ax.axvline(data.mean(), color='red', linestyle='--', label=f'Mean = {data.mean():.1f}')
ax.legend()

Why density=True? Normalizes area to 1, allows overlaying PDF curves.

4. Bar plot (ax.bar): Categorical comparisons

fig, ax = plt.subplots()
models = ['LogReg', 'SVM', 'RandomForest', 'XGBoost']
accuracy = [0.82, 0.85, 0.89, 0.91]
bars = ax.bar(models, accuracy, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'])
ax.set_ylabel('Accuracy')
ax.set_ylim([0.75, 0.95])  # Don't start at 0 for small differences
ax.set_title('Model Comparison')
# Annotate bars
for bar, acc in zip(bars, accuracy):
   height = bar.get_height()
   ax.text(bar.get_x() + bar.get_width()/2, height + 0.01,
           f'{acc:.2f}', ha='center', va='bottom')

Why annotate? Precise values matter for model selection.

Worked example Subplots for Multi-Panel Figures

Problem: Compare train/val loss AND accuracy side-by-side.

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
 
epochs = np.arange(1, 51)
train_loss = 2.5 * np.exp(-epochs/10) + 0.1
val_loss = train_loss + 0.15 + 0.02*np.random.randn(50)
train_acc = 1 - train_loss/2.5
val_acc = 1 - val_loss/2.5
 
# Left panel: Loss
ax1.plot(epochs, train_loss, label='Train')
ax1.plot(epochs, val_loss, label='Val')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.legend()
ax1.set_title('Loss Curves')
 
# Right panel: Accuracy
ax2.plot(epochs, train_acc, label='Train')
ax2.plot(epochs, val_acc, label='Val')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Accuracy')
ax2.legend()
ax2.set_title('Accuracy Curves')
plt.tight_layout()

Why side-by-side? Spot overfitting instantly (val loss rises while train drops).

Seaborn: Statistical Visualization

Distribution Plots

Worked example Histograms with KDE (Kernel Density Estimate)

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.normal(0, 1, 1000)
 
fig, ax = plt.subplots()
sns.histplot(data, kde=True, bins=30, color='skyblue', edgecolor='black', ax=ax)
ax.set_xlabel('Value')
ax.set_ylabel('Frequency')
ax.set_title('Distribution with KDE Overlay')

What kde=True does: Fits a Gaussian kernel at each data point, sums them → smooth density estimate. Why use it? See the "true" underlying distribution beyond histogram bining artifacts.

Worked example Violin Plots for Group Comparisons

Problem: Compare loss distributions across 3 optimizers (Adam, SGD, RMSprop) over 50 runs each.

import pandas as pd
np.random.seed(42)
df = pd.DataFrame({
   'Optimizer': ['Adam']*50 + ['SGD']*50 + ['RMSprop']*50,
   'Final Loss': np.concatenate([
       np.random.normal(0.12, 0.02, 50),  # Adam: low mean, low variance
       np.random.normal(0.18, 0.05, 50),  # SGD: higher mean, higher variance
       np.random.normal(0.14, 0.03, 50)   # RMSprop: middle
   ])
})
fig, ax = plt.subplots()
sns.violinplot(data=df, x='Optimizer', y='Final Loss', ax=ax)
ax.set_title('Optimizer Stability Comparison')

Why violin > boxplot? Shows full distribution shape (bimodal? skewed?). Boxplot only shows quartiles.

Relationship Plots

Worked example Regression Plot with Confidence Interval

np.random.seed(0)
x = np.linspace(0, 10, 50)
y = 2*x + 1 + np.random.normal(0, 2, 50)
 
fig, ax = plt.subplots()
sns.regplot(x=x, y=y, ax=ax, scatter_kws={'alpha':0.5}, line_kws={'color':'red'})
ax.set_xlabel('Training Set Size (k)')
ax.set_ylabel('Test Error')
ax.set_title('Learning Curve with95% CI')

What the shaded region means: "If we resampled data, 95% of fitted lines would pass through this band." Why it matters: Wide band → high uncertainty, need more data.

Worked example Heatmap for Confusion Matrix

from sklearn.metrics import confusion_matrix
 
y_true = np.array([0,0,1,1,2,2] * 10)
y_pred = y_true.copy()
y_pred[::5] = (y_pred[::5] + 1) % 3  # Inject 20% errors
 
cm = confusion_matrix(y_true, y_pred)
fig, ax = plt.subplots(figsize=(6,5))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
           xticklabels=['Cat','Dog','Bird'],
           yticklabels=['Cat','Dog','Bird'], ax=ax)
ax.set_xlabel('Predicted')
ax.set_ylabel('True')
ax.set_title('Confusion Matrix')

Why heatmap? Instantly spot which classes are confused (off-diagonal cells).

Categorical Plots

Worked example Count Plot for Class Imbalance

df = pd.DataFrame({
   'Class': ['Fraud']*50 + ['Normal']*950
})
 
fig, ax = plt.subplots()
sns.countplot(data=df, x='Class', ax=ax, palette='Set2')
ax.set_ylabel('Count')
ax.set_title('Dataset Class Distribution')
# Annotate counts
for p in ax.patches:
   ax.text(p.get_x() + p.get_width()/2, p.get_height() + 10, 
           int(p.get_height()), ha='center')

Why this matters for ML? 95% class imbalance → accuracy is a meaningless metric (always predict "Normal" → 95% accuracy but useless model).

Common Mistakes & Fixes

Common mistake Mistake 1: Starting Y-Axis at 0 for Non-Ratio Data

Wrong intuition: "All bar charts should start at 0, otherwise it's misleading." Why it feels right: For quantities where 0 means "nothing" (e.g., revenue), truncating exaggerates differences.

The fix:

Ratio scales (money, count): Start at 0
Interval scales (temperature, accuracy difference): Truncate to show detail

# Comparing models at89%, 90%, 91% accuracy
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
 
models = ['A', 'B', 'C']
acc = [0.89, 0.90, 0.91]
 
# Misleading (starts at 0)
ax1.bar(models, acc)
ax1.set_ylim([0, 1])
ax1.set_title('Started at 0: Differences invisible')
 
# Clear (zomed in)
ax2.bar(models, acc)
ax2.set_ylim([0.88, 0.92])
ax2.set_title('Zomed: Real differences visible')

Rule of thumb: If zero is not a meaningful baseline for your metric, don't anchor to it.

Common mistake Mistake 2: Using

plt.plot() in Functions (State-Machine Hell) Wrong code:

def plot_loss(losses):
   plt.plot(losses)  # Modifies global state!
   plt.xlabel('Epoch')
plot_loss(train_losses)
plot_loss(val_losses)  # Oops, both on same axes, but which?

Why it fails: plt.plot() draws on the "current" Axes (implicit global variable). If you call plt.figure() later, you lose track.

The fix: Pass Axes objects explicitly (O interface)

def plot_loss(ax, losses, label):
   ax.plot(losses, label=label)
   ax.set_xlabel('Epoch')
   ax.set_ylabel('Loss')
   ax.legend()
fig, ax = plt.subplots()
plot_loss(ax, train_losses, 'Train')
plot_loss(ax, val_losses, 'Val')  # Both on same ax, controlled

Common mistake Mistake 3: Ignoring Color Perception (Rainbow Colormaps)

Wrong choice: cmap='jet' (rainbow: blue→green→yellow→red)

Why it feels right: "More colors = more information."

Why it's wrong:

Not perceptually uniform (yellow appears "higher" than red)
Colorblind unfriendly (8% of men can't distinguish red/green)
Loses information when printed in grayscale

The fix: Use perceptually-uniform colormaps

Sequential (low→high): viridis, plasma, cividis (colorblind-safe)
Diverging (negative←zero→positive): coolwarm, RdBu
Qualitative (categories): Set2, tab10

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
 
data = np.random.rand(10, 10)
 
ax1.imshow(data, cmap='jet')
ax1.set_title('Jet (Bad: perceptually non-uniform)')
ax2.imshow(data, cmap='viridis')
ax2.set_title('Viridis (Good: perceptually uniform)')

Common mistake Mistake 4: Not Saving Figures with Correct DPI

Wrong:

plt.savefig('plot.png')  # Default DPI=100, looks pixelated in papers

The fix:

plt.savefig('plot.png', dpi=300, bbox_inches='tight')
# dpi=300 for publications, bbox_inches='tight' removes excess whitespace

Advanced Techniques

Formula Figure Size and Aspect Ratio

Golden ratio: Width =1.618 × Height (aesthetically pleasing)

For two side-by-side plots:

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# Width=12 allows 6 inches per plot

Why inches? Matplotlib's display-independent unit. 1 inch = 72 points = DPI pixels when saved.

Worked example Customizing Seaborn Themes

import seaborn as sns
 
# Set global style
sns.set_theme(style='whitegrid', palette='muted', font_scale=1.2)
 
# Temporarily override
with sns.axes_style('darkgrid'):
   fig, ax = plt.subplots()
   ax.plot([1,2,3], [1,4,9])
   # This plot has darkgrid
# Outside `with` block: back to whitegrid

Available styles: whitegrid, darkgrid, white, dark, ticks

Memory Aid

Active Recall Questions

Recall Explain Matplotlib to a 12-year-old

Imagine you have a blank poster board (that's the Figure). You tape a grid paper onto it (that's the Axes). Now you draw a line graph of your test scores over time—the line is an Artist (something visible).

You could tape multiple grid papers one poster (subplots). Each grid has its own graph.

Matplotlib = the tools to draw. Seaborn = a smart assistant that draws common patterns for you (like "draw me a graph showing if taller people weigh more, and add a best-fit line automatically").

Connections

1.4.01-NumPy-arrays-and-operations — Arrays are the data, plots are the visualization
1.4.02-Pandas-DataFrames-and-data-manipulation — Seaborn integrates directly with DataFrames
2.1.05-Gradient-descent-optimization — Plot loss curves to diagnose optimization
2.3.04-Confusion-matrix-and-classification-metrics — Heatmaps for confusion matrices
3.2.02-Overfitting-vs-underfitting — Train/val curves reveal overfitting
4.1.01-Exploratory-data-analysis — Visualization is the first step in EDA

#flashcards/ai-ml

What are the two main interfaces in Matplotlib and when should you use each? :: pyplot (state-machine) like plt.plot() for quick REPL sketches. Object-oriented like fig, ax = plt.subplots(); ax.plot() for production code because you have explicit control over which Axes you're modifying, enabling reproducibility and composability.

What is the difference between a Figure and an Axes in Matplotlib?

Figure is the entire canvas/window. Axes (note: plural, not "axis") is a single plot area within the figure with its own coordinate system. One Figure can contain multiple Axes (subplots).

Why use ax.set_yscale('log') when plotting training loss?

Loss often decreases exponentially during training. A log scale makes the tail of the curve (small improvements in later epochs) visible instead of being compressed near zero.

What does density=True do in ax.hist() and why use it?

Normalizes the histogram so the total area equals 1, converting it to a probability density. This allows you to overlay theoretical PDF curves for comparison.

In Seaborn's regplot(), what does the shaded region around the regression line represent?

The 95% confidence interval for the regression line. It shows: "If we resampled the data many times, 95% of fitted lines would pass through this band." Wide bands indicate high uncertainty.

Why is a violin plot better than a boxplot?

Violin plots show the full distribution shape (is it bimodal? skewed? uniform?) while boxplots only show quartiles, potentially hiding important distribution characteristics like multiple peaks.

When should a bar chart NOT start at zero?

For interval scales (accuracy, temperature) where zero is not a meaningful baseline. Example: comparing models at 89%, 90%, 91% accuracy—starting at 0 makes differences invisible. Ratio scales (revenue, count) should start at 0.

Why avoid the'jet' colormap?

(1) Not perceptually uniform—yellow appears "brighter" than red even at same intensity. (2) Not colorblind-safe—8% of men can't distinguish red/green. (3) Loses structure when printed in grayscale. Use'viridis' or 'plasma' instead.

What's the difference between plt.plot() and ax.plot() in terms of code safety?

plt.plot() modifies global implicit state ("current" Axes), causing bugs in functions and loops. ax.plot() explicitly specifies which Axes to draw on, making code reproducible and composable.

What does transform=ax.transAxes do when placing text?

Places text in Axes coordinates (0-1 normalized within the plot area) instead of data coordinates. Example: ax.text(0.5, 0.9, 'Title', transform=ax.transAxes) puts text at top-center regardless of data range.

What DPI should you use when saving figures for publication?

300 DPI (dots per inch) is the standard for print publications. Also use bbox_inches='tight' to remove excess whitespace: plt.savefig('plot.png', dpi=300, bbox_inches='tight').

Why use sns.heatmap() for confusion matrices?

Instantly reveals which classes are confused (off-diagonal cells). Color intensity shows error magnitude. annot=True overlays exact counts, combining visual and numerical information.

What does kde=True add to a histogram in Seaborn?

Overlays a Kernel Density Estimate—a smooth curve showing the underlying probability distribution estimated by placing a Gaussian kernel at each data point and summing them.

How do you make a plot colorblind-accessible?

Use perceptually-uniform colormaps: 'viridis', 'plasma', 'cividis' (all colorblind-safe). For categorical data, use 'Set2' or 'tab10'. Avoid red-green combinations. Test with a colorblind simulator.

What's the purpose of plt.tight_layout()?

Automatically adjusts subplot spacing and margins to prevent labels, titles, and tick marks from overlapping or being clipped at figure edges.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, yeh note basically yeh samjha raha hai ki data ko sirf numbers me dekhna kaafi nahi hota. Socho tumhare paas ek neural network hai jo 1000x10 ka probability matrix output karta hai — us raw numbers ke matrix ko dekh ke tumhe kuch samajh nahi aayega. Lekin agar tum usko plot bana ke visual form me dekho, toh patterns turant samajh aa jaate hain — jaise data balanced hai ya nahi, loss smoothly kam ho raha hai ya nahi, model kahan fail kar raha hai. Isiliye visualization ko "debugging with your visual cortex" kehte hain, kyunki humans graphs me outliers aur trends spreadsheet ke comparison me 1000 guna fast pakad lete hain.

Ab tools ki baat karein toh do main libraries hain — Matplotlib jo foundation hai (MATLAB jaisa API), aur Seaborn jo Matplotlib ke upar built ek statistical layer hai jisme better defaults aur ready-made statistical functions hote hain. Matplotlib ka structure hierarchical hai: sabse bada container hai Figure (poora canvas), uske andar hoti hai Axes (ek plot area — dhyan rahe yeh "axis" se alag hai), aur har visible cheez (line, text) ko Artist kehte hain. Do interface milte hain — ek plt.plot() wala pyplot style jo quick aur easy hai lekin global state modify karta hai, aur doosra Object-Oriented style (fig, ax = plt.subplots()) jo explicit aur reproducible hai. Industry me OO style hi standard hai kyunki tum exactly control kar sakte ho ki kaunse Axes pe draw ho raha hai — especially jab multiple subplots ho.

Ek important cheez jo yeh note highlight karta hai woh hai coordinate systems. Matplotlib me data coordinates (actual values), Axes coordinates (0 se 1 tak normalized), Figure coordinates, aur display (pixels) — sab alag hote hain. Iska practical fayda yeh hai ki agar tumhe text ko "20% left se, 80% bottom se" fixed jagah pe rakhna hai chahe data range kuch bhi ho, toh tum transform=ax.transAxes use karte ho. Yeh chhoti si baat exam aur real projects dono me kaam aati hai, kyunki without proper transform tumhara text screen se bahar ja sakta hai. Overall, yeh topic tumhare liye foundation hai — kyunki aage har ML project me tum data explore karne, results dikhane, aur models debug karne ke liye yehi visualization skills baar-baar use karoge.

Overview

Core Concepts

Matplotlib Fundamentals

The Object-Oriented Pattern (WHY/HOW)

Seaborn: Statistical Visualization

Distribution Plots

Relationship Plots

Categorical Plots

Common Mistakes & Fixes

Advanced Techniques

Memory Aid

Active Recall Questions

Connections

Concept Map

Hinglish (regional understanding)

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Python & Scientific Computing

Connections