Làm cách nào để xác định k khi sử dụng phân cụm k-nghĩa?

Tôi đã nghiên cứu về phân cụm k-nghĩa và một điều không rõ ràng là cách bạn chọn giá trị của k. Nó chỉ là một vấn đề của thử nghiệm và lỗi, hoặc có nhiều hơn cho nó?

Bạn có thể tối đa hóa Tiêu chí Thông tin Bayes (BIC):

BIC(C | X) = L(X | C) - (p / 2) * log n

trong đó L(X | C)khả năng đăng nhập của tập dữ liệu Xtheo mô hình C, plà số lượng tham số trong mô hình Cvà nlà số điểm trong tập dữ liệu. Xem "Phương tiện X: mở rộng K -means với ước tính hiệu quả số lượng cụm" của Dan Pelleg và Andrew Moore trong ICML 2000.

Một cách tiếp cận khác là bắt đầu với một giá trị lớn cho kvà tiếp tục loại bỏ centroid (giảm k) cho đến khi nó không còn làm giảm độ dài mô tả. Xem "Nguyên tắc MDL để định lượng véc tơ mạnh mẽ" của Horst Bischof, Ales Leonardis và Alexander Selb trong Phân tích mẫu và ứng dụng vol. 2, tr. 59-72, 1999.

Cuối cùng, bạn có thể bắt đầu với một cụm, sau đó tiếp tục tách cụm cho đến khi các điểm được gán cho mỗi cụm có phân phối Gaussian. Trong "Học k trong k -means" (NIPS 2003), Greg Hamerly và Charles Elkan cho thấy một số bằng chứng cho thấy điều này hoạt động tốt hơn BIC và BIC không xử phạt đủ độ phức tạp của mô hình.

Về cơ bản, bạn muốn tìm sự cân bằng giữa hai biến: số lượng cụm ( k ) và phương sai trung bình của các cụm. Bạn muốn giảm thiểu cái trước trong khi cũng giảm thiểu cái sau. Tất nhiên, khi số lượng cụm tăng lên, phương sai trung bình giảm (cho đến trường hợp tầm thường là k = n và phương sai = 0).

Như mọi khi trong phân tích dữ liệu, không có một phương pháp thực sự nào hoạt động tốt hơn tất cả các phương pháp khác trong mọi trường hợp. Cuối cùng, bạn phải sử dụng phán đoán tốt nhất của riêng bạn. Do đó, nó giúp vẽ đồ thị số cụm theo phương sai trung bình (giả định rằng bạn đã chạy thuật toán cho một vài giá trị của k ). Sau đó, bạn có thể sử dụng số lượng cụm ở đầu gối của đường cong.

Có, bạn có thể tìm thấy số cụm tốt nhất bằng phương pháp Elbow, nhưng tôi thấy thật khó khăn khi tìm giá trị của cụm từ biểu đồ khuỷu tay bằng cách sử dụng tập lệnh. Bạn có thể quan sát biểu đồ khuỷu tay và tự tìm điểm khuỷu tay, nhưng rất nhiều công việc tìm thấy nó từ kịch bản.

Vì vậy, một lựa chọn khác là sử dụng Phương pháp Silhouette để tìm nó. Kết quả từ Silhouette hoàn toàn tuân thủ kết quả từ phương pháp Elbow trong R.

Đây là những gì tôi đã làm.

#Dataset for Clustering
n = 150
g = 6 
set.seed(g)
d <- data.frame(x = unlist(lapply(1:g, function(i) rnorm(n/g, runif(1)*i^2))), 
                y = unlist(lapply(1:g, function(i) rnorm(n/g, runif(1)*i^2))))
mydata<-d
#Plot 3X2 plots
attach(mtcars)
par(mfrow=c(3,2))

#Plot the original dataset
plot(mydata$x,mydata$y,main="Original Dataset")

#Scree plot to deterine the number of clusters
wss <- (nrow(mydata)-1)*sum(apply(mydata,2,var))
  for (i in 2:15) {
    wss[i] <- sum(kmeans(mydata,centers=i)$withinss)
}   
plot(1:15, wss, type="b", xlab="Number of Clusters",ylab="Within groups sum of squares")

# Ward Hierarchical Clustering
d <- dist(mydata, method = "euclidean") # distance matrix
fit <- hclust(d, method="ward") 
plot(fit) # display dendogram
groups <- cutree(fit, k=5) # cut tree into 5 clusters
# draw dendogram with red borders around the 5 clusters 
rect.hclust(fit, k=5, border="red")

#Silhouette analysis for determining the number of clusters
library(fpc)
asw <- numeric(20)
for (k in 2:20)
  asw[[k]] <- pam(mydata, k) $ silinfo $ avg.width
k.best <- which.max(asw)

cat("silhouette-optimal number of clusters:", k.best, "\n")
plot(pam(d, k.best))

# K-Means Cluster Analysis
fit <- kmeans(mydata,k.best)
mydata 
# get cluster means 
aggregate(mydata,by=list(fit$cluster),FUN=mean)
# append cluster assignment
mydata <- data.frame(mydata, clusterid=fit$cluster)
plot(mydata$x,mydata$y, col = fit$cluster, main="K-means Clustering results")

Hy vọng nó giúp!!

Có thể là một người mới bắt đầu như tôi đang tìm kiếm ví dụ mã. thông tin cho Silhouette_score có sẵn ở đây.

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

range_n_clusters = [2, 3, 4]            # clusters range you want to select
dataToFit = [[12,23],[112,46],[45,23]]  # sample data
best_clusters = 0                       # best cluster number which you will get
previous_silh_avg = 0.0

for n_clusters in range_n_clusters:
    clusterer = KMeans(n_clusters=n_clusters)
    cluster_labels = clusterer.fit_predict(dataToFit)
    silhouette_avg = silhouette_score(dataToFit, cluster_labels)
    if silhouette_avg > previous_silh_avg:
        previous_silh_avg = silhouette_avg
        best_clusters = n_clusters

# Final Kmeans for best_clusters
kmeans = KMeans(n_clusters=best_clusters, random_state=0).fit(dataToFit)

Hãy xem bài báo này , "Học chữ k trong phương tiện k" của Greg Ham xưa, Charles Elkan. Nó sử dụng một bài kiểm tra Gaussian để xác định đúng số lượng cụm. Ngoài ra, các tác giả cho rằng phương pháp này tốt hơn BIC được đề cập trong câu trả lời được chấp nhận.

Có một thứ gọi là Rule of Thumb. Nó nói rằng số lượng các cụm có thể được tính bằng

k = (n/2)^0.5

Trong đó n là tổng số phần tử từ mẫu của bạn. Bạn có thể kiểm tra tính xác thực của thông tin này trên tờ giấy sau:

http://www.ijarcsms.com/docs/apers/volume1/su6/V1I6-0015.pdf

Ngoài ra còn có một phương pháp khác gọi là G-mean, trong đó phân phối của bạn tuân theo Phân phối Gaussian hoặc Phân phối chuẩn. Nó bao gồm tăng k cho đến khi tất cả các nhóm k của bạn tuân theo Phân phối Gaussian. Nó đòi hỏi rất nhiều số liệu thống kê nhưng có thể được thực hiện. Đây là nguồn:

http://auge.nips.cc/apers/2526-learning-the-k-in-k-means.pdf

Tôi hi vọng cái này giúp được!

Đầu tiên xây dựng một cây bao trùm tối thiểu của dữ liệu của bạn. Loại bỏ các cạnh đắt nhất của K-1 sẽ tách cây thành các cụm K,
do đó bạn có thể tạo MST một lần, xem xét các khoảng cách / số liệu của cụm cho K khác nhau và lấy đầu gối của đường cong.

Điều này chỉ hoạt động cho Single-linkage_clustering , nhưng vì nó nhanh và dễ dàng. Thêm vào đó, MST làm cho hình ảnh tốt.
Xem ví dụ về biểu đồ MST trong phần mềm trực quan thống kê.stackexchange để phân cụm .

Tôi ngạc nhiên không ai đã đề cập đến bài viết tuyệt vời này: http://www.ee.columbia.edu/~dpwe/ con / PolDN05-kmeans.pdf

Sau khi làm theo một số gợi ý khác, cuối cùng tôi cũng bắt gặp bài viết này khi đọc blog này: https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/

Sau đó tôi đã triển khai nó trong Scala, một triển khai cho các trường hợp sử dụng của tôi cung cấp kết quả thực sự tốt. Mã đây:

import breeze.linalg.DenseVector
import Kmeans.{Features, _}
import nak.cluster.{Kmeans => NakKmeans}

import scala.collection.immutable.IndexedSeq
import scala.collection.mutable.ListBuffer

/*
https://datasciencelab.wordpress.com/2014/01/21/selection-of-k-in-k-means-clustering-reloaded/
 */
class Kmeans(features: Features) {
  def fkAlphaDispersionCentroids(k: Int, dispersionOfKMinus1: Double = 0d, alphaOfKMinus1: Double = 1d): (Double, Double, Double, Features) = {
    if (1 == k || 0d == dispersionOfKMinus1) (1d, 1d, 1d, Vector.empty)
    else {
      val featureDimensions = features.headOption.map(_.size).getOrElse(1)
      val (dispersion, centroids: Features) = new NakKmeans[DenseVector[Double]](features).run(k)
      val alpha =
        if (2 == k) 1d - 3d / (4d * featureDimensions)
        else alphaOfKMinus1 + (1d - alphaOfKMinus1) / 6d
      val fk = dispersion / (alpha * dispersionOfKMinus1)
      (fk, alpha, dispersion, centroids)
    }
  }

  def fks(maxK: Int = maxK): List[(Double, Double, Double, Features)] = {
    val fadcs = ListBuffer[(Double, Double, Double, Features)](fkAlphaDispersionCentroids(1))
    var k = 2
    while (k <= maxK) {
      val (fk, alpha, dispersion, features) = fadcs(k - 2)
      fadcs += fkAlphaDispersionCentroids(k, dispersion, alpha)
      k += 1
    }
    fadcs.toList
  }

  def detK: (Double, Features) = {
    val vals = fks().minBy(_._1)
    (vals._3, vals._4)
  }
}

object Kmeans {
  val maxK = 10
  type Features = IndexedSeq[DenseVector[Double]]
}

Nếu bạn sử dụng MATLAB, bất kỳ phiên bản nào kể từ 2013b, bạn có thể sử dụng hàm evalclustersđể tìm ra mức tối ưu knào cho một tập dữ liệu đã cho.

Chức năng này cho phép bạn chọn từ trong số 3 thuật toán phân nhóm - kmeans, linkagevà gmdistribution.

Nó cũng cho phép bạn chọn trong số các tiêu chí đánh giá 4 phân nhóm - CalinskiHarabasz, DaviesBouldin, gapvà silhouette.

Nếu bạn không biết số lượng cụm k để cung cấp làm tham số cho phương tiện k, thì có bốn cách để tìm nó tự động:

• G-nghĩa là đại số: nó tự động phát hiện ra số cụm tự động bằng cách sử dụng kiểm tra thống kê để quyết định có nên chia trung tâm k-mean thành hai. Thuật toán này thực hiện một cách tiếp cận phân cấp để phát hiện số lượng cụm, dựa trên kiểm tra thống kê cho giả thuyết rằng một tập hợp dữ liệu tuân theo phân phối Gaussian (hàm liên tục xấp xỉ phân phối nhị thức chính xác của các sự kiện) và nếu không, nó sẽ phân tách cụm . Nó bắt đầu với một số lượng nhỏ các trung tâm, giả sử chỉ một cụm (k = 1), sau đó thuật toán chia nó thành hai trung tâm (k = 2) và chia tách hai trung tâm này một lần nữa (k = 4), có bốn trung tâm toàn bộ. Nếu G-nghĩa không chấp nhận bốn trung tâm này thì câu trả lời là bước trước: hai trung tâm trong trường hợp này (k = 2). Đây là số cụm mà tập dữ liệu của bạn sẽ được chia thành. G-mean rất hữu ích khi bạn không có ước tính về số lượng cụm bạn sẽ nhận được sau khi nhóm các thể hiện của bạn. Lưu ý rằng lựa chọn bất tiện cho tham số "k" có thể cho kết quả sai. Phiên bản song song của g-mean được gọi làphương tiện p . Nguồn G-mean: nguồn 1 nguồn 2 nguồn 3

• x-nghĩa : một thuật toán mới có hiệu quả, tìm kiếm không gian của các vị trí cụm và số lượng cụm để tối ưu hóa Tiêu chí Thông tin Bayes (BIC) hoặc tiêu chí Thông tin Akaike (AIC). Phiên bản k-mean này tìm thấy số k và cũng tăng tốc k-mean.

• Phương tiện k trực tuyến hoặc Truyền trực tuyến k-nghĩa: nó cho phép thực thi phương tiện k bằng cách quét toàn bộ dữ liệu một lần và nó tự động tìm thấy số k tối ưu. Spark thực hiện nó.

• Thuật toán MeanShift : đó là một kỹ thuật phân cụm không theo tỷ lệ, không đòi hỏi kiến ​​thức trước về số lượng cụm và không giới hạn hình dạng của các cụm. Phân cụm dịch chuyển trung bình nhằm mục đích khám phá các blobbs trong mật độ mẫu mịn. Nó là một thuật toán dựa trên centroid, hoạt động bằng cách cập nhật các ứng cử viên cho centroid là giá trị trung bình của các điểm trong một khu vực nhất định. Những ứng cử viên này sau đó được lọc trong giai đoạn hậu xử lý để loại bỏ các bản sao gần giống nhau để tạo thành tập trung tâm cuối cùng. Nguồn: source1 , source2 , source3

Tôi đã sử dụng giải pháp tôi tìm thấy ở đây: http://efavdb.com/mean-shift/ và nó hoạt động rất tốt với tôi:

import numpy as np
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets.samples_generator import make_blobs
import matplotlib.pyplot as plt
from itertools import cycle
from PIL import Image

#%% Generate sample data
centers = [[1, 1], [-.75, -1], [1, -1], [-3, 2]]
X, _ = make_blobs(n_samples=10000, centers=centers, cluster_std=0.6)

#%% Compute clustering with MeanShift

# The bandwidth can be automatically estimated
bandwidth = estimate_bandwidth(X, quantile=.1,
                               n_samples=500)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

n_clusters_ = labels.max()+1

#%% Plot result
plt.figure(1)
plt.clf()

colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for k, col in zip(range(n_clusters_), colors):
    my_members = labels == k
    cluster_center = cluster_centers[k]
    plt.plot(X[my_members, 0], X[my_members, 1], col + '.')
    plt.plot(cluster_center[0], cluster_center[1],
             'o', markerfacecolor=col,
             markeredgecolor='k', markersize=14)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()

Ý tưởng của tôi là sử dụng Hệ số Silhouette để tìm số cụm tối ưu (K). Chi tiết giải thích ở đây .

Giả sử bạn có một ma trận dữ liệu được gọi DATA, bạn có thể thực hiện phân vùng xung quanh các medoid với ước tính số lượng cụm (bằng phân tích hình bóng) như thế này:

library(fpc)
maxk <- 20  # arbitrary here, you can set this to whatever you like
estimatedK <- pamk(dist(DATA), krange=1:maxk)$nc

Một câu trả lời có thể là sử dụng Thuật toán Meta Heuristic như Thuật toán di truyền để tìm k. Điều đó thật đơn giản. bạn có thể sử dụng K ngẫu nhiên (trong một số phạm vi) và đánh giá chức năng phù hợp của Thuật toán di truyền với một số phép đo như Silhouette và Tìm cơ sở K tốt nhất trên chức năng phù hợp.

https://en.wikipedia.org/wiki/Sil Silhouette_(clustering)

km=[]
for i in range(num_data.shape[1]):
    kmeans = KMeans(n_clusters=ncluster[i])#we take number of cluster bandwidth theory
    ndata=num_data[[i]].dropna()
    ndata['labels']=kmeans.fit_predict(ndata.values)
    cluster=ndata
    co=cluster.groupby(['labels'])[cluster.columns[0]].count()#count for frequency
    me=cluster.groupby(['labels'])[cluster.columns[0]].median()#median
    ma=cluster.groupby(['labels'])[cluster.columns[0]].max()#Maximum
    mi=cluster.groupby(['labels'])[cluster.columns[0]].min()#Minimum
    stat=pd.concat([mi,ma,me,co],axis=1)#Add all column
    stat['variable']=stat.columns[1]#Column name change
    stat.columns=['Minimum','Maximum','Median','count','variable']
    l=[]
    for j in range(ncluster[i]):
        n=[mi.loc[j],ma.loc[j]] 
        l.append(n)

    stat['Class']=l
    stat=stat.sort(['Minimum'])
    stat=stat[['variable','Class','Minimum','Maximum','Median','count']]
    if missing_num.iloc[i]>0:
        stat.loc[ncluster[i]]=0
        if stat.iloc[ncluster[i],5]==0:
            stat.iloc[ncluster[i],5]=missing_num.iloc[i]
            stat.iloc[ncluster[i],0]=stat.iloc[0,0]
    stat['Percentage']=(stat[[5]])*100/count_row#Freq PERCENTAGE
    stat['Cumulative Percentage']=stat['Percentage'].cumsum()
    km.append(stat)
cluster=pd.concat(km,axis=0)## see documentation for more info
cluster=cluster.round({'Minimum': 2, 'Maximum': 2,'Median':2,'Percentage':2,'Cumulative Percentage':2})

Một cách tiếp cận khác là sử dụng Bản đồ tự tổ chức (SOP) để tìm số cụm tối ưu. SOM (Bản đồ tự tổ chức) là một phương pháp mạng thần kinh không giám sát, chỉ cần đầu vào được sử dụng để phân cụm để giải quyết vấn đề. Cách tiếp cận này được sử dụng trong một bài báo về phân khúc khách hàng.

Tài liệu tham khảo của bài báo là

Abdellah Amine và cộng sự, Mô hình phân khúc khách hàng trong thương mại điện tử sử dụng kỹ thuật phân cụm và mô hình LRFM: Trường hợp cửa hàng trực tuyến ở Morocco, Viện hàn lâm khoa học, kỹ thuật và công nghệ thế giới Tạp chí quốc tế về máy tính và kỹ thuật thông tin Vol: 9, No: 8 , 2015, 1999 - 2010

Xin chào, tôi sẽ làm cho nó đơn giản và dễ giải thích, tôi muốn xác định các cụm bằng thư viện 'NbClust'.

Bây giờ, làm thế nào để sử dụng hàm 'NbClust' để xác định đúng số cụm: Bạn có thể kiểm tra dự án thực tế trong Github với dữ liệu và cụm thực tế - Thuật toán mở rộng cho thuật toán 'kmeans' này cũng được thực hiện bằng cách sử dụng đúng số lượng 'tâm'.

Liên kết dự án Github: https://github.com/RutvijBhutaiya/Thailand-Customer-Engloyment-Facebook

Bạn có thể chọn số lượng cụm bằng cách kiểm tra trực quan các điểm dữ liệu của mình, nhưng bạn sẽ sớm nhận ra rằng có rất nhiều sự mơ hồ trong quy trình này cho tất cả ngoại trừ các tập dữ liệu đơn giản nhất. Điều này không phải lúc nào cũng xấu, bởi vì bạn đang học tập không giám sát và có một số sự chủ quan cố hữu trong quá trình ghi nhãn. Ở đây, có kinh nghiệm trước đó với vấn đề cụ thể hoặc một cái gì đó tương tự sẽ giúp bạn chọn đúng giá trị.

Nếu bạn muốn có một số gợi ý về số lượng cụm mà bạn nên sử dụng, bạn có thể áp dụng phương pháp Khuỷu tay:

Trước hết, tính tổng lỗi bình phương (SSE) cho một số giá trị của k (ví dụ 2, 4, 6, 8, v.v.). SSE được định nghĩa là tổng khoảng cách bình phương giữa mỗi thành viên của cụm và tâm của nó. Về mặt toán học:

SSE = ∑Ki = 1∑x∈cidist (x, ci) 2

Nếu bạn vẽ k với SSE, bạn sẽ thấy lỗi giảm khi k lớn hơn; điều này là do khi số cụm tăng lên, chúng sẽ nhỏ hơn, do đó độ méo cũng nhỏ hơn. Ý tưởng của phương pháp khuỷu tay là chọn k mà SSE giảm đột ngột. Điều này tạo ra "hiệu ứng khuỷu tay" trong biểu đồ, như bạn có thể thấy trong hình sau:

Trong trường hợp này, k = 6 là giá trị mà phương thức Elbow đã chọn. Hãy xem xét rằng phương pháp Elbow là một heuristic và, như vậy, nó có thể hoặc có thể không hoạt động tốt trong trường hợp cụ thể của bạn. Đôi khi, có nhiều hơn một khuỷu tay, hoặc không có khuỷu tay nào cả. Trong những tình huống đó, bạn thường kết thúc việc tính toán k tốt nhất bằng cách đánh giá mức độ hiệu quả của phương tiện k trong bối cảnh của vấn đề phân cụm cụ thể mà bạn đang cố gắng giải quyết.

Tôi đã làm việc trên một gói kneed Python (thuật toán Kneedle). Nó tìm thấy số cụm một cách linh hoạt khi điểm đường cong bắt đầu phẳng..Gen một tập hợp các giá trị x và y, kneed sẽ trả về điểm đầu gối của hàm. Điểm đầu gối là điểm có độ cong tối đa. Đây là mã mẫu.

y = [7342,1301373073857, 6881,7109460930769, 6531,1657905495022,
6356,2255554679778, 6209,8382535595829, 6094,9052166741121, 5980,0191582610196, 5880,1869867848218, 5779,8957906367368, 5691,1879324562778, 5617,5153566271356, 5532,2613232619951, 5467,352265375117, 5395,4493783888756, 5345,3459908298091, 5290,6769823693812, 5243,5271656371888, 5207,2501206569532, 5164,9617535255456]

x = phạm vi (1, len (y) +1)

từ nhập khẩu kneed kneeLocator kn = kneeLocator (x, y, cong = 'lồi', direction = 'giảm')

in (kn.knee)