2. 程式人生 > >【機器學習】聚類演算法：層次聚類

【機器學習】聚類演算法：層次聚類

阿新 • • 發佈：2019-01-10

本文是“漫談 Clustering 系列”中的第 8 篇，參見本系列的其他文章。

系列不小心又拖了好久，其實正兒八經的 blog 也好久沒有寫了，因為比較忙嘛，不過覺得 Hierarchical Clustering 這個話題我能說的東西應該不多，所以還是先寫了吧（我準備這次一個公式都不貼 :D ）。Hierarchical Clustering 正如它字面上的意思那樣，是層次化的聚類，得出來的結構是一棵樹，如右圖所示。在前面我們介紹過不少聚類方法，但是都是“平坦”型的聚類，然而他們還有一個更大的共同點，或者說是弱點，就是難以確定類別數。實際上，（在某次不太正式的電話面試裡）我曾被問及過這個問題，就是聚類的時候如何確定類別數。

我能想到的方法都是比較 naive 或者比較不靠譜的，比如：

  • 根據資料的來源使用領域相關的以及一些先驗的知識來進行估計——說了等於沒有說啊……
  • 降維到二維平面上，然後如果資料形狀比較好的話，也許可以直觀地看出類別的大致數目。
  • 通過譜分析，找相鄰特徵值 gap 較大的地方——這個方法我只瞭解個大概，而且我覺得“較大”這樣的詞也讓它變得不能自動化了。

當時對方問“你還有沒有什麼問題”的時候我竟然忘記了問他這個問題到底有沒有什麼更好的解決辦法，事後真是相當後悔啊。不過後來在實驗室裡詢問了一下，得到一些線索，總的來說複雜度是比較高的，待我下次有機會再細說（先自己研究研究）。

不過言歸正傳，這裡要說的 Hierarchical Clustering 從某種意義上來說也算是解決了這個問題，因為在做 Clustering 的時候並不需要知道類別數，而得到的結果是一棵樹，事後可以在任意的地方橫切一刀，得到指定數目的 cluster ，按需取即可。

聽上去很誘人，不過其實 Hierarchical Clustering 的想法很簡單，主要分為兩大類：agglomerative（自底向上）和 divisive（自頂向下）。首先說前者，自底向上，一開始，每個資料點各自為一個類別，然後每一次迭代選取距離最近的兩個類別，把他們合併，直到最後只剩下一個類別為止，至此一棵樹構造完成。

看起來很簡單吧？ :D 其實確實也是比較簡單的，不過還是有兩個問題需要先說清除才行：

  1. 如何計算兩個點的距離？這個通常是 problem dependent 的，一般情況下可以直接用一些比較通用的距離就可以了，比如歐氏距離等。
  2. 如何計算兩個類別之間的距離？一開始所有的類別都是一個點，計算距離只是計算兩個點之間的距離，但是經過後續合併之後，一個類別裡就不止一個點了，那距離又要怎樣算呢？到這裡又有三個變種：
    • Single Linkage：又叫做 nearest-neighbor ，就是取兩個集合中距離最近的兩個點的距離作為這兩個集合的距離，容易造成一種叫做 Chaining 的效果，兩個 cluster 明明從“大局”上離得比較遠，但是由於其中個別的點距離比較近就被合併了，並且這樣合併之後 Chaining 效應會進一步擴大，最後會得到比較鬆散的 cluster 。
    • Complete Linkage：這個則完全是 Single Linkage 的反面極端，取兩個集合中距離最遠的兩個點的距離作為兩個集合的距離。其效果也是剛好相反的，限制非常大，兩個 cluster 即使已經很接近了，但是隻要有不配合的點存在，就頑固到底，老死不相合並，也是不太好的辦法。
    • Group Average：這種方法看起來相對有道理一些，也就是把兩個集合中的點兩兩的距離全部放在一起求一個平均值，相對也能得到合適一點的結果。

總的來說，一般都不太用 Single Linkage 或者 Complete Linkage 這兩種過於極端的方法。整個 agglomerative hierarchical clustering 的演算法就是這個樣子，描述起來還是相當簡單的，不過計算起來複雜度還是比較高的，要找出距離最近的兩個點，需要一個雙重迴圈，而且 Group Average 計算距離的時候也是一個雙重迴圈。

另外，需要提一下的是本文一開始的那個樹狀結構圖，它有一個專門的稱呼，叫做 Dendrogram ，其實就是一種二叉樹，畫的時候讓子樹的高度和它兩個後代合併時相互之間的距離大小成比例，就可以得到一個相對直觀的結構概覽。不妨再用最開始生成的那個三個 Gaussian Distribution 的資料集來舉一個例子，我採用 Group Average 的方式來計算距離，agglomerative clustering 的程式碼很簡單，沒有做什麼優化，就是直接的雙重迴圈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def do_clustering(nodes):
    # make a copy, do not touch the original list
    nodes = nodes[:]
    while len(nodes) > 1:
        print "Clustering [%d]..." % len(nodes)
        min_distance = float('inf')
        min_pair = (-1, -1)
        for i in range(len(nodes)):
            for j in range(i+1, len(nodes)):
                distance = nodes[i].distance(nodes[j])
                if distance < min_distance:
                    min_distance = distance
                    min_pair = (i, j)
        i, j = min_pair
        node1 = nodes[i]
        node2 = nodes[j]
        del nodes[j] # note should del j first (j > i)
        del nodes[i]
        nodes.append(node1.merge(node2, min_distance))
 
    return nodes[0]

資料點又一千多個，畫出來的 dendrogram 非常大，為了讓結果看起來更直觀一點，我把每個葉節點用它本身的 label 來染色，並且向上合併的時候按照權重混合一下顏色，最後把圖縮放一下得到這樣的一個結果（點選檢視原圖）：

tree_scaled

或者可以把所有葉子節點全部拉伸一下看，在右邊對齊，似乎起來更加直觀一點：

tree_full_depth_scaled

從這個圖上可以很直觀地看出來聚類的結果，形成一個層次，而且也在總體上把上個大類分開來了。由於這裡我把圖橫過來畫了，所以在需要具體的 flat cluster 劃分的時候，直觀地從圖上可以看成豎著劃一條線，打斷之後得到一片“森林”，再把每個子樹裡的所有元素變成一個“扁平”的集合即可。完整的 Python 程式碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

from scipy.linalg import norm
from PIL import Image, ImageDraw
 
def make_list(obj):
    if isinstance(obj, list):
        return obj
    return [obj]
 
class Node(object):
    def __init__(self, fea, gnd, left=None, right=None, children_dist=1):
        self.__fea = make_list(fea)
        self.__gnd = make_list(gnd)
        self.left = left
        self.right = right
        self.children_dist = children_dist
 
        self.depth = self.__calc_depth()
        self.height = self.__calc_height()
 
    def to_dendrogram(self, filename):
        height_factor = 3
        depth_factor = 20
        total_height = int(self.height*height_factor)
        total_depth = int(self.depth*depth_factor) + depth_factor
        im = Image.new('RGBA', (total_depth, total_height))
        draw = ImageDraw.Draw(im)
        self.draw_dendrogram(draw, depth_factor, total_height/2,
                             depth_factor, height_factor, total_depth)
        im.save(filename)
 
 
    def draw_dendrogram(self,draw,x,y,depth_factor,height_factor,total_depth):
        if self.is_terminal():
            color_self = ((255,0,0), (0,255,0), (0,0,255))[int(self.__gnd[0])]
            draw.line((x, y, total_depth, y), fill=color_self)
            return color_self
        else:
            y1 = int(y-self.right.height*height_factor/2)
            y2 = int(y+self.left.height*height_factor/2)
            xc = int(x + self.children_dist*depth_factor)
            color_left = self.left.draw_dendrogram(draw, xc, y1, depth_factor,
                                                   height_factor, total_depth)
            color_right = self.right.draw_dendrogram(draw, xc, y2, depth_factor,
                                                     height_factor, total_depth)
 
            left_depth = self.left.depth
            right_depth = self.right.depth
            sum_depth = left_depth + right_depth
            if sum_depth == 0:
                sum_depth = 1
                left_depth = 0.5
                right_depth = 0.5
            color_self = tuple([int((a*left_depth+b*right_depth)/sum_depth)
                                for a, b in zip(color_left, color_right)])
            draw.line((xc, y1, xc, y2), fill=color_self)
            draw.line((x, y, xc, y), fill=color_self)
            return color_self
 
 
    # use Group Average to calculate distance
    def distance(self, other):
        return sum([norm(x1-x2)
                    for x1 in self.__fea
                    for x2 in other.__fea]) \
                / (len(self.__fea)*len(other.__fea))
 
    def is_terminal(self):
        return self.left is None and self.right is None
 
    def __calc_depth(self):
        if self.is_terminal():
            return 0
        return max(self.left.depth, self.right.depth) + self.children_dist
 
    def __calc_height(self):
        if self.is_terminal():
            return 1
        return self.left.height + self.right.height
 
    def merge(self, other, distance):
        return Node(self.__fea + other.__fea,
                    self.__gnd + other.__gnd,
                    self, other, distance)
 
 
def do_clustering(nodes):
    # make a copy, do not touch the original list
    nodes = nodes[:]
    while len(nodes) > 1:
        print "Clustering [%d]..." % len(nodes)
        min_distance = float('inf')
        min_pair = (-1, -1)
        for i in range(len(nodes)):
            for j in range(i+1, len(nodes)):
                distance = nodes[i].distance(nodes[j])
                if distance < min_distance:
                    min_distance = distance
                    min_pair = (i, j)
        i, j = min_pair
        node1 = nodes[i]
        node2 = nodes[j]
        del nodes[j] # note should del j first (j > i)
        del nodes[i]
        nodes.append(node1.merge(node2, min_distance))
 
    return nodes[0]

agglomerative clustering 差不多就這樣了，再來看 divisive clustering ，也就是自頂向下的層次聚類，這種方法並沒有 agglomerative clustering 這樣受關注，大概因為把一個節點分割為兩個並不如把兩個節點結合為一個那麼簡單吧，通常在需要做 hierarchical clustering 但總體的 cluster 數目又不太多的時候可以考慮這種方法，這時可以分割到符合條件為止，而不必一直分割到每個資料點一個 cluster 。

總的來說，divisive clustering 的每一次分割需要關注兩個方面：一是選哪一個 cluster 來分割；二是如何分割。關於 cluster 的選取，通常採用一些衡量鬆散程度的度量值來比較，例如 cluster 中距離最遠的兩個資料點之間的距離，或者 cluster 中所有節點相互距離的平均值等，直接選取最“鬆散”的一個 cluster 來進行分割。而分割的方法也有多種，比如，直接採用普通的 flat clustering 演算法（例如 k-means）來進行二類聚類，不過這樣的方法計算量變得很大，而且像 k-means 這樣的和初值選取關係很大的演算法，會導致結果不穩定。另一種比較常用的分割方法如下：

  • 待分割的 cluster 記為 G ，在 G 中取出一個到其他點的平均距離最遠的點 x ，構成新 cluster H；
  • 在 G 中選取這樣的點 x’ ，x’ 到 G 中其他點的平均距離減去 x’ 到 H 中所有點的平均距離這個差值最大，將其歸入 H 中；
  • 重複上一個步驟，直到差值為負。

到此為止，我的 hierarchical clustering 介紹就結束了。總的來說，在我個人看來，hierarchical clustering 演算法似乎都是描述起來很簡單，計算起來很困難（計算量很大）。並且，不管是 agglomerative 還是 divisive 實際上都是貪心演算法了，也並不能保證能得到全域性最優的。而得到的結果，雖然說可以從直觀上來得到一個比較形象的大局觀，但是似乎實際用處並不如眾多 flat clustering 演算法那麼廣泛。

相關推薦

【機器學習】聚類演算法：層次聚類

本文是“漫談 Clustering 系列”中的第 8 篇，參見本系列的其他文章。 系列不小心又拖了好久，其實正兒八經的 blog 也好久沒有寫了，因為比較忙嘛，不過覺得 Hierarchical Clustering 這個話題我能說的東西應該不多，所以還是先寫了吧（我準

【機器學習】聚類演算法：層次聚類、K-means聚類

     所謂聚類，就是將相似的事物聚集在一 起，而將不相似的事物劃分到不同的類別的過程，是資料分析之中十分重要的一種手段。比如古典生物學之中，人們通過物種的形貌特徵將其分門別類，可以說就是 一種樸素的人工聚類。如此，我們就可以將世界上紛繁複雜的資訊，簡化為少數方便人們理解的類別，可以說是人類認知這個

【機器學習】DBSCAN Algorithms基於密度的聚類算法

多次 使用 缺點 有效 結束 基於 需要 att 共享 一、算法思想： DBSCAN(Density-Based Spatial Clustering of Applications with Noise)是一個比較有代表性的基於密度的聚

【機器學習】線性迴歸演算法的過擬合比較

回顧 過擬合與欠擬合 主要介紹了什麼是欠擬合什麼是過擬合 對抗過擬合 主要介紹了線性迴歸中對抗過擬合的方法，主要包括：L1-norm的LASSO迴歸、L2-norm的Ridge迴歸，此外還有一個沒有提到，L1-norm和L2-norm結合的Elasitc Net(彈性網

【機器學習】決策樹演算法（二）— 程式碼實現

#coding=utf8 ‘’’ Created on 2018年11月4日 @author: xiaofengyang 決策樹演算法：ID3演算法 ‘’’ from sklearn.feature_extraction import DictVectorize

【機器學習】神經網路（一）——多類分類問題

一、問題引入 早在監督學習中我們已經使用Logistic迴歸很好地解決二類分類問題。但現實生活中，更多的是多類分類問題（比如識別10個手寫數字）。本文引入神經網路模型解決多類分類問題。 二、神經網路模型介紹 神經網路模型是一個非常強大的模型，起源於嘗試讓機

【機器學習】（5）：貝葉斯決策定理

      其中，P(C|x)表示觀測到資料x時事件C發生的條件概率，我們稱為後驗概率（posterior probability）；P(C)=P(C=1)是事件C=1發生時的概率，稱為先驗概率（prior probabilty），因為這是在觀察到資料x之前就已經得到的關於C的知識；P(x|C)稱為類似然，與

【機器學習】迴歸案例實踐：資料處理建模調參

# -*- coding: utf-8 -*- """迴歸問題案例.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google

【機器學習】K近鄰演算法

Knn演算法是一種簡單的監督學習演算法，雖然效能並不算非常出色，但是可解釋性非常強。理論上可以證明，Knn可以以任意精度擬合真實分類高維曲面。 一、Knn演算法分析 1、該演算法在處理樣本分佈不均勻的時候效果比較差。比如正類的樣本數量為1000，反類的樣本數量為100，即

【機器學習】梯度下降演算法分析與簡述

梯度下降演算法分析與簡述 梯度下降(gradient descent)是一種最優化演算法，基於爬山法的搜尋策略，其原理簡單易懂，廣泛應用於機器學習和各種神經網路模型中。在吳恩達的神經網路課程中，梯度下降演算法是最先拿來教學的基礎演算法。 梯度下降演算法的

【機器學習】梯度下降演算法及梯度優化演算法

用於評估機器學習模型的就是損失函式，我們訓練的目的基本上都是最小化損失，這個最小化的方式就要用優化演算法了，機器學習中最常用的就是梯度下降演算法。 導數、方向導數和梯度 要了解梯度下降演算法是什麼首要知道梯度是什麼，導數和方向導數又是瞭解梯度的前提。

【機器學習】關於t-sne：降維、視覺化

關於t-sne：降維、視覺化 機器學習中，我們的使用的資料基本都是高維的，所以我們很難直接從資料中觀察分佈和特徵。因此出現了很多資料降維的手段幫助我們提取特徵和視覺化資料。這就是流行學習方法(Manifold Learning):假設資料是均勻取樣於一個高維歐

【機器學習】決策樹演算法的基本原理

　　參考周志華老師的《機器學習》一書，對決策樹演算法進行總結。 　　決策樹(Decision Tree)是在已知各種情況發生概率的基礎上，通過構建決策樹來求取淨現值期望值大於等於0的概率，評價專案風險，判斷其可行性的決策分析方法，是直觀運用概率分析的圖解法。

【機器學習】最近鄰演算法KNN原理、流程框圖、程式碼實現及優缺點

通過機器學習教學視訊，初識KNN演算法，對原理和演算法流程通過小應用進行Python實現，有了自己的一些理解。因此在此整理一下，既是對自己學習的階段性總結，也希望能和更多的朋友們共同交流學習相關演算法，如有不完善的地方歡迎批評指正。1、KNN演算法原理KNN，全稱k-Near

【機器學習】K-Means演算法的原理流程、程式碼實現及優缺點

分類是根據樣本某些屬性或某類特徵（可以融合多類特徵），把樣本型別歸為已確定的某一類別中。機器學習中常見的分類演算法有：SVM(支援向量機)、KNN(最鄰近法)、Decision Tree(決策樹分類法)

王小草【機器學習】筆記--EM演算法

標籤（空格分隔）： 王小草機器學習筆記 EM演算法的英文全稱是Expectation Maximization Algorithm，也就是求期望最大化，也就是我們常說的目標函式求最大值的演算法。EM演算法，直觀的說，就是有一堆未知的資料（比如一些特徵值），

【機器學習】K均值演算法

K均值演算法是最基礎的一種聚類演算法。具體演算法描述就不提了，資料實在太多，這裡說一下它的特點和侷限性。 一、K均值的特點 1、容易陷入區域性最小值 之所以陷入區域性最小值，是因為初始值設定的有問題，即初始的K個base點在屬性空間中的位置直接影響了最終的聚類結果。所以可

【機器學習】k-近鄰演算法（k-nearest neighbor, k-NN）

前言 kk近鄰學習是一種常用的監督學習方法。 kk近鄰法的輸入為例項的特徵向量，對應於特徵空間的點；輸出為例項的類別，可以取多類。 kk近鄰法的工作機制很簡單：給定測試樣本，基於某種距離度量（關於

【機器學習】：Kmeans均值聚類演算法原理(附帶Python程式碼實現)

這個演算法中文名為k均值聚類演算法，首先我們在二維的特殊條件下討論其實現的過程，方便大家理解。 第一步.隨機生成質心 由於這是一個無監督學習的演算法，因此我們首先在一個二維的座標軸下隨機給定一堆點，並隨即給定兩個質心，我們這個演算法的目的就是將這一堆點根據它們自身的座標特徵分為兩類，因此選取了兩個質心，什麼時

【機器學習】接地氣地解釋K-means聚類演算法

       俗話說“物以類聚，人以群分”，這句話在K-means聚類演算法裡面得到了充分的繼承。而K-means演算法的實際應用範圍可謂是大到無法估量，基本可以說，只要你想不到，沒有聚類聚不起來的東西！       &nbs