python實現一個層次聚類方法

層次聚類(Hierarchical Clustering)

一.概念

　　層次聚類不需要指定聚類的數目，首先它是將數據中的每個實例看作一個類，然后將最相似的兩個類合並，該過程迭代計算只到剩下一個類為止，類由兩個子類構成，每個子類又由更小的兩個子類構成。如下圖所示：

二.合並方法

在聚類中每次迭代都將兩個最近的類進行合並，這個類間的距離計算方法常用的有三種：

1.單連接聚類(Single-linkage clustering)

　　在單連接聚類中，兩個類間的距離定義為一個類的所有實例到另一個類的所有實例之間最短的那個距離。如上圖中類A(A1,A2)，B(B1,B2)，C(C1,C2)，A類和B類間的最短距離是A1到B1，所以A類與B類更近，所有A和B合並。

2.全連接聚類(Complete-linkage clustering)

　　在全連接聚類中，兩個類間的距離定義為一個類的所有實例到另一個類的所有實例之間最長的那個距離。圖中A類和B類間最長距離是A2到B2，B類和C類最長距離是B1到C1，distance(B1-C1)<distance(A2-B2)，所以B類和C類合並在一起。

3.平均連接聚類(Average-linkage clustering)

　　在平均連接聚類中，類間的距離為一個類的所有實例到另一個類的所有實例的平均距離。

三.python實現(單連接)

#!/usr/bin/python
# -*- coding: utf-8 -*-

from queue import PriorityQueue
import math
import codecs


"""
層次聚類
"""
class HCluster:

    #一列的中位數
    def getMedian(self,alist):
        tmp = list(alist)
        tmp.sort()
        alen = len(tmp)
        if alen % 2 == 1:
            return tmp[alen // 2]
        else:
            return (tmp[alen // 2] + tmp[(alen // 2) - 1]) / 2

    #對數值型數據進行歸一化，使用絕對標准分[絕對標准差->asd=sum(x-u)/len(x),x的標准分->(x-u)/絕對標准差，u是中位數]
    def normalize(self,column):
        median = self.getMedian(column)
        asd = sum([abs(x - median) for x in column]) / len(column)
        result = [(x - median) / asd for x in column]
        return result

    def __init__(self,filepath):
        self.data={}
        self.counter=0
        self.queue=PriorityQueue()
        line_1=True#開頭第一行
        with codecs.open(filepath,'r','utf-8') as f:
            for line in f:
                #第一行為描述信息
                if line_1:
                    line_1=False
                    header=line.split(',')
                    self.cols=len(header)
                    self.data=[[] for i in range(self.cols)]
                else:
                    instances=line.split(',')
                    toggle=0
                    for instance in range(self.cols):
                        if toggle==0:
                            self.data[instance].append(instances[instance])
                            toggle=1
                        else:
                            self.data[instance].append(float(instances[instance]))
        #歸一化數值列
        for i in range(1,self.cols):
            self.data[i]=self.normalize(self.data[i])

        #歐氏距離計算元素i到所有其它元素的距離，放到鄰居字典中，比如i=1,j=2...，結構如i=1的鄰居-》{2: ((1,2), 1.23),  3: ((1, 3), 2.3)... }
        #找到最近鄰
        #基於最近鄰將元素放到優先隊列中
        #data[0]放的是label標簽，data[1]和data[2]是數值型屬性
        rows=len(self.data[0])
        for i in range(rows):
            minDistance=10000
            nearestNeighbor=0
            neighbors={}
            for j in range(rows):
                if i!=j:
                    dist=self.distance(i,j)
                    if i<j:
                        pair=(i,j)
                    else:
                        pair=(j,i)
                    neighbors[j]=(pair,dist)
                    if dist<minDistance:
                        minDistance=dist
                        nearestNeighbor=j
            #創建最近鄰對
            if i<nearestNeighbor:
                nearestPair=(i,nearestNeighbor)
            else:
                nearestPair=(nearestNeighbor,i)
            #放入優先對列中，(最近鄰距離，counter,[label標簽名，最近鄰元組，所有鄰居])
            self.queue.put((minDistance,self.counter,[[self.data[0][i]],nearestPair,neighbors]))
            self.counter+=1

    #歐氏距離,d(x,y)=math.sqrt(sum((x-y)*(x-y)))
    def distance(self,i,j):
        sumSquares=0
        for k in range(1,self.cols):
            sumSquares+=(self.data[k][i]-self.data[k][j])**2
        return math.sqrt(sumSquares)

    #聚類
    def cluster(self):
        done=False
        while not done:
            topOne=self.queue.get()
            nearestPair=topOne[2][1]
            if not self.queue.empty():
                nextOne=self.queue.get()
                nearPair=nextOne[2][1]
                tmp=[]
                #nextOne是否是topOne的最近鄰，如不是繼續找
                while nearPair!=nearestPair:
                    tmp.append((nextOne[0],self.counter,nextOne[2]))
                    self.counter+=1
                    nextOne=self.queue.get()
                    nearPair=nextOne[2][1]
                #重新加回Pop出的不相等最近鄰的元素
                for item in tmp:
                    self.queue.put(item)

                if len(topOne[2][0])==1:
                    item1=topOne[2][0][0]
                else:
                    item1=topOne[2][0]
                if len(nextOne[2][0])==1:
                    item2=nextOne[2][0][0]
                else:
                    item2=nextOne[2][0]
                #聯合兩個最近鄰族成一個新族
                curCluster=(item1,item2)
                #下面使用單連接方法建立新族中的鄰居距離元素，一：計算上面新族的最近鄰。二：建立新的鄰居。如果 item1和item3距離是2，item2和item3距離是4，則在新族中的距離是2
                minDistance=10000
                nearestPair=()
                nearestNeighbor=''
                merged={}
                nNeighbors=nextOne[2][2]
                for key,value in topOne[2][2].items():
                    if key in nNeighbors:
                        if nNeighbors[key][1]<value[1]:
                            dist=nNeighbors[key]
                        else:
                            dist=value
                        if dist[1]<minDistance:
                            minDistance=dist[1]
                            nearestPair=dist[0]
                            nearestNeighbor=key
                        merged[key]=dist
                if merged=={}:
                    return curCluster
                else:
                    self.queue.put((minDistance,self.counter,[curCluster,nearestPair,merged]))
                    self.counter+=1

if __name__=='__main__':
    hcluser=HCluster('filePath')
    cluser=hcluser.cluster()
    print(cluser)

 參考：1.machine.learning.an.algorithmic.perspective.2nd.edition.

　　　 2.a programmer's guide to data mining