• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    利用Python如何实现K-means聚类算法

    前言

    K-Means 是一种非常简单的聚类算法(聚类算法都属于无监督学习)。给定固定数量的聚类和输入数据集,该算法试图将数据划分为聚类,使得聚类内部具有较高的相似性,聚类与聚类之间具有较低的相似性。

    算法原理

    1. 初始化聚类中心,或者在输入数据范围内随机选择,或者使用一些现有的训练样本(推荐)

    2. 直到收敛

    目标函数

    聚类算法的目标函数试图找到聚类中心,以便数据将划分到相应的聚类中,并使得数据与其最接近的聚类中心之间的距离尽可能小。

    给定一组数据X1,...,Xn和一个正数k,找到k个聚类中心C1,...,Ck并最小化目标函数:

    其中是质心,计算表达式为

    上图a表达了初始的数据集,假设k=2。在图b中,我们随机选择了两个k类所对应的类别质心,即图中的红色质心和蓝色质心,然后分别求样本中所有点到这两个质心的距离,并标记每个样本的类别为和该样本距离最小的质心的类别,如图c所示,经过计算样本和红色质心和蓝色质心的距离,我们得到了所有样本点的第一轮迭代后的类别。此时我们对我们当前标记为红色和蓝色的点分别求其新的质心,如图4所示,新的红色质心和蓝色质心的位置已经发生了变动。图e和图f重复了我们在图c和图d的过程,即将所有点的类别标记为距离最近的质心的类别并求新的质心。最终我们得到的两个类别如图f。当然在实际K-Mean算法中,我们一般会多次运行图c和图d,才能达到最终的比较优的类别。

    算法流程

    注意点:

    1. 对于K-Means算法,首先要注意的是k值的选择,一般来说,我们会根据对数据的先验经验选择一个合适的k值,如果没有什么先验知识,则可以通过交叉验证选择一个合适的k值
    2. 在确定了k的个数后,我们需要选择k个初始化的质心,就像上图b中的随机质心。由于我们是启发式方法,k个初始化的质心的位置选择对最后的聚类结果和运行时间都有很大的影响,因此需要选择合适的k个质心,最好这些质心不能太近。

    流程:

    输入是样本集D={x1,x2,...xm},聚类的簇树k,最大迭代次数N

    输出是簇划分C={C1,C2,...Ck}

        1) 从数据集D中随机选择k个样本作为初始的k个质心向量: {μ1,μ2,...,μk}

        2)对于n=1,2,...,N

          a) 将簇划分C初始化为Ct=∅  t=1,2...k

          b) 对于i=1,2...m,计算样本xi和各个质心向量μj(j=1,2,...k)的距离:,将xixi标记最小的为所对应的类别。此时更新

          c) 对于j=1,2,...,k,对Cj中所有的样本点重新计算新的质心

          e) 如果所有的k个质心向量都没有发生变化,则转到步骤3)

        3) 输出簇划分C={C1,C2,...Ck}

     Python实现

    import numpy as np
    import matplotlib.pyplot as plt
    import random
    from sklearn.datasets import make_blobs
    np.random.seed(123)
    from sklearn.cluster import KMeans
    class Kmeans:
        def __init__(self,data,k):
            self.data=data
            self.k = k
        def cluster_data_Bysklearn(self):
            kmeans_model = KMeans(self.k,random_state=1)
            labels = kmeans_model.fit(self.data).labels_
            print(labels)
            return labels
     
        def kmeans(self):
            # 获取4个随机数
            rarray = np.random.random(size=self.k)
            # 乘以数据集大小——>数据集中随机的4个点
            rarray = np.floor(rarray * len(self.data))
            # 转为int
            rarray = rarray.astype(int)
            print('数据集中随机索引', rarray)
            # 随机取数据集中的4个点作为初始中心点
            center = data[rarray]
            # 测试比较偏、比较集中的点,效果依然完美,测试需要删除以上代码
            # center = np.array([[4.6,-2.5],[4.4,-1.7],[4.3,-0.7],[4.8,-1.1]])
            # 1行80列的0数组,标记每个样本所属的类(k[i])
            cls = np.zeros([len(self.data)], np.int)
            print('初始center=\n', center)
            run = True
            time = 0
            n = len(self.data)
            while run:
                time = time + 1
                for i in range(n):
                    # 求差
                    tmp = data[i] - center
                    # 求平方
                    tmp = np.square(tmp)
                    # axis=1表示按行求和
                    tmp = np.sum(tmp, axis=1)
                    # 取最小(最近)的给该点“染色”(标记每个样本所属的类(k[i]))
                    cls[i] = np.argmin(tmp)
                # 如果没有修改各分类中心点,就结束循环
                run = False
                # 计算更新每个类的中心点
                for i in range(self.k):
                    # 找到属于该类的所有样本
                    club = data[cls == i]
                    # axis=0表示按列求平均值,计算出新的中心点
                    newcenter = np.mean(club, axis=0)
                    # 如果新旧center的差距很小,看做他们相等,否则更新之。run置true,再来一次循环
                    ss = np.abs(center[i] - newcenter)
                    if np.sum(ss, axis=0) > 1e-4:
                        center[i] = newcenter
                        run = True
                print('new center=\n', center)
            print('程序结束,迭代次数:', time)
            # 按类打印图表,因为每打印一次,颜色都不一样,所以可区分出来
            # for i in range(self.k):
            #     club = data[cls == i]
            #     self.showtable(club)
            # 打印最后的中心点
            self.showtable(center)
            #打印聚类标签
            print(cls)
     
        def showtable(self,data):
            x = data.T[0]
            y = data.T[1]
            plt.scatter(x, y)
            plt.show()
     
    if __name__ == '__main__':
        data = np.random.rand(10,2)
        K = 4
        model = Kmeans(data,K)
     
        model.kmeans()
        model.cluster_data_Bysklearn()

    结果:

    自写得出的    [0 2 0 0 0 2 3 2 1 2]
    调用模型的出的[0 2 0 1 0 2 3 2 3 0]

    jupyter notebook实现

    import numpy as np
    import matplotlib.pyplot as plt
    import random
    from sklearn.datasets import make_blobs
     
     
    %matplotlib inline
    X, y = make_blobs(centers=6, n_samples=1000)
    print(f'Shape of dataset: {X.shape}')
     
    fig = plt.figure(figsize=(8,6))
    plt.scatter(X[:,0], X[:,1], c=y)
    plt.title("Dataset with 6 clusters")
    plt.xlabel("First feature")
    plt.ylabel("Second feature")
    plt.show()

     

    class KMeans():
        def __init__(self, n_clusters=6):
            self.k = n_clusters
     
        def fit(self, data):
            """
            Fits the k-means model to the given dataset
            """
            n_samples, _ = data.shape
            # initialize cluster centers
            self.centers = np.array(random.sample(list(data), self.k))
            self.initial_centers = np.copy(self.centers)
     
            # We will keep track of whether the assignment of data points
            # to the clusters has changed. If it stops changing, we are 
            # done fitting the model
            old_assigns = None
            n_iters = 0
     
            while True:
                new_assigns = [self.classify(datapoint) for datapoint in data]
     
                if new_assigns == old_assigns:
                    print(f"Training finished after {n_iters} iterations!")
                    return
     
                old_assigns = new_assigns
                n_iters += 1
     
                # recalculate centers
                for id_ in range(self.k):
                    points_idx = np.where(np.array(new_assigns) == id_)
                    datapoints = data[points_idx]
                    self.centers[id_] = datapoints.mean(axis=0)
     
        def l2_distance(self, datapoint):
            dists = np.sqrt(np.sum((self.centers - datapoint)**2, axis=1))
            return dists
     
        def classify(self, datapoint):
            """
            Given a datapoint, compute the cluster closest to the
            datapoint. Return the cluster ID of that cluster.
            """
            dists = self.l2_distance(datapoint)
            return np.argmin(dists)
     
        def plot_clusters(self, data):
            plt.figure(figsize=(12,10))
            plt.title("Initial centers in black, final centers in red")
            plt.scatter(data[:, 0], data[:, 1], marker='.', c='y')
            plt.scatter(self.centers[:, 0], self.centers[:,1], c='r')
            plt.scatter(self.initial_centers[:, 0], self.initial_centers[:,1], c='k')
            plt.show()
    X = np.random.randn(10,100)
    kmeans = KMeans(n_clusters=6)
    kmeans.fit(X)
    for data in X:
        print(kmeans.classify(data))

    总结

    K-Means的主要优点:

    1)原理简单,容易实现

    2)可解释度较强

    K-Means的主要缺点:

    1)K值很难确定

    2)局部最优

    3)对噪音和异常点敏感

    4)需样本存在均值(限定数据种类)

    5)聚类效果依赖于聚类中心的初始化

    6)对于非凸数据集或类别规模差异太大的数据效果不好

    到此这篇关于利用Python如何实现K-means聚类算法的文章就介绍到这了,更多相关Python实现K-means聚类算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    您可能感兴趣的文章:
    • python中实现k-means聚类算法详解
    • python实现鸢尾花三种聚类算法(K-means,AGNES,DBScan)
    • python基于K-means聚类算法的图像分割
    • K-means聚类算法介绍与利用python实现的代码示例
    • Python机器学习之K-Means聚类实现详解
    • 在Python中使用K-Means聚类和PCA主成分分析进行图像压缩
    • Python机器学习算法之k均值聚类(k-means)
    • python实现k-means聚类算法
    • Python用K-means聚类算法进行客户分群的实现
    • k-means 聚类算法与Python实现代码
    上一篇:(手写)PCA原理及其Python实现图文详解
    下一篇:Django使用HTTP协议向服务器传参方式小结
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    利用Python如何实现K-means聚类算法 利用,Python,如何,实现,K-means,