Lesson � Intermediate

CLUSTERING:
BINA LABELS KE
GROUPS BANANA.

Clustering unsupervised learning hai � bina labels ke data ko groups mein baant-te hain. Customer segmentation, anomaly detection, document grouping � sab clustering se hota hai. Jab tumhe pata na ho ki data mein kitne groups hain, tab clustering kaam aata hai.

? 22 min✓ Intermediate✓ Prerequisite: KNN

WHY: Clustering kyun seekhein?

Clustering unsupervised learning ka sabse powerful tool hai. Jab data mein labels nahi hote � jaise customer behavior, sensor readings, ya text documents � tab clustering se patterns dhundhte hain. Real-world mein: customer segmentation (kon sa group zyada kharch karta hai), anomaly detection (fraud transactions), image compression (similar colors group karna), aur recommendation systems (similar users dhundhna). KNN seekhne ke baad clustering ka concept clearly samajh aayega � dono distance-based hain.

K-MEANS

Data ko K groups mein baant-ta hai. Har group ka ek center (centroid) hota hai. Points apne nearest center ke group mein jaate hain. Fast hai lekin K value pehle se deni padti hai.

DBSCAN

Density-based clustering � points jo ek-doosre ke close hain unko group karta hai. Noise points alag se identify karta hai. K value ki zaroorat nahi, automatically groups dhundhta hai.

HIERARCHICAL

Tree jaisa structure banata hai � pehle sab points alag hain, phir ek ek karke merge karte jaate hain (agglomerative) ya ek big group ko split karte jaate hain (divisive). Dendrogram se visualization hoti hai.

ELBOW METHOD

K-Means mein sahi K value dhoondne ka method. Different K values pe inertia (within-cluster sum of squares) plot karo. Jahan curve "elbow" shape banaye � wahi best K hai.

HOW: K-Means kaam kaise karta hai

K-Means sabse simple aur popular clustering algorithm hai. Ye K centroids randomly place karta hai, phir har data point ko nearest centroid ke group mein daalta hai, aur centroids ko update karta hai jab tak convergence na ho jaye. Ye process repeat hota hai jab tak centroids move na karlein.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import numpy as np

# Customer data: age aur income
X = np.array([[25,50000],[30,60000],[35,80000],[45,120000],
 [20,30000],[50,150000],[28,55000],[40,100000]])

# Scaling zaroori hai � distance-based hai
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means with 3 clusters
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = kmeans.fit_predict(X_scaled)

print(f"Labels: {labels}")
print(f"Centroids:\n{kmeans.cluster_centers_}")
print(f"Inertia: {kmeans.inertia_:.2f}")

ℹ

Mental model: Socho tumhe 10 bachon ko 3 teams mein baantna hai (height) aur weight ke basis pe. Pehle 3 random leaders choose karo, phir har bacha apne nearest leader ki team mein jaata hai. Phir team ka naya leader (centroid) banta hai. Ye process tab tak chalta hai jab tak teams stable na ho jayein.

ELBOW METHOD: Sahi K dhoondna

K-Means mein sabse bada sawal hai � K (number of clusters) kitna rakhein✓ Elbow method se ye decide karte hain. Different K values ke liye inertia (within-cluster sum of squares) calculate karo aur plot karo. Jahan curve mein "elbow" banega � wahi optimal K hai. Zyada K = overfitting, kam K = underfitting.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[25,50000],[30,60000],[35,80000],[45,120000],
 [20,30000],[50,150000],[28,55000],[40,100000],
 [22,40000],[48,130000]])

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Elbow method � different K try karo
inertias = []
K_range = range(1, 8)

for k in K_range:
 km = KMeans(n_clusters=k, random_state=42, n_init=10)
 km.fit(X_scaled)
 inertias.append(km.inertia_)
 print(f"K={k}: Inertia={km.inertia_:.2f}")

# Elbow point dhoondho
diffs = np.diff(inertias)
diffs2 = np.diff(diffs)
optimal_k = np.argmax(diffs2) + 2
print(f"\nOptimal K: {optimal_k}")

DBSCAN: Density-based grouping

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) density ke basis pe groups banata hai. Ye do parameters use karta hai: eps (maximum distance between two points) aur min_samples (minimum points ek cluster mein). Ye irregular shapes ke clusters bhi handle kar sakta hai jo K-Means nahi kar sakta.

from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler
import numpy as np

# Same customer data
X = np.array([[25,50000],[30,60000],[35,80000],[45,120000],
 [20,30000],[50,150000],[28,55000],[40,100000]])

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# DBSCAN � eps aur min_samples tune karo
dbscan = DBSCAN(eps=0.8, min_samples=2)
labels = dbscan.fit_predict(X_scaled)

print(f"Labels: {labels}")
print(f"Unique clusters: {set(labels)}")
n_noise = list(labels).count(-1)
print(f"Noise points: {n_noise}")

# Core points kaunse hain
print(f"\nCore samples: {dbscan.core_sample_indices_}")
print(f"Components:\n{dbscan.components_}")

ℹ

K-Means vs DBSCAN: K-Means circular clusters dhundhta hai aur K pehle se dena padta hai. DBSCAN irregular shapes handle karta hai aur noise points ko (-1 label) alag se identify karta hai. Agar data mein outliers hain toh DBSCAN better hai.

HIERARCHICAL: Tree structure

Hierarchical clustering do tarah ka hota hai: Agglomerative (bottom-up � shuru mein sab points alag hain, phir merge karte jaate hain) aur Divisive (top-down � ek big group hai jo split hota jaata hai). Agglomerative zyada popular hai. Iska result dendrogram mein dikhta hai � tree jaisa visualization.

from sklearn.cluster import AgglomerativeClustering
from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[25,50000],[30,60000],[35,80000],[45,120000],
 [20,30000],[50,150000],[28,55000],[40,100000]])

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Agglomerative (bottom-up)
agg = AgglomerativeClustering(n_clusters=3)
labels = agg.fit_predict(X_scaled)
print(f"Agglomerative Labels: {labels}")

# Linkage types: ward, complete, average, single
for link in ['ward', 'complete', 'average']:
 agg = AgglomerativeClustering(n_clusters=3, linkage=link)
 labels = agg.fit_predict(X_scaled)
 print(f"{link:10s}: {labels}")

KAB KYA USE KAREIN: Algorithm comparison

Har clustering algorithm ka apna fayda hai. K-Means fast hai aur simple data ke liye best hai. DBSCAN noise handle karta hai aur irregular shapes ke liye best hai. Hierarchical visualization deta hai aur jab tumhe pata na ho ki kitne groups hain tab useful hai.

from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
import numpy as np

X = np.array([[25,50000],[30,60000],[35,80000],[45,120000],
 [20,30000],[50,150000],[28,55000],[40,100000],
 [22,40000],[48,130000]])

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means
km = KMeans(n_clusters=3, random_state=42, n_init=10)
km_labels = km.fit_predict(X_scaled)
km_score = silhouette_score(X_scaled, km_labels)

# DBSCAN
db = DBSCAN(eps=0.8, min_samples=2)
db_labels = db.fit_predict(X_scaled)
# Noise points (-1) ko exclude karo
mask = db_labels != -1
if mask.sum() > 1 and len(set(db_labels[mask])) > 1:
 db_score = silhouette_score(X_scaled[mask], db_labels[mask])
else:
 db_score = -1

# Hierarchical
hc = AgglomerativeClustering(n_clusters=3)
hc_labels = hc.fit_predict(X_scaled)
hc_score = silhouette_score(X_scaled, hc_labels)

print(f"K-Means: Silhouette = {km_score:.3f}")
print(f"DBSCAN: Silhouette = {db_score:.3f}")
print(f"Hierarchical: Silhouette = {hc_score:.3f}")
print(f"\nBest: {'K-Means' if km_score > max(db_score, hc_score) else 'DBSCAN' if db_score > hc_score else 'Hierarchical'}")

ℹ

Silhouette Score: -1 se 1 tak hota hai. 1 = perfect clustering, 0 = clusters overlap kar rahe hain, -1 = wrong clustering. Jitna zyada score, utna better clustering. Ye metric tumhe batata hai ki algorithm ne kitna achha groups banaye hain.

Try it: Customer data cluster karo

Editor mein customer data hai � K-Means se clusters banao. K value change karke dekho clusters kaise change hote hain. Elbow method implement karo aur sahi K dhoondo. Silhouette score se quality check karo.

Python playgroundFirst run download kar sakta hai

main.py

from sklearn.cluster import KMeans, DBSCAN
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
import numpy as np

# Customer data: age aur income (in thousands)
X = np.array([[25,50],[30,60],[35,80],[45,120],
 [20,30],[50,150],[28,55],[40,100],
 [22,40],[48,130],[32,70],[42,110]])

# Scale karo � distance-based hai clustering
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means with K=3
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
labels = kmeans.fit_predict(X_scaled)

print("=== K-Means Clustering ===")
for i in range(3):
 cluster_points = X[labels == i]
 print(f"\nCluster {i}: {len(cluster_points)} customers")
 print(f" Avg Age: {cluster_points[:,0].mean():.0f}")
 print(f" Avg Income: ?{cluster_points[:,1].mean()*1000:.0f}")

print(f"\nInertia: {kmeans.inertia_:.2f}")
print(f"Silhouette: {silhouette_score(X_scaled, labels):.3f}")

# Elbow method
print("\n=== Elbow Method ===")
for k in range(1, 7):
 km = KMeans(n_clusters=k, random_state=42, n_init=10)
 km.fit(X_scaled)
 print(f"K={k}: Inertia={km.inertia_:.2f}")

# DBSCAN
print("\n=== DBSCAN ===")
dbscan = DBSCAN(eps=0.8, min_samples=2)
db_labels = dbscan.fit_predict(X_scaled)
print(f"Labels: {db_labels}")
n_clusters = len(set(db_labels)) - (1 if -1 in db_labels else 0)
print(f"Clusters found: {n_clusters}")
print(f"Noise points: {list(db_labels).count(-1)}")

Optional input (har line ek input)

Run Python dabayein

Quick check

K-Means mein Elbow method kya hai?

Socho: K-Means mein K (number of clusters) pehle se dena padta hai. Toh sahi K kaise dhundhte hain✓ Kya plot karte hain?

Common clustering mistakes

Feature scaling na karna: Clustering distance-based hai � bina scaling ke features with larger values dominate karenge. Income (50000) age (25) ko dominate kar lega. Hamesha StandardScaler use karo.
K value randomly choose karna: K=3 ya K=5 randomly mat lo � Elbow method ya Silhouette score se decide karo. Wrong K se meaningless clusters banenge.
DBSCAN ke parameters na tune karna: eps aur min_samples bahut important hai. Default values se kaam nahi chalega � data ke hisaab se tune karo. Pehle k-distance plot dekho eps ke liye.
Clustering ko classification samajhna: Clustering unsupervised hai � koi ground truth nahi hota. Labels meaningful hone chahiye, sirf groups banana kaafi nahi hai. Domain knowledge zaroori hai.
High-dimensional data pe directly clustering karna: Curse of dimensionality � distance meaningless ho jata hai jab features zyada ho. Pehle PCA se dimensions kam karo, phir clustering karo.

Clustering clear?

Ab Dimensionality Reduction par chalo � PCA se features ko compress karna seekho. Clustering ke baad dimensionality reduction samajhna natural progression hai.

CLUSTERING:BINA LABELS KEGROUPS BANANA.