聚类算法的编程结构

Question

我正在尝试实现以下（分裂）聚类算法（下面是该算法的简短形式，完整描述可用here）：

从样本 x, i = 1, ..., n 开始，n 被视为 n 个数据点的单个集群，并且为所有点对定义了相异矩阵 D。修正一个阈值T来决定是否分裂一个簇。

首先确定所有数据点对之间的距离，选择它们之间距离(Dmax)最大的一对。
将 Dmax 与 T 进行比较。如果 Dmax > T，则通过使用所选对作为两个新簇中的第一个元素，将单个簇一分为二。剩余的 n - 2 个数据点被放入两个新集群之一。如果 D(x_i, x_l) < D(x_j, x_l)，则 x_l 被添加到包含 x_i 的新簇中，否则为添加到包含 x_i.
在第二阶段，在两个新簇之一中找到值 D(x_i, x_j) 以找到簇中距离最大的对它们之间的 Dmax。如果 Dmax < T，则集群的划分停止，并考虑另一个集群。然后在从该迭代生成的集群上重复该过程。

输出是集群数据记录的层次结构。请教如何实现聚类算法。

编辑 1: 我附上 Python 定义距离（相关系数）的函数和在数据矩阵中找到最大距离的函数。

# Read data from GitHub
import pandas as pd
df = pd.read_csv('https://raw.githubusercontent.com/nico/collectiveintelligence-book/master/blogdata.txt', sep = '\t', index_col = 0)
data = df.values.tolist()
data = data[1:10]

# Define correlation coefficient as distance of choice
def pearson(v1, v2):
  # Simple sums
  sum1 = sum(v1)
  sum2 = sum(v2)
  # Sums of the squares
  sum1Sq = sum([pow(v, 2) for v in v1])
  sum2Sq = sum([pow(v, 2) for v in v2]) 
  # Sum of the products
  pSum=sum([v1[i] * v2[i] for i in range(len(v1))])
  # Calculate r (Pearson score)
  num = pSum - (sum1 * sum2 / len(v1))
  den = sqrt((sum1Sq - pow(sum1,2) / len(v1)) * (sum2Sq - pow(sum2, 2) / len(v1)))
  if den == 0: return 0
  return num / den


# Find largest distance
dist={}
max_dist = pearson(data[0], data[0])
# Loop over upper triangle of data matrix
for i in range(len(data)):
  for j in range(i + 1, len(data)):
     # Compute distance for each pair
     dist_curr = pearson(data[i], data[j])
     # Store distance in dict
     dist[(i, j)] = dist_curr
     # Store max distance
     if dist_curr > max_dist:
       max_dist = dist_curr

编辑 2： 下面粘贴的是 Dschoni 的回答中的函数。

# Euclidean distance
def euclidean(x,y):
  x = numpy.array(x)
  y = numpy.array(y) 
  return numpy.sqrt(numpy.sum((x-y)**2))

# Create matrix
def dist_mat(data):
  dist = {}
  for i in range(len(data)):
    for j in range(i + 1, len(data)):
      dist[(i, j)] = euclidean(data[i], data[j])
  return dist


# Returns i & k for max distance
def my_max(dict):
    return max(dict)

# Sort function
list1 = []
list2 = []
def sort (rcd, i, k):
  list1.append(i)
  list2.append(k)
  for j in range(len(rcd)):
    if (euclidean(rcd[j], rcd[i]) < euclidean(rcd[j], rcd[k])):
      list1.append(j)
    else:
      list2.append(j)

编辑 3： 当我运行 @Dschoni 提供的代码时，算法按预期工作。然后我修改了 create_distance_list 函数，这样我们就可以计算多元数据点之间的距离。我使用欧氏距离。对于玩具示例，我加载 iris 数据。我只对数据集的前 50 个实例进行聚类。

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header = None, sep = ',')
df = df.drop(4, 1)
df = df[1:50]
data = df.values.tolist()

idl=range(len(data))
dist = create_distance_list(data)
print sort(dist, idl)

结果如下：

[[24], [17], [4], [7], [40], [13], [14], [15], [26, 27, 38], [3, 16, 39], [25], [42], [18, 20, 45], [43], [1, 2, 11, 46], [12, 37, 41], [5], [21], [22], [10, 23, 28, 29], [6, 34, 48], [0, 8, 33, 36, 44], [31], [32], [19], [30], [35], [9, 47]]

一些数据点仍然聚集在一起。我通过在 sort 函数的 actual 字典中添加少量数据噪音来解决这个问题：

# Add small random noise
for key in actual:    
  actual[key] +=  np.random.normal(0, 0.005)

知道如何正确解决这个问题吗？

Answer 1

欧几里得距离的正确工作示例：

import numpy as np
#For random number generation


def create_distance_list(l):
'''Create a distance list for every
unique tuple of pairs'''
    dist={}
    for i in range(len(l)):
        for k in range(i+1,len(l)):
            dist[(i,k)]=abs(l[i]-l[k])
    return dist

def maximum(distance_dict):
'''Returns the key of the maximum value if unique
or a random key with the maximum value.'''
    maximum = max(distance_dict.values())
    max_key = [key for key, value in distance_dict.items() if value == maximum]
    if len(max_key)>1:
        random_key = np.random.random_integers(0,len(max_key)-1)
        return (max_key[random_key],)
    else:
        return max_key

def construct_new_dict(distance_dict,index_list):
'''Helper function to create a distance map for a subset
of data points.'''
    new={}
    for i in range(len(index_list)):
        for k in range(i+1,len(index_list)):
            m = index_list[i]
            n = index_list[k]
            new[(m,n)]=distance_dict[(m,n)]
    return new

def sort(distance_dict,idl,threshold=4):
    result=[idl]
    i=0
    try:
        while True:
            if len(result[i])>=2:
            actual=construct_new_dict(dist,result[i]) 
                act_max=maximum(actual)
                if distance_dict[act_max[0]]>threshold:
                    j = act_max[0][0]
                    k = act_max[0][1]
                    result[i].remove(j)
                    result[i].remove(k)
                    l1=[j]
                    l2=[k]
                    for iterr in range(len(result[i])):
                        s = result[i][iterr]
                        if s>j:
                            c1=(j,s)
                        else:
                            c1=(s,j)
                        if s>k:
                            c2=(k,s)
                        else: 
                            c2=(s,k)
                        if actual[c1]<actual[c2]:
                            l1.append(s)
                        else:
                            l2.append(s)
                    result.remove(result[i])
    #What to do if distance is equal?
                    l1.sort()
                    l2.sort()
                    result.append(l1)
                    result.append(l2)
                else:
                    i+=1
            else:
                i+=1
    except:
        return result


#This is the dataset
a = [1,2,2.5,5]
#Giving each entry a unique ID
idl=range(len(a))
dist = create_distance_list(a)
print sort(dist,idl)

我写代码是为了可读性，有很多东西可以做得更快、更可靠、更漂亮。这只是为了让您了解如何完成。

Answer 2

Some data points are still clustered together. I solve this problem by adding small amount of data noise to actual dictionary in the sort function.

If Dmax > T then divide single cluster in two

您的描述不一定会创建 n 个集群。
如果一个簇有两条距离小于T,
的记录他们会聚集在一起（我错过了什么吗？）

聚类算法的编程结构

Which programming structure for clustering algorithm

python

data-structures

cluster-analysis

hierarchical-clustering