系列不小心又拖了好久,其实正儿八经的 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. 深入理解C/C++ [Deep C (and C++)]

    编程是困难的,正确的使用C/C++编程尤其困难.确实,不管是C还是C++,很难看到那种良好定义并且编写规范的代码.为什么专业的程序员写出这样的代码?因为绝大部分程序员都没有深刻的理解他们所使用的语言. ...

  2. 使用combobox下拉列表框实现省 市 县 的三级联动

    package com.hanqi.entity; //地区 public class Region { //地区id private String regionID; //地区名称 private ...

  3. day20模块作业

    1.模块化作业 1.回顾文件递归遍历. 默写一遍. 入口在: 当文件是个文件夹的时候 出口在: 文件是一个文件 2.计算时间差(用户输入起始时间和结束时间. 计算时间差(小时), 例如, 用户输入20 ...

  4. day13列表推导式作业详解

    1.day13题目 2,用列表推导式做下列小题 (1)过滤掉长度小于3的字符串列表,并将剩下的转换成大写字母 (2)求(x,y)其中x是0-5之间的偶数,y是0-5之间的奇数组成的元祖列表 (3)求M ...

  5. Leetcode初级算法(字符串篇)

    目录 反转字符串 颠倒整数 字符串中的第一个唯一字符 有效的字母异位词 验证回文字符串 实现strStr() 数数并说 最长公共前缀 字符串转整数(atoi) 反转字符串 和vector同样的进行sw ...

  6. BestCoder Round #86 1001

    链接http://acm.hdu.edu.cn/showproblem.php?pid=5804 题意:给你一些商店和他的商品价格,然后给你一个记账本,问你记大了就是1,否则是0 解法:模拟,注意测试 ...

  7. spring retry注解

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/20 ...

  8. python入门之random模块

    #!/usr/bin/env python #_*_encoding: utf-8_*_ import random print(random.random()) #生成一个在0到1之间的随机浮点数 ...

  9. CentOS 7 iptables 开放8080端口

    # 安装iptables-services [root@localhost bin]# yum install iptables-services [root@localhost bin]# /bin ...

  10. koa2 从入门到进阶之路 (五)

    之前的文章我们介绍了一下 koa 中使用 ejs 模板及页面渲染,本篇文章我们来看一下 koa post提交数据及 koa-bodyparser中间件. 在前端页面中,不免会用到 form 表单和 p ...