KMeans聚类python编程实现

分手后的思念是犯贱 2023-02-14 10:15 15阅读 0赞

![在这里插入图片描述][20200602101413283.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70]

# Kmeans算法介绍 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 1]

## 基本原理 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 3]

# 伪代码 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 4]

# 聚类结果评估 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 6]

# 编程实现 #

封装，KMeansCluster\_Class.py

# -*- coding: utf-8 -*-
    
    
    """ Created on Mon May 4 16:26:05 2020 @author: Hja @Company：北京师范大学珠海分校 @version: V1.0 @contact: 583082258@qq.com 2018--2020 @software: Spyder @file: KMeansCluster_Class.py @time: 2020/4/22 9:02 @Desc：kMeans聚类 """
    
    
    import time
    from copy import deepcopy
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    from sklearn.datasets import make_blobs
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    import mglearn
    import warnings
    warnings.filterwarnings("ignore")#消除警告
    # 初始化图形参数
    plt.rcParams['figure.figsize'] = (16,9)# 设置大小
    # 图形美化
    plt.style.use('ggplot')
    
    
    
    class KMeansCluster(object):
        '''KMeans聚类'''
        
        
        def __init__(self,n_clusters = 8,max_iter = 300):
            ''' n_clusters: ，默认= 8,形成的簇数以及生成的质心数 max_iter :默认为300,单次运行的k均值算法的最大迭代次数 '''
            self.n_clusters = n_clusters
            self.max_iter = max_iter
            self.X_train = None# 训练集
            self.n_iter = None# 运行迭代的次数
            self.Center_point = None# 保存当前中心点的坐标
            self.Center_point_old = None# 用于保存中心点更新前的坐标
            self.clusters = None# 用于保存数据所属的中心点
            self.iteration_flag = None# 迭代标识位，通过计算新旧中心点的距离
            self.labels_ = None# 保存训练数据类标,标签本身并没有先验意义
    # self.DBI = None# 度量聚类优劣的指标, DBI指数,越小越好
            self.Intra_Dis = None# 存放所有类内距离之和
            self.score = None# 存放 类间间距/类内间距 来衡量聚类结果的好坏，越大越好
            
        def dist(self,matrix_a,matrix_b,ax = 1):
            # linalg=linear（线性）+algebra（代数），norm则表示范数，默认二范数
            # axis=1表示按行向量处理，求多个行向量的范数
            ''' matrix_a like : array([[12., 40.], [80., 22.], [10., 4.]], dtype=float32) matrix_b like: array([[0., 0.], [0., 0.], [0., 0.]]) if axis = 1,即按行求范数 return array([41.76122604, 82.96987405, 10.77032961]) or axis = 0,按列求范数 returnarray([81.51073549, 45.82575695]) '''
            return np.linalg.norm(matrix_a - matrix_b,axis = ax)
        
        
        
        
        def fit(self,X_train):
            self.X_train = X_train
            # X_train is a np.array
            
            # Center_point 是一个n_clusters行，X_train.shape[1]列的矩阵
            self.Center_point = np.zeros((self.n_clusters,self.X_train.shape[1]),dtype = np.float32)# 存放随机初始化的中心点
    # print(self.Center_point)
            
            
            # 随机获得中心点
            for i in range(self.X_train.shape[1]):# 面对多维数据集
    # print(i)
                self.Center_point[:,i] =  np.random.choice(self.X_train[:,i],size = self.n_clusters)
                # Center_point 的第i列从 X_train的第i列中随机抽取长度为 n_clusters
    # print('第{}列：{}'.format(i,self.Center_point[:,i]))
                
                
                
            self.Center_point_old = np.zeros(self.Center_point.shape,dtype = np.float32)# 初始化
            # 用于保存数据所属的中心点
            self.clusters = np.zeros(len(self.X_train),dtype = np.int)
            # 迭代标识位，通过计算新旧中心点的距离
    # self.iteration_flag = self.dist(self.Center_point,self.Center_point_old,1)
            self.iteration_flag = np.ones(self.n_clusters)
                
            # 记录迭代次数
            self.n_iter = 1
            # 若中心点不再变化 or 循环次数超过300次,则退出循环
            print('-'*25,'The kmeans is running...','-'*25)
            while self.iteration_flag.any() != 0 and self.n_iter < self.max_iter:
                # 同时满足两个条件则继续循环
                # iteration_flag like：array([0,0,0]) 则会退出循环
                
                
                # 循环计算每个点对应的最近中心点
                for i in range(len(self.X_train)):
                    # 计算出每个点与中心点的距离
                    distances = self.dist(self.X_train[i],self.Center_point,1)#x[i] like : array([17.93671, 15.78481])
                    # distances like :array([44.3666806 , 81.91375025, 10.73731025])
                    # 其中第一个值是x[i] 到 Center_point中第一个点的距离
                    
                    # 记录x[i] 离Center_point中最近的点
                    culuster = np.argmin(distances)# np.argmin(a)返回 a 中最小元素的索引
                    # 记录每个样例点与那个中心点距离最近
                    self.clusters[i] = culuster
                
                
                # 用深度拷贝将当前的中心点保存
                self.Center_point_old = deepcopy(self.Center_point)
                ''' 为什么用深度拷贝？ d = Center_point d like:array([[12., 40.], [80., 22.], [10., 4.]], dtype=float32) Center_point like: array([[12., 40.], [80., 22.], [10., 4.]], dtype=float32) Then Center_point[0] = np.array([1,1]) d = array([[ 1., 1.], [80., 22.], [10., 4.]], dtype=float32) '''
    # print(self.Center_point_old)
                # 从属于同一中心点放到一个数组中，然后按照列的方向取平均值更新中心点
                for i in range(self.n_clusters):
                    # 第 i 个类簇
                    points = [self.X_train[j] for j in range(len(self.X_train)) if self.clusters[j] == i]
                    
                    if points == []:# 如果某一类并没有分到数据点，points = []，那么np.mean()后会返回nan，影响后续计算
    # In: np.mean([])
    # Out: nan
                        self.Center_point[i] = np.zeros(self.X_train.shape[1],dtype = np.float32)
                    else:
                        # 更新中心点
                        self.Center_point[i] = np.mean(points,axis = 0)# 按照列的方向取平均值
                    
                    
                    
                print(u'**循环第%d次**'%self.n_iter)
                self.n_iter += 1
    # 更新新旧中心点的距离
                self.iteration_flag = self.dist(self.Center_point,self.Center_point_old,1)
                print("新中心点与旧点的距离：", self.iteration_flag)
            
    
        
            self.labels_ = self.clusters# 存放数据类别
            self.Intra_class_spacing()# 运行该函数，给self.Intra_Dis 赋值
            self.score = self.Inter_class_spacing() / self.Intra_Dis # 衡量聚类结果
    # self.DBI = self.Davies_Bouldin()# 计算DBI系数
    
    
        def predict(self,X_test):
            
            ''' 根据当前的中心点 对X_test进行预测 标签本身并没有先验意义 '''
            
            clusters_pred = np.zeros(len(X_test))# 存放类标
            for i in range(len(X_test)):# 循环计算每个点对应的最近中心点
                distances = self.dist(X_test[i],self.Center_point,1)# 计算距离
                cluster = np.argmin(distances)# 得出类别，其实就是索引
                clusters_pred[i] = cluster
            
            return clusters_pred
    
        
        
        def Intra_class_spacing(self):
            ''' 计算类内间距 return like :{0: 17.75349746798756, 1: 18.41602776546014, 2: 17.605171601877746} 0类 类内间距：17.75... 1类 类内间距:18.41..... 2类 类内间距:17.6..... '''
            Intra_dic = { }
            Intra_dis = 0.0
            
            for i in range(self.n_clusters):
                # 取出第 i 类的数据点
                points = [self.X_train[j] for j in range(len(self.X_train)) if self.clusters[j] == i]
                
                if points == []:# 健壮性
                    continue
                
                else:
                    dis = 0.0
                    temp = 0.0
                    for point in points:# 计算每一条数据与同类其他所有数据的距离
                        dis += np.sum(self.dist(point,points))# 求和
                
    # print(points)
                    # 距离求和 除以 该类样本数 的平方
                    temp = dis / len(points) ** 2
                
                    Intra_dic[i] = temp# 第 i类的类内距离存放在字典中
                    
                    Intra_dis += temp# 将所有类内距离相加
            
            self.Intra_Dis = Intra_dis / float(self.n_clusters)# 取均值封装
            
            return Intra_dic
        
        
        
        
        
        def Inter_class_spacing(self):
            ''' 计算类间间距 '''
            Inter_dis = 0.0
            count = 0# 计数器
    # pass
            # 比如聚成3 类，即n_clusters = 3
            # 那么i = 0,j = [0,1,2,3),计算0-1类间的距离，0-2类间的距离
            # 那么i = 1,j = [1,2,3),计算1-2类间的距离
            # 那么i = 2,j = [2,3),不计算
            for i in range(self.n_clusters):
                for j in range(i + 1,self.n_clusters):
                    if i != j:
                        count += 1
                        # 取出第 i 类的数据点
                        points_i = [self.X_train[k] for k in range(len(self.X_train)) if self.clusters[k] == i]
                        # 取出第 j 类的数据点
                        points_j = [self.X_train[k] for k in range(len(self.X_train)) if self.clusters[k] == j]
                        
                        if points_i == [] or points_j == []:# 如果某一类没有分配到数据点，在k值较大时会有这种情况，此时分母就为0
                            continue
                        else:
                            dis = 0.0# 存放距离的中间变量
                            for point in points_i:# 计算 i类 每一条数据与 j类 所有数据的距离
                                dis += np.sum(self.dist(point,points_j))
                                
                            temp = np.sum(dis) / (len(points_i) * len(points_j))
                            
                            
                            Inter_dis += temp# 将所有类间距离相加
            
            return Inter_dis / float(count)# 取平均

## 先跑一下正常的二维数据集，下面的接在上面代码下面 ##

if __name__ == '__main__':
    
        # 导入数据集
        path = r'F:\大三下\李艳老师数据挖掘实践\实验八\KMeans数据集.csv'
        data = pd.read_csv(path,header = None)
        #print(data.shape)
        #print(data.head())
    
        X_train = np.array(data,dtype = np.float64)
        
        
        # 建模
        kmeans = KMeansCluster(n_clusters = 3,max_iter = 30)
        kmeans.fit(X_train)
        
        
        
        # 结果可视化
        colors = ['r','g','b','y','c','m']
        fig,ax = plt.subplots()
        # 不同的子集用不同的颜色
        for i in range(kmeans.n_clusters):
            points = np.array([X_train[j] for j in range(len(X_train)) if kmeans.clusters[j] == i])
    
            ax.scatter(points[:,0],points[:,1],s = 7,c = colors[i])
        ax.scatter(kmeans.Center_point[:, 0], kmeans.Center_point[:, 1], marker='*', s=200, c='black')
        plt.show()
        print('类间间距 / 类内间距 ：{:.2f} 越大代表结果越好'.format(kmeans.score))

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 7]

## 再尝试一下三维数据 ##

if __name__ == '__main__':
        # 三维数据
        X,y = make_blobs(n_samples = 1000,n_features = 3,random_state = 1)
        kmeans = KMeansCluster(n_clusters = 3,max_iter = 30)
        kmeans.fit(X)
        
        #定义坐标轴
        fig = plt.figure()
        ax = plt.axes(projection='3d')
        
        
        colors = ['r','g','b','y','c','m']
    ## 不同的子集用不同的颜色
        for i in range(kmeans.n_clusters):
            points = np.array([X[j] for j in range(len(X)) if kmeans.clusters[j] == i])
            ax.scatter3D(points[:,0],points[:,1],points[:,2],s = 7,c = colors[i])
        ax.scatter3D(kmeans.Center_point[:, 0], kmeans.Center_point[:, 1],kmeans.Center_point[:,2], marker='*', s=200, c='black')
        plt.show()
        print('类间间距 / 类内间距 ：{:.2f} 越大代表结果越好'.format(kmeans.score))

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 8]

## KMeans无法识别具有复杂形状的簇 ##

if __name__ == '__main__':
        # KMeans无法识别具有复杂形状的簇
        from sklearn.datasets import make_moons
        X,y = make_moons(n_samples = 5000,noise = 0.05,random_state = 1)
        # 将数据聚类成2个簇
        kmeans = KMeansCluster(n_clusters = 3,max_iter = 100)
        kmeans.fit(X)
        # 结果可视化
        colors = ['r','g','b','y','c','m']
        fig,ax = plt.subplots()
        # 不同的子集用不同的颜色
        for i in range(kmeans.n_clusters):
            points = np.array([X[j] for j in range(len(X)) if kmeans.clusters[j] == i])
            ax.scatter(points[:,0],points[:,1],s = 1,c = colors[i])
        ax.scatter(kmeans.Center_point[:, 0], kmeans.Center_point[:, 1], marker='*', s=200, c='black')
        plt.show()
        print('k = {}时 *类间间距 / 类内间距 ：{:.2f}* 越大代表结果越好'.format(kmeans.n_clusters,kmeans.score))

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 9]

[20200602101413283.png]: https://img-blog.csdnimg.cn/20200602101413283.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200602101512151.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200602101623944.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020060210163527.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200602101709874.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200602101743587.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200602101820133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200602101827357.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200602102656541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200602102933236.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200602103116297.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h1YW5namlhYWFhYQ==,size_16,color_FFFFFF,t_70