用Spyder实现AGNES算法和DIANA算法

 1.AGNES算法

注意事项

1、参考网址 https://blog.csdn.net/I_am_Tony_Stark/article/details/121282253

2、文件下载地址

链接：百度网盘 请输入提取码
提取码：ygtl
3、cluster_500-10_7 这个文件，如果放在桌面 需要更改代码第8行的路径，
具体操作为：
（1）右键放在桌面的这个文件，,点击属性
（2）复制位置，将右斜杠改为左斜杠
（3）在第8行代码中将其加到   /cluster_500-10_7.csv  前面

import numpy as np
import pandas as pd

import time
start = time.time()

# 读取数据
read_df = pd.read_csv('C:/Users/F117/Desktop/cluster_500-10_7.csv')

target = read_df.iloc[:, -1]
data = read_df.iloc[:, 1:-1]

k = 7
n = data.shape[0]
dis = np.zeros([n, n])
pre_target = np.arange(n)

# 初始化dis矩阵
# 求两两簇（点）之间的距离
for i in range(n-1):
    for j in range(i+1, n):
        dis[j][i] = ((data.iloc[j] - data.iloc[i]) ** 2).sum()
    print("初始化dis矩阵进度：{}/{}".format(i+1, n))
# 下三角复制到上三角
i_lower = np.triu_indices(n, 0)
dis[i_lower] = dis.T[i_lower]
# 无穷大为最大值
MAX = float('inf')
# 对角线附上最大值不参与运算
dis[np.diag_indices_from(dis)] = MAX
print("初始化dis矩阵进度：{}/{}".format(n, n))

_iter = 1

print("开始循环迭代")

while _iter <= n:
    # 找出最距离最小的两个点
    pA, pB = divmod(dis.argmin(), dis.shape[1])
    # 将新平均距离赋给pA，作为新的各簇到新簇pApB的值
    dis[:, pA] = (dis[:, pA] + dis[:, pB]) / 2
    dis[pA] = dis[:, pA]
    # pB簇置为最大
    dis[:, pB] = MAX
    dis[pB] = MAX
    # 将B所在pB簇所有点全部赋上点A所在的簇序号值
    pre_target[np.where(pre_target == pB)] = pA
    # 簇数
    c_num = len(np.unique(pre_target))
    if _iter % 10 == 0:
        print("循环迭代次数：{}，此时有{}个簇".format(_iter, c_num))
    # 循环直至分成k簇
    if c_num == k:
        break
    _iter += 1
    
print("结束循环迭代")

#pca降维
from sklearn.decomposition import PCA

pca = PCA(n_components=2)
newData = pca.fit_transform(data)
newData = pd.DataFrame(newData)

# 可视化
import matplotlib.pyplot as plt
x = np.array(newData.iloc[:, 0])
y = np.array(newData.iloc[:, 1])

# 原数据
plt.subplot(2,1,1)
plt.scatter(x, y, c=np.array(target))
# 预测数据
plt.subplot(2,1,2)
plt.scatter(x, y, c=pre_target)
plt.show()

end = time.time()
print(end-start)

2.DIANA算法 

注意事项

1、参考网址  https://blog.csdn.net/Vici__/article/details/107551226
2、用Pycharm和Spyder都可以直接运行

import math
 
'''
Point类，记录坐标x，y和点的名字id
'''
class Point:
    '''
    初始化函数
    '''
    def __init__(self, x, y, name, id):
        self.x = x # 横坐标
        self.y = y # 纵坐标
        self.name = name # 名字 
        self.id =  id # 编号 
    '''
    计算两点之间的欧几里得距离
    '''
    def calc_Euclidean_distance(self, p2):
        return math.sqrt((self.x - p2.x) * (self.x - p2.x) + (self.y - p2.y) * (self.y - p2.y))
 
'''
1. 获取数据集
'''
def get_dataset():
    # 原始数据集以元组形式存放，(横坐标，纵坐标，编号)
    datas = [(0, 2, 'A'), (0, 0, 'B'), (1.5, 0, 'C'), (5, 0, 'D'), (5, 2, 'E')]
    dataset = [] # 用于计算两点之间的距离，形式 [point1, point2...]
    id_point_dict = {} # 编号和点的映射
    temp_list = []
    for i in range(len(datas)): # 遍历原始数据集
        point = Point(datas[i][0], datas[i][1], datas[i][2], i) # 利用(横坐标，纵坐标，编号)实例化
        id_point_dict[str(i)] = point
        dataset.append(point) # 放入dataset中
        temp_list.append(point)
    return dataset, id_point_dict # [p1, p2], {id: point}
 
'''
2. 计算任意两点之间的距离
'''
def get_dist(dataset):
    n = len(dataset) # 点的个数
    dist = [] # 存放任意两点之间的距离
    for i in range(n):
        dist_i = [] # 临时列表
        for j in range(n): # 遍历数据集
            # 计算距离并放入临时列表中
            dist_i.append(dataset[i].calc_Euclidean_distance(dataset[j]))
        dist.append(dist_i) # 利用临时列表创建二维列表
    # 打印dist
    print("任意两点之间的距离：")
    for d in dist:
        print(d)
    print()
    return dist
 
'''
3. 计算簇内数据点相异度
'''
def get_dissimilitude(dist, ids):
    n = len(ids) # 这个簇的数据点个数
    dissimilitudes = {} # 存放数据点相异度
    for id1 in ids:
        id1_num = int(id1)
        d = 0 # 点id1的相异度，初始化为0
        for id2 in ids: # 遍历其它数据点
            id2_num = int(id2)
            d += dist[id1_num][id2_num] # 加上两点距离
        dissimilitudes[id1] = d / (n-1) # 计算相异度
    return dissimilitudes
'''
4. 寻找最大相异度的点
'''
def get_max_diff(dissimilitudes):
    Max = -1 # 最大相异度值，初始化为一个负值
    Max_id = -1 # 最大相异度值的数据点编号
    for id, diff in dissimilitudes.items(): # 遍历之前得到的相异度字典
        if diff > Max: # 有更大的，就更新
            Max = diff
            Max_id = id
    return Max_id # 返回最大相异度值的数据点编号
 
'''
5. DIANA算法主函数
'''
def DIANA(dataset, k, id_point_dict):
    dist = get_dist(dataset) # 获取任意两点之间距离（欧几里得距离）
    res = [] # 结果列表，存放每次操作完成后的簇组合
    ids = [] # 初始簇
    for i in range(len(dataset)):
        ids.append(str(i)) # 初始簇中包含所有数据点的编号
    res.append(ids) # 初始簇入结果列表
 
    while len(res) < k: # 簇的个数为k个时，退出循环
        t_res = [] # 结果列表res的复制，只用于遍历
        for t in res:
            t_res.append(t)
        for ids in t_res: # 遍历复制的结果列表
            splinter_group = [] # splinter group
            old_party = [] # old party
            dissimilitudes = get_dissimilitude(dist, ids) # 计算ids这个簇的相异度
            Max_id = get_max_diff(dissimilitudes) # 得到这个簇里最大相异度的数据点
            splinter_group.append(Max_id) # 放入splinter group
            for id in ids:        # 其余数据点放入old party
                old_party.append(id)
            old_party.remove(Max_id) # 全放进去，然后把最大点删掉就可以了
            pre_len = -1 # 用于判断old_party列表不再增加时，退出循环
            while pre_len != len(old_party): # 不相等说明，old_party列表还在变化
                pre_len = len(old_party) # 更新pre_len
                change_ids = [] 
                # 在old party中寻找 到splinter group中的点（E点）的最近距离
                # 小于等于到old party中的点的最近距离的点，找出D点，
                # 把该点加入splinter group中。在此数据集中，
                # 仅有点D到点E的距离2.3<3.5（5.3，5，3.5），
                # 所以将点D加入到splinter group 中（D,E点）；
                for id1 in old_party: # 在old party中寻找，遍历
                    Min = float("INF")
                    flag = True # 判断该点是否符合要求
                    for id2 in splinter_group: # splinter_group中若有多个点，需要找到最近距离
                        if dist[int(id1)][int(id2)] < Min:
                            Min = dist[int(id1)][int(id2)]
                    for id3 in old_party: # 寻找最近距离小于等于到old party中的点的最近距离的点
                        if (Min > dist[int(id1)][int(id3)]) and (id1 != id3): # 不符合要求的置为False，并退出循环
                            flag = False
                            break
                    if flag: # 该点符合要求
                        change_ids.append(id1) # 放入change_ids列表中，表示需要变化的数据点
                for id in change_ids: # 遍历
                    old_party.remove(id) # 从old_party中删除
                    splinter_group.append(id) # 放入splinter_group
            if len(splinter_group) != 0 and len(old_party) != 0: # 当前簇发生变化了，更新结果列表res
                res.remove(ids)   # 删除旧簇
                res.append(splinter_group) # 加入两个新簇
                res.append(old_party)
            # 打印结果看看
            print("-------------------------")
            print("最终聚类结果：")
            for r in res:
                for id in r:
                     # 我们之前用的都是数据点的编号，用id_point_dict找到该点，并打印他的名字
                    print(id_point_dict[id].name, end="")
                print()
 
# 测试
dataset, id_point_dict = get_dataset()
k = 2
DIANA(dataset, k, id_point_dict)