kmeans演算法python實現

⑴ 減法聚類如何用python實現

下面是一個k-means聚類演算法在python2.7.5上面的具體實現，你需要先安裝Numpy和Matplotlib：
from numpy import *
import time
import matplotlib.pyplot as plt

# calculate Euclidean distance
def euclDistance(vector1, vector2):
return sqrt(sum(power(vector2 - vector1, 2)))
# init centroids with random samples
def initCentroids(dataSet, k):
numSamples, dim = dataSet.shape
centroids = zeros((k, dim))
for i in range(k):
index = int(random.uniform(0, numSamples))
centroids[i, :] = dataSet[index, :]
return centroids
# k-means cluster
def kmeans(dataSet, k):
numSamples = dataSet.shape[0]
# first column stores which cluster this sample belongs to,
# second column stores the error between this sample and its centroid
clusterAssment = mat(zeros((numSamples, 2)))
clusterChanged = True
## step 1: init centroids
centroids = initCentroids(dataSet, k)
while clusterChanged:
clusterChanged = False
## for each sample
for i in xrange(numSamples):
minDist = 100000.0
minIndex = 0
## for each centroid
## step 2: find the centroid who is closest
for j in range(k):
distance = euclDistance(centroids[j, :], dataSet[i, :])
if distance < minDist:
minDist = distance
minIndex = j

## step 3: update its cluster
if clusterAssment[i, 0] != minIndex:
clusterChanged = True
clusterAssment[i, :] = minIndex, minDist**2
## step 4: update centroids
for j in range(k):
pointsInCluster = dataSet[nonzero(clusterAssment[:, 0].A == j)[0]]
centroids[j, :] = mean(pointsInCluster, axis = 0)
print 'Congratulations, cluster complete!'
return centroids, clusterAssment
# show your cluster only available with 2-D data
def showCluster(dataSet, k, centroids, clusterAssment):
numSamples, dim = dataSet.shape
if dim != 2:
print "Sorry! I can not draw because the dimension of your data is not 2!"
return 1
mark = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '<r', 'pr']
if k > len(mark):
print "Sorry! Your k is too large! please contact Zouxy"
return 1
# draw all samples
for i in xrange(numSamples):
markIndex = int(clusterAssment[i, 0])
plt.plot(dataSet[i, 0], dataSet[i, 1], mark[markIndex])
mark = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '<b', 'pb']
# draw the centroids
for i in range(k):
plt.plot(centroids[i, 0], centroids[i, 1], mark[i], markersize = 12)
plt.show()

⑵ kmeans演算法用Python怎麼實現

frommathimportpi,sin,cos

fromrandomimportrandom,choice
fromimporttry:
importpsyco
psyco.full()
exceptImportError:
pass
FLOAT_MAX=1e100
classPoint:
__slots__=["x","y","group"]
def__init__(self,x=0.0,y=0.0,group=0):
self.x,self.y,self.group=x,y,group
defgenerate_points(npoints,radius):
points=[Point()for_inxrange(npoints)]
#note:thisisnotauniform2-ddistribution
forpinpoints:
r=random()*radius
ang=random()*2*pi
p.x=r*cos(ang)
p.y=r*sin(ang)
returnpoints
defnearest_cluster_center(point,cluster_centers):
""""""
defsqr_distance_2D(a,b):
return(a.x-b.x)**2+(a.y-b.y)**2
min_index=point.group
min_dist=FLOAT_MAX
fori,ccinenumerate(cluster_centers):
d=sqr_distance_2D(cc,point)
ifmin_dist>d:
min_dist=d
min_index=i
return(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=1...len(c_c)-1
sum=0
forj,pinenumerate(points):
d[j]=nearest_cluster_center(p,cluster_centers[:i])[1]#第j個數據點p與各個中心點距離的最小值
sum+=d[j]
sum*=random()
forj,diinenumerate(d):
sum-=di
ifsum>0:
continue
cluster_centers[i]=(points[j])
break
forpinpoints:
p.group=nearest_cluster_center(p,cluster_centers)[0]
'''
points是數據點，nclusters是給定的簇類數目
'''
deflloyd(points,nclusters):
cluster_centers=[Point()for_inxrange(nclusters)]#根據指定的中心點個數，初始化中心點，均為(0,0,0)
#callk++init
kpp(points,cluster_centers)#選擇初始種子點
#下面是kmeans
lenpts10=len(points)>>10
changed=0
whileTrue:
#
forccincluster_centers:
cc.x=0
cc.y=0
cc.group=0
forpinpoints:
cluster_centers[p.group].group+=1#與該種子點在同一簇的數據點的個數
cluster_centers[p.group].x+=p.x
cluster_centers[p.group].y+=p.y
forccincluster_centers:#生成新的中心點
cc.x/=cc.group
cc.y/=cc.group
#
changed=0#記錄所屬簇發生變化的數據點的個數
forpinpoints:
min_i=nearest_cluster_center(p,cluster_centers)[0]
ifmin_i!=p.group:
changed+=1
p.group=min_i
#stopwhen99.9%ofpointsaregood
ifchanged<=lenpts10:
break
fori,ccinenumerate(cluster_centers):
cc.group=i
returncluster_centers
defprint_eps(points,cluster_centers,W=400,H=400):
Color=namedtuple("Color","rgb");
colors=[]
foriinxrange(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
forpinpoints:
ifmax_x<p.x:max_x=p.x
ifmin_x>p.x:min_x=p.x
ifmax_y<p.y:max_y=p.y
ifmin_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
%%%%BoundingBox:-5-5%d%d"%(W+10,H+10)
print("/l{rlineto}def/m{rmoveto}def
"+
"/c{.25subexch.25subexch.50360arcfill}def
"+
"/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:
continue
print("%.3f%.3fc"%((p.x-cx)*scale+W/2,
(p.y-cy)*scale+H/2))
print("
0setgray%g%gs"%((cc.x-cx)*scale+W/2,
(cc.y-cy)*scale+H/2))
print"
%%%%EOF"
defmain():
npoints=30000
k=7##clusters
points=generate_points(npoints,10)
cluster_centers=lloyd(points,k)
print_eps(points,cluster_centers)
main()

⑶ k-means聚類演算法python實現，導入的數據集有什麼要求

一，K-Means聚類演算法原理
k-means 演算法接受參數 k
；然後將事先輸入的n個數據對象劃分為
k個聚類以便使得所獲得的聚類滿足：同一聚類中的對象相似度較高；而不同聚類中的對象相似度較小。聚類相似度是利用各聚類中對象的均值所獲得一個「中心對
象」（引力中心）來進行計算的。
K-means演算法是最為經典的基於劃分的聚類方法，是十大經典數據挖掘演算法之一。K-means演算法的基本思想是：以空間中k個點為中心進行聚類，對最靠近他們的對象歸類。通過迭代的方法，逐次更新各聚類中心的值，直至得到最好的聚類結果。

⑷ python代碼如何應用系統聚類和K-means聚類法進行聚類分析 然後選擇變數，建立適當的模型

-Means聚類演算法
k-means演算法以k為參數，把n個對象分成k個簇，使簇內具有較高的相似度，而簇間的相似度較低。

隨機選擇k個點作為初始的聚類中心。
對於剩下的點，根據其與聚類中心的距離，將其歸入最近的簇。
對每個簇，計算所有點的均值作為新的聚類中心。
重復2，3直到聚類中心不再發生改變

Figure 1

K-means的應用
數據介紹：
現有1999年全國31個省份城鎮居民家庭平均每人全年消費性支出的八大主要變數數據，這八大變數分別是：食品、衣著、家庭設備用品及服務、醫療保健、交通和通訊、娛樂教育文化服務、居住以及雜項商品和服務。利用已有數據，對31個省份進行聚類。

實驗目的：
通過聚類，了解1999年各個省份的消費水平在國內的情況。

技術路線：
sklearn.cluster.Kmeans

數據實例：

⑸ 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步。

⑹ 建議收藏！10 種 Python 聚類演算法完整操作示例

聚類或聚類分析是無監督學習問題。它通常被用作數據分析技術，用於發現數據中的有趣模式，例如基於其行為的客戶群。有許多聚類演算法可供選擇，對於所有情況，沒有單一的最佳聚類演算法。相反，最好探索一系列聚類演算法以及每種演算法的不同配置。在本教程中，你將發現如何在 python 中安裝和使用頂級聚類演算法。完成本教程後，你將知道：

聚類分析，即聚類，是一項無監督的機器學習任務。它包括自動發現數據中的自然分組。與監督學習（類似預測建模）不同，聚類演算法只解釋輸入數據，並在特徵空間中找到自然組或群集。

群集通常是特徵空間中的密度區域，其中來自域的示例（觀測或數據行）比其他群集更接近群集。群集可以具有作為樣本或點特徵空間的中心(質心)，並且可以具有邊界或范圍。

聚類可以作為數據分析活動提供幫助，以便了解更多關於問題域的信息，即所謂的模式發現或知識發現。例如：

聚類還可用作特徵工程的類型，其中現有的和新的示例可被映射並標記為屬於數據中所標識的群集之一。雖然確實存在許多特定於群集的定量措施，但是對所識別的群集的評估是主觀的，並且可能需要領域專家。通常，聚類演算法在人工合成數據集上與預先定義的群集進行學術比較，預計演算法會發現這些群集。

有許多類型的聚類演算法。許多演算法在特徵空間中的示例之間使用相似度或距離度量，以發現密集的觀測區域。因此，在使用聚類演算法之前，擴展數據通常是良好的實踐。

一些聚類演算法要求您指定或猜測數據中要發現的群集的數量，而另一些演算法要求指定觀測之間的最小距離，其中示例可以被視為「關閉」或「連接」。因此，聚類分析是一個迭代過程，在該過程中，對所識別的群集的主觀評估被反饋回演算法配置的改變中，直到達到期望的或適當的結果。scikit-learn 庫提供了一套不同的聚類演算法供選擇。下面列出了10種比較流行的演算法：

每個演算法都提供了一種不同的方法來應對數據中發現自然組的挑戰。沒有最好的聚類演算法，也沒有簡單的方法來找到最好的演算法為您的數據沒有使用控制實驗。在本教程中，我們將回顧如何使用來自 scikit-learn 庫的這10個流行的聚類演算法中的每一個。這些示例將為您復制粘貼示例並在自己的數據上測試方法提供基礎。我們不會深入研究演算法如何工作的理論，也不會直接比較它們。讓我們深入研究一下。

在本節中，我們將回顧如何在 scikit-learn 中使用10個流行的聚類演算法。這包括一個擬合模型的例子和可視化結果的例子。這些示例用於將粘貼復制到您自己的項目中，並將方法應用於您自己的數據。

1.庫安裝

首先，讓我們安裝庫。不要跳過此步驟，因為你需要確保安裝了最新版本。你可以使用 pip Python 安裝程序安裝 scikit-learn 存儲庫，如下所示：

接下來，讓我們確認已經安裝了庫，並且您正在使用一個現代版本。運行以下腳本以輸出庫版本號。

運行該示例時，您應該看到以下版本號或更高版本。

2.聚類數據集

我們將使用 make _ classification ()函數創建一個測試二分類數據集。數據集將有1000個示例，每個類有兩個輸入要素和一個群集。這些群集在兩個維度上是可見的，因此我們可以用散點圖繪制數據，並通過指定的群集對圖中的點進行顏色繪制。這將有助於了解，至少在測試問題上，群集的識別能力如何。該測試問題中的群集基於多變數高斯，並非所有聚類演算法都能有效地識別這些類型的群集。因此，本教程中的結果不應用作比較一般方法的基礎。下面列出了創建和匯總合成聚類數據集的示例。

運行該示例將創建合成的聚類數據集，然後創建輸入數據的散點圖，其中點由類標簽（理想化的群集）著色。我們可以清楚地看到兩個不同的數據組在兩個維度，並希望一個自動的聚類演算法可以檢測這些分組。

已知聚類著色點的合成聚類數據集的散點圖接下來，我們可以開始查看應用於此數據集的聚類演算法的示例。我已經做了一些最小的嘗試來調整每個方法到數據集。3.親和力傳播親和力傳播包括找到一組最能概括數據的範例。

它是通過 AffinityPropagation 類實現的，要調整的主要配置是將「 阻尼 」設置為0.5到1，甚至可能是「首選項」。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，我無法取得良好的結果。

數據集的散點圖，具有使用親和力傳播識別的聚類

4.聚合聚類

聚合聚類涉及合並示例，直到達到所需的群集數量為止。它是層次聚類方法的更廣泛類的一部分，通過 AgglomerationClustering 類實現的，主要配置是「 n _ clusters 」集，這是對數據中的群集數量的估計，例如2。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，可以找到一個合理的分組。

使用聚集聚類識別出具有聚類的數據集的散點圖

5.BIRCHBIRCH

聚類（ BIRCH 是平衡迭代減少的縮寫，聚類使用層次結構)包括構造一個樹狀結構，從中提取聚類質心。

它是通過 Birch 類實現的，主要配置是「 threshold 」和「 n _ clusters 」超參數，後者提供了群集數量的估計。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，可以找到一個很好的分組。

使用BIRCH聚類確定具有聚類的數據集的散點圖

6.DBSCANDBSCAN

聚類（其中 DBSCAN 是基於密度的空間聚類的雜訊應用程序）涉及在域中尋找高密度區域，並將其周圍的特徵空間區域擴展為群集。

它是通過 DBSCAN 類實現的，主要配置是「 eps 」和「 min _ samples 」超參數。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，盡管需要更多的調整，但是找到了合理的分組。

使用DBSCAN集群識別出具有集群的數據集的散點圖

7.K均值

K-均值聚類可以是最常見的聚類演算法，並涉及向群集分配示例，以盡量減少每個群集內的方差。

它是通過 K-均值類實現的，要優化的主要配置是「 n _ clusters 」超參數設置為數據中估計的群集數量。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，可以找到一個合理的分組，盡管每個維度中的不等等方差使得該方法不太適合該數據集。

使用K均值聚類識別出具有聚類的數據集的散點圖

8.Mini-Batch

K-均值Mini-Batch K-均值是 K-均值的修改版本，它使用小批量的樣本而不是整個數據集對群集質心進行更新，這可以使大數據集的更新速度更快，並且可能對統計雜訊更健壯。

它是通過 MiniBatchKMeans 類實現的，要優化的主配置是「 n _ clusters 」超參數，設置為數據中估計的群集數量。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，會找到與標准 K-均值演算法相當的結果。

帶有最小批次K均值聚類的聚類數據集的散點圖

9.均值漂移聚類

均值漂移聚類涉及到根據特徵空間中的實例密度來尋找和調整質心。

它是通過 MeanShift 類實現的，主要配置是「帶寬」超參數。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，可以在數據中找到一組合理的群集。

具有均值漂移聚類的聚類數據集散點圖

10.OPTICSOPTICS

聚類（ OPTICS 短於訂購點數以標識聚類結構）是上述 DBSCAN 的修改版本。

它是通過 OPTICS 類實現的，主要配置是「 eps 」和「 min _ samples 」超參數。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，我無法在此數據集上獲得合理的結果。

使用OPTICS聚類確定具有聚類的數據集的散點圖

11.光譜聚類

光譜聚類是一類通用的聚類方法，取自線性線性代數。

它是通過 Spectral 聚類類實現的，而主要的 Spectral 聚類是一個由聚類方法組成的通用類，取自線性線性代數。要優化的是「 n _ clusters 」超參數，用於指定數據中的估計群集數量。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，找到了合理的集群。

使用光譜聚類聚類識別出具有聚類的數據集的散點圖

12.高斯混合模型

高斯混合模型總結了一個多變數概率密度函數，顧名思義就是混合了高斯概率分布。它是通過 Gaussian Mixture 類實現的，要優化的主要配置是「 n _ clusters 」超參數，用於指定數據中估計的群集數量。下面列出了完整的示例。

運行該示例符合訓練數據集上的模型，並預測數據集中每個示例的群集。然後創建一個散點圖，並由其指定的群集著色。在這種情況下，我們可以看到群集被完美地識別。這並不奇怪，因為數據集是作為 Gaussian 的混合生成的。

使用高斯混合聚類識別出具有聚類的數據集的散點圖

在本文中，你發現了如何在 python 中安裝和使用頂級聚類演算法。具體來說，你學到了：

⑺ 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()
  

這里是聚類結果，還是很不錯的啦

⑻ 在python中如何使用kmeans得出SSE

用sklearn包，裡面有你要的kmeans演算法，然後找到聚類評判指標，也有你要的SSE。