Unsupervised Learning

The Story That Explains Unsupervised Learningवह कहानी जो Unsupervised Learning समझाती है一个解释无监督学习的故事

In supervised learning, you give the model thousands of emails already labelled Spam / Not Spam, and it learns to predict the label. In unsupervised learning, you give it the same emails with no labels at all and ask: "What natural groups exist here?"

Supervised learning में आप model को हज़ारों emails देते हैं जिन पर पहले से Spam / Not Spam का label है, और वह label predict करना सीखता है। Unsupervised learning में आप वही emails बिना किसी label के देते हैं और पूछते हैं: "यहाँ कौन से स्वाभाविक groups हैं?"

在有监督学习中，你给模型成千上万封已标好垃圾邮件 / 非垃圾邮件的邮件，它学习预测标签。 在无监督学习中，你给它同样的邮件，但完全没有标签，然后问："这里存在哪些自然的分组？"

The Three Families of Unsupervised LearningUnsupervised Learning के तीन परिवार无监督学习的三大家族

Unsupervised methods fall into three broad families. Each one answers a different question about your data.

Unsupervised तरीके तीन बड़े परिवारों में आते हैं। हर एक आपके data के बारे में एक अलग सवाल का जवाब देता है।

无监督方法分为三大家族，每一类回答关于数据的不同问题。

Clustering — K-Means: The City PlannerClustering — K-Means: शहर का Planner聚类 — K-Means：城市规划师

The quantity K-Means minimises is called inertia: the sum of squared distances from each point to its centroid. Lower inertia means tighter clusters. Every assign step and every move step can only lower it, so K-Means always stops — but possibly at a local minimum, which is why it is run several times (n_init) from different starts.

K-Means जिस मात्रा को घटाता है उसे inertia कहते हैं: हर point से उसके centroid तक की दूरी² का जोड़। कम inertia मतलब कसे हुए clusters. हर assign step और हर move step इसे सिर्फ़ घटा सकता है, इसलिए K-Means हमेशा रुकता है — पर शायद किसी local minimum पर, इसीलिए इसे अलग-अलग शुरुआतों से कई बार चलाया जाता है (n_init)।

K-Means 最小化的量叫作惯性（inertia）：每个点到其质心距离平方之和。惯性越低，簇越紧凑。每次分配和每次移动都只会让它下降，所以 K-Means 一定会停止 —— 但可能停在局部最小值，这就是为什么要从不同起点运行多次（n_init）。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

# ── Generate synthetic customer data ────────────────────
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.8, random_state=42)

# ── Scale (K-Means IS distance-sensitive) ───────────────
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ── Elbow method — find optimal K ───────────────────────
inertias = []
K_range = range(1, 11)
for k in K_range:
    km = KMeans(n_clusters=k, n_init=10, random_state=42)
    km.fit(X_scaled)
    inertias.append(km.inertia_)
print("Inertia for K=1..10:", [round(v, 1) for v in inertias])

# ── Fit final model ──────────────────────────────────────
kmeans = KMeans(n_clusters=4, n_init=20, random_state=42)
labels = kmeans.fit_predict(X_scaled)

print(f"Inertia:         {kmeans.inertia_:.2f}")
print(f"Cluster centres: {kmeans.cluster_centers_.shape}")
print(f"Cluster sizes:   {np.bincount(labels)}")

Choosing K — The Elbow Method and Silhouette ScoreK चुनना — Elbow Method और Silhouette Score如何选择 K — 肘部法与轮廓系数

Picking K is one of the hardest decisions in K-Means. Two tools help: the elbow in the inertia curve, and the silhouette score.

K चुनना K-Means का सबसे मुश्किल फ़ैसला है। दो औज़ार मदद करते हैं: inertia curve का elbow, और silhouette score.

选择 K 是 K-Means 中最难的决定之一。有两个工具可以帮忙：惯性曲线的肘部，以及轮廓系数（silhouette score）。

from sklearn.metrics import silhouette_score

# ── Test K = 2 to 10 using silhouette score ─────────────
sil_scores = []
for k in range(2, 11):
    km = KMeans(n_clusters=k, n_init=10, random_state=42)
    lbl = km.fit_predict(X_scaled)
    score = silhouette_score(X_scaled, lbl)
    sil_scores.append((k, score))
    print(f"K={k}  Silhouette={score:.4f}")

best_k = max(sil_scores, key=lambda x: x[1])
print(f"\nBest K: {best_k[0]}  Score: {best_k[1]:.4f}")

Clustering — DBSCAN: The Astronomer's LensClustering — DBSCAN: खगोलशास्त्री का Lens聚类 — DBSCAN：天文学家的镜头

from sklearn.cluster import DBSCAN, KMeans
from sklearn.datasets import make_circles
from sklearn.metrics import adjusted_rand_score

# ── Concentric rings — K-Means can't handle this ────────
X_rings, y_true = make_circles(n_samples=400, noise=0.05, factor=0.5, random_state=42)
X_rings = StandardScaler().fit_transform(X_rings)

# ── DBSCAN ───────────────────────────────────────────────
db = DBSCAN(eps=0.3, min_samples=8)
db_labels = db.fit_predict(X_rings)

n_clusters = len(set(db_labels)) - (1 if -1 in db_labels else 0)
n_noise    = list(db_labels).count(-1)

print(f"Clusters found:  {n_clusters}")
print(f"Noise points:    {n_noise}")
print(f"Unique labels:   {sorted(int(l) for l in set(db_labels))}")

# ── Compare with K-Means (K=2) using the true ring labels ──
km_labels = KMeans(n_clusters=2, n_init=10, random_state=42).fit_predict(X_rings)
print(f"\nAgreement with true rings (ARI, 1.0 = perfect):")
print(f"  DBSCAN : {adjusted_rand_score(y_true, db_labels):.3f}")
print(f"  K-Means: {adjusted_rand_score(y_true, km_labels):.3f}")

Clustering — Hierarchical: The Family TreeClustering — Hierarchical: वंश-वृक्ष聚类 — 层次聚类：家谱树

from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage

# ── Fit hierarchical clustering ──────────────────────────
hier = AgglomerativeClustering(
    n_clusters=4,
    linkage='ward'      # minimises intra-cluster variance at each merge
)
hier_labels = hier.fit_predict(X_scaled)

print(f"Cluster sizes: {np.bincount(hier_labels)}")

# ── Full dendrogram (use linkage on a small sample) ──────
Z = linkage(X_scaled[:50], method='ward')
# Z is a (49 x 4) merge matrix — plot with scipy dendrogram()
print(f"Merge matrix shape: {Z.shape}")
print(f"Last merge distance: {Z[-1, 2]:.3f}")

Dimensionality Reduction — PCA: The Shadow on the WallDimensionality Reduction — PCA: दीवार पर परछाई降维 — PCA：墙上的影子

from sklearn.decomposition import PCA
from sklearn.datasets import load_digits

# ── Digits dataset: 1797 samples × 64 pixel features ────
digits = load_digits()
X_dig  = digits.data          # shape (1797, 64)
X_dig  = StandardScaler().fit_transform(X_dig)

# ── How many components explain 95% variance? ────────────
pca_full = PCA(n_components=0.95)
X_pca    = pca_full.fit_transform(X_dig)

print(f"Original dims:   {X_dig.shape[1]}")
print(f"Reduced dims:    {X_pca.shape[1]}")
print(f"Variance retained: {sum(pca_full.explained_variance_ratio_):.4f}")

# ── 2D projection for visualisation ─────────────────────
pca_2d  = PCA(n_components=2)
X_2d    = pca_2d.fit_transform(X_dig)
print(f"2D variance:     {sum(pca_2d.explained_variance_ratio_):.4f}")
print(f"PC1 explains:    {pca_2d.explained_variance_ratio_[0]:.4f}")
print(f"PC2 explains:    {pca_2d.explained_variance_ratio_[1]:.4f}")

Dimensionality Reduction — t-SNE: The Neighbourhood MapperDimensionality Reduction — t-SNE: पड़ोस का नक्शा降维 — t-SNE：邻里地图

from sklearn.manifold import TSNE

# ── t-SNE: always reduce with PCA first for speed ────────
pca_50  = PCA(n_components=50, random_state=42)
X_50    = pca_50.fit_transform(X_dig)        # PCA → 50 dims first

tsne    = TSNE(
    n_components=2,
    perplexity=40,          # typical range: 5–50
    max_iter=1000,           # called n_iter before scikit-learn 1.5
    random_state=42,
    learning_rate='auto'
)
X_tsne = tsne.fit_transform(X_50)

print(f"t-SNE output shape: {X_tsne.shape}")
print(f"KL divergence:      {tsne.kl_divergence_:.4f}")
# Lower KL = better embedding (closer to original distances)

Autoencoders — The Art of Compressing and RebuildingAutoencoders — Compress करने और दोबारा बनाने की कला自编码器 — 压缩与重建的艺术

import tensorflow as tf
from tensorflow import keras
import numpy as np
from sklearn.decomposition import PCA

tf.keras.utils.set_random_seed(42)   # reproducible weights

# ── Simple autoencoder for MNIST-like digits ─────────────
input_dim  = 64    # sklearn digits: 8x8 = 64 pixels
latent_dim = 8     # compress to 8 dimensions

# ── Encoder ───────────────────────────────────────────────
inputs  = keras.Input(shape=(input_dim,))
encoded = keras.layers.Dense(32, activation='relu')(inputs)
latent  = keras.layers.Dense(latent_dim, activation='relu')(encoded)

# ── Decoder ───────────────────────────────────────────────
decoded  = keras.layers.Dense(32, activation='relu')(latent)
outputs  = keras.layers.Dense(input_dim, activation='sigmoid')(decoded)

# ── Full autoencoder ──────────────────────────────────────
autoencoder = keras.Model(inputs, outputs)
autoencoder.compile(optimizer='adam', loss='mse')

# ── Normalise to [0,1] ────────────────────────────────────
X_norm = digits.data / 16.0

autoencoder.fit(X_norm, X_norm,   # target = input (reconstruction)
              epochs=50, batch_size=32, validation_split=0.1, verbose=0)

# ── Extract compressed representations ───────────────────
encoder_model = keras.Model(inputs, latent)
X_compressed  = encoder_model.predict(X_norm, verbose=0)
print(f"Compressed shape: {X_compressed.shape}")  # (1797, 8)

# ── How well does it rebuild the images? Compare with PCA (8 components) ──
X_rebuilt = autoencoder.predict(X_norm, verbose=0)
pca8 = PCA(n_components=8).fit(X_norm)
X_pca_rebuilt = pca8.inverse_transform(pca8.transform(X_norm))
print(f"Reconstruction MSE, autoencoder: {np.mean((X_norm - X_rebuilt) ** 2):.4f}")
print(f"Reconstruction MSE, PCA (8):     {np.mean((X_norm - X_pca_rebuilt) ** 2):.4f}")

Anomaly Detection — Isolation Forest: The Odd One OutAnomaly Detection — Isolation Forest: अलग वाला异常检测 — 孤立森林：找出"另类"

from sklearn.ensemble import IsolationForest
import numpy as np

# ── Credit card fraud detection simulation ───────────────
np.random.seed(42)
X_normal = np.random.randn(500, 5)                     # 500 normal transactions
X_fraud  = np.random.randn(20, 5) * 4 + 6              # 20 anomalous transactions
X_all    = np.vstack([X_normal, X_fraud])

# ── Isolation Forest ─────────────────────────────────────
iso = IsolationForest(
    n_estimators=200,
    contamination=0.04,   # expected anomaly fraction (~4%)
    random_state=42
)
preds  = iso.fit_predict(X_all)        # +1 = normal, -1 = anomaly
scores = iso.score_samples(X_all)       # lower score = more anomalous

n_detected = (preds == -1).sum()
actual_frauds_found = sum((preds[500:]) == -1)

print(f"Total anomalies flagged: {n_detected}")
print(f"Real frauds detected:    {actual_frauds_found} / 20")
print(f"Lowest anomaly score:    {scores.min():.4f}")

End-to-End Pipeline — Customer SegmentationEnd-to-End Pipeline — Customer Segmentation端到端流程 — 客户细分

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# ── Simulate customers from 4 hidden behaviour types ───────
rng = np.random.default_rng(42)
types = {            # recency, frequency, spend, order value, categories, returns
    'vip':        (10,  20, 2500, 120, 10, 2.0),
    'regular':    (30,  10,  600,  60,  6, 1.0),
    'occasional': (70,   4,  200,  45,  3, 0.5),
    'at_risk':    (160,  2,  120,  55,  2, 0.3),
}
sizes = [200, 700, 700, 400]
rows = []
for (name, m), n in zip(types.items(), sizes):
    rows.append(pd.DataFrame({
        'recency_days':       rng.gamma(4, m[0] / 4, n),
        'frequency':          rng.poisson(m[1], n),
        'total_spend':        rng.lognormal(np.log(m[2]), 0.35, n),
        'avg_order_value':    rng.lognormal(np.log(m[3]), 0.25, n),
        'categories_browsed': rng.poisson(m[4], n),
        'returns_count':      rng.poisson(m[5], n),
    }))
df = pd.concat(rows, ignore_index=True)

# ── Step 1: tame skew, then scale ──────────────────────────
X = df.copy()
X[['total_spend', 'avg_order_value']] = np.log1p(X[['total_spend', 'avg_order_value']])
X_scaled = StandardScaler().fit_transform(X)

# ── Step 2: PCA — 90% variance ────────────────────────────
pca   = PCA(n_components=0.90, random_state=42)
X_pca = pca.fit_transform(X_scaled)
print(f"Features after PCA: {X_pca.shape[1]} (from {X.shape[1]})")

# ── Step 3: Choose K with the silhouette score ─────────────
best_k, best_sil = 2, -1   # silhouette alone
for k in range(2, 9):
    lbl = KMeans(n_clusters=k, n_init=10, random_state=42).fit_predict(X_pca)
    sil = silhouette_score(X_pca, lbl)
    print(f"  K={k}  silhouette={sil:.3f}")
    if sil > best_sil:
        best_sil, best_k = sil, k
print(f"Best K by silhouette: {best_k}")

# ── Step 4: Fit K=4 (business choice) and profile in ORIGINAL units ──
K = 4
df['segment'] = KMeans(n_clusters=K, n_init=20, random_state=42).fit_predict(X_pca)
profile = df.groupby('segment').mean().round(1)
profile['size'] = df['segment'].value_counts().sort_index()
print("\nSegment profiles (means):")
print(profile.to_string())

Algorithm Comparison — When to Use WhatAlgorithms की तुलना — कब क्या इस्तेमाल करें算法对比 — 何时用什么

Golden Rules for Unsupervised LearningUnsupervised Learning के सुनहरे नियम无监督学习的黄金法则