06聚類演算法-程式碼案例二-K-Means演算法和MiniBatchK-Means演算法比較

白爾摩斯發表於2018-12-08

03 聚類演算法 – K-means聚類
 04 聚類演算法 – 程式碼案例一 – K-means聚類
 05 聚類演算法 – 二分K-Means、K-Means++、K-Means||、Canopy、Mini Batch K-Means演算法

常規操作：

import time  
import numpy as np  
import matplotlib.pyplot as plt  
import matplotlib as mpl
from sklearn.cluster import MiniBatchKMeans, KMeans  
from sklearn.metrics.pairwise import pairwise_distances_argmin  
from sklearn.datasets.samples_generator import make_blobs  

## 設定屬性防止中文亂碼
mpl.rcParams[`font.sans-serif`] = [u`SimHei`]
mpl.rcParams[`axes.unicode_minus`] = False

一、初始化三個中心

centers = [[1, 1], [-1, -1], [1, -1]] 
clusters = len(centers)  #聚類的數目為3

產生3000組二維的資料，中心是意思三個中心點，標準差是0.7

X, Y = make_blobs(n_samples=3000, centers=centers, cluster_std=0.7, random_state=28)

二、構建kmeans演算法

k_means = KMeans(init=`k-means++`, n_clusters=clusters, random_state=28)
t0 = time.time() #當前時間
k_means.fit(X)  #訓練模型
km_batch = time.time() - t0  #使用kmeans訓練資料的消耗時間
print ("K-Means演算法模型訓練消耗時間:%.4fs" % km_batch)

K-Means演算法模型訓練消耗時間:0.1861s

三、構建MiniBatchKMeans演算法

batch_size = 100
mbk = MiniBatchKMeans(init=`k-means++`, n_clusters=clusters, 
    batch_size=batch_size, random_state=28)  
t0 = time.time()  
mbk.fit(X)  
mbk_batch = time.time() - t0  
print ("Mini Batch K-Means演算法模型訓練消耗時間:%.4fs" % mbk_batch)

Mini Batch K-Means演算法模型訓練消耗時間:0.1511s

四、預測結果

km_y_hat = k_means.predict(X)
mbkm_y_hat = mbk.predict(X)

五、獲取聚類中心點並聚類中心點進行排序（方便後面畫圖）

#輸出kmeans聚類中心點
k_means_cluster_centers = k_means.cluster_centers_

#輸出mbk聚類中心點
mbk_means_cluster_centers = mbk.cluster_centers_
print ("K-Means演算法聚類中心點:
center=", k_means_cluster_centers)
print ("Mini Batch K-Means演算法聚類中心點:
center=", mbk_means_cluster_centers)
order = pairwise_distances_argmin(k_means_cluster_centers,  
                                  mbk_means_cluster_centers)

K-Means演算法聚類中心點:
center= [[-1.0600799 -1.05662982]
[ 1.02975208 -1.07435837]
[ 1.01491055 1.02216649]]
Mini Batch K-Means演算法聚類中心點:
center= [[ 0.99602094 1.10688195]
[-1.00828286 -1.05983915]
[ 1.07892315 -0.94286826]]

六、畫圖

plt.figure(figsize=(12, 6), facecolor=`w`)
plt.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.9)
cm = mpl.colors.ListedColormap([`#FFC2CC`, `#C2FFCC`, `#CCC2FF`])
cm2 = mpl.colors.ListedColormap([`#FF0000`, `#00FF00`, `#0000FF`])

1、原始資料

plt.subplot(221)
plt.scatter(X[:, 0], X[:, 1], c=Y, s=6, cmap=cm, edgecolors=`none`)
plt.title(u`原始資料分佈圖`)
plt.xticks(())
plt.yticks(())
plt.grid(True)

2、K-Means演算法聚類結果圖

plt.subplot(222)
plt.scatter(X[:,0], X[:,1], c=km_y_hat, s=6, cmap=cm,edgecolors=`none`)
plt.scatter(k_means_cluster_centers[:,0],  
     k_means_cluster_centers[:,1],c=range(clusters),s=60,cmap=cm2,edgecolors=`none`)
plt.title(u`K-Means演算法聚類結果圖`)
plt.xticks(())
plt.yticks(())
plt.text(-3.8, 3,  `train time: %.2fms` % (km_batch*1000))  
plt.grid(True)

3、Mini Batch K-Means演算法聚類結果圖

plt.subplot(223)
plt.scatter(X[:,0], X[:,1], c=mbkm_y_hat, s=6, cmap=cm,edgecolors=`none`)
plt.scatter(mbk_means_cluster_centers[:,0], 
    mbk_means_cluster_centers[:,1],c=range(clusters),s=60,cmap=cm2,edgecolors=`none`)
plt.title(u`Mini Batch K-Means演算法聚類結果圖`)
plt.xticks(())
plt.yticks(())
plt.text(-3.8, 3,  `train time: %.2fms` % (mbk_batch*1000))  
plt.grid(True)

different = list(map(lambda x: (x!=0) & (x!=1) & (x!=2), mbkm_y_hat))
for k in range(clusters):  
    different += ((km_y_hat == k) != (mbkm_y_hat == order[k]))
identic = np.logical_not(different)
different_nodes = len(list(filter(lambda x:x, different)))

4、Mini Batch K-Means和K-Means演算法預測結果不同的點

plt.subplot(224)
plt.plot(X[identic, 0], X[identic, 1], `w`, markerfacecolor=`#bbbbbb`, marker=`.`)  
plt.plot(X[different, 0], X[different, 1], `w`, markerfacecolor=`m`, marker=`.`)  
plt.title(u`Mini Batch K-Means和K-Means演算法預測結果不同的點`)  
plt.xticks(())  
plt.yticks(())
plt.text(-3.8, 2,  `different nodes: %d` % (different_nodes))