python的kmeans包
第一種: 引用scikit-learn包
fromsklearn.clusterimportKMeans
k=10#Kmeans的k值
model=Kmeans(n_clusters=k)
X=[[1,2],[1,3],[2,1],....]#改成你的數據
model.fit(X)
#然後就訓練好了,可以查看model的屬性
model.cluster_centers
model.labels_
第二種: 自己寫代碼實現
importnumpyasnp
importrandom
data=[[1,1,1],[1,1,3],[1,2,1],[5,1,1],[5,1,2],[5,2,1],[5,5,5],[5,5,4],[5,4,4]]
data=np.array(data)
k=4#kmeans的k
n_iteration=500#最大迭代次數
#求初始化的k個質心(這k個質心必須包含在k個點的凸空間內)
center=np.matrix(np.zeros((k,len(data[0]))))
center_after=np.matrix(np.zeros((k,len(data[0]))))
foriinrange(len(data[0])):
center[:,i]=min(data[:,i])+(max(data[:,i])-min(data[:,i]))*np.random.rand(k,1)
defcalc_distance(x,y,distance='eucidean'):
x,y=np.array(x),np.array(y)
ifdistance=='eucidean':
returnnp.sqrt(np.sum((y-x)**2))
n=0
while1:
n+=1
print('第%s次迭代'%n)
#計算所有點到每個質心的距離,將每個點分到距離最近的那個點那一類
#9個點里哪個質心最近,就分到第幾個類
label=np.argmin(np.array([calc_distance(x,y)forxindataforyincenter]).reshape(len(data),k),axis=1)
print(label)
#重新計算質心
foriinrange(k):
center_after[i]=np.mean(np.array([data[j]forjinrange(len(data))iflabel[j]==i]),axis=0)
ifnp.sum(np.abs(center_after-center))<0.01:
#print(np.sum(np.abs(center_after-center)))
print('相鄰兩次迭代改變甚小,迭代結束')
break
ifn>n_iteration:
print('迭代次數已達上限,迭代結束')
break
center=center_after
❷ kmeans演算法用Python怎麼實現
frommathimportpi,sin,,choicefromimporttry:importpsycopsyco.full()exceptImportError:passFLOAT_MAX=1e100classPoint:__slots__=["x","y","group"]def__init__(self,x=0.0,y=0.0,group=0):self.x,self.y,self.group=x,y,groupdefgenerate_points(npoints,radius):points=[Point()for_inxrange(npoints)]#note:thisisnotauniform2-ddistributionforpinpoints:r=random()*radiusang=random()*2*pip.x=r*cos(ang)p.y=r*sin(ang)returnpointsdefnearest_cluster_center(point,cluster_centers):""""""defsqr_distance_2D(a,b):return(a.x-b.x)**2+(a.y-b.y)**2min_index=point.groupmin_dist=FLOAT_MAXfori,ccinenumerate(cluster_centers):d=sqr_distance_2D(cc,point)ifmin_dist>d:min_dist=dmin_index=ireturn(min_index,min_dist)'''points是數據點，nclusters是給定的簇類數目cluster_centers包含初始化的nclusters個中心點，開始都是對象->(0,0,0)'''defkpp(points,cluster_centers):cluster_centers[0]=(choice(points))#隨機選取第一個中心點d=[0.0for_inxrange(len(points))]#列表，長度為len(points)，保存每個點離最近的中心點的距離foriinxrange(1,len(cluster_centers)):#i=1len(c_c)-1sum=0forj,pinenumerate(points):d[j]=nearest_cluster_center(p,cluster_centers[:i])[1]#第j個數據點p與各個中心點距離的最小值sum+=d[j]sum*=random()forj,diinenumerate(d):sum-=diifsum>0:continuecluster_centers[i]=(points[j])breakforpinpoints:p.group=nearest_cluster_center(p,cluster_centers)[0]'''points是數據點，nclusters是給定的簇類數目'''deflloyd(points,nclusters):cluster_centers=[Point()for_inxrange(nclusters)]#根據指定的中心點個數，初始化中心點，均為(0,0,0)#callk++initkpp(points,cluster_centers)#選擇初始種子點#下面是kmeanslenpts10=len(points)>>10changed=0whileTrue:#_centers:cc.x=0cc.y=0cc.group=0forpinpoints:cluster_centers[p.group].group+=1#與該種子點在同一簇的數據點的個數cluster_centers[p.group].x+=p.xcluster_centers[p.group].y+=p.yforccincluster_centers:#生成新的中心點cc.x/=cc.groupcc.y/=cc.group#=0#記錄所屬簇發生變化的數據點的個數forpinpoints:min_i=nearest_cluster_center(p,cluster_centers)[0]ifmin_i!=p.group:changed+=1p.group=min_i#stopwhen99.9%ofpointsaregoodifchangedp.x:min_x=p.xifmax_yp.y:min_y=p.yscale=min(W/(max_x-min_x),H/(max_y-min_y))cx=(max_x+min_x)/2cy=(max_y+min_y)/2print"%%!PS-Adobe-3.0\n%%%%BoundingBox:-5-5%d%d"%(W+10,H+10)print("/l{rlineto}def/m{rmoveto}def\n"+"/c{.25subexch.25subexch.50360arcfill}def\n"+"/s{moveto-20m22l2-2l-2-2lclosepath"+""+"}def")fori,ccinenumerate(cluster_centers):print("%g%g%gsetrgbcolor"%(colors[i].r,colors[i].g,colors[i].b))forpinpoints:ifp.group!=i:continueprint("%.3f%.3fc"%((p.x-cx)*scale+W/2,(p.y-cy)*scale+H/2))print("\n0setgray%g%gs"%((cc.x-cx)*scale+W/2,(cc.y-cy)*scale+H/2))print"\n%%%%EOF"defmain():npoints=30000k=7##clusterspoints=generate_points(npoints,10)cluster_centers=lloyd(points,k)print_eps(points,cluster_centers)main()
❸ kmeans演算法用Python怎麼實現
函數
loadDataSet(fileName)
從文件中讀取數據集
distEclud(vecA, vecB)
計算距離，這里用的是歐氏距離，當然其他合理的距離都是可以的
randCent(dataSet, k)
隨機生成初始的質心，這里是雖具選取數據范圍內的點
kMeans(dataSet, k, distMeas=distEclud, createCent=randCent)
kmeans演算法，輸入數據和k值。後面兩個事可選的距離計算方式和初始質心的選擇方式
show(dataSet, k, centroids, clusterAssment)
可視化結果
- 1 #coding=utf-8 2 from numpy import * 3 4 def loadDataSet(fileName): 5 dataMat = [] 6 fr = open(fileName) 7 for line in fr.readlines(): 8 curLine = line.strip().split(' ') 9 fltLine = map(float, curLine)10 dataMat.append(fltLine)11 return dataMat12 13 #計算兩個向量的距離，用的是歐幾里得距離14 def distEclud(vecA, vecB):15 return sqrt(sum(power(vecA - vecB, 2)))16 17 #隨機生成初始的質心（ng的課說的初始方式是隨機選K個點）
18 def randCent(dataSet, k):19 n = shape(dataSet)[1]20 centroids = mat(zeros((k,n)))21 for j in range(n):22 minJ = min(dataSet[:,j])23 rangeJ = float(max(array(dataSet)[:,j]) - minJ)24 centroids[:,j] = minJ + rangeJ * random.rand(k,1)25 return centroids26 27 def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):28 m = shape(dataSet)[0]29 clusterAssment = mat(zeros((m,2)))#create mat to assign data points
30 #to a centroid, also holds SE of each point31 centroids = createCent(dataSet, k)32 clusterChanged = True33 while clusterChanged:34 clusterChanged = False35 for i in range(m):#for each data point assign it to the closest centroid36 minDist = inf37 minIndex = -138 for j in range(k):39 distJI = distMeas(centroids[j,:],dataSet[i,:])40 if distJI < minDist:41 minDist = distJI; minIndex = j42 if clusterAssment[i,0] != minIndex:
43 clusterChanged = True44 clusterAssment[i,:] = minIndex,minDist**245 print centroids46 for cent in range(k):#recalculate centroids47 ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]]#get all the point in this cluster48 centroids[cent,:] = mean(ptsInClust, axis=0) #assign centroid to mean
49 return centroids, clusterAssment50 51 def show(dataSet, k, centroids, clusterAssment):52 from matplotlib import pyplot as plt
53 numSamples, dim = dataSet.shape
54 mark = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '<r', 'pr']
55 for i in xrange(numSamples):
56 markIndex = int(clusterAssment[i, 0])
57 plt.plot(dataSet[i, 0], dataSet[i, 1], mark[markIndex])
58 mark = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '<b', 'pb']
59 for i in range(k):
60 plt.plot(centroids[i, 0], centroids[i, 1], mark[i], markersize = 12)
61 plt.show()62 63 def main():64 dataMat = mat(loadDataSet('testSet.txt'))65 myCentroids, clustAssing= kMeans(dataMat,4)66 print myCentroids67 show(dataMat, 4, myCentroids, clustAssing)
68 69 70 if __name__ == '__main__':71 main()
這里是聚類結果，還是很不錯的啦
❹ kmeans演算法用Python怎麼實現
k-means演算法實際上就是通過計算不同樣本間的距離來判斷他們的相近關系的，相近的就會放到同一個類別中去。
1.首先我們需要選擇一個k值，也就是我們希望把數據分成多少類，這里k值的選擇對結果的影響很大，Ng的課說的選擇方法有兩種一種是elbow method，簡單的說就是根據聚類的結果和k的函數關系判斷k為多少的時候效果最好。另一種則是根據具體的需求確定，比如說進行襯衫尺寸的聚類你可能就會考慮分成三類（L,M,S）等
2.然後我們需要選擇最初的聚類點（或者叫質心），這里的選擇一般是隨機選擇的，代碼中的是在數據范圍內隨機選擇，另一種是隨機選擇數據中的點。這些點的選擇會很大程度上影響到最終的結果，也就是說運氣不好的話就到局部最小值去了。這里有兩種處理方法，一種是多次取均值，另一種則是後面的改進演算法（bisecting K-means）
3.終於我們開始進入正題了，接下來我們會把數據集中所有的點都計算下與這些質心的距離，把它們分到離它們質心最近的那一類中去。完成後我們則需要將每個簇算出平均值，用這個點作為新的質心。反復重復這兩步，直到收斂我們就得到了最終的結果。
❺ kmeans演算法用Python怎麼實現
1、從Kmeans說起
Kmeans是一個非常基礎的聚類演算法，使用了迭代的思想，關於其原理這里不說了。下面說一下如何在matlab中使用kmeans演算法。
創建7個二維的數據點：
復制代碼 代碼如下:
x=[randn(3,2)*.4;randn(4,2)*.5+ones(4,1)*[4 4]];
使用kmeans函數：
復制代碼 代碼如下:
class = kmeans(x, 2);
x是數據點，x的每一行代表一個數據；2指定要有2個中心點，也就是聚類結果要有2個簇。 class將是一個具有70個元素的列向量，這些元素依次對應70個數據點，元素值代表著其對應的數據點所處的分類號。某次運行後，class的值是：
復制代碼 代碼如下:
2
2
2
1
1
1
1
這說明x的前三個數據點屬於簇2，而後四個數據點屬於簇1。 kmeans函數也可以像下面這樣使用：
復制代碼 代碼如下:
>> [class, C, sumd, D] = kmeans(x, 2)
class =
2
2
2
1
1
1
1
C =
4.0629 4.0845
-0.1341 0.1201
sumd =
1.2017
0.2939
D =
34.3727 0.0184
29.5644 0.1858
36.3511 0.0898
0.1247 37.4801
0.7537 24.0659
0.1979 36.7666
0.1256 36.2149
class依舊代表著每個數據點的分類;C包含最終的中心點，一行代表一個中心點；sumd代表著每個中心點與所屬簇內各個數據點的距離之和；D的
每一行也對應一個數據點，行中的數值依次是該數據點與各個中心點之間的距離，Kmeans默認使用的距離是歐幾里得距離（參考資料[3]）的平方值。
kmeans函數使用的距離，也可以是曼哈頓距離（L1-距離），以及其他類型的距離，可以通過添加參數指定。
kmeans有幾個缺點（這在很多資料上都有說明）：
1、最終簇的類別數目（即中心點或者說種子點的數目）k並不一定能事先知道，所以如何選一個合適的k的值是一個問題。
2、最開始的種子點的選擇的好壞會影響到聚類結果。
3、對雜訊和離群點敏感。
4、等等。
2、kmeans++演算法的基本思路
kmeans++演算法的主要工作體現在種子點的選擇上，基本原則是使得各個種子點之間的距離盡可能的大，但是又得排除雜訊的影響。 以下為基本思路：
1、從輸入的數據點集合（要求有k個聚類）中隨機選擇一個點作為第一個聚類中心
2、對於數據集中的每一個點x，計算它與最近聚類中心(指已選擇的聚類中心)的距離D(x)
3、選擇一個新的數據點作為新的聚類中心，選擇的原則是：D(x)較大的點，被選取作為聚類中心的概率較大
4、重復2和3直到k個聚類中心被選出來
5、利用這k個初始的聚類中心來運行標準的k-means演算法
假定數據點集合X有n個數據點，依次用X(1)、X(2)、……、X(n)表示，那麼，在第2步中依次計算每個數據點與最近的種子點（聚類中心）的
距離，依次得到D(1)、D(2)、……、D(n)構成的集合D。在D中，為了避免雜訊，不能直接選取值最大的元素，應該選擇值較大的元素，然後將其對應
的數據點作為種子點。
如何選擇值較大的元素呢，下面是一種思路（暫未找到最初的來源，在資料[2]等地方均有提及，筆者換了一種讓自己更好理解的說法）：
把集合D中的每個元素D(x)想像為一根線L(x)，線的長度就是元素的值。將這些線依次按照L(1)、L(2)、……、L(n)的順序連接起來，組成長
線L。L(1)、L(2)、……、L(n)稱為L的子線。根據概率的相關知識，如果我們在L上隨機選擇一個點，那麼這個點所在的子線很有可能是比較長的子
線，而這個子線對應的數據點就可以作為種子點。下文中kmeans++的兩種實現均是這個原理。
3、python版本的kmeans++
在http://rosettacode.org/wiki/K-means%2B%2B_clustering 中能找到多種編程語言版本的Kmeans++實現。下面的內容是基於python的實現（中文注釋是筆者添加的）：
復制代碼 代碼如下:
from math import pi, sin, cos
from collections import namedtuple
from random import random, choice
from import
try:
import psyco
psyco.full()
except ImportError:
pass
FLOAT_MAX = 1e100
class Point:
__slots__ = ["x", "y", "group"]
def __init__(self, x=0.0, y=0.0, group=0):
self.x, self.y, self.group = x, y, group
def generate_points(npoints, radius):
points = [Point() for _ in xrange(npoints)]
# note: this is not a uniform 2-d distribution
for p in points:
r = random() * radius
ang = random() * 2 * pi
p.x = r * cos(ang)
p.y = r * sin(ang)
return points
def nearest_cluster_center(point, cluster_centers):
"""Distance and index of the closest cluster center"""
def sqr_distance_2D(a, b):
return (a.x - b.x) ** 2 + (a.y - b.y) ** 2
min_index = point.group
min_dist = FLOAT_MAX
for i, cc in enumerate(cluster_centers):
d = sqr_distance_2D(cc, point)
if min_dist > d:
min_dist = d
min_index = i
return (min_index, min_dist)
'''
points是數據點，nclusters是給定的簇類數目
cluster_centers包含初始化的nclusters個中心點，開始都是對象->(0,0,0)
'''
def kpp(points, cluster_centers):
cluster_centers[0] = (choice(points)) #隨機選取第一個中心點
d = [0.0 for _ in xrange(len(points))] #列表，長度為len(points)，保存每個點離最近的中心點的距離
for i in xrange(1, len(cluster_centers)): # i=1...len(c_c)-1
sum = 0
for j, p in enumerate(points):
d[j] = nearest_cluster_center(p, cluster_centers[:i])[1] #第j個數據點p與各個中心點距離的最小值
sum += d[j]
sum *= random()
for j, di in enumerate(d):
sum -= di
if sum > 0:
continue
cluster_centers[i] = (points[j])
break
for p in points:
p.group = nearest_cluster_center(p, cluster_centers)[0]
'''
points是數據點，nclusters是給定的簇類數目
'''
def lloyd(points, nclusters):
cluster_centers = [Point() for _ in xrange(nclusters)] #根據指定的中心點個數，初始化中心點，均為(0,0,0)
# call k++ init
kpp(points, cluster_centers) #選擇初始種子點
# 下面是kmeans
lenpts10 = len(points) >> 10
changed = 0
while True:
# group element for centroids are used as counters
for cc in cluster_centers:
cc.x = 0
cc.y = 0
cc.group = 0
for p in points:
cluster_centers[p.group].group += 1 #與該種子點在同一簇的數據點的個數
cluster_centers[p.group].x += p.x
cluster_centers[p.group].y += p.y
for cc in cluster_centers: #生成新的中心點
cc.x /= cc.group
cc.y /= cc.group
# find closest centroid of each PointPtr
changed = 0 #記錄所屬簇發生變化的數據點的個數
for p in points:
min_i = nearest_cluster_center(p, cluster_centers)[0]
if min_i != p.group:
changed += 1
p.group = min_i
# stop when 99.9% of points are good
if changed <= lenpts10:
break
for i, cc in enumerate(cluster_centers):
cc.group = i
return cluster_centers
def print_eps(points, cluster_centers, W=400, H=400):
Color = namedtuple("Color", "r g b");
colors = []
for i in xrange(len(cluster_centers)):
colors.append(Color((3 * (i + 1) % 11) / 11.0,
(7 * i % 11) / 11.0,
(9 * i % 11) / 11.0))
max_x = max_y = -FLOAT_MAX
min_x = min_y = FLOAT_MAX
for p in points:
if max_x < p.x: max_x = p.x
if min_x > p.x: min_x = p.x
if max_y < p.y: max_y = p.y
if min_y > p.y: min_y = p.y
scale = min(W / (max_x - min_x),
H / (max_y - min_y))
cx = (max_x + min_x) / 2
cy = (max_y + min_y) / 2
print "%%!PS-Adobe-3.0\n%%%%BoundingBox: -5 -5 %d %d" % (W + 10, H + 10)
print ("/l {rlineto} def /m {rmoveto} def\n" +
"/c { .25 sub exch .25 sub exch .5 0 360 arc fill } def\n" +
"/s { moveto -2 0 m 2 2 l 2 -2 l -2 -2 l closepath " +
" gsave 1 setgray fill grestore gsave 3 setlinewidth" +
" 1 setgray stroke grestore 0 setgray stroke }def")
for i, cc in enumerate(cluster_centers):
print ("%g %g %g setrgbcolor" %
(colors[i].r, colors[i].g, colors[i].b))
for p in points:
if p.group != i:
continue
print ("%.3f %.3f c" % ((p.x - cx) * scale + W / 2,
(p.y - cy) * scale + H / 2))
print ("\n0 setgray %g %g s" % ((cc.x - cx) * scale + W / 2,
(cc.y - cy) * scale + H / 2))
print "\n%%%%EOF"
def main():
npoints = 30000
k = 7 # # clusters
points = generate_points(npoints, 10)
cluster_centers = lloyd(points, k)
print_eps(points, cluster_centers)
main()
上述代碼實現的演算法是針對二維數據的，所以Point對象有三個屬性，分別是在x軸上的值、在y軸上的值、以及所屬的簇的標識。函數lloyd是
kmeans++演算法的整體實現，其先是通過kpp函數選取合適的種子點，然後對數據集實行kmeans演算法進行聚類。kpp函數的實現完全符合上述
kmeans++的基本思路的2、3、4步。
❻ kmeans聚類python哪個包中有
sklearn
http://scikit-learn.org/stable/
❼ kmeans演算法用Python怎麼實現
1、從Kmeans說起
Kmeans是一個非常基礎的聚類演算法，使用了迭代的思想，關於其原理這里不說了。下面說一下如何在matlab中使用kmeans演算法。
創建7個二維的數據點：
復制代碼代碼如下:
x=[randn(3,2)*.4;randn(4,2)*.5+ones(4,1)*[4 4]];
使用kmeans函數：
復制代碼代碼如下:
class = kmeans(x, 2);
x是數據點，x的每一行代表一個數據；2指定要有2個中心點，也就是聚類結果要有2個簇。 class將是一個具有70個元素的列向量，這些元素依次對應70個數據點，元素值代表著其對應的數據點所處的分類號。某次運行後，class的值是：
復制代碼代碼如下:
2
2
2
1
1
1
1
這說明x的前三個數據點屬於簇2，而後四個數據點屬於簇1。 kmeans函數也可以像下面這樣使用：
復制代碼代碼如下:
>> [class, C, sumd, D] = kmeans(x, 2)
class =
2
2
2
1
1
1
1
C =
4.0629 4.0845
-0.1341 0.1201
sumd =
1.2017
0.2939
D =
34.3727 0.0184
29.5644 0.1858
36.3511 0.0898
0.1247 37.4801
0.7537 24.0659
0.1979 36.7666
0.1256 36.2149
class依舊代表著每個數據點的分類;C包含最終的中心點，一行代表一個中心點；sumd代表著每個中心點與所屬簇內各個數據點的距離之和；D的每一行也對應一個數據點，行中的數值依次是該數據點與各個中心點之間的距離，Kmeans默認使用的距離是歐幾里得距離（參考資料[3]）的平方值。kmeans函數使用的距離，也可以是曼哈頓距離（L1-距離），以及其他類型的距離，可以通過添加參數指定。
kmeans有幾個缺點（這在很多資料上都有說明）：
1、最終簇的類別數目（即中心點或者說種子點的數目）k並不一定能事先知道，所以如何選一個合適的k的值是一個問題。
2、最開始的種子點的選擇的好壞會影響到聚類結果。
3、對雜訊和離群點敏感。
4、等等。
2、kmeans++演算法的基本思路
kmeans++演算法的主要工作體現在種子點的選擇上，基本原則是使得各個種子點之間的距離盡可能的大，但是又得排除雜訊的影響。 以下為基本思路：
1、從輸入的數據點集合（要求有k個聚類）中隨機選擇一個點作為第一個聚類中心
2、對於數據集中的每一個點x，計算它與最近聚類中心(指已選擇的聚類中心)的距離D(x)
3、選擇一個新的數據點作為新的聚類中心，選擇的原則是：D(x)較大的點，被選取作為聚類中心的概率較大
4、重復2和3直到k個聚類中心被選出來
5、利用這k個初始的聚類中心來運行標準的k-means演算法
假定數據點集合X有n個數據點，依次用X(1)、X(2)、……、X(n)表示，那麼，在第2步中依次計算每個數據點與最近的種子點（聚類中心）的距離，依次得到D(1)、D(2)、……、D(n)構成的集合D。在D中，為了避免雜訊，不能直接選取值最大的元素，應該選擇值較大的元素，然後將其對應的數據點作為種子點。
如何選擇值較大的元素呢，下面是一種思路（暫未找到最初的來源，在資料[2]等地方均有提及，筆者換了一種讓自己更好理解的說法）： 把集合D中的每個元素D(x)想像為一根線L(x)，線的長度就是元素的值。將這些線依次按照L(1)、L(2)、……、L(n)的順序連接起來，組成長線L。L(1)、L(2)、……、L(n)稱為L的子線。根據概率的相關知識，如果我們在L上隨機選擇一個點，那麼這個點所在的子線很有可能是比較長的子線，而這個子線對應的數據點就可以作為種子點。下文中kmeans++的兩種實現均是這個原理。
3、python版本的kmeans++
在http://rosettacode.org/wiki/K-means%2B%2B_clustering 中能找到多種編程語言版本的Kmeans++實現。下面的內容是基於python的實現（中文注釋是筆者添加的）：
復制代碼代碼如下:
from math import pi, sin, cos
from collections import namedtuple
from random import random, choice
from import
try:
import psyco
psyco.full()
except ImportError:
pass
FLOAT_MAX = 1e100
class Point:
__slots__ = ["x", "y", "group"]
def __init__(self, x=0.0, y=0.0, group=0):
self.x, self.y, self.group = x, y, group
def generate_points(npoints, radius):
points = [Point() for _ in xrange(npoints)]
# note: this is not a uniform 2-d distribution
for p in points:
r = random() * radius
ang = random() * 2 * pi
p.x = r * cos(ang)
p.y = r * sin(ang)
return points
def nearest_cluster_center(point, cluster_centers):
"""Distance and index of the closest cluster center"""
def sqr_distance_2D(a, b):
return (a.x - b.x) ** 2 + (a.y - b.y) ** 2
min_index = point.group
min_dist = FLOAT_MAX
for i, cc in enumerate(cluster_centers):
d = sqr_distance_2D(cc, point)
if min_dist > d:
min_dist = d
min_index = i
return (min_index, min_dist)
'''
points是數據點，nclusters是給定的簇類數目
cluster_centers包含初始化的nclusters個中心點，開始都是對象->(0,0,0)
'''
def kpp(points, cluster_centers):
cluster_centers[0] = (choice(points)) #隨機選取第一個中心點
d = [0.0 for _ in xrange(len(points))] #列表，長度為len(points)，保存每個點離最近的中心點的距離
for i in xrange(1, len(cluster_centers)): # i=1...len(c_c)-1
sum = 0
for j, p in enumerate(points):
d[j] = nearest_cluster_center(p, cluster_centers[:i])[1] #第j個數據點p與各個中心點距離的最小值
sum += d[j]
sum *= random()
for j, di in enumerate(d):
sum -= di
if sum > 0:
continue
cluster_centers[i] = (points[j])
break
for p in points:
p.group = nearest_cluster_center(p, cluster_centers)[0]
'''
points是數據點，nclusters是給定的簇類數目
'''
def lloyd(points, nclusters):
cluster_centers = [Point() for _ in xrange(nclusters)] #根據指定的中心點個數，初始化中心點，均為(0,0,0)
# call k++ init
kpp(points, cluster_centers) #選擇初始種子點
# 下面是kmeans
lenpts10 = len(points) >> 10
changed = 0
while True:
# group element for centroids are used as counters
for cc in cluster_centers:
cc.x = 0
cc.y = 0
cc.group = 0
for p in points:
cluster_centers[p.group].group += 1 #與該種子點在同一簇的數據點的個數
cluster_centers[p.group].x += p.x
cluster_centers[p.group].y += p.y
for cc in cluster_centers: #生成新的中心點
cc.x /= cc.group
cc.y /= cc.group
# find closest centroid of each PointPtr
changed = 0 #記錄所屬簇發生變化的數據點的個數
for p in points:
min_i = nearest_cluster_center(p, cluster_centers)[0]
if min_i != p.group:
changed += 1
p.group = min_i
# stop when 99.9% of points are good
if changed <= lenpts10:
break
for i, cc in enumerate(cluster_centers):
cc.group = i
return cluster_centers
def print_eps(points, cluster_centers, W=400, H=400):
Color = namedtuple("Color", "r g b");
colors = []
for i in xrange(len(cluster_centers)):
colors.append(Color((3 * (i + 1) % 11) / 11.0,
(7 * i % 11) / 11.0,
(9 * i % 11) / 11.0))
max_x = max_y = -FLOAT_MAX
min_x = min_y = FLOAT_MAX
for p in points:
if max_x < p.x: max_x = p.x
if min_x > p.x: min_x = p.x
if max_y < p.y: max_y = p.y
if min_y > p.y: min_y = p.y
scale = min(W / (max_x - min_x),
H / (max_y - min_y))
cx = (max_x + min_x) / 2
cy = (max_y + min_y) / 2
print "%%!PS-Adobe-3.0\n%%%%BoundingBox: -5 -5 %d %d" % (W + 10, H + 10)
print ("/l {rlineto} def /m {rmoveto} def\n" +
"/c { .25 sub exch .25 sub exch .5 0 360 arc fill } def\n" +
"/s { moveto -2 0 m 2 2 l 2 -2 l -2 -2 l closepath " +
" gsave 1 setgray fill grestore gsave 3 setlinewidth" +
" 1 setgray stroke grestore 0 setgray stroke }def")
for i, cc in enumerate(cluster_centers):
print ("%g %g %g setrgbcolor" %
(colors[i].r, colors[i].g, colors[i].b))
for p in points:
if p.group != i:
continue
print ("%.3f %.3f c" % ((p.x - cx) * scale + W / 2,
(p.y - cy) * scale + H / 2))
print ("\n0 setgray %g %g s" % ((cc.x - cx) * scale + W / 2,
(cc.y - cy) * scale + H / 2))
print "\n%%%%EOF"
def main():
npoints = 30000
k = 7 # # clusters
points = generate_points(npoints, 10)
cluster_centers = lloyd(points, k)
print_eps(points, cluster_centers)
main()
上述代碼實現的演算法是針對二維數據的，所以Point對象有三個屬性，分別是在x軸上的值、在y軸上的值、以及所屬的簇的標識。函數lloyd是kmeans++演算法的整體實現，其先是通過kpp函數選取合適的種子點，然後對數據集實行kmeans演算法進行聚類。kpp函數的實現完全符合上述kmeans++的基本思路的2、3、4步。
❽ kmeans演算法用Python怎麼實現
from numpy import *
import numpy as np
def distEclud(vecA, vecB):
return sqrt(sum(power(vecA - vecB, 2)))
def randCent(dataSet, k):
n = shape(dataSet)[1]
centroids = mat(zeros((k,n)))
for j in range(n):
minJ = min(dataSet[:,j])
rangeJ = float(max(array(dataSet)[:,j]) - minJ)
centroids[:,j] = minJ + rangeJ * random.rand(k,1)
return centroids
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
m = shape(dataSet)[0]
❾ 在python中如何使用kmeans得出SSE
用sklearn包，裡面有你要的kmeans演算法，然後找到聚類評判指標，也有你要的SSE。