Bỏ qua đến nội dung chính
Mục lục

K-means clustering: n_init, inertia_ và scale dữ liệu

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 1/7 · Chương 8

Học không giám sát

  • 10 phút
  • Trung cấp
  • Python 3.14
  • Cập nhật

Thuật toán K-means chia các dòng của một bảng thành K cụm bằng hai bước lặp lại: gán mỗi điểm vào tâm gần nó nhất, rồi dời mỗi tâm về trung bình các điểm vừa gán, cho tới khi không điểm nào đổi cụm. Bạn dùng nó khi có bảng khách hàng mà không có cột nhãn nào, và muốn biết khách tự chia thành mấy kiểu mua sắm giống nhau.

Cần biết trước: StandardScaler, log1p cho cột lệch phải và groupby.

Hai bước của K-means: gán điểm, dời tâm

Khác học có giám sát, ở đây không có cột đáp án để model bắt chước. K-means chỉ cố làm cho các điểm nằm sát tâm cụm của chúng, và đo độ sát đó bằng inertia:

J=∑i=1n∑j=1p(xij−μcij)2J = \sum_{i=1}^{n} \sum_{j=1}^{p} (x_{ij} - \mu_{c_i j})^2

Trong đó:

  • n (len(X)): số điểm, mỗi điểm là một dòng của bảng; p: số cột.

  • x_ij: giá trị cột thứ j của điểm thứ i.

  • c_i (labels_[i]): số thứ tự cụm của điểm thứ i.

  • μ_cj (cluster_centers_): giá trị cột thứ j của tâm cụm c, bằng trung bình các điểm trong cụm.

  • J (inertia_): cộng dồn, trên mọi điểm, bình phương khoảng cách tới tâm cụm mà điểm đó thuộc về.

Cả hai bước đều không làm J tăng: điểm chọn tâm gần hơn, và trung bình là điểm có tổng bình phương khoảng cách nhỏ nhất tới một nhóm số. Vì vậy vòng lặp dừng sau hữu hạn vòng.

Tính tay ba vòng trên sáu khách

Sáu khách, mỗi khách hai số: số đơn trong 12 tháng và số danh mục đã mua. Hai tâm ban đầu đặt ngay ở hai khách đầu, cả hai nằm trong nhóm mua ít. Cột J tính sau khi dời tâm:

Vòng

Nhãn sau bước gán

Tâm 0

Tâm 1

J

1

0, 1, 1, 1, 1, 1

(2, 1)

(14.8, 4.4)

468

2

0, 0, 0, 1, 1, 1

(3, 1.33)

(22.33, 6.33)

16

3

0, 0, 0, 1, 1, 1

(3, 1.33)

(22.33, 6.33)

16

Khối dưới làm đúng các bước đó bằng Python thuần, không thư viện:

python
diem = [(2, 1), (3, 1), (4, 2), (20, 6), (22, 7), (25, 6)]
tam = [diem[0], diem[1]]
def bp(p, q):
    return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2

def tam_moi(nhan, k):
    nhom = [p for p, c in zip(diem, nhan) if c == k]
    return (sum(x for x, _ in nhom) / len(nhom),
            sum(y for _, y in nhom) / len(nhom))
for vong in range(1, 4):
    nhan = [int(bp(p, tam[1]) < bp(p, tam[0])) for p in diem]
    tam = [tam_moi(nhan, 0), tam_moi(nhan, 1)]
    J = sum(bp(p, tam[c]) for p, c in zip(diem, nhan))
    print(vong, nhan, [(round(x, 2), round(y, 2)) for x, y in tam],
          J)

KẾT QUẢ

1 [0, 1, 1, 1, 1, 1] [(2.0, 1.0), (14.8, 4.4)] 468.0
2 [0, 0, 0, 1, 1, 1] [(3.0, 1.33), (22.33, 6.33)] 16.0
3 [0, 0, 0, 1, 1, 1] [(3.0, 1.33), (22.33, 6.33)] 16.0

Ở vòng 1 khách thứ ba bị kéo sang tâm 1, vì tâm 0 đứng đúng ở khách đầu. Từ vòng 2 hai nhóm đã đúng, vòng 3 không đổi gì nên thuật toán dừng. Đổi diem[1] thành diem[5] rồi chạy lại: ngay vòng 1, J đã là 16.0.

KMeans trong scikit-learn

KMeans làm cùng việc trên mảng NumPy. Ghi rõ ba tham số: n_clusters là K, n_init là số lần chạy lại từ các bộ tâm ban đầu khác nhau, random_state cố định các bộ tâm đó:

python
import numpy as np
from sklearn.cluster import KMeans

X = np.array([[2, 1], [3, 1], [4, 2], [20, 6], [22, 7], [25, 6]])
km = KMeans(n_clusters=2, n_init=10, random_state=0).fit(X)
print("labels_:", km.labels_)
print("cluster_centers_:")
print(km.cluster_centers_.round(2))
print("inertia_:", round(km.inertia_, 2))

KẾT QUẢ

labels_: [1 1 1 0 0 0]
cluster_centers_:
[[22.33  6.33]
 [ 3.    1.33]]
inertia_: 16.0

Tâm và inertia khớp vòng cuối của bảng tính tay. Số thứ tự cụm chỉ là cái tên: nhóm mua nhiều mang số 0 ở đây, nhưng có thể mang số 1 với bộ tâm ban đầu khác.

n_init: chạy lại từ nhiều bộ tâm ban đầu

K-means chỉ đi xuống từ chỗ xuất phát, nên một bộ tâm ban đầu xấu có thể dừng ở một cách chia tệ. Khối dưới sinh ba đám điểm, rồi chạy 20 lần, mỗi lần một bộ tâm chọn ngẫu nhiên (init="random", n_init=1):

python
import numpy as np
from sklearn.cluster import KMeans

rng = np.random.default_rng(7)
tam_that = np.array([[0, 0], [5, 0], [2.5, 4]])
X = np.vstack([rng.normal(c, 0.8, (60, 2)) for c in tam_that])
moi_lan = [KMeans(3, init="random", n_init=1, random_state=s)
           .fit(X).inertia_ for s in range(20)]
tot_nhat = min(moi_lan)
so_lan_tot = sum(abs(j - tot_nhat) < 1e-6 for j in moi_lan)
print("Inertia tốt nhất:", round(tot_nhat, 1))
print("Inertia tệ nhất: ", round(max(moi_lan), 1))
print("Số lần đạt tốt nhất:", so_lan_tot, "/ 20")
gop = KMeans(3, init="random", n_init=10, random_state=0).fit(X)
print("n_init=10:", round(gop.inertia_, 1))

KẾT QUẢ

Inertia tốt nhất: 190.6
Inertia tệ nhất:  876.3
Số lần đạt tốt nhất: 18 / 20
n_init=10: 190.6

Lần chạy này: 18 trên 20 lần đạt inertia 190,6, hai lần dừng ở 876,3, vì hai tâm chia nhau một đám còn một tâm ôm hai đám. n_init=10 chạy mười lần rồi giữ lần có inertia_ nhỏ nhất. Mặc định của scikit-learn 1.8 là n_init="auto", chỉ một lần chạy với cách đặt tâm k-means++, nên bài luôn ghi n_init=10. Đổi hạt giống 7 thành số khác rồi chạy lại để xem tỉ lệ đổi theo.

Scale trước khi phân cụm

Bảng chi_tieu_khach_hang.csv (số giả lập của AIDev) có 1.500 khách của chuỗi Sóc Nhanh, sáu cột số: số ngày từ lần mua cuối, số đơn, tổng chi và giá trị đơn trung bình (nghìn đồng), tỉ lệ đơn có giảm giá, số danh mục. Mỗi cột góp bình phương chênh lệch của nó vào khoảng cách, nên cột có số lớn quyết định khoảng cách.

np.log1p kéo các cột lệch phải (tổng chi từ 121 nghìn tới gần 280 triệu) về gần đối xứng, StandardScaler đưa sáu cột về cùng thang; bài chọn scaler bàn thêm về ngoại lai. Phân cụm xong, đọc từng cụm bằng trung vị trên bảng gốc, để số vẫn là ngày, đơn và nghìn đồng:

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

kh = pd.read_csv("chi_tieu_khach_hang.csv").drop(columns="ma_kh")
lech = kh.columns[:4]  # bốn cột đếm và tiền
X = kh.copy()
X[lech] = np.log1p(X[lech])
Z = StandardScaler().fit_transform(X)
km = KMeans(n_clusters=4, n_init=10, random_state=0).fit(Z)
print(np.bincount(km.labels_))
cot = ["so_ngay_tu_lan_mua_cuoi", "so_don_12_thang",
       "tong_chi_12_thang_nghin", "ti_le_don_giam_gia"]
print(kh.groupby(km.labels_)[cot].median())

KẾT QUẢ

[443 398 371 288]
   so_ngay_tu_lan_mua_cuoi  so_don_12_thang  \
0                     69.0              5.0   
1                     26.0             14.0   
2                    194.0              1.0   
3                     13.0             27.0   

   tong_chi_12_thang_nghin  ti_le_don_giam_gia  
0                   1452.0                0.24  
1                   2637.5                0.70  
2                    379.0                0.28  
3                  17206.0                0.12  

Bốn cụm giờ có cỡ gần nhau và khác nhau ở nhiều cột. Cụm 3 có lần mua cuối gần nhất, số đơn và tổng chi cao nhất. Cụm 1 dùng mã giảm giá ở 70% số đơn. Cụm 0 hơn hai tháng chưa quay lại, cụm 2 chỉ mua một lần từ lâu. Đặt tên và chọn số cụm là việc của bài chọn số cụm K.

Kiểm tra nhanh

  1. Trong bảng tính tay sáu khách, nếu bỏ khách thứ ba (4 đơn, 2 danh mục) thì vòng 1 gán năm khách còn lại vào tâm nào?

    • Cả năm khách vào tâm 0
    • Khách đầu vào tâm 0, bốn khách còn lại vào tâm 1
    • Hai khách đầu vào tâm 0, ba khách cuối vào tâm 1
  2. Sau from sklearn.cluster import KMeans, KMeans(n_clusters=2, n_init=10, random_state=0).fit([[0], [2], [10], [12]]).inertia_ cho kết quả gì?

    • 4.0
    • 2.0
    • 8.0
    • 0.0
  3. Những câu nào đúng về n_init?

    • n_init=10 chạy K-means mười lần từ mười bộ tâm ban đầu rồi giữ lần có inertia_ nhỏ nhất
    • Mỗi lần chạy K-means luôn tới cùng một cách chia, nên n_init chỉ làm chậm
    • Một bộ tâm ban đầu xấu có thể làm K-means dừng ở cách chia có inertia cao hơn
    • n_init là số vòng gán điểm, dời tâm của một lần chạy
  4. Trong pitfall chạy K-means trên cột gốc, vì sao một cụm có 1.249 khách?

    • Vì n_init=10 quá nhỏ cho 1.500 khách
    • Vì K-means luôn tạo một cụm lớn và các cụm nhỏ
    • Vì tổng chi tính bằng nghìn đồng lớn hơn các cột khác hàng nghìn lần, nên khoảng cách gần như chỉ đo tổng chi
Đúng hết lần đầu +15 XP

Bài tập

Đổi tâm cụm về đơn vị gốc

kh là một DataFrame các cột số dương, cac_cot là list tên các cột cần phân cụm, k là số cụm. Viết thân hàm tam_cum_goc(kh, cac_cot, k):

  • lấy np.log1p của các cột cac_cot, rồi chuẩn hóa bằng StandardScaler;

  • phân cụm bằng KMeans(n_clusters=k, n_init=10, random_state=0);

  • đổi cluster_centers_ về đơn vị gốc: inverse_transform() của scaler làm ngược bước chuẩn hóa, np.expm1 làm ngược bước log;

  • sắp các tâm theo cột đầu của cac_cot tăng dần.

Hàm không sửa bảng kh của nơi gọi.

Trả về: mỗi dòng một tâm, mỗi cột theo thứ tự cac_cot, một ndarray.

Ví dụ với tám khách có so_don 1, 2, 2, 3, 20, 25, 30, 40, tong_chi 200, 300, 250, 400, 9000, 12000, 15000, 20000 và k = 2, hai tâm là khoảng (1.91; 278.35) và (27.86; 13416.45).

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

def tam_cum_goc(kh, cac_cot, k):
    pass  # Viết thân hàm thay cho dòng này

Tóm tắt

  • K-means lặp hai bước: gán mỗi điểm vào tâm gần nhất, dời mỗi tâm về trung bình các điểm của nó.

  • inertia_ đo các điểm nằm sát tâm cụm tới đâu; không vòng nào làm nó tăng.

  • n_init=10 chạy từ mười bộ tâm ban đầu và giữ lần có inertia_ nhỏ nhất; random_state cố định các bộ tâm.

  • labels_ cho biết mỗi dòng rơi vào cụm số mấy, cluster_centers_ là tọa độ các tâm; số thứ tự không mang nghĩa.

  • Trước khi phân cụm, log các cột lệch phải và scale mọi cột, rồi đọc cụm bằng trung vị trên bảng gốc.

Câu hỏi thường gặp

K-means là gì, khác KNN ở đâu?

K-means không cần cột nhãn: nó tự tìm K nhóm. KNN là model có giám sát, đoán nhãn của một dòng mới từ K dòng gần nó nhất đã có nhãn. Chữ K của hai thuật toán là hai thứ khác nhau: số cụm và số hàng xóm. Bài KNN dạy thuật toán thứ hai.

Làm sao biết nên chọn bao nhiêu cụm?

K-means không tự chọn K. Bạn chạy với nhiều K, nhìn inertia giảm tới đâu thì chững lại, đo silhouette, rồi đối chiếu với việc mỗi nhóm sẽ được dùng ra sao. Bài chọn số cụm K làm đủ ba việc đó trên cùng bảng khách này.

Vì sao chạy lại KMeans thì cụm 0 thành cụm 2?

Vì số thứ tự cụm phụ thuộc bộ tâm ban đầu, mà bộ tâm này chọn ngẫu nhiên khi không có random_state. Cố định random_state để kết quả lặp lại được, và luôn gọi tên một cụm theo trung vị các cột của nó, không theo con số; bài phân cụm phân cấp giới thiệu một thước đo so hai cách chia bỏ qua chuyện đánh số.

Chủ đề

k means

Dữ liệu của bài

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập