如何使用Python语言实现K-Means聚类算法

这篇文章给大家分享的是有关如何使用Python语言实现K-Means聚类算法的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

1 概述

1.1 无监督学习

      在一个典型的监督学习中，我们有一个有标签的训练集，我们的目标是找到能够区分正
样本和负样本的决策边界，在这里的监督学习中，我们有一系列标签，我们需要据此拟合一
个假设函数。与此不同的是，在非监督学习中，我们的数据没有附带任何标签，我们拿到的
数据就是这样的：

在这里我们有一系列点，却没有标签。因此，我们的训练集可以写成只有：

 我们没有任何标签?。因此，图上画的这些点没有标签信息。也就是说，在非监 督学习中，我们需要将一系列无标签的训练数据，输入到一个算法中，然后我们告诉这个算法，快去为我们找找这个数据的内在结构给定数据。我们可能需要某种算法帮助我们寻找一 种结构。图上的数据看起来可以分成两个分开的点集（称为簇）， 一个能够找到我圈出的这 些点集的算法，就被称为聚类算法 。
       这将是我们介绍的第一个非监督学习算法。当然，此后我们还将提到其他类型的非监督
学习算法，它们可以为我们找到其他类型的结构或者其他的一些模式，而不只是簇。

我们将先介绍聚类算法。此后，我们将陆续介绍其他算法。那么聚类算法一般用来做什
么呢？

       比如市场分割。也许你在数据库中存储了许多客户的信息，而你希望将他们分成不同的客户群，这样你可以对不同类型的客户分别销售产品或者分别提供更适合的服务。社交网络分析：事实上有许多研究人员正在研究这样一些内容，他们关注一群人，关注社交网络，例如 Facebook ， Google+，或者是其他的一些信息，比如说：你经常跟哪些人联系，而这些人又经常给哪些人发邮件，由此找到关系密切的人群。因此，这可能需要另一个聚类算法，你希望用它发现社交网络中关系密切的朋友。 研究这个问题，希望使用聚类算法来更好的组织计算机集群，或者更好的管理数据中心。因为如果你知道数据中心中，那些计算机经常协作工作。那么，你可以重新分配资源，重新布局网络。由此优化数据中心，优化数据通信。
     最后，我实际上还在研究如何利用聚类算法了解星系的形成。然后用这个知识，了解一
些天文学上的细节问题。好的，这就是聚类算法。这将是我们介绍的第一个非监督学习算法,接下来，我们将开始介绍一个具体的聚类算法。

1.2 聚类

1.3 K-Mean均值算法

2 K-Mean均值算法 

2.1 引入

K- 均值 是最普及的聚类算法，算法接受一个未标记的数据集，然后将数据聚类成不同的
组

步骤：

• 设定 K 个类别的中心的初值；

• 计算每个样本到 K个中心的距离，按最近距离进行分类；

• 以每个类别中样本的均值，更新该类别的中心；

• 重复迭代以上步骤，直到达到终止条件（迭代次数、最小平方误差、簇中心点变化率）。

下面是一个聚类示例： 

K-means聚类算法：

K-均值算法的伪代码如下：

Repeat {
for i = 1 to m
c(i) := index (form 1 to K) of cluster centroid closest to x(i)
for k = 1 to K
μk := average (mean) of points assigned to cluster k
}

算法分为两个步骤，第一个 for 循环是赋值步骤，即：对于每一个样例 i ，计算其应该属
于的类。第二个 for 循环是聚类中心的移动，即：对于每一个类K ，重新计算该类的质心。

from sklearn.cluster import KMeans  # 导入 sklearn.cluster.KMeans 类
import numpy as np
 
X = np.array([[1,2], [1,4], [1,0], [10,2], [10,4], [10,0]])
kmCluster = KMeans(n_clusters=2).fit(X)  # 建立模型并进行聚类，设定 K=2
print("聚类中心坐标:",kmCluster.cluster_centers_)  # 返回每个聚类中心的坐标
print("分类结果:",kmCluster.labels_)  # 返回样本集的分类结果
print("显示预测判断:",kmCluster.predict([[0, 0], [12, 3]]))  # 根据模型聚类结果进行预测判断

聚类中心坐标: [[10.  2.]
 [ 1.  2.]]
分类结果: [1 1 1 0 0 0]
显示预测判断: [1 0]
 
Process finished with exit code 0

2.2 针对大样本集的改进算法：Mini Batch K-Means 

对于样本集巨大的问题，例如样本量大于 10万、特征变量大于100，K-Means算法耗费的速度和内存很大。SKlearn 提供了针对大样本集的改进算法Mini Batch K-Means，并不使用全部样本数据，而是每次抽样选取小样本集进行 K-Means聚类，进行循环迭代。Mini Batch K-Means 虽然性能略有降低，但极大的提高了运行速度和内存占用。　

from sklearn.cluster import MiniBatchKMeans # 导入 .MiniBatchKMeans 类
import numpy as np
X = np.array([[1,2], [1,4], [1,0], [4,2], [4,0], [4,4],
              [4,5], [0,1], [2,2],[3,2], [5,5], [1,-1]])
# fit on the whole data
mbkmCluster = MiniBatchKMeans(n_clusters=3,batch_size=6,max_iter=10).fit(X)
print("聚类中心的坐标:",mbkmCluster.cluster_centers_) # 返回每个聚类中心的坐标
print("样本集的分类结果:",mbkmCluster.labels_)  # 返回样本集的分类结果
print("显示判断结果：样本属于哪个类别:",mbkmCluster.predict([[0,0], [4,5]]))  # 根据模型聚类结果进行预测判断

聚类中心的坐标: [[ 2.55932203  1.76271186]
 [ 0.75862069 -0.20689655]
 [ 4.20588235  4.5       ]]
样本集的分类结果: [0 0 1 0 0 2 2 1 0 0 2 1]
显示判断结果：样本属于哪个类别: [1 2]
 
Process finished with exit code 0

2.3 图像

from sklearn.cluster import kmeans_plusplus
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
 
# Generate sample data
n_samples = 4000
n_components = 4
 
X, y_true = make_blobs(
    n_samples=n_samples, centers=n_components, cluster_std=0.60, random_state=0
)
X = X[:, ::-1]
 
# Calculate seeds from kmeans++
centers_init, indices = kmeans_plusplus(X, n_clusters=4, random_state=0)
 
# Plot init seeds along side sample data
plt.figure(1)
colors = ["#4EACC5", "#FF9C34", "#4E9A06", "m"]
 
for k, col in enumerate(colors):
    cluster_data = y_true == k
    plt.scatter(X[cluster_data, 0], X[cluster_data, 1], c=col, marker=".", s=10)
 
plt.scatter(centers_init[:, 0], centers_init[:, 1], c="b", s=50)
plt.title("K-Means++ Initialization")
plt.xticks([])
plt.yticks([])
plt.show()

3 案例1 

3.1 代码

#  -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans, MiniBatchKMeans
 
def main():
    # 读取数据文件
    file = pd.read_excel('K-Means.xlsx', header=0)  # 首行为标题行
    file = file.dropna()  # 删除含有缺失值的数据
    # print(file.dtypes)  # 查看 df 各列的数据类型
    # print(file.shape)  # 查看 df 的行数和列数
    print(file.head())
 
    # 数据准备
    z_scaler = lambda x:(x-np.mean(x))/np.std(x)  # 定义数据标准化函数
    dfScaler = file[['D1','D2','D3','D4','D5','D6','D7','D8','D9','D10']].apply(z_scaler)  # 数据归一化
    dfData = pd.concat([file[['地区']], dfScaler], axis=1)  # 列级别合并
    df = dfData.loc[:,['D1','D2','D3','D4','D5','D6','D7','D8','D9','D10']]  # 基于全部 10个特征聚类分析
    # df = dfData.loc[:,['D1','D2','D7','D8','D9','D10']]  # 降维后选取 6个特征聚类分析
    X = np.array(df)  # 准备 sklearn.cluster.KMeans 模型数据
    print("Shape of cluster data:", X.shape)
 
    # KMeans 聚类分析(sklearn.cluster.KMeans)
    nCluster = 4
    kmCluster = KMeans(n_clusters=nCluster).fit(X)  # 建立模型并进行聚类，设定 K=4
    print("Cluster centers:\n", kmCluster.cluster_centers_)  # 返回每个聚类中心的坐标
    print("Cluster results:\n", kmCluster.labels_)  # 返回样本集的分类结果
 
    # 整理聚类结果(太棒啦！)
    listName = dfData['地区'].tolist()  # 将 dfData 的首列 '地区' 转换为 list
    dictCluster = dict(zip(listName,kmCluster.labels_))  # 将 listName 与聚类结果关联，组成字典
    listCluster = [[] for k in range(nCluster)]
    for v in range(0, len(dictCluster)):
        k = list(dictCluster.values())[v]  # 第v个城市的分类是 k
        listCluster[k].append(list(dictCluster.keys())[v])  # 将第v个城市添加到 第k类
    print("\n聚类分析结果(分为{}类):".format(nCluster))  # 返回样本集的分类结果
    for k in range(nCluster):
        print("第 {} 类：{}".format(k, listCluster[k]))  # 显示第 k 类的结果
 
    return
 
if __name__ == '__main__':
    main()

3.2 结果 

地区    D1   D2   D3    D4   D5   D6     D7    D8    D9    D10
0  北京  5.96  310  461  1557  931  319  44.36  2615  2.20  13631
1  上海  3.39  234  308  1035  498  161  35.02  3052  0.90  12665
2  天津  2.35  157  229   713  295  109  38.40  3031  0.86   9385
3  陕西  1.35   81  111   364  150   58  30.45  2699  1.22   7881
4  辽宁  1.50   88  128   421  144   58  34.30  2808  0.54   7733
Shape of cluster data: (30, 10)
Cluster centers:
 [[-3.04626787e-01 -2.89307971e-01 -2.90845727e-01 -2.88480032e-01
  -2.85445404e-01 -2.85283077e-01 -6.22770669e-02  1.12938023e-03
  -2.71308432e-01 -3.03408599e-01]
 [ 4.44318512e+00  3.97251590e+00  4.16079449e+00  4.20994153e+00
   4.61768098e+00  4.65296699e+00  2.45321197e+00  4.02147595e-01
   4.22779099e+00  2.44672575e+00]
 [ 1.52987871e+00  2.10479182e+00  1.97836141e+00  1.92037518e+00
   1.54974999e+00  1.50344182e+00  1.13526879e+00  1.13595799e+00
   8.39397483e-01  1.38149832e+00]
 [ 4.17353928e-01 -6.60092295e-01 -5.55528420e-01 -5.50211065e-01
  -2.95600461e-01 -2.42490616e-01 -3.10454580e+00 -2.70342746e+00
   1.14743326e+00  2.67890118e+00]]
Cluster results:
 [1 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0]
 
聚类分析结果(分为4类):
第 0 类：['陕西', '辽宁', '吉林', '黑龙江', '湖北', '江苏', '广东', '四川', '山东', '甘肃', '湖南', '浙江', '新疆', '福建', '山西', '河北', '安徽', '云南', '江西', '海南', '内蒙古', '河南', '广西', '宁夏', '贵州', '青海']
第 1 类：['北京']
第 2 类：['上海', '天津']
第 3 类：['西藏']
 
Process finished with exit code 0

4 案例2

4.1 案例——数据

（1）数据介绍：

现有1999年全国31个省份城镇居民家庭平均每人全年消费性支出的八个主要变量数据，这八个变量分别是：食品、衣着、家庭设备用品及服务、医疗保健、交通和通讯、娱乐教育文化服务、居住以及杂项商品和服务。利用已有数据，对31个省份进行聚类。

（2）实验目的：

通过聚类，了解 1999 年各个省份的消费水平在国内的情况

1999年全国31个省份城镇居民家庭平均每人全年消费性支出数据：

4.2 代码

#*========================1. 建立工程，导入sklearn相关包======================================**
 
import numpy as np
from sklearn.cluster import KMeans
 
#*======================2. 加载数据，创建K-means算法实例，并进行训练，获得标签====================**
 
def loadData(filePath):
    fr = open(filePath, 'r+')            #r+：读写打开一个文本文件
    lines = fr.readlines()           #.readlines() 一次读取整个文件（类似于 .read() ) .readline() 每次只读.readlines() 慢得多。
    retData = []                     #retData：用来存储城市的各项消费信息
    retCityName = []                 #retCityName：用来存储城市名称
    for line in lines:
        items = line.strip().split(",")
        retCityName.append(items[0])
        retData.append([float(items[i]) for i in range(1, len(items))])
    return retData, retCityName      #返回值：返回城市名称，以及该城市的各项消费信息
 
def main():
    data, cityName = loadData('city.txt')    #1.利用loadData方法读取数据
    km = KMeans(n_clusters=4)                #2.创建实例
    label = km.fit_predict(data)             #3.调用Kmeans（）fit_predict()方法进行计算
    expenses = np.sum(km.cluster_centers_, axis=1)
    # print(expenses)
    CityCluster = [[], [], [], []]          #将城市按label分成设定的簇
    for i in range(len(cityName)):
        CityCluster[label[i]].append(cityName[i])   #将每个簇的城市输出
    for i in range(len(CityCluster)):              #将每个簇的平均花费输出
        print("Expenses:%.2f" % expenses[i])
        print(CityCluster[i])
 
if __name__ == '__main__':
    main()
 
#*=============3. 输出标签，查看结果========================================**
 
#将城市按照消费水平n_clusters类，消费水平相近的城市聚集在一类中
#expense：聚类中心点的数值加和，也就是平均消费水平

4.3 结果 

（1）聚成2类：km = KMeans(n_clusters=2)

（2）聚成3类：km = KMeans(n_clusters=3)

（3）聚成4类：km = KMeans(n_clusters=4)  

从结果可以看出消费水平相近的省市聚集在了一类，例如消费最高的“北京”“上海”“广东”
聚集在了消费最高的类别。聚4类时，结果可以比较明显的看出消费层级。

 4.4 拓展&&改进

计算两条数据相似性时，Sklearn 的K-Means默认用的是欧式距离。虽然还有余弦相似度，马氏距离等多种方法，但没有设定计算距离方法的参数。

（1）如果想要自定义计算距离的方式时，可以更改此处源码。
（2）建议使用 scipy.spatial.distance.cdist 方法。

使用形式：scipy.spatial.distance.cdist(A, B, metric=‘cosine’)：

重要参数：

A：A向量
B：B向量
metric: 计算A和B距离的方法，更改此参数可以更改调用的计算距离的方法

感谢各位的阅读！关于“如何使用Python语言实现K-Means聚类算法”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！