K-means clustering: n_init, inertia_ và scale dữ liệu
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
Trong bài này · 12
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:
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:
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 đó:
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.0Tâ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):
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.6Lầ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:
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
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
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.02.08.00.0
Những câu nào đúng về
n_init?n_init=10chạ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_initchỉ 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_initlà số vòng gán điểm, dời tâm của một lần chạy
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=10quá 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
- Vì
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.log1pcủa các cộtcac_cot, rồi chuẩn hóa bằngStandardScaler;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.expm1làm ngược bước log;sắp các tâm theo cột đầu của
cac_cottă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).
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àyTó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=10chạy từ mười bộ tâm ban đầu và giữ lần cóinertia_nhỏ nhất;random_statecố đị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ủ đề
Dữ liệu của bài
- Tải xuống
chi_tieu_khach_hang.csv
CSV · 41.72 KB
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
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.