Matplotlib and Seaborn visualization — Hinglish notes

1.4.8 · AI-ML › Python & Scientific Computing

Overview

Data visualization numerical arrays ko visual insights mein transform karta hai. Matplotlib Python ki foundational plotting library hai (MATLAB-jaisi API), jabki Seaborn ek statistical visualization layer hai jo Matplotlib ke upar bani hai, better defaults aur statistical functions ke saath.

Core Concepts

Matplotlib Fundamentals

The Object-Oriented Pattern (WHY/HOW)

OO interface kyun use karein?

Explicit control: Tum jaante ho ki tum kis Axes pe draw kar rahe ho (subplots ke liye critical)
Reproducibility: Koi hidden global state nahi
Composability: Functions ax ko argument ke roop mein accept kar sakte hain

Anatomy kaise kaam karta hai:

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()

Yeh step kyun?

fig, ax = plt.subplots(): Ek Figure aur ek single Axes unpack karta hai. 2×2 grid ke liye: fig, axes = plt.subplots(2, 2) se axes[0,0], axes[0,1], wagera milte hain.
ax.plot(): Is specific Axes pe draw karta hai, kisi global state pe nahi
tight_layout(): Spacing auto-adjust karta hai taaki labels overlap na karein

Formula Matplotlib Mein Coordinate Systems

Matplotlib multiple coordinate systems use karta hai:

Data coordinates: Actual x, y values (jaise radians, amplitude)
Axes coordinates: Axes box ke andar normalized [0,1] × [0,1]
Figure coordinates: Poore Figure ke andar normalized [0,1] × [0,1]
Display coordinates: Screen pe pixels

Transforms inke beech convert karte hain: $display = T_{data\todisplay} \cdot data$ Yeh kyun matter karta hai: Text ko "left se 20%, bottom se 80%" pe place karne ke liye, data range chahe kuch bhi ho:

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

transform=ax.transAxes ke bina, text data coordinates (0.2, 0.8) pe hoga, jo screen se bahar ho sakta hai.

Worked example Plot Types aur Kab Use Karein

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)

Log scale kyun? Loss aksar exponentially decrease hota hai—log scale tail ko visible banata hai.

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')

Colorbar kyun? Information ka teesra dimension (jaise prediction confidence, density).

3. Histogram (ax.hist): Ek single variable ki distribution

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()

density=True kyun? Area ko 1 pe normalize karta hai, PDF curves overlay karne deta hai.

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')

Annotate kyun? Model selection ke liye precise values matter karti hain.

Worked example Multi-Panel Figures ke liye Subplots

Problem: Train/val loss AUR accuracy ko side-by-side compare karo.

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()

Side-by-side kyun? Overfitting turant spot ho jaata hai (val loss badhta hai jabki train loss gitta hai).

Seaborn: Statistical Visualization

Distribution Plots

Worked example KDE (Kernel Density Estimate) ke Saath Histograms

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')

kde=True kya karta hai: Har data point pe ek Gaussian kernel fit karta hai, unhe sum karta hai → smooth density estimate. Ise kyun use karein? Histogram binning artifacts se pare "true" underlying distribution dekho.

Worked example Group Comparisons ke liye Violin Plots

Problem: 50-50-50 runs mein 3 optimizers (Adam, SGD, RMSprop) ke loss distributions compare karo.

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')

Violin > boxplot kyun? Poori distribution shape dikhata hai (bimodal hai? skewed hai?). Boxplot sirf quartiles dikhata hai.

Relationship Plots

Worked example Confidence Interval ke Saath Regression Plot

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')

Shaded region ka matlab: "Agar hum data resample karein, toh 95% fitted lines is band se guzrengi." Yeh kyun matter karta hai: Wide band → high uncertainty, zyada data chahiye.

Worked example Confusion Matrix ke liye Heatmap

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')

Heatmap kyun? Turant pata chalta hai kaunse classes confuse ho rahe hain (off-diagonal cells).

Categorical Plots

Worked example Class Imbalance ke liye Count Plot

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')

ML ke liye yeh kyun matter karta hai? 95% class imbalance → accuracy ek meaningless metric hai (hamesha "Normal" predict karo → 95% accuracy lekin useless model).

Common Mistakes & Fixes

Common mistake Mistake 1: Non-Ratio Data ke liye Y-Axis ko 0 se Shuru Karna

Galat intuition: "Saare bar charts 0 se shuru hone chahiye, warna yeh misleading hai." Kyun sahi lagta hai: Jin quantities mein 0 ka matlab "kuch nahi" hai (jaise revenue), truncating differences ko exaggerate karta hai.

Fix:

Ratio scales (paisa, count): 0 se shuru karo
Interval scales (temperature, accuracy difference): Detail dikhane ke liye truncate karo

# 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: Agar zero tumhare metric ke liye meaningful baseline nahi hai, toh uspe anchor mat karo.

Common mistake Mistake 2: Functions Mein

plt.plot() Use Karna (State-Machine Hell) Galat code:

def plot_loss(losses):
   plt.plot(losses)  # Modifies global state!
   plt.xlabel('Epoch')
plot_loss(train_losses)
plot_loss(val_losses)  # Oops, dono same axes pe, lekin kaunse?

Yeh kyun fail hota hai: plt.plot() "current" Axes (implicit global variable) pe draw karta hai. Agar baad mein plt.figure() call karo, toh track kho jaata hai.

Fix: Axes objects explicitly pass karo (OO 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')  # Dono same ax pe, controlled

Common mistake Mistake 3: Color Perception ko Ignore Karna (Rainbow Colormaps)

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

Kyun sahi lagta hai: "Zyada colors = zyada information."

Kyun galat hai:

Perceptually uniform nahi hai (yellow "zyada upar" lagta hai red se)
Colorblind ke liye unfriendly (8% men red/green mein distinguish nahi kar sakte)
Grayscale mein print hone pe information kho jaati hai

Fix: Perceptually-uniform colormaps use karo

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: Figures ko Correct DPI ke Saath Save Na Karna

Galat:

plt.savefig('plot.png')  # Default DPI=100, papers mein pixelated lagta hai

Fix:

plt.savefig('plot.png', dpi=300, bbox_inches='tight')
# dpi=300 publications ke liye, bbox_inches='tight' excess whitespace hatata hai

Advanced Techniques

Formula Figure Size aur Aspect Ratio

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

Do side-by-side plots ke liye:

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# Width=12 se har plot ke liye 6 inches milte hain

Inches kyun? Matplotlib ka display-independent unit. 1 inch = 72 points = save karne pe DPI pixels.

Worked example Seaborn Themes Customize Karna

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])
   # Is plot mein darkgrid hai
# `with` block ke bahar: wapas whitegrid

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

Memory Aid

Active Recall Questions

Recall Matplotlib ko ek 12-saal ke bacche ko explain karo

Socho tumhare paas ek blank poster board hai (woh hai Figure). Tum uspe ek grid paper tape karte ho (woh hai Axes). Ab tum time ke saath apne test scores ka ek line graph draw karte ho—woh line ek Artist hai (kuch visible).

Tum ek poster pe multiple grid papers tape kar sakte ho (subplots). Har grid ka apna graph hai.

Matplotlib = draw karne ke tools. Seaborn = ek smart assistant jo tumhare liye common patterns draw karta hai (jaise "mere liye ek graph draw karo jo dikhaye ki kya lambe log zyada weight karte hain, aur automatically ek best-fit line add karo").

Connections

1.4.01-NumPy-arrays-and-operations — Arrays data hain, plots visualization hain
1.4.02-Pandas-DataFrames-and-data-manipulation — Seaborn directly DataFrames ke saath integrate karta hai
2.1.05-Gradient-descent-optimization — Optimization diagnose karne ke liye loss curves plot karo
2.3.04-Confusion-matrix-and-classification-metrics — Confusion matrices ke liye heatmaps
3.2.02-Overfitting-vs-underfitting — Train/val curves overfitting reveal karte hain
4.1.01-Exploratory-data-analysis — Visualization EDA ka pehla step hai

#flashcards/ai-ml

Matplotlib mein do main interfaces kaunse hain aur inhe kab use karna chahiye? :: pyplot (state-machine) jaise plt.plot() quick REPL sketches ke liye. Object-oriented jaise fig, ax = plt.subplots(); ax.plot() production code ke liye kyunki tumhare paas explicit control hai ki tum kaunsa Axes modify kar rahe ho, reproducibility aur composability enable hoti hai.

Matplotlib mein Figure aur Axes mein kya fark hai?

Figure poora canvas/window hai. Axes (note: plural, "axis" nahi) figure ke andar ek single plot area hai apne coordinate system ke saath. Ek Figure mein multiple Axes (subplots) ho sakte hain.

Training loss plot karte waqt ax.set_yscale('log') kyun use karein?

Training ke dauran loss aksar exponentially decrease hota hai. Log scale curve ki tail (baad ke epochs mein chhote improvements) ko visible banata hai, warna woh zero ke paas compress ho jaati.

ax.hist() mein density=True kya karta hai aur ise kyun use karein?

Histogram ko normalize karta hai taaki total area 1 ho jaaye, isse probability density mein convert karta hai. Yeh tumhe comparison ke liye theoretical PDF curves overlay karne deta hai.

Seaborn ke regplot() mein regression line ke aas-paas shaded region kya represent karta hai?

Regression line ke liye 95% confidence interval. Yeh dikhata hai: "Agar hum data ko kai baar resample karein, toh 95% fitted lines is band se guzrengi." Wide bands high uncertainty indicate karti hain.

Violin plot boxplot se behtar kyun hai?

Violin plots poori distribution shape dikhate hain (kya yeh bimodal hai? skewed? uniform?) jabki boxplots sirf quartiles dikhate hain, potentially important distribution characteristics jaise multiple peaks chhupa dete hain.

Bar chart kabhi zero se shuru nahi karna chahiye?

Interval scales (accuracy, temperature) ke liye jahan zero meaningful baseline nahi hai. Example: 89%, 90%, 91% accuracy waale models compare karna—0 se shuru karne pe differences invisible ho jaate hain. Ratio scales (revenue, count) 0 se shuru hone chahiye.

'jet' colormap se kyun bachein?

(1) Perceptually uniform nahi—yellow same intensity pe bhi red se "brighter" lagta hai. (2) Colorblind-safe nahi—8% men red/green mein distinguish nahi kar sakte. (3) Grayscale mein print karne pe structure kho jaata hai. Iske bajaye 'viridis' ya 'plasma' use karo.

Code safety ke terms mein plt.plot() aur ax.plot() mein kya fark hai?

plt.plot() global implicit state ("current" Axes) modify karta hai, functions aur loops mein bugs create karta hai. ax.plot() explicitly specify karta hai ki kis Axes pe draw karna hai, code ko reproducible aur composable banata hai.

Text place karte waqt transform=ax.transAxes kya karta hai?

Text ko data coordinates ki jagah Axes coordinates (plot area ke andar 0-1 normalized) mein place karta hai. Example: ax.text(0.5, 0.9, 'Title', transform=ax.transAxes) text ko data range chahe kuch bhi ho, top-center pe rakhta hai.

Publications ke liye figures save karte waqt kaunsa DPI use karna chahiye?

Print publications ke liye 300 DPI (dots per inch) standard hai. Saath mein bbox_inches='tight' bhi use karo excess whitespace hatane ke liye: plt.savefig('plot.png', dpi=300, bbox_inches='tight').

Confusion matrices ke liye sns.heatmap() kyun use karein?

Turant reveal karta hai kaunse classes confuse ho rahe hain (off-diagonal cells). Color intensity error magnitude dikhati hai. annot=True exact counts overlay karta hai, visual aur numerical information combine karta hai.

Seaborn mein histogram mein kde=True kya add karta hai?

Kernel Density Estimate overlay karta hai—ek smooth curve jo underlying probability distribution dikhati hai, har data point pe ek Gaussian kernel place karke aur unhe sum karke estimate ki jaati hai.

Plot ko colorblind-accessible kaise banayein?

Perceptually-uniform colormaps use karo: 'viridis', 'plasma', 'cividis' (sab colorblind-safe hain). Categorical data ke liye 'Set2' ya 'tab10' use karo. Red-green combinations se bachein. Colorblind simulator se test karo.

plt.tight_layout() ka kya purpose hai?

Subplot spacing aur margins automatically adjust karta hai taaki labels, titles, aur tick marks overlap na hon ya figure edges pe clip na hon.