sklearn 中的聚類方法的使用

本文轉載自查看原文 2020-04-23 16:23 1707 聚類算法/ sklearn

1.K-Means 算法：

KMeans(n_clusters, init, n_init, max_iter, tol, 
precompute_distances, verbose, random_state, copy_x, n_jobs, algorithm)

KMeans類的主要參數有：

　　　　1) n_clusters: 即我們的k值，一般需要多試一些值以獲得較好的聚類效果。k值好壞的評估標准在下面會講。

　　　　2）max_iter：最大的迭代次數，一般如果是凸數據集的話可以不管這個值，如果數據集不是凸的，可能很難收斂，此時可以指定最大的迭代次數讓算法可以及時退出循環。

　　　　3）n_init：用不同的初始化質心運行算法的次數。由於K-Means是結果受初始值影響的局部最優的迭代算法，因此需要多跑幾次以選擇一個較好的聚類效果，默認是10，一般不需要改。如果你的k值較大，則可以適當增大這個值。

　　　　4）init： 即初始值選擇的方式，可以為完全隨機選擇'random',優化過的'k-means++'或者自己指定初始化的k個質心。一般建議使用默認的'k-means++'。

　　　　5）algorithm：有“auto”, “full” or “elkan”三種選擇。"full"就是我們傳統的K-Means算法， “elkan”是我們原理篇講的elkan K-Means算法。默認的"auto"則會根據數據值是否是稀疏的，來決定如何選擇"full"和“elkan”。一般數據是稠密的，那么就是 “elkan”，否則就是"full"。一般來說建議直接用默認的"auto"

適用於大數據集的MiniBatchKMeans 算法：

MiniBatchKMeans類的主要參數比KMeans類稍多，主要有：

　　　　1) n_clusters: 即我們的k值，和KMeans類的n_clusters意義一樣。

　　　　2）max_iter：最大的迭代次數，和KMeans類的max_iter意義一樣。

　　　　3）n_init：用不同的初始化質心運行算法的次數。這里和KMeans類意義稍有不同，KMeans類里的n_init是用同樣的訓練集數據來跑不同的初始化質心從而運行算法。而MiniBatchKMeans類的n_init則是每次用不一樣的采樣數據集來跑不同的初始化質心運行算法。

　　　　4）batch_size：即用來跑Mini Batch KMeans算法的采樣集的大小，默認是100.如果發現數據集的類別較多或者噪音點較多，需要增加這個值以達到較好的聚類效果。

　　　　5）init： 即初始值選擇的方式，和KMeans類的init意義一樣。

　　　　6）init_size: 用來做質心初始值候選的樣本個數，默認是batch_size的3倍，一般用默認值就可以了。

　　　　7）reassignment_ratio: 某個類別質心被重新賦值的最大次數比例，這個和max_iter一樣是為了控制算法運行時間的。這個比例是占樣本總數的比例，乘以樣本總數就得到了每個類別質心可以重新賦值的次數。如果取值較高的話算法收斂時間可能會增加，尤其是那些暫時擁有樣本數較少的質心。默認是0.01。如果數據量不是超大的話，比如1w以下，建議使用默認值。如果數據量超過1w，類別又比較多，可能需要適當減少這個比例值。具體要根據訓練集來決定。

　　　　8）max_no_improvement：即連續多少個Mini Batch沒有改善聚類效果的話，就停止算法，和reassignment_ratio， max_iter一樣是為了控制算法運行時間的。默認是10.一般用默認值就足夠了。

來源於：劉建平的blog

　　　　K-Means的主要優點有：

　　　　1）原理比較簡單，實現也是很容易，收斂速度快。

　　　　2）聚類效果較優。

　　　　3）算法的可解釋度比較強。

　　　　4）主要需要調參的參數僅僅是簇數k。

　　　　K-Means的主要缺點有：

　　　　1）K值的選取不好把握

　　　　2）對於不是凸的數據集比較難收斂

　　　　3）如果各隱含類別的數據不平衡，比如各隱含類別的數據量嚴重失衡，或者各隱含類別的方差不同，則聚類效果不佳。

　　　　4）采用迭代方法，得到的結果只是局部最優。

　　　　5）對噪音和異常點比較的敏感。

k 值評估標准：

from sklearn.metrics import calinski_harabaz_score

計算公式為： $s(k) = \frac{tr(B_k)}{tr(W_k)} \frac{m-k}{k-1}$

其中m為訓練集樣本數，k為類別數。 $B_{k}$ 為類別之間的協方差矩陣， $W_{k}$ 為類別內部數據的協方差矩陣。tr為矩陣的跡。

類別內部數據的協方差越小越好，類別之間的協方差越大越好，這樣的Calinski-Harabasz分數會高.

#coding=gbk # 在scikit-learn中，包括兩個K-Means的算法，一個是傳統的K-Means算法，對應的類是KMeans。 # 另一個是基於采樣的Mini Batch K-Means算法，對應的類是MiniBatchKMeans。 # from sklearn.cluster import KMeans # km = KMeans(n_clusters, init, n_init, max_iter, tol, precompute_distances, verbose, random_state, copy_x, n_jobs, algorithm) import numpy as np import matplotlib.pyplot as plt from sklearn.datasets.samples_generator import make_blobs centers = [[-1,-1],[0,0], [1,1], [2,2]] cluster_std = [0.4, 0.2, 0.2, 0.2] X, y = make_blobs(n_samples=1000, n_features=2, centers = centers, cluster_std = cluster_std, random_state = 666) plt.scatter(X[:, 0], X[:, 1], marker='o') print(X.shape) # plt.show() from sklearn.cluster import KMeans km = KMeans(n_clusters=2, random_state = 666) #將數據集分為2類 y_pre = km.fit_predict(X) plt.scatter(X[:, 0], X[:, 1], c= y_pre) #c 為color 使得y_pre 的數據是另一種顏色。 # plt.show() print(y_pre[:5]) # [0 1 1 0 1] 將X 每行對應的數據 為y_pre 類 # 使用Calinski-Harabasz Index評估的聚類分數: 分數越高，表示聚類的效果越好 from sklearn.metrics import calinski_harabaz_score print(calinski_harabaz_score(X, y_pre)) # 3088.084577541466 #將簇分為3類 y_pre1 = KMeans(n_clusters=3, random_state=666).fit_predict(X) plt.scatter(X[:, 0], X[:, 1], c =y_pre1) # plt.show() print(calinski_harabaz_score(X, y_pre1)) # 2963.0232832196702 #將簇分為4類 y_pre2 = KMeans(n_clusters=4, random_state=666).fit_predict(X) plt.scatter(X[:, 0], X[:, 1], c=y_pre2) # plt.show() print(calinski_harabaz_score(X, y_pre2)) # 6154.881371748304 #使用MiniBatchKMeans 類， 使用batch size為200 from sklearn.cluster import MiniBatchKMeans for index, k in enumerate((2,3,4,5)): plt.subplot(2, 2, index+1) y_pre = MiniBatchKMeans(n_clusters=k, batch_size=200, random_state=666).fit_predict(X) score = calinski_harabaz_score(X, y_pre) plt.text(.99, .01, ('k=%d, score: %.2f'%(k, score)), transform=plt.gca().transAxes, size=10, horizontalalignment='right') plt.scatter(X[:, 0], X[:, 1], c=y_pre) plt.show()

2.BIRCH 聚類算法：

BIRCH 聚類是一種基於層次划分的算法，算法詳細原理可以參照：劉建平的blogs

摘自其算法小結：

BIRCH算法可以不用輸入類別數K值，這點和K-Means，Mini Batch K-Means不同。如果不輸入K值，則最后的CF元組的組數即為最終的K，否則會按照輸入的K值對CF元組按距離大小進行合並。

　　　　一般來說，BIRCH算法適用於樣本量較大的情況，這點和Mini Batch K-Means類似，但是BIRCH適用於類別數比較大的情況，而Mini Batch K-Means一般用於類別數適中或者較少的時候。BIRCH除了聚類還可以額外做一些異常點檢測和數據初步按類別規約的預處理。但是如果數據特征的維度非常大，比如大於20，則BIRCH不太適合，此時Mini Batch K-Means的表現較好。

　　　　對於調參，BIRCH要比K-Means，Mini Batch K-Means復雜，因為它需要對CF Tree的幾個關鍵的參數進行調參，這幾個參數對CF Tree的最終形式影響很大。

　　　　最后總結下BIRCH算法的優缺點：

　　　　BIRCH算法的主要優點有：

　　　　1) 節約內存，所有的樣本都在磁盤上，CF Tree僅僅存了CF節點和對應的指針。

　　　　2) 聚類速度快，只需要一遍掃描訓練集就可以建立CF Tree，CF Tree的增刪改都很快。

　　　　3) 可以識別噪音點，還可以對數據集進行初步分類的預處理

　　　　BIRCH算法的主要缺點有：

　　　　1) 由於CF Tree對每個節點的CF個數有限制，導致聚類的結果可能和真實的類別分布不同.

　　　　2) 對高維特征的數據聚類效果不好。此時可以選擇Mini Batch K-Means

　　　　3) 如果數據集的分布簇不是類似於超球體，或者說不是凸的，則聚類效果不好。

聚類算法	樣本量	特征維度	類別數，簇
K-Means	較小，凸數據集	較小	較小
MiniBatchKMeans	較大，凸數據集	> 20, 較大	適中或者較少
BIRCH	較大，凸數據集	< 20, 較小	較大
DBSCAN	，凸、非凸數據集

在CF Tree中，幾個關鍵的參數為內部節點的最大CF數B，葉子節點的最大CF數L，葉節點每個CF的最大樣本半徑閾值T。這三個參數定了，CF Tree的結構也基本確定了，最后的聚類效果也基本確定。可以說BIRCH的調參就是調試B,L和T。

　　至於類別數K，此時反而是可選的，不輸入K，則BIRCH會對CF Tree里各葉子節點CF中樣本的情況自己決定類別數K值，如果輸入K值，則BIRCH會CF Tree里各葉子節點CF進行合並，直到類別數為K。

BIRCH參數：

1) threshold:即葉節點每個CF的最大樣本半徑閾值T，它決定了每個CF里所有樣本形成的超球體的半徑閾值。一般來說threshold越小，則CF Tree的建立階段的規模會越大，即BIRCH算法第一階段所花的時間和內存會越多。但是選擇多大以達到聚類效果則需要通過調參決定。默認值是0.5.如果樣本的方差較大，則一般需要增大這個默認值。

　　　　2) branching_factor：即CF Tree內部節點的最大CF數B，以及葉子節點的最大CF數L。這里scikit-learn對這兩個參數進行了統一取值。也就是說，branching_factor決定了CF Tree里所有節點的最大CF數。默認是50。如果樣本量非常大，比如大於10萬，則一般需要增大這個默認值。選擇多大的branching_factor以達到聚類效果則需要通過和threshold一起調參決定

　　　　3）n_clusters：即類別數K，在BIRCH算法是可選的，如果類別數非常多，我們也沒有先驗知識，則一般輸入None，此時BIRCH算法第4階段不會運行。但是如果我們有類別的先驗知識，則推薦輸入這個可選的類別值。默認是3，即最終聚為3類。

　　　　4）compute_labels：布爾值，表示是否標示類別輸出，默認是True。一般使用默認值挺好，這樣可以看到聚類效果。

#coding=gbk import numpy as np import matplotlib.pyplot as plt from sklearn.datasets.samples_generator import make_blobs centers = [[-1,-1],[0,0], [1,1], [2,2]] cluster_std = [0.4, 0.3, 0.4, 0.2] X, y = make_blobs(n_samples=1000, n_features=2, centers = centers, cluster_std = cluster_std, random_state = 666) # plt.scatter(X[:, 0], X[:, 1], marker='o') # print(X.shape) # plt.show() print(y.shape) # plt.scatter(X[:, 0], X[:, 1], c= y) #原數據的散點圖 # plt.show() from sklearn.cluster import Birch from sklearn.metrics import calinski_harabaz_score y_pre = Birch(n_clusters=None).fit_predict(X) plt.scatter(X[:,0], X[:,1], c= y_pre) # plt.show() print(calinski_harabaz_score(X, y_pre)) # 2868.147538476159 #我們知道原來的簇就是4類， 當輸入的簇是 4 的時候 y_pre1 = Birch(n_clusters=4).fit_predict(X) plt.scatter(X[:, 0], X[:, 1], c=y_pre1) # plt.show() print(calinski_harabaz_score(X, y_pre1)) # 3678.4610499009887 # 對於threshold和branching_factor我們前面還沒有去調參，使用了默認的threshold值0.5和默認的branching_factor值50 #將閾值降低 y_pre2 = Birch(n_clusters=4, threshold=0.3).fit_predict(X) print(calinski_harabaz_score(X, y_pre2)) # 3598.0354960257487 反而降低了 y_pre3 = Birch(n_clusters=4, threshold=0.1).fit_predict(X) print(calinski_harabaz_score(X, y_pre3)) # 3427.014275063579 #將默認的branching_factor 降低 y_pre4 = Birch(n_clusters=4, branching_factor=20).fit_predict(X) print(calinski_harabaz_score(X, y_pre4)) # 3678.4610499009887 #未改變 y_pre5 = Birch(n_clusters=4, branching_factor=10,).fit_predict(X) print(calinski_harabaz_score(X, y_pre5)) # 3678.4610499009887 y_pred = Birch(n_clusters=4, branching_factor=80).fit_predict(X) print(calinski_harabaz_score(X, y_pred)) #3678.4610499009887

3、DBSCAN 算法（(Density-Based Spatial Clustering of Applications with Noise，具有噪聲的基於密度的聚類方法）

DBSCAN 算法是一種基於密度的聚類算法。

DBSCAN 算法是一種基於密度的聚類算法：
　　1.聚類的時候不需要預先指定簇的個數
　　2.最終的簇的個數不確定
DBSCAN算法將數據點分為三類：
　　1.核心點：在半徑Eps內含有超過MinPts數目的點。
　　2.邊界點：在半徑Eps內點的數量小於MinPts,但是落在核心點的鄰域內的點。
　　3.噪音點：既不是核心點也不是邊界點的點。

轉存失敗重新上傳取消

圖中黃色的點為邊界點（以其為中心點），因為在半徑Eps內，它領域內的點不超過MinPts個，我們這里設置的MinPts為5。

DBSCAN 算法小節：算法的優缺點：

和傳統的K-Means算法相比，DBSCAN最大的不同就是不需要輸入類別數k，當然它最大的優勢是可以發現任意形狀的聚類簇，而不是像K-Means，一般僅僅使用於凸的樣本集聚類。同時它在聚類的同時還可以找出異常點，這點和BIRCH算法類似。

　　　　那么我們什么時候需要用DBSCAN來聚類呢？一般來說，如果數據集是稠密的，並且數據集不是凸的，那么用DBSCAN會比K-Means聚類效果好很多。如果數據集不是稠密的，則不推薦用DBSCAN來聚類。

　　　　下面對DBSCAN算法的優缺點做一個總結。

　　DBSCAN的主要優點有：

　　　　1）可以對任意形狀的稠密數據集進行聚類，相對的，K-Means之類的聚類算法一般只適用於凸數據集。

　　　　2）可以在聚類的同時發現異常點，對數據集中的異常點不敏感。

　　　　3）聚類結果沒有偏倚，相對的，K-Means之類的聚類算法初始值對聚類結果有很大影響。

　　DBSCAN的主要缺點有：

　　　　1）如果樣本集的密度不均勻、聚類間距差相差很大時，聚類質量較差，這時用DBSCAN聚類一般不適合。

　　　　2）如果樣本集較大時，聚類收斂時間較長，此時可以對搜索最近鄰時建立的KD樹或者球樹進行規模限制來改進。

　　　　3）調參相對於傳統的K-Means之類的聚類算法稍復雜，主要需要對距離閾值ϵ，鄰域樣本數閾值MinPts聯合調參，不同的參數組合對最后的聚類效果有較大影響。

from : 劉建平的blog

DBSCAN 算法的參數調節：

1）eps： DBSCAN算法參數，即ϵ-鄰域的距離閾值，和樣本距離超過ϵϵ的樣本點不在ϵϵ-鄰域內。默認值是0.5.一般需要通過在多組值里面選擇一個合適的閾值。eps過大，則更多的點會落在核心對象的ϵϵ-鄰域，此時我們的類別數可能會減少，本來不應該是一類的樣本也會被划為一類。反之則類別數可能會增大，本來是一類的樣本卻被划分開。

　　　　2）min_samples： DBSCAN算法參數，即樣本點要成為核心對象所需要的ϵϵ-鄰域的樣本數閾值。默認值是5. 一般需要通過在多組值里面選擇一個合適的閾值。通常和eps一起調參。在eps一定的情況下，min_samples過大，則核心對象會過少，此時簇內部分本來是一類的樣本可能會被標為噪音點，類別數也會變多。反之min_samples過小的話，則會產生大量的核心對象，可能會導致類別數過少。

　　　　3）metric：最近鄰距離度量參數。可以使用的距離度量較多，一般來說DBSCAN使用默認的歐式距離（即p=2的閔可夫斯基距離）就可以滿足我們的需求。可以使用的距離度量參數有：

　　　　a) 歐式距離 “euclidean”: $\sqrt{\sum\limits_{i=1}^{n}(x_i-y_i)^2}$

　　　　b) 曼哈頓距離 “manhattan”： $\sum\limits_{i=1}^{n}|x_i-y_i|$

　　　　c) 切比雪夫距離“chebyshev”:

　　　　d) 閔可夫斯基距離 “minkowski”: $\sqrt[p]{\sum\limits_{i=1}^{n}(|x_i-y_i|)^p}$ p=1為曼哈頓距離， p=2為歐式距離。

　　　　e) 帶權重閔可夫斯基距離 “wminkowski”: $\sqrt[p]{\sum\limits_{i=1}^{n}(w*|x_i-y_i|)^p}$ 其中w為特征權重

　　　　f) 標准化歐式距離 “seuclidean”: 即對於各特征維度做了歸一化以后的歐式距離。此時各樣本特征維度的均值為0，方差為1.

　　　　g) 馬氏距離“mahalanobis”： $\sqrt{(x-y)^TS^{-1}(x-y)}$ 其中， $S^{-1}$ 為樣本協方差矩陣的逆矩陣。當樣本分布獨立時， S為單位矩陣，此時馬氏距離等同於歐式距離。

　　還有一些其他不是實數的距離度量，一般在DBSCAN算法用不上，這里也就不列了。

　　　　4）algorithm：最近鄰搜索算法參數，算法一共有三種，第一種是蠻力實現，第二種是KD樹實現，第三種是球樹實現。這三種方法在K近鄰法(KNN)原理小結中都有講述，如果不熟悉可以去復習下。對於這個參數，一共有4種可選輸入，‘brute’對應第一種蠻力實現，‘kd_tree’對應第二種KD樹實現，‘ball_tree’對應第三種的球樹實現， ‘auto’則會在上面三種算法中做權衡，選擇一個擬合最好的最優算法。需要注意的是，如果輸入樣本特征是稀疏的時候，無論我們選擇哪種算法，最后scikit-learn都會去用蠻力實現‘brute’。個人的經驗，一般情況使用默認的 ‘auto’就夠了。如果數據量很大或者特征也很多，用"auto"建樹時間可能會很長，效率不高，建議選擇KD樹實現‘kd_tree’，此時如果發現‘kd_tree’速度比較慢或者已經知道樣本分布不是很均勻時，可以嘗試用‘ball_tree’。而如果輸入樣本是稀疏的，無論你選擇哪個算法最后實際運行的都是‘brute’。

　　　　5）leaf_size：最近鄰搜索算法參數，為使用KD樹或者球樹時，停止建子樹的葉子節點數量的閾值。這個值越小，則生成的KD樹或者球樹就越大，層數越深，建樹時間越長，反之，則生成的KD樹或者球樹會小，層數較淺，建樹時間較短。默認是30. 因為這個值一般只影響算法的運行速度和使用內存大小，因此一般情況下可以不管它。

　　　　6） p: 最近鄰距離度量參數。只用於閔可夫斯基距離和帶權重閔可夫斯基距離中p值的選擇，p=1為曼哈頓距離， p=2為歐式距離。如果使用默認的歐式距離不需要管這個參數。

　　　　以上就是DBSCAN類的主要參數介紹，其實需要調參的就是兩個參數eps和min_samples，這兩個值的組合對最終的聚類效果有很大的影響。

#coding=gbk #DBSCAN 聚類算法的使用,生成3簇數據，兩組都是非凸的 import numpy as np import matplotlib.pyplot as plt from sklearn.datasets.samples_generator import make_circles, make_blobs #產生大小兩個圓的數據，noise高斯噪聲，factor:內圓和外圓之間的比例因子。 X1, y1 = make_circles(n_samples=5000, factor=0.6, noise=0.05, random_state=666) X2, y2 = make_blobs(n_samples=1000, n_features=2, centers =[[1.2,1.2]], cluster_std=[[0.1]], random_state=666 ) X = np.concatenate((X1, X2)) y = np.concatenate((y1, y2)) plt.scatter(X[:, 0], X[:, 1], marker='o', color='red') # plt.show() # help(make_circles) #使用KMeans進行聚類 from sklearn.cluster import KMeans from sklearn.metrics import calinski_harabaz_score y_km_pre = KMeans(n_clusters=3, random_state=666).fit_predict(X) plt.scatter(X[:, 0], X[:, 1], c=y_km_pre) # plt.show() print(calinski_harabaz_score(X, y_km_pre)) # 6662.414512503257 print('原來的聚類分簇的分數：'+ str(calinski_harabaz_score(X, y))) # 原來的聚類分簇的分數：373.350055300171, 不能使用此方法進行評定 #使用DBSCAN 算法進行調參 from sklearn.cluster import DBSCAN y_db_pre = DBSCAN(eps=0.5, min_samples=5).fit_predict(X) #使用默認參數 plt.scatter(X[:, 0], X[:, 1],c=y_db_pre) # plt.show() #DBSCAN 在不進行調參的情況下，將全部數據都分為是一類 # print(calinski_harabaz_score(X, y_db_pre)) 只有一類，無法計算 #先只是將領域減小 y_pre = DBSCAN(eps=0.1, min_samples=5).fit_predict(X) plt.scatter(X[:, 0], X[:,1], c=y_pre) # plt.show() print(calinski_harabaz_score(X, y_pre)) # 1387.9460424040549 #將領域減少並且增大周圍的樣本數 y_pre1 = DBSCAN(eps=0.1, min_samples=15).fit_predict(X) plt.scatter(X[:,0], X[:, 1], c=y_pre1) # plt.show() print(calinski_harabaz_score(X, y_pre1)) # 1387.9460424040549

4、譜聚類算法（spectral clustering）：

比起傳統的K-Means算法，譜聚類對數據分布的適應性更強，聚類效果也很優秀，同時聚類的計算量也小很多，更加難能可貴的是實現起來也不復雜。

譜聚類算法的優缺點：

譜聚類算法的主要優點有：

　　　　1）譜聚類只需要數據之間的相似度矩陣，因此對於處理稀疏數據的聚類很有效。這點傳統聚類算法比如K-Means 很難做到

　　　　2）由於使用了降維，因此在處理高維數據聚類時的復雜度比傳統聚類算法好。

譜聚類算法的主要缺點有：

　　　　1）如果最終聚類的維度非常高，則由於降維的幅度不夠，譜聚類的運行速度和最后的聚類效果均不好。

　　　　2) 聚類效果依賴於相似矩陣，不同的相似矩陣得到的最終聚類效果可能很不同。

from: blog

調參詳細參考：

#coding=gbk import numpy as np import time from sklearn.cluster import SpectralClustering from sklearn.datasets import make_blobs from sklearn.metrics import calinski_harabaz_score #生成500個 6 維的數據集， 分為 5 個簇 X, y = make_blobs(n_samples=500, n_features=6, centers=5, cluster_std=[0.4, 0.4, 0.3, 0.3, 0.4], random_state=666) print(X.shape) print(y.shape) y_pre = SpectralClustering().fit_predict(X) score = calinski_harabaz_score(X, y_pre) print('calinski_harabaz_score:'+ str(score)) # calinski_harabaz_score:11509.943254338412 #使用高斯核，對n_cluster 和 gamma 進行調參 start = time.clock() best_score, best_k, best_gamma = 0,0,0 for gamma in (0.01, 0.1, 1, 5): for k in (3, 4, 5, 6): y_pre = SpectralClustering(n_clusters=k, gamma=gamma).fit_predict(X) score = calinski_harabaz_score(X, y_pre) print('calinski_harabaz_score: %.3f, k value: % d, gamma value: %f'%(calinski_harabaz_score(X, y_pre), k, gamma)) if score > best_score: best_score = score best_k = k best_gamma = gamma print('best_score:%.3f, best_k: %d , best_gamma: %.3f'%(best_score, best_k, best_gamma)) end = time.clock() real_time = end -start print('spending time: %.3f '%real_time + 's')

(500, 6)
(500,)
calinski_harabaz_score:8470.922907812417
calinski_harabaz_score: 1015.206, k value:  3, gamma value: 0.010000
calinski_harabaz_score: 1739.986, k value:  4, gamma value: 0.010000
calinski_harabaz_score: 30624.310, k value:  5, gamma value: 0.010000
calinski_harabaz_score: 25497.191, k value:  6, gamma value: 0.010000
calinski_harabaz_score: 687.243, k value:  3, gamma value: 0.100000
calinski_harabaz_score: 1739.986, k value:  4, gamma value: 0.100000
calinski_harabaz_score: 30624.310, k value:  5, gamma value: 0.100000
calinski_harabaz_score: 25518.793, k value:  6, gamma value: 0.100000
calinski_harabaz_score: 161.824, k value:  3, gamma value: 1.000000
calinski_harabaz_score: 455.559, k value:  4, gamma value: 1.000000
calinski_harabaz_score: 30624.310, k value:  5, gamma value: 1.000000
calinski_harabaz_score: 25489.137, k value:  6, gamma value: 1.000000
calinski_harabaz_score: 56.004, k value:  3, gamma value: 5.000000
calinski_harabaz_score: 99.142, k value:  4, gamma value: 5.000000
calinski_harabaz_score: 98.842, k value:  5, gamma value: 5.000000
calinski_harabaz_score: 109.097, k value:  6, gamma value: 5.000000
best_score:30624.310, best_k: 5 , best_gamma: 0.010
spending time: 2.280 s

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 sklearn中各種分類方法聚類方法簡介聚類方法總結學習sklearn聚類使用顏色聚類方法綜述四種聚類方法之比較 single-pass單遍聚類方法 python實現一個層次聚類方法 Python中sklearn中的譜聚類代碼 sklearn中PCA的使用方法