1. import numpy as np
    3. # 计算两个点的欧式距离
    4. def euclidean_distance(point1, point2):
    5.     return (np.sum((point1 - point2) ** 2)) ** 0.5
    7. # 定义中心初始化函数
    8. def centroids_init(k, X):
    9.     n_samples, n_features = X.shape  # 
    10.     indexes = [i for i in range(n_samples)]  # 索引
    11.     centroids = np.zeros((k, n_features))  
    12.     for i in range(k):
    13.         # 每一次循环随机选择一个类别中心
    14.         random.shuffle(indexes)  # 这样可以保证不被重复选取
    15.         centroid = X[indexes.pop()]
    16.         centroids[i] = centroid
    17.     return centroids
    20. # 计算样本距离哪个质心最近
    21. def closest_centroid(sample, centroids):
    22.     # sample 一个样本
    23.     # centroids 所有质心
    24.     cls = 0  
    25.     closest_dist = float('inf')
    26.     for i, centroid in enumerate(centroids):
    27.         # 根据欧式距离判断，选择最小距离的中心点所属类别
    28.         distance = euclidean_distance(sample, centroid)
    29.         if distance < closest_dist:
    30.             cls = i
    31.             closest_dist = distance
    32.     return cls  # 返回类别索引
    35. # 找出各个样本属于哪个类别
    36. def create_clusters(centroids, k, X):
    37.     n_samples = np.shape(X)[0]
    38.     clusters = [[] for _ in range(k)]
    39.     for sample_i, sample in enumerate(X):
    40.         # 将样本划分到最近的类别区域
    41.         cls = closest_centroid(sample, centroids)
    42.         clusters[cls].append(sample_i)
    43.     return clusters
    46. # 根据聚类结果重新计算质心
    47. def calculate_centroids(clusters, k, X):
    48.     n_features = np.shape(X)[1]
    49.     centroids = np.zeros((k, n_features))
    50.     # 以当前每个类样本的均值为新的中心点
    51.     for i, cluster in enumerate(clusters):
    52.         centroid = np.mean(X[cluster], axis=0)
    53.         centroids[i] = centroid
    54.     return centroids
    57. # 获取最终每个样本所属的聚类类别
    58. def get_cluster_labels(clusters, X):
    59.     y_pred = np.zeros(np.shape(X)[0])  # 样本数量大小
    60.     for cluster_i, cluster in enumerate(clusters):  # 遍历每个簇
    61.         for sample_i in cluster:  # 遍历簇中的所有样本
    62.             y_pred[sample_i] = cluster_i
    63.     return y_pred
    66. # 根据上述各流程定义kmeans算法流程
    67. def kmeans(X, k, max_iterations):
    68.     # 1.初始化中心点
    69.     centroids = centroids_init(k, X)
    70.     # 遍历迭代求解
    71.     for itera in range(max_iterations):
    72.         # 2.将各个样本分配到其所属质心的簇中
    73.         clusters = create_clusters(centroids, k, X)
    74.         # 保存当前中心点 
    75.         prev_centroids = centroids
    76.         # 3.根据聚类结果计算新的中心点
    77.         centroids = calculate_centroids(clusters, k, X)
    78.         # 4.设定收敛条件为中心点是否发生变化
    79.         diff = centroids - prev_centroids    
    80.         if not diff.any():        
    81.             break
    82.     # 返回最终的聚类标签
    83.     return get_cluster_labels(clusters, X)
    86. """
    87. 1、计算欧式距离
    88. 2、初始化中心
    89. 3、计算一个样本到所属的类别
    90. 4、各个样本的所属质心
    91. 5、重新计算质心
    92. 6、比较前后质心
    93. 7、获取最终类别
    94. 8、迭代
    95. """
    98. # 测试数据
    99. X = np.array([[0,2],[0,0],[1,0],[5,0],[5,2]])
    100. # 设定聚类类别为2个，最大迭代次数为10次
    101. labels = kmeans(X, 2, 10)
    102. # 打印每个样本所属的类别标签
    103. print(labels)