单链聚类算法_第九章 聚类

聚类

通过物品特征来计算距离，并自动分类到不同的群集或组中。

层次聚类算法

对于层次聚类算法，我们不需要预先指定分类的数量，这个算方法会将每条数据都当作是一个分类，每次迭代的时候合并距离最近的两个分类，直到剩下一个分类为止。

聚类的结果：顶层有一个大分类，这个分类下有两个子分类，每个子分类下又有两个子分类，依次内推，层级聚类也因此得名。

在合并的时候，我们会计算两个分类之间的距离，可以采用不同的方法，如下图 A、B、C 三个分类，我们可以采取：

单链聚类

在单链聚类中，分类之间的距离由两个分类相距最近的两个元素决定。如上图中分类 A 和分类 B 的距离由 A1 和 B1 的距离决定，因为这个距离小于 A1 到 B2、A2 到 B1 的距离，这样一来我们会将 A 和 B 进行合并。

全链聚类

在全链聚类中，分类之间的距离由两个分类相距最远的两个元素决定。因此上图中分类 A 和 B 的距离是 A2 到 B2 的距离，最后会将分类 B 和 C 进行合并。

平均链接聚类

在平均链接聚类中，分类之间的距离由分类之间两两元素的平均距离决定。因此上图中会将分类 B 和 C 进行合并。

例：用狗的高度和重量来进行聚类

计算欧几里得距离：

计算过程

第一步：找到最近的两个元素，进行聚类

第二部：在找到距离最近你的两个元素，进行聚类：

第三步：重复上面的步骤

算法实现层次聚类

from queue import PriorityQueue

import math

"""

层次聚类示例代码

"""

def getMedian(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

def normalizeColumn(column):

"""计算修正的标准分"""

median = getMedian(column)

asd = sum([abs(x - median) for x in column]) / len(column)

result = [(x - median) / asd for x in column]

return result

class hClusterer:

"""该聚类器默认数据的第一列是标签，其它列是数值型的特征。"""

def __init__(self, filename):

file = open(filename)

self.data = {}

self.counter = 0

self.queue = PriorityQueue()

lines = file.readlines()

file.close()

header = lines[0].split(',')

self.cols = len(header)

self.data = [[] for i in range(len(header))]

for line in lines[1:]:

cells = line.split(',')

toggle = 0

for cell in range(self.cols):

if toggle == 0:

self.data[cell].append(cells[cell])

toggle = 1

else:

self.data[cell].append(float(cells[cell]))

# 标准化特征列(即跳过第一列)

for i in range(1, self.cols):

self.data[i] = normalizeColumn(self.data[i])

###

### 数据已经读入内存并做了标准化，对于每一条记录，将执行以下步骤：

### 1. 计算该分类和其他分类的距离，如当前分类的下标是1，

### 它和下标为2及下标为3的分类之间的距离用以下形式表示：

### {2: ((1, 2), 1.23), 3: ((1, 3), 2.3)... }

### 2. 找出距离最近的分类；

### 3. 将该分类插入到优先队列中。

###

# 插入队列

rows = len(self.data[0])

for i in range(rows):

for i in range(rows):

minDistance = 99999

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

nearestNum = j

# 记录这两个分类的配对信息

if i < nearestNeighbor:

nearestPair = (i, nearestNeighbor)

else:

nearestPair = (nearestNeighbor, i)

# 插入优先队列

self.queue.put((minDistance, self.counter,

[[self.data[0][i]], nearestPair, neighbors]))

self.counter += 1

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]<