Thuật Toán K-Means Là Gì? 4 Bước Hoạt Động, Ví Dụ Tính Tay Và Code Python Từ A-Z

Thuật toán K-Means là thuật toán phân cụm (clustering) không giám sát phổ biến nhất trong Machine Learning: nó chia một tập dữ liệu thành K nhóm sao cho mỗi điểm thuộc về cụm có tâm (centroid) gần nó nhất, và tổng bình phương khoảng cách từ các điểm đến tâm cụm của chúng là nhỏ nhất. Thuật toán lặp lại hai bước đơn giản – gán điểm vào tâm gần nhất và cập nhật tâm bằng trung bình các điểm – cho đến khi các cụm không còn thay đổi.

Bài viết này giải thích K-Means theo cách một người làm dữ liệu thực sự cần: từ trực giác, công thức toán, ví dụ tính tay từng bước, cách chọn K, code Python (cả tự viết bằng NumPy lẫn scikit-learn), cho đến những sai lầm thường gặp khi đưa K-Means vào dự án thật như phân khúc khách hàng.

Thuật toán K-Means là gì?

Thuật toán K-Means thuộc nhóm phân cụm dựa trên tâm (centroid-based clustering). “K” là số cụm bạn muốn tìm, còn “Means” chỉ việc mỗi cụm được đại diện bởi giá trị trung bình (mean) của các điểm thuộc cụm đó.

Khác với phân loại (classification) – nơi mô hình học từ dữ liệu đã có nhãn như “spam/không spam” – thuật toán K-Means nhận vào dữ liệu không có nhãn và tự phát hiện cấu trúc nhóm ẩn bên trong. Vì vậy nó thuộc nhóm học máy không giám sát, thường được dùng ở giai đoạn khám phá dữ liệu (EDA) hoặc làm bước tiền xử lý cho các mô hình khác.

Ví dụ trực giác: một chuỗi bán lẻ có 50.000 khách hàng với hai thông tin là tần suất mua và giá trị đơn hàng trung bình. Không ai gán sẵn nhãn “khách VIP” hay “khách vãng lai”. thuật toán K-Means có thể tự chia họ thành, chẳng hạn, 4 nhóm có hành vi tương đồng – và đội marketing sẽ đặt tên, xây chiến dịch riêng cho từng nhóm.

Lịch sử ngắn gọn

• 1957: Stuart Lloyd (Bell Labs) đề xuất thuật toán cho bài toán lượng tử hóa tín hiệu (PCM). Công trình chỉ được công bố chính thức năm 1982 trên IEEE Transactions on Information Theory – vì thế thuật toán chuẩn còn được gọi là thuật toán Lloyd.
• 1967: James MacQueen lần đầu dùng thuật ngữ “k-means” trong bài báo tại Berkeley Symposium.
• 2007: David Arthur và Sergei Vassilvitskii giới thiệu k-means++ – cách khởi tạo tâm thông minh, đến nay là mặc định trong scikit-learn.

Sau gần 70 năm, thuật toán K-Means vẫn nằm trong danh sách “10 thuật toán hàng đầu trong khai phá dữ liệu” (Wu et al., 2008) và là thuật toán phân cụm đầu tiên mà hầu hết lộ trình học Data Science giảng dạy.

Các khái niệm cần nắm trước khi học thuật toán K-Means

Hàm mục tiêu: thuật toán K-Means thực sự tối ưu cái gì?

Cho tập dữ liệu gồm n điểm x₁, …, x_n trong không gian d chiều, thuật toán K-Means tìm cách chia chúng thành K cụm C₁, …, C_K để tối thiểu hóa:

J = Σ_k=1^K Σ_{x ∈ Ck} ‖x − μ_k‖²

trong đó μ_k là trung bình các điểm trong cụm C_k. Đại lượng J chính là WCSS, thuộc tính inertia_ trong scikit-learn.

Hai nhận xét quan trọng giúp hiểu vì sao thuật toán hoạt động:

1. Khi cố định tâm, cách tốt nhất để giảm J là gán mỗi điểm vào tâm gần nhất (bước Assignment).
2. Khi cố định cụm, điểm làm Σ‖x − μ‖² nhỏ nhất chính là trung bình cộng của cụm (lấy đạo hàm theo μ và cho bằng 0 sẽ ra μ = trung bình). Đây là bước Update.

Mỗi bước đều làm J giảm hoặc giữ nguyên, và số cách chia cụm là hữu hạn, nên thuật toán luôn hội tụ. Tuy nhiên, nó chỉ đảm bảo hội tụ về cực tiểu cục bộ, không phải nghiệm tối ưu toàn cục – bài toán tối ưu K-Means chính xác là NP-hard ngay cả với K = 2 (Aloise et al., 2009). Đây là lý do khởi tạo tốt và chạy nhiều lần lại quan trọng đến vậy.

Thuật toán K-Means hoạt động như thế nào? 4 bước cốt lõi

Hình 1: Với khởi tạo ngẫu nhiên kém (hai tâm rơi vào cùng một nhóm), thuật toán K-Means vẫn dần “kéo” các tâm về đúng 4 cụm sau vài vòng lặp.

1. Chọn K và khởi tạo tâm: chọn ngẫu nhiên K điểm làm tâm ban đầu (hoặc dùng k-means++).
2. Gán cụm (Assignment step): với mỗi điểm, tính khoảng cách tới K tâm và gán điểm vào cụm có tâm gần nhất.
3. Cập nhật tâm (Update step): tính lại mỗi tâm bằng trung bình tọa độ các điểm vừa được gán vào cụm đó.
4. Kiểm tra hội tụ: nếu nhãn cụm không đổi (hoặc tâm dịch chuyển < ngưỡng tol, hoặc đạt số vòng tối đa) thì dừng; ngược lại quay lại bước 2.

Mã giả:

Input: dữ liệu X (n điểm), số cụm K
Khởi tạo μ1, ..., μK
repeat
    for mỗi điểm xi:
        ci = argmin_k ||xi - μk||²          # gán cụm
    for mỗi cụm k:
        μk = trung bình các xi có ci = k     # cập nhật tâm
until nhãn ci không thay đổi
return c, μ

Ví dụ thuật toán K-Means tính tay từng bước

Để thấy rõ cơ chế, hãy chạy thuật toán K-Means với K = 2 trên 6 điểm 2 chiều:

A(1,1), B(2,1), C(1,2), D(8,8), E(9,8), F(8,9)

Cố tình khởi tạo “kém”: chọn μ₁ = A(1,1) và μ₂ = B(2,1) – hai tâm nằm sát nhau.

Vòng lặp 1 – Gán cụm (khoảng cách Euclid):

Cập nhật tâm: μ₁ = trung bình(A, C) = (1; 1,5); μ₂ = trung bình(B, D, E, F) = ((2+8+9+8)/4; (1+8+8+9)/4) = (6,75; 6,5).

Vòng lặp 2 – Gán cụm: điểm B(2,1) giờ cách μ₁ chỉ 1,12 nhưng cách μ₂ tới 7,27 → B chuyển sang cụm 1. Các điểm còn lại giữ nguyên. Cụm mới: {A, B, C} và {D, E, F}.

Cập nhật tâm: μ₁ = (1,33; 1,33); μ₂ = (8,33; 8,33).

Vòng lặp 3: không điểm nào đổi cụm → hội tụ.

Kết quả: WCSS mỗi cụm = 2/9 + 5/9 + 5/9 ≈ 1,33, tổng WCSS ≈ 2,67. Dù khởi tạo kém, thuật toán vẫn tự sửa sai chỉ sau 2 vòng – nhưng với dữ liệu phức tạp hơn, khởi tạo kém có thể khiến nó “kẹt” ở nghiệm xấu. Đó là lúc cần đến k-means++.

K-Means++: khởi tạo tâm thông minh

K-means++ (Arthur & Vassilvitskii, 2007) chọn tâm ban đầu sao cho chúng trải đều trên dữ liệu:

1. Chọn ngẫu nhiên tâm đầu tiên từ dữ liệu.
2. Với mỗi điểm x, tính D(x) – khoảng cách tới tâm gần nhất đã chọn.
3. Chọn tâm tiếp theo với xác suất tỉ lệ thuận với D(x)² – điểm càng xa các tâm hiện có càng dễ được chọn.
4. Lặp lại đến khi đủ K tâm, rồi chạy thuật toán K-Means chuẩn.

Các tác giả chứng minh k-means++ cho kết quả kỳ vọng nằm trong phạm vi O(log K) so với nghiệm tối ưu, đồng thời thực nghiệm cho thấy hội tụ nhanh hơn và WCSS thấp hơn rõ rệt so với khởi tạo ngẫu nhiên. Trong scikit-learn, init="k-means++" là mặc định; kết hợp thêm n_init (chạy nhiều lần với khởi tạo khác nhau và giữ kết quả có inertia thấp nhất) để giảm rủi ro cực tiểu cục bộ.

Cách chọn số cụm K tối ưu cho thuật toán K-Means

Đây là câu hỏi người học hỏi nhiều nhất. Không có “đáp án đúng” tuyệt đối, nhưng có 3 công cụ định lượng phổ biến, nên dùng kết hợp:

Hình 2: Chọn K cho thuật toán K-Means – trên dữ liệu thật có 4 cụm, WCSS gãy khúc rõ ở K = 4 và Silhouette cũng đạt đỉnh (0,81) tại K = 4. Số liệu tính bằng scikit-learn 1.x.

1. Phương pháp Elbow (khuỷu tay)

Chạy thuật toán K-Means với K = 1, 2, …, 10 và vẽ WCSS theo K. WCSS luôn giảm khi K tăng (K = n thì WCSS = 0), nhưng tới một điểm thì mức giảm chậm hẳn lại – điểm “khuỷu tay” đó là K hợp lý. Nhược điểm: với dữ liệu thật, khuỷu tay thường không rõ ràng và việc đọc biểu đồ khá chủ quan.

2. Silhouette Score

Với mỗi điểm i, tính a(i) = khoảng cách trung bình tới các điểm cùng cụm, b(i) = khoảng cách trung bình tới các điểm của cụm gần nhất khác. Khi đó:

s(i) = (b(i) − a(i)) / max(a(i), b(i))

s(i) nằm trong khoảng [−1, 1]: gần 1 nghĩa là điểm nằm đúng cụm và tách biệt tốt; gần 0 là nằm ở ranh giới; âm là có thể bị gán nhầm. Chọn K có silhouette trung bình cao nhất (Rousseeuw, 1987). Lưu ý silhouette tốn O(n²) nên với dữ liệu lớn hãy tính trên một mẫu con (tham số sample_size).

3. Gap Statistic

Tibshirani, Walther & Hastie (2001) so sánh log(WCSS) của dữ liệu thật với log(WCSS) kỳ vọng trên dữ liệu ngẫu nhiên phân bố đều. K tốt nhất là K nhỏ nhất mà khoảng cách (gap) đủ lớn. Phương pháp này chặt chẽ về mặt thống kê hơn Elbow nhưng tính toán nặng hơn.

4. Đừng quên yếu tố nghiệp vụ

Trong thực tế, K còn phụ thuộc vào việc doanh nghiệp có thể hành động với bao nhiêu nhóm. Phân khúc khách hàng thành 12 cụm có thể đẹp về toán học, nhưng đội marketing chỉ đủ nguồn lực chạy 4–5 chiến dịch. Hãy dùng chỉ số để thu hẹp khoảng K, rồi chọn cuối cùng dựa trên khả năng diễn giải và hành động.

Code Python: triển khai thuật toán K-Means

Cách 1: Tự viết thuật toán K-Means bằng NumPy (để hiểu bản chất)

import numpy as np

def kmeans(X, k, max_iter=300, tol=1e-4, seed=42):
    rng = np.random.default_rng(seed)
    # 1. Khởi tạo: chọn ngẫu nhiên k điểm làm tâm
    centroids = X[rng.choice(len(X), size=k, replace=False)]

    for i in range(max_iter):
        # 2. Gán cụm: khoảng cách từ mọi điểm tới mọi tâm, shape (n, k)
        dists = np.linalg.norm(X[:, None, :] - centroids[None, :, :], axis=2)
        labels = dists.argmin(axis=1)

        # 3. Cập nhật tâm (giữ nguyên tâm cũ nếu cụm bị rỗng)
        new_centroids = np.array([
            X[labels == j].mean(axis=0) if np.any(labels == j) else centroids[j]
            for j in range(k)
        ])

        # 4. Kiểm tra hội tụ
        shift = np.linalg.norm(new_centroids - centroids)
        centroids = new_centroids
        if shift < tol:
            break

    inertia = ((X - centroids[labels]) ** 2).sum()
    return labels, centroids, inertia

# Ví dụ tính tay ở trên
X = np.array([[1, 1], [2, 1], [1, 2], [8, 8], [9, 8], [8, 9]], dtype=float)
labels, centers, wcss = kmeans(X, k=2)
print(labels, centers.round(2), round(wcss, 2))   # WCSS ≈ 2.67

Cách 2: Dùng scikit-learn (dùng cho dự án thật)

from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

X, _ = make_blobs(n_samples=600, centers=4, cluster_std=0.9, random_state=42)
X = StandardScaler().fit_transform(X)        # luôn chuẩn hóa trước K-Means

# Thử nhiều giá trị K
for k in range(2, 10):
    km = KMeans(n_clusters=k, init="k-means++", n_init=10, random_state=42)
    labels = km.fit_predict(X)
    print(f"K={k}: inertia={km.inertia_:.1f}, silhouette={silhouette_score(X, labels):.3f}")

# Huấn luyện mô hình cuối cùng
best = KMeans(n_clusters=4, n_init=10, random_state=42).fit(X)
print(best.cluster_centers_)       # tọa độ các tâm
print(best.labels_[:10])           # nhãn cụm của 10 điểm đầu
print(best.n_iter_)                # số vòng lặp đến khi hội tụ

Các tham số đáng chú ý khi triển khai thuật toán K-Means bằng lớp KMeans trong scikit-learn:

• n_clusters: số cụm K.
• init: "k-means++" (mặc định) hoặc "random", hoặc mảng tâm tự chọn.
• n_init: số lần chạy với khởi tạo khác nhau; từ phiên bản 1.4 mặc định là "auto" (1 lần khi dùng k-means++). Với dữ liệu khó, nên đặt 10 hoặc hơn.
• max_iter, tol: điều kiện dừng.
• algorithm: "lloyd" (mặc định) hoặc "elkan" – dùng bất đẳng thức tam giác để bỏ qua các phép tính khoảng cách không cần thiết, nhanh hơn với cụm tách biệt rõ.

Nếu bạn mới bắt đầu với Python, hãy xem thêm bài học Python cho Data Science để nắm NumPy, Pandas trước khi thực hành.

Ưu điểm và nhược điểm của thuật toán K-Means

Những sai lầm thường gặp khi dùng thuật toán K-Means (và cách khắc phục)

Đây là các lỗi khi áp dụng thuật toán K-Means mà chúng tôi thường thấy khi chấm bài tập và review dự án của học viên:

1. Không chuẩn hóa dữ liệu. Nếu một cột là “thu nhập” (hàng chục triệu) và cột kia là “tuổi” (vài chục), khoảng cách Euclid gần như chỉ phụ thuộc vào thu nhập. Luôn dùng StandardScaler hoặc MinMaxScaler; với dữ liệu lệch mạnh (doanh thu, số lần mua), cân nhắc biến đổi log trước.
2. Đưa biến phân loại đã mã hóa số vào thẳng. Mã hóa “Hà Nội = 1, TP.HCM = 2, Đà Nẵng = 3” rồi tính trung bình là vô nghĩa. Dùng K-Modes/K-Prototypes hoặc one-hot kèm cân nhắc trọng số.
3. Bỏ qua ngoại lai. Một vài khách hàng doanh nghiệp mua cực lớn có thể kéo lệch cả một tâm cụm hoặc chiếm riêng một cụm. Hãy phát hiện và xử lý ngoại lai (IQR, Isolation Forest) hoặc dùng K-Medoids.
4. Quá nhiều chiều. Ở không gian hàng trăm chiều, khoảng cách giữa các điểm trở nên gần như bằng nhau (“lời nguyền chiều dữ liệu”). Giảm chiều bằng PCA trước khi phân cụm.
5. Tin vào một lần chạy duy nhất. Luôn đặt random_state để tái lập và n_init > 1 để ổn định kết quả.
6. Coi cụm là “sự thật”. Thuật toán K-Means luôn trả về K cụm, kể cả khi dữ liệu không có cấu trúc cụm nào. Hãy kiểm tra silhouette và diễn giải bằng nghiệp vụ trước khi ra quyết định.

Các biến thể của thuật toán K-Means

• Mini-Batch K-Means: cập nhật tâm trên các lô (batch) nhỏ thay vì toàn bộ dữ liệu, nhanh hơn nhiều lần với dữ liệu hàng triệu dòng, đổi lại chất lượng giảm nhẹ (Sculley, 2010).
• K-Medoids (PAM): tâm cụm phải là một điểm dữ liệu thật và có thể dùng mọi thước đo khoảng cách → bền vững hơn với ngoại lai.
• K-Modes / K-Prototypes: dành cho dữ liệu phân loại hoặc hỗn hợp số – phân loại (Huang, 1998).
• Fuzzy C-Means: phân cụm “mềm” – mỗi điểm thuộc nhiều cụm với các mức độ thành viên khác nhau.
• Bisecting K-Means: liên tục chia đôi cụm lớn nhất, tạo cấu trúc phân cấp; có sẵn trong scikit-learn từ phiên bản 1.1.
• Spherical K-Means: dùng độ tương đồng cosine, phù hợp cho văn bản và vector embedding.

So sánh thuật toán K-Means với các thuật toán phân cụm khác

Quy tắc chọn nhanh: dữ liệu lớn, cụm tương đối tròn đều → thuật toán K-Means. Cụm hình dạng bất kỳ, nhiều nhiễu → DBSCAN/HDBSCAN. Cần xem cấu trúc phân cấp trên dữ liệu nhỏ → Hierarchical. Cụm chồng lấn, cần xác suất thuộc cụm → GMM. Về bản chất, thuật toán K-Means có thể xem là trường hợp đặc biệt của GMM khi các phân phối có hiệp phương sai cầu bằng nhau và gán cứng.

Ứng dụng thực tế của thuật toán K-Means

1. Phân khúc khách hàng (Customer Segmentation)

Ứng dụng phổ biến nhất của thuật toán K-Means trong doanh nghiệp. Quy trình điển hình với mô hình RFM:

1. Tính cho mỗi khách hàng: Recency (số ngày từ lần mua gần nhất), Frequency (số đơn), Monetary (tổng chi tiêu).
2. Biến đổi log cho Frequency và Monetary (thường lệch phải mạnh), sau đó chuẩn hóa.
3. Chạy thuật toán K-Means với K từ 2–8, chọn K bằng Elbow + Silhouette + thảo luận với đội kinh doanh.
4. Diễn giải tâm cụm thành chân dung: “Khách trung thành giá trị cao”, “Khách mới tiềm năng”, “Khách có nguy cơ rời bỏ”, “Khách ngủ đông”…
5. Thiết kế hành động riêng: ưu đãi giữ chân, chương trình VIP, chiến dịch kích hoạt lại.

2. Nén ảnh và lượng tử hóa màu

Coi mỗi pixel là một điểm 3 chiều (R, G, B), chạy thuật toán K-Means với K = 16 rồi thay màu mỗi pixel bằng màu tâm cụm. Ảnh từ hàng chục nghìn màu chỉ còn 16 màu, dung lượng giảm mạnh trong khi mắt người khó nhận ra khác biệt. Đây cũng là nguồn gốc của thuật toán K-Means trong bài toán lượng tử hóa vector (vector quantization) của Lloyd.

3. Phát hiện bất thường

Sau khi phân cụm giao dịch “bình thường”, những điểm có khoảng cách tới tâm cụm gần nhất lớn bất thường có thể là gian lận hoặc lỗi hệ thống cần kiểm tra.

4. Xử lý văn bản và hệ thống AI

Phân cụm các vector embedding (ví dụ từ mô hình BERT) để gom nhóm chủ đề tin tức, phản hồi khách hàng, hoặc ticket hỗ trợ. Trong các cơ sở dữ liệu vector, thuật toán K-Means còn được dùng để xây chỉ mục IVF (Inverted File Index) giúp tìm kiếm tương đồng nhanh cho hệ thống RAG.

5. Tài chính và đầu tư

Trong đầu tư định lượng, thuật toán K-Means được dùng để gom nhóm cổ phiếu có hành vi giá tương đồng (dựa trên lợi suất, biến động, tương quan) nhằm đa dạng hóa danh mục, hoặc nhận diện các “chế độ thị trường” (market regime) như tăng mạnh, đi ngang, biến động cao. Bạn có thể học cách áp dụng Machine Learning vào giao dịch tại Khóa học Auto Trading – xây bot giao dịch bằng Python.

6. Các lĩnh vực khác

Phân vùng ảnh y tế, phân nhóm cửa hàng/khu vực bán hàng theo đặc điểm, tối ưu vị trí kho hàng trong logistics, phân nhóm cảm biến IoT, và tạo đặc trưng (feature engineering) – dùng nhãn cụm hoặc khoảng cách tới các tâm làm biến đầu vào cho mô hình có giám sát.

Câu hỏi thường gặp về thuật toán K-Means

Thuật toán K-Means là học có giám sát hay không giám sát?

Thuật toán K-Means thuộc nhóm học không giám sát, vì nó làm việc trên dữ liệu không có nhãn và tự tìm ra cấu trúc nhóm.

Thuật toán K-Means khác KNN như thế nào?

Hai thuật toán thường bị nhầm do cùng có chữ “K”. K-Means là thuật toán phân cụm không giám sát, K là số cụm. KNN (K-Nearest Neighbors) là thuật toán phân loại/hồi quy có giám sát, K là số láng giềng gần nhất dùng để dự đoán nhãn cho điểm mới.

Thuật toán K-Means có luôn hội tụ không?

Có. Mỗi vòng lặp không làm tăng WCSS và số cách chia cụm là hữu hạn nên thuật toán luôn hội tụ. Tuy nhiên, kết quả chỉ là cực tiểu cục bộ, vì vậy nên dùng k-means++ và chạy nhiều lần (n_init).

Có bắt buộc phải chuẩn hóa dữ liệu trước khi chạy thuật toán K-Means không?

Gần như luôn nên chuẩn hóa. Thuật toán K-Means dựa trên khoảng cách Euclid nên biến có thang đo lớn sẽ áp đảo kết quả. Ngoại lệ là khi các biến vốn cùng đơn vị và cùng thang đo (ví dụ giá trị pixel RGB).

Thuật toán K-Means có dùng được cho dữ liệu phân loại không?

Không nên dùng trực tiếp, vì “trung bình” của các nhãn phân loại không có nghĩa. Hãy dùng K-Modes cho dữ liệu phân loại hoặc K-Prototypes cho dữ liệu hỗn hợp.

Làm sao chọn số cụm K tốt nhất cho thuật toán K-Means?

Kết hợp phương pháp Elbow, Silhouette Score (chọn K có điểm cao nhất) và Gap Statistic, sau đó đối chiếu với khả năng diễn giải và hành động của nghiệp vụ.

Kết luận

Thuật toán K-Means tồn tại gần 70 năm nhưng vẫn là công cụ đầu tiên mà Data Analyst, Data Scientist và AI Engineer tìm đến khi cần khám phá cấu trúc trong dữ liệu không nhãn. Sức mạnh của nó nằm ở sự đơn giản: hai bước gán – cập nhật, một hàm mục tiêu rõ ràng, tốc độ cao và kết quả dễ giải thích. Để dùng thuật toán K-Means hiệu quả trong dự án thật, hãy nhớ bốn nguyên tắc: chuẩn hóa dữ liệu, khởi tạo bằng k-means++ với nhiều lần chạy, chọn K bằng cả chỉ số lẫn nghiệp vụ, và kiểm tra giả định về hình dạng cụm trước khi tin vào kết quả.

Tài liệu tham khảo

1. Lloyd, S. P. (1982). Least squares quantization in PCM. IEEE Transactions on Information Theory, 28(2), 129–137.
2. MacQueen, J. (1967). Some methods for classification and analysis of multivariate observations. Proceedings of the 5th Berkeley Symposium on Mathematical Statistics and Probability, 1, 281–297.
3. Arthur, D., & Vassilvitskii, S. (2007). k-means++: The advantages of careful seeding. Proceedings of the 18th ACM-SIAM Symposium on Discrete Algorithms (SODA), 1027–1035.
4. Rousseeuw, P. J. (1987). Silhouettes: A graphical aid to the interpretation and validation of cluster analysis. Journal of Computational and Applied Mathematics, 20, 53–65.
5. Tibshirani, R., Walther, G., & Hastie, T. (2001). Estimating the number of clusters in a data set via the gap statistic. Journal of the Royal Statistical Society: Series B, 63(2), 411–423.
6. Aloise, D., Deshpande, A., Hansen, P., & Popat, P. (2009). NP-hardness of Euclidean sum-of-squares clustering. Machine Learning, 75(2), 245–248.
7. Sculley, D. (2010). Web-scale k-means clustering. Proceedings of WWW 2010, 1177–1178.
8. Wu, X. et al. (2008). Top 10 algorithms in data mining. Knowledge and Information Systems, 14(1), 1–37.
9. Tài liệu chính thức scikit-learn: Clustering – K-means.