K-Means Clustering

The Story That Explains K-Meansवह कहानी जो K-Means समझाती है一个讲清 K-Means 的故事

K-Means Clustering is an unsupervised machine learning algorithm that splits a dataset into K separate, non-overlapping clusters. Each data point belongs to the cluster whose centroid (centre point) is closest to it. The algorithm repeats two simple moves until the cluster assignments stop changing.

K-Means Clustering एक unsupervised machine learning algorithm है जो dataset को K अलग, बिना overlap वाले clusters में बाँटता है। हर data point उस cluster में जाता है जिसका centroid (केंद्र point) उसके सबसे पास है। Algorithm दो आसान कदम तब तक दोहराता है जब तक clusters बदलना बंद न कर दें।

K-Means 聚类是一种无监督机器学习算法（unsupervised learning），它把数据集分成 K 个互不重叠的簇（cluster）。 每个数据点属于离它最近的那个质心（centroid，中心点）所在的簇。算法反复执行两个简单动作，直到各点的归属不再变化。

K-Means in Pictures — Understand It Before the Mathsतस्वीरों में K-Means — गणित से पहले समझें图解 K-Means — 先看懂，再学公式

Before any formula, learn six words. Every picture and simulator on this page uses them.

किसी भी formula से पहले छह शब्द सीख लें। इस page की हर तस्वीर और simulator इन्हीं का इस्तेमाल करता है।

在看任何公式之前，先学会六个词。本页的每张图和每个模拟器都会用到它们。

Everyday things that work like K-Meansरोज़ की चीज़ें जो K-Means की तरह काम करती हैं日常生活中像 K-Means 一样运作的事物

One full loop, in four picturesएक पूरा loop, चार तस्वीरों में一次完整的循环，四张图

These four panels are computed, not hand-drawn: 18 dots, K = 3, and a deliberately bad start. The shaded background shows which centroid owns each area. Watch the WCSS fall.

ये चार panels हाथ से नहीं बनाए गए, गणना करके बनाए गए हैं: 18 dots, K = 3, और जान-बूझकर ख़राब शुरुआत। पीछे का रंग दिखाता है कि हर इलाका किस centroid का है। WCSS को गिरते देखें।

这四幅图是真实计算出来的，不是手画的：18 个点，K = 3，并故意给了一个很差的起点。背景颜色表示每块区域归哪个质心。注意 WCSS 如何下降。

The Algorithm — Step by StepAlgorithm — एक-एक कदम算法 — 一步一步来

K-Means follows a simple loop of five steps. Once you see them as a story, you will not forget them.

K-Means पाँच कदमों का एक आसान loop है। एक बार कहानी के रूप में देख लिया, तो आप इन्हें नहीं भूलेंगे।

K-Means 是一个由五步组成的简单循环。用故事看过一遍，你就不会忘记。

The Objective Function — What K-Means MinimisesObjective Function — K-Means क्या घटाता है目标函数 — K-Means 在最小化什么

K-Means is not guessing at random — it is making one number as small as possible. Knowing that number explains both its power and its limits.

K-Means random अंदाज़ा नहीं लगाता — यह एक number को जितना हो सके छोटा करता है। उस number को समझने से इसकी ताक़त और सीमाएँ दोनों समझ आती हैं।

K-Means 不是在乱猜 —— 它在把一个数字变得尽可能小。理解这个数字，就能同时理解它的优势和局限。

A worked example you can check by handएक हल किया उदाहरण जिसे आप हाथ से जाँच सकते हैं一个可以手算验证的例子

Six shops on a map, K = 2, and a bad start: both centroids begin next to each other at (1, 1) and (2, 1).

Map पर छह दुकानें, K = 2, और ख़राब शुरुआत: दोनों centroids पास-पास (1, 1) और (2, 1) पर शुरू होते हैं।

地图上有六家店，K = 2，起点很差：两个质心挨在一起，分别从 (1, 1) 和 (2, 1) 出发。

Points: A(1,1) B(2,1) C(1,2) D(5,4) E(6,5) F(5,5). Check one number yourself: in iteration 1, D is √18 ≈ 4.24 from c₁ = (2,1) and 5 from c₀ = (1,1), so D joins cluster 1. The code below repeats the same steps with NumPy.

Points: A(1,1) B(2,1) C(1,2) D(5,4) E(6,5) F(5,5). एक number खुद जाँचें: iteration 1 में D, c₁ = (2,1) से √18 ≈ 4.24 और c₀ = (1,1) से 5 दूर है, इसलिए D cluster 1 में जाता है। नीचे का code NumPy से यही steps दोहराता है।

各点：A(1,1) B(2,1) C(1,2) D(5,4) E(6,5) F(5,5)。自己验证一个数：第 1 轮中，D 到 c₁ = (2,1) 的距离是 √18 ≈ 4.24，到 c₀ = (1,1) 是 5，所以 D 归入簇 1。下面的代码用 NumPy 重复了同样的步骤。

import numpy as np

# 6 shops on a map (x, y in km) and K = 2 delivery hubs
X = np.array([[1, 1], [2, 1], [1, 2], [5, 4], [6, 5], [5, 5]], dtype=float)
C = np.array([[1, 1], [2, 1]], dtype=float)      # a deliberately bad start

for it in range(1, 10):
    # ASSIGN: squared distance from every point to every centroid
    d2 = ((X[:, None, :] - C[None, :, :]) ** 2).sum(axis=2)
    labels = d2.argmin(axis=1)
    wcss = d2[np.arange(len(X)), labels].sum()
    print(f"Iteration {it}: labels = {labels.tolist()}  WCSS = {wcss:.3f}")
    # MOVE: each centroid goes to the mean of its points
    newC = np.array([X[labels == k].mean(axis=0) for k in range(2)])
    print(f"   new centroids = {np.round(newC, 3).tolist()}")
    if np.allclose(newC, C):
        print("   centroids did not move → converged")
        break
    C = newC

K-Means++ — The Smarter StartK-Means++ — समझदार शुरुआतK-Means++ — 更聪明的起点

Choosing K — The Hardest PartK चुनना — सबसे मुश्किल हिस्सा选择 K — 最难的部分

K-Means needs K before it starts. This is its biggest weakness, and the source of the most common beginner mistake: just picking K = 3 because it sounds right. Here are the most reliable ways to choose.

K-Means को शुरू करने से पहले K चाहिए। यह इसकी सबसे बड़ी कमज़ोरी है, और शुरुआती लोगों की सबसे आम ग़लती की वजह: बस K = 3 चुन लेना क्योंकि यह ठीक लगता है। चुनने के सबसे भरोसेमंद तरीके ये हैं।

K-Means 在开始前就需要 K。这是它最大的弱点，也是初学者最常见错误的来源：只因为“听起来合适”就选 K = 3。下面是最可靠的选择方法。

When K-Means Works — and When It FailsK-Means कब चलता है — और कब फ़ेल होता हैK-Means 何时有效 — 何时失效

Feature Scaling — A Must for K-MeansFeature Scaling — K-Means के लिए ज़रूरी特征缩放 — K-Means 的必做步骤

Python Code — K-Means from Scratch to ProductionPython Code — शुरुआत से Production तक K-MeansPython 代码 — 从入门到生产

Let us build up step by step: first a minimal working example, then the standard pattern with the elbow method and silhouette scores. Every output below is the real output of the code.

चलिए एक-एक कदम बनाते हैं: पहले एक छोटा working example, फिर elbow method और silhouette scores वाला standard pattern. नीचे का हर output code का असली output है।

我们一步步来：先写一个最小可运行示例，再写包含肘部法和轮廓系数的标准流程。下面每个输出都是代码真实运行的结果。

9.1 — Minimal Example (Synthetic Data)9.1 — छोटा Example (Synthetic Data)9.1 — 最小示例（合成数据）

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

# 1. Generate synthetic data — 300 points in 4 natural clusters
X, y_true = make_blobs(n_samples=300, centers=4,
                        cluster_std=0.70, random_state=42)

# 2. Scale features — ALWAYS do this before K-Means
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Fit K-Means with K=4 (K-Means++ initialisation is the default)
kmeans = KMeans(n_clusters=4, init='k-means++',
                n_init=10, random_state=42)
kmeans.fit(X_scaled)

# 4. Results
labels     = kmeans.labels_          # cluster ID for each point
centroids  = kmeans.cluster_centers_ # centroid coordinates
inertia    = kmeans.inertia_         # WCSS (lower = tighter clusters)
iterations = kmeans.n_iter_          # how many EM iterations ran

print(f"WCSS (Inertia):  {inertia:.2f}")
print(f"Iterations:      {iterations}")
print(f"Cluster counts:  {np.bincount(labels)}")

The 4 blobs are far apart, so K-Means needs only 2 iterations and puts exactly 75 points in each cluster. n_iter_ is the iteration count of the best of the 10 runs.

4 blobs एक-दूसरे से बहुत दूर हैं, इसलिए K-Means को सिर्फ़ 2 iterations चाहिए और हर cluster में ठीक 75 points आते हैं। n_iter_ 10 runs में से सबसे अच्छे run की iteration गिनती है।

4 个团相距很远，所以 K-Means 只需 2 轮迭代，每个簇正好 75 个点。n_iter_ 是 10 次运行中最佳那次的迭代次数。

9.2 — Finding the Right K: Elbow + Silhouette9.2 — सही K खोजना: Elbow + Silhouette9.2 — 找到合适的 K：肘部法 + 轮廓系数

from sklearn.metrics import silhouette_score

wcss_list   = []
sil_list    = []
K_range     = range(2, 11)

for k in K_range:
    km = KMeans(n_clusters=k, init='k-means++',
                 n_init=10, random_state=42)
    km.fit(X_scaled)
    wcss_list.append(km.inertia_)
    sil_list.append(silhouette_score(X_scaled, km.labels_))

# Print both metrics side by side
print(f"{'K':>3}  {'WCSS':>10}  {'Silhouette':>12}")
print("-" * 30)
for k, w, s in zip(K_range, wcss_list, sil_list):
    print(f"{k:>3}  {w:>10.2f}  {s:>12.4f}")

best_k = K_range[sil_list.index(max(sil_list))]
print(f"\nBest K by Silhouette: {best_k}")

Watch K-Means Run — LiveK-Means को चलते देखें — Live实时观看 K-Means 运行

Section 02 showed one loop as still pictures. Here the loop runs live on 140 points. Each press of "One step" does half an iteration: first ASSIGN (points change colour), then MOVE (centroids slide to the mean).

Section 02 में एक loop को रुकी हुई तस्वीरों में दिखाया था। यहाँ वही loop 140 points पर live चलता है। "एक step" का हर press आधा iteration करता है: पहले ASSIGN (points का रंग बदलता है), फिर MOVE (centroids mean पर खिसकते हैं)।

第 02 节用静态图展示了一次循环。这里同样的循环在 140 个点上实时运行。每按一次“走一步”执行半轮：先分配（点变色），再移动（质心滑向均值）。

On easy data like this, K-Means usually converges in a handful of iterations. Real data with overlapping groups can need tens of iterations; scikit-learn stops at max_iter=300 or when the centroids move less than tol.

ऐसे आसान data पर K-Means आमतौर पर कुछ ही iterations में converge हो जाता है। Overlap वाले groups के असली data को दसियों iterations लग सकते हैं; scikit-learn max_iter=300 पर या जब centroids tol से कम हिलें, तब रुकता है।

在这种简单数据上，K-Means 通常几轮就收敛。组间有重叠的真实数据可能需要几十轮；scikit-learn 在达到 max_iter=300 或质心移动小于 tol 时停止。

📋 Case Study 1 — Customer Segmentation for an E-Commerce Shop📋 Case Study 1 — E-Commerce Shop के लिए Customer Segmentation📋 案例一 — 电商平台的客户分群

Step 1 — Load and Explore the DataStep 1 — Data load करें और देखें第 1 步 — 加载并查看数据

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

# Simulate 50,000 customers from 4 hidden shopping habits
# (in real life you do NOT know these types — K-Means must find them)
rng = np.random.default_rng(42)
habits = {               # orders/year, avg order value (£), share of customers
    'dormant':        (2,   70, 0.22),
    'vip':            (20, 220, 0.18),
    'core_regular':   (8,  110, 0.38),
    'bargain_hunter': (14,  35, 0.22),
}
n = 50000
parts = []
for name, (freq, aov, share) in habits.items():
    m = int(n * share)
    f = rng.poisson(freq, m) + 1                       # at least 1 order
    v = rng.lognormal(np.log(aov), 0.20, m).round(2)   # order value
    parts.append(pd.DataFrame({'purchase_freq': f, 'avg_order_value': v}))
df = pd.concat(parts, ignore_index=True).sample(frac=1, random_state=42).reset_index(drop=True)
df['total_spend']  = (df['purchase_freq'] * df['avg_order_value']).round(2)
df.insert(0, 'customer_id', range(1, n + 1))

print(df[['total_spend', 'purchase_freq', 'avg_order_value']].describe().round(2))

Step 2 — Scale and Find the Best KStep 2 — Scale करें और सबसे अच्छा K खोजें第 2 步 — 缩放并寻找最佳 K

# Select features. Spend and order value are skewed, so take the log first
features = ['total_spend', 'purchase_freq', 'avg_order_value']
X = df[features].copy()
X[['total_spend', 'avg_order_value']] = np.log1p(X[['total_spend', 'avg_order_value']])
scaler = StandardScaler()
X_sc   = scaler.fit_transform(X)

# Evaluate K=2 to K=8
results = []
for k in range(2, 9):
    km = KMeans(n_clusters=k, init='k-means++',
                 n_init=10, random_state=42)
    km.fit(X_sc)
    sil = silhouette_score(X_sc, km.labels_, sample_size=5000, random_state=42)
    results.append({'K': k, 'WCSS': round(km.inertia_, 1), 'Silhouette': round(sil, 4)})

print(pd.DataFrame(results).to_string(index=False))

Real result: WCSS drops a lot until K = 4 (44,803 → 20,917) and then only slowly (17,505, 15,114 …), and the silhouette is highest at K = 4 (0.57). Note the log step: money columns are skewed (a few big spenders), and the log stops them from dominating the distances.

असली नतीजा: WCSS K = 4 तक बहुत गिरता है (44,803 → 20,917) और फिर धीरे-धीरे (17,505, 15,114 …), और silhouette K = 4 पर सबसे ऊँचा है (0.57)। Log वाला step ध्यान दें: पैसे वाले columns टेढ़े (skewed) होते हैं (कुछ बड़े ख़र्च करने वाले), और log उन्हें distances पर हावी होने से रोकता है।

真实结果：WCSS 在 K = 4 之前大幅下降（44,803 → 20,917），之后下降变慢（17,505、15,114 …），轮廓系数在 K = 4 时最高（0.57）。注意取对数这一步：金额类列是偏斜的（少数大客户），取对数能防止它们主导距离。

Step 3 — Fit the Final Model (K = 4) and Profile the SegmentsStep 3 — Final Model (K = 4) fit करें और Segments का Profile बनाएँ第 3 步 — 训练最终模型（K = 4）并给客户群画像

# Fit final model
final_km = KMeans(n_clusters=4, init='k-means++',
                   n_init=20, random_state=42)
df['segment'] = final_km.fit_predict(X_sc)

# Profile each segment in ORIGINAL units (easy to read)
profile = df.groupby('segment')[features].mean().round(2)
profile['count']   = df.groupby('segment').size()
profile['% share'] = (profile['count'] / n * 100).round(1)
print(profile)

Step 4 — Business Names and Action PlanStep 4 — Business नाम और Action Plan第 4 步 — 业务命名与行动方案

📋 Case Study 2 — Image Compression with K-Means📋 Case Study 2 — K-Means से Image Compression📋 案例二 — 用 K-Means 压缩图像

Step 1 — Load and Reshape the ImageStep 1 — Image load करें और Reshape करें第 1 步 — 加载并重塑图像

We use a real photo that ships with scikit-learn, so the code runs anywhere without downloading anything. Swap in your own photo with PIL as shown in the comment.

हम scikit-learn के साथ आने वाली एक असली photo इस्तेमाल करते हैं, ताकि code बिना कुछ download किए कहीं भी चले। Comment में दिखाए तरीके से PIL से अपनी photo लगाएँ।

我们使用 scikit-learn 自带的一张真实照片，这样代码无需下载任何东西就能运行。按注释所示，用 PIL 换成你自己的照片即可。

import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import load_sample_image

# Load a real photo that ships with scikit-learn (no download needed).
# For your own photo: img = np.array(PIL.Image.open('beach.jpg').convert('RGB'))
img = load_sample_image('china.jpg')
h, w, c = img.shape
print(f"Image shape: {h}×{w} pixels, {c} colour channels")
print(f"Total unique colours (theoretical): {256**3:,}")
n_unique = len(np.unique(img.reshape(-1, 3), axis=0))
print(f"Total unique colours (actual):       {n_unique:,}")

# Reshape: from (H, W, 3) to (H*W, 3)
# Each row is now one pixel with [R, G, B]
pixels = img.reshape(-1, 3).astype('float32')
print(f"Pixel matrix shape: {pixels.shape}")

Step 2 — Fit K-Means on Pixel ColoursStep 2 — Pixel रंगों पर K-Means Fit करें第 2 步 — 在像素颜色上训练 K-Means

# Fit K-Means: find 64 representative colours
# Note: RGB values 0–255 are already on the same scale, so no scaling needed
K = 64
km = KMeans(n_clusters=K, init='k-means++',
             n_init=3, max_iter=100, random_state=42)

# Use a random sample for speed, then predict all pixels
rng = np.random.default_rng(42)
sample_idx = rng.choice(len(pixels), size=50000, replace=False)
km.fit(pixels[sample_idx])

# Assign every pixel to its nearest centroid colour
labels = km.predict(pixels)

# Reconstruct: replace each pixel with its centroid colour
palette    = km.cluster_centers_.round().astype('uint8')  # 64×3 colour palette
compressed = palette[labels].reshape(h, w, 3)             # back to (H, W, 3)

raw_bytes = h * w * 3
new_bytes = h * w * np.log2(K) / 8 + K * 3          # indices + the palette itself
err = np.abs(compressed.astype(int) - img.astype(int)).mean()
print(f"Original unique colours:    {n_unique:,}")
print(f"Compressed unique colours:  {len(np.unique(compressed.reshape(-1, 3), axis=0))}")
print(f"Original storage (raw):     {raw_bytes:,} bytes")
print(f"Compressed storage:         {new_bytes:,.0f} bytes")
print(f"Compression ratio:          {raw_bytes / new_bytes:.1f}×")
print(f"Average colour error:       {err:.1f} (out of 255)")

The "compressed storage" counts the 6-bit index of every pixel plus the 64 × 3 palette itself (192 bytes). The average error of 4.5 out of 255 per channel is hard to see with the eye.

"Compressed storage" में हर pixel का 6-bit index और 64 × 3 का palette (192 bytes) दोनों गिने गए हैं। हर channel पर 255 में से 4.5 का औसत error आँख से मुश्किल से दिखता है।

“压缩后存储”包括每个像素的 6 位索引，以及 64 × 3 的调色板本身（192 字节）。每通道平均误差 4.5（满分 255），肉眼几乎看不出来。

Step 3 — Compare Different K ValuesStep 3 — अलग-अलग K की तुलना第 3 步 — 比较不同的 K

# Compare size and quality at different K values
for k_val in [4, 8, 16, 32, 64, 128]:
    km_temp = KMeans(n_clusters=k_val, init='k-means++',
                      n_init=3, max_iter=100, random_state=42)
    km_temp.fit(pixels[sample_idx])
    lbl_temp  = km_temp.predict(pixels)
    pal_temp  = km_temp.cluster_centers_.round().astype('uint8')
    err       = np.abs(pal_temp[lbl_temp].astype(int) - pixels.astype(int)).mean()
    bits_px   = int(np.ceil(np.log2(k_val)))
    bytes_tot = h * w * bits_px // 8
    ratio     = h * w * 3 / bytes_tot
    print(f"K={k_val:4d} | Bits/pixel: {bits_px} | "
          f"Size: {bytes_tot:>9,} bytes | Ratio: {ratio:4.1f}× | Avg error: {err:5.1f}")

K-Means Limitations — What No One Tells BeginnersK-Means की सीमाएँ — जो कोई शुरुआती लोगों को नहीं बताताK-Means 的局限 — 没人告诉初学者的事

K-Means vs Other Clustering AlgorithmsK-Means vs दूसरे Clustering AlgorithmsK-Means 与其他聚类算法对比

Mini-Batch K-Means — For Large DatasetsMini-Batch K-Means — बड़े Datasets के लिएMini-Batch K-Means — 面向大数据集

Standard K-Means looks at every data point in every iteration. Mini-Batch K-Means updates the centroids from small random samples (mini-batches) instead. Each update is very cheap, and the data can arrive in chunks, so it works even when the data does not fit in memory. The price: centroids that are slightly less accurate.

Standard K-Means हर iteration में हर data point देखता है। Mini-Batch K-Means इसकी जगह छोटे random samples (mini-batches) से centroids update करता है। हर update बहुत सस्ता है, और data टुकड़ों में आ सकता है, इसलिए यह तब भी काम करता है जब data memory में न समाए। क़ीमत: centroids थोड़े कम सटीक।

标准 K-Means 每一轮都要看所有数据点。Mini-Batch K-Means 则用小的随机样本（小批量）来更新质心。 每次更新都非常便宜，而且数据可以分块到达，所以即使数据装不进内存也能用。代价是：质心的精度略低一些。

import numpy as np
import time
from sklearn.cluster import KMeans, MiniBatchKMeans

# Simulate 1 million records: 20 overlapping groups in 10 features
rng = np.random.default_rng(42)
centres = rng.uniform(-10, 10, size=(20, 10))
X_big = centres[rng.integers(0, 20, 1_000_000)] + rng.normal(0, 3, (1_000_000, 10))

# 1) Standard K-Means: uses ALL rows in every iteration
t0 = time.time()
km_std = KMeans(n_clusters=20, n_init=3, random_state=42).fit(X_big)
print(f"Standard K-Means : {time.time()-t0:5.2f}s  WCSS={km_std.inertia_:,.0f}")

# 2) Mini-Batch K-Means: each step uses only 1,024 random rows
t1 = time.time()
km_mb = MiniBatchKMeans(n_clusters=20, batch_size=1024,
                        n_init=3, random_state=42).fit(X_big)
print(f"Mini-Batch       : {time.time()-t1:5.2f}s  WCSS={km_mb.inertia_:,.0f}")

# 3) Mini-Batch with partial_fit: data arrives in chunks
#    (e.g. read 100k rows at a time from a file that does not fit in RAM)
km_stream = MiniBatchKMeans(n_clusters=20, batch_size=1024, random_state=42)
t2 = time.time()
for chunk in np.array_split(X_big, 10):            # 10 chunks of 100k rows
    for batch in np.array_split(chunk, 100):       # 100 mini-batches per chunk
        km_stream.partial_fit(batch)
wcss_stream = -km_stream.score(X_big)              # score() = minus WCSS
print(f"partial_fit      : {time.time()-t2:5.2f}s  WCSS={wcss_stream:,.0f}")

gap = (km_mb.inertia_ / km_std.inertia_ - 1) * 100
print(f"\nMini-Batch WCSS is {gap:.1f}% worse than standard K-Means.")

Golden RulesGolden Rules黄金法则