系列不小心又拖了好久,其实正儿八经的 blog 也好久没有写了,因为比较忙嘛,不过觉得 Hierarchical Clustering 这个话题我能说的东西应该不多,所以还是先写了吧(我准备这次一个公式都不贴  )。Hierarchical Clustering 正如它字面上的意思那样,是层次化的聚类,得出来的结构是一棵树,如右图所示。在前面我们介绍过不少聚类方法,但是都是“平坦”型的聚类,然而他们还有一个更大的共同点,或者说是弱点,就是难以确定类别数。实际上,(在某次不太正式的电话面试里)我曾被问及过这个问题,就是聚类的时候如何确定类别数。

我能想到的方法都是比较 naive 或者比较不靠谱的,比如:

  • 根据数据的来源使用领域相关的以及一些先验的知识来进行估计——说了等于没有说啊……
  • 降维到二维平面上,然后如果数据形状比较好的话,也许可以直观地看出类别的大致数目。
  • 通过谱分析,找相邻特征值 gap 较大的地方——这个方法我只了解个大概,而且我觉得“较大”这样的词也让它变得不能自动化了。

当时对方问“你还有没有什么问题”的时候我竟然忘记了问他这个问题到底有没有什么更好的解决办法,事后真是相当后悔啊。不过后来在实验室里询问了一下,得到一些线索,总的来说复杂度是比较高的,待我下次有机会再细说(先自己研究研究)。

不过言归正传,这里要说的 Hierarchical Clustering 从某种意义上来说也算是解决了这个问题,因为在做 Clustering 的时候并不需要知道类别数,而得到的结果是一棵树,事后可以在任意的地方横切一刀,得到指定数目的 cluster ,按需取即可。

听上去很诱人,不过其实 Hierarchical Clustering 的想法很简单,主要分为两大类:agglomerative(自底向上)和 divisive(自顶向下)。首先说前者,自底向上,一开始,每个数据点各自为一个类别,然后每一次迭代选取距离最近的两个类别,把他们合并,直到最后只剩下一个类别为止,至此一棵树构造完成。

看起来很简单吧?  其实确实也是比较简单的,不过还是有两个问题需要先说清除才行:

  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 来染色,并且向上合并的时候按照权重混合一下颜色,最后把图缩放一下得到这样的一个结果(点击查看原图):

或者可以把所有叶子节点全部拉伸一下看,在右边对齐,似乎起来更加直观一点:

从这个图上可以很直观地看出来聚类的结果,形成一个层次,而且也在总体上把上个大类分开来了。由于这里我把图横过来画了,所以在需要具体的 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 (5): Hierarchical Clustering的更多相关文章

  1. Python-层次聚类-Hierarchical clustering

    层次聚类关键方法#coding:UTF-8#Hierarchical clustering 层次聚类from E_distance import Euclidean_distance from yez ...

  2. 层次聚类 Hierarchical Clustering

    -------------------------------- 不管是GMM,还是k-means,都面临一个问题,就是k的个数如何选取?比如在bag-of-words模型中,用k-means训练码书 ...

  3. 漫谈 Clustering (4): Spectral Clustering

    转:http://blog.pluskid.org/?p=287 如果说 K-means 和 GMM 这些聚类的方法是古代流行的算法的话,那么这次要讲的 Spectral Clustering 就可以 ...

  4. 漫谈 Clustering (4): Spectral Clustering<转载>

    转自http://blog.pluskid.org/?p=287 如果说 K-means 和 GMM 这些聚类的方法是古代流行的算法的话,那么这次要讲的 Spectral Clustering 就可以 ...

  5. Hierarchical clustering:利用层次聚类算法来把100张图片自动分成红绿蓝三种色调—Jaosn niu

    #!/usr/bin/python # coding:utf-8 from PIL import Image, ImageDraw from HierarchicalClustering import ...

  6. 机器学习(6): 层次聚类 hierarchical clustering

    假设有N个待聚类的样本,对于层次聚类来说,步骤:        1.(初始化)把每个样本归为一类,计算每两个类之间的距离,也就是样本与样本之间的相似度:        2.寻找各个类之间最近的两个类, ...

  7. K-Means clusternig example with Python and Scikit-learn(推荐)

    https://www.pythonprogramming.net/flat-clustering-machine-learning-python-scikit-learn/ Unsupervised ...

  8. [Python] 机器学习库资料汇总

    声明:以下内容转载自平行宇宙. Python在科学计算领域,有两个重要的扩展模块:Numpy和Scipy.其中Numpy是一个用python实现的科学计算包.包括: 一个强大的N维数组对象Array: ...

  9. python数据挖掘领域工具包

    原文:http://qxde01.blog.163.com/blog/static/67335744201368101922991/ Python在科学计算领域,有两个重要的扩展模块:Numpy和Sc ...

随机推荐

  1. 洛谷P2812校园网络【Network of Schools加强版】

    题目背景 浙江省的几所\(OI\)强校的神犇发明了一种人工智能,可以\(AC\)任何题目,所以他们决定建立一个网络来共享这个软件.但是由于他们脑力劳动过多导致全身无力身体被\(♂\)掏\(♂\)空,他 ...

  2. Angular学习笔记【如何正确使用第三方组件】

    例如:ng-bootstrap的使用: 1.首先肯定是先要安装,参考官网给出的指令安装即可.(npm install --save @ng-bootstrap/ng-bootstrap) 2.在App ...

  3. BZOJ 1924 && Luogu P2403 [SDOI2010]所驼门王的宝藏 恶心建图+缩点DP

    记住:map一定要这么用: if(mp[x[i]+dx[j]].find(y[i]+dy[j])!=mp[x[i]+dx[j]].end()) add(i,mp[x[i]+dx[j]][y[i]+dy ...

  4. Chapter10

    package scala import java.io.{PrintStream, PrintWriter}import java.util.Date import scala.util.loggi ...

  5. (六)Redis主从自动恢复-sentinel

    原文地址,转载请注明出处: http://blog.csdn.net/qq_34021712/article/details/72026313     ©王赛超 准备工作:(1个master,2个sl ...

  6. PHP中文手册2

    11.异常处理 用户可以用自定义的异常处理类来扩展 PHP 内置的异常处理类.以下的代码说明了在内置的异常处理类中,哪些属性和方法在子类中是可访问和可继承的.译者注:以下这段代码只为说明内置异常处理类 ...

  7. android 开发AlertDialog.builder对话框的实现

    AndroidAPI提供了Dialog对话框控件,但google明确指出不建议开发者只是使用Dialog来创建对话框,而应该自定义对话框或者使用API中提供的Dialog的子类,如AlertDialo ...

  8. 性能测试学习第十天_controller

    集合点设置 controller虚拟多个用户执行脚本启动步骤不一定同步,集合点在脚本的某处设置一个标记,当有虚拟用户运行到这个标记的时候,停下等待所有用户都达到这个标记,再一同进行下面的步骤.这样可以 ...

  9. GitHub上易于高效开发的Android开源项目TOP20--适合新手

    1. android-async-http android-async-http是Android上的一个异步.基于回调的HTTP客户端开发包,建立在Apache的HttpClient库上. 2. an ...

  10. Spring相关理解

    日常拖完整患者............... 待续...