07机器学习实战k-means

た入场券 2021-12-23 15:47 177阅读 0赞

# K-Means原理初探 #

K-Means算法的思想很简单，对于给定的样本集，按照样本之间的距离大小，将样本集划分为K个簇。让簇内的点尽量紧密的连在一起，而让簇间的距离尽量的大。

![1542450-20190414165806310-1760859880.png][]

如果我们想直接求上式的最小值并不容易，这是一个NP难的问题，因此只能采用启发式的迭代方法。

K-Means采用的启发式方式很简单，用下面一组图就可以形象的描述。

![1542450-20190414165851446-1359454516.png][]

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

当然在实际K-Mean算法中，我们一般会多次运行图c和图d，才能达到最终的比较优的类别。

1. 归类：

聚类(clustering) 属于非监督学习 (unsupervised learning)

无类别标记(class label)

2. 举例：

![1542450-20190414170030426-786273303.png][]

3. K-means 算法：

3.1 Clustering 中的经典算法，数据挖掘十大经典算法之一

3.2 算法接受参数 k ；然后将事先输入的n个数据对象划分为 k个聚类以便使得所获得的聚类满足：同一

聚类中的对象相似度较高；而不同聚类中的对象相似度较小。

3.3 算法思想：

以空间中k个点为中心进行聚类，对最靠近他们的对象归类。通过迭代的方法，逐次更新各聚类中心

的值，直至得到最好的聚类结果

3.4 算法描述：

（1）适当选择c个类的初始中心；

（2）在第k次迭代中，对任意一个样本，求其到c各中心的距离，将该样本归到距离最短的中心所在

的类；

（3）利用均值等方法更新该类的中心值；

（4）对于所有的c个聚类中心，如果利用（2）（3）的迭代法更新后，值保持不变，则迭代结束，

否则继续迭代。

3.5 算法流程：

输入：k, data[n];
    （1） 选择k个初始中心点，例如c[0]=data[0],…c[k-1]=data[k-1];
    （2） 对于data[0]….data[n], 分别与c[0]…c[k-1]比较，假定与c[i]差值最少，就标记为i;
    （3） 对于所有标记为i点，重新计算c[i]={ 所有标记为i的data[j]之和}/标记为i的个数；
    （4） 重复(2)(3),直到所有c[i]值的变化小于给定阈值。

优点：速度快，简单

缺点：最终结果跟初始点选择相关，容易陷入局部最优，需直到k值

In \[5\]:

import numpy as np
    
    
    def shouldStop(oldCentroids, centroids, iterations, maxIt):
        """
        :param oldCentroids: 老的聚类中心
        :param centroids: 聚类中心
        :param iterations: 第几次迭代
        :param maxIt: 最大迭代次数
        :return: True or False
        """
        if iterations > maxIt:
            return True
        return np.array_equal(oldCentroids, centroids)
    
    
    def updateLabels(dataSet, centroids):
        """
        更新数据集中每个点的类别
        :param dataSet: 数据集
        :param centroids: 聚类中心
        """
        numPoints, numDim = dataSet.shape
        for i in range(0, numPoints):
            dataSet[i, -1] = getLabelFromClosestCentroid(dataSet[i, :-1], centroids)
    
    
    def getLabelFromClosestCentroid(dataSetRow, centroids):
        """
        :param dataSetRow:数据集中一个实例（一个点）
        :param centroids: 聚类中心
        :return: 返回属于哪个标签（属于哪个类）
        """
        label = centroids[0, -1]  # 初始化类别为第0个实例的类别
        minDist = np.linalg.norm(dataSetRow - centroids[0, :-1])  # 初始化最小距离为与第0个聚类中心的距离
        for i in range(1, centroids.shape[0]):
            dist = np.linalg.norm(dataSetRow - centroids[i, :-1])  # 欧式距离
            if dist < minDist:
                minDist = dist
                label = centroids[i, -1]
        print("minDist:", minDist)
        return label
    
    
    def getCentroids(dataSet, k):
        """
        # Each centroid is the geometric mean of the points that
        # have that centroid's label. Important: If a centroid is empty (no points have
        # that centroid's label) you should randomly re-initialize it.
        :param dataSet: 数据集
        :param k: 几个类别
        :return: 更新之后的聚类中心
        """
        result = np.zeros((k, dataSet.shape[1]))
        for i in range(1, k + 1):
            oneCluster = dataSet[dataSet[:, -1] == i, :-1]
            result[i - 1, :-1] = np.mean(oneCluster + np.spacing(1), axis=0)  # 防止对空列表求平均
            result[i - 1, -1] = i
        return result

ML之Kmeans：利用自定义Kmeans函数实现对多个坐标点(自定义四个点)进行自动(最多迭代10次)分类

In \[6\]:

def kmeans(X, k, maxIt):
        numPoints, numDim = X.shape
        dataSet = np.zeros((numPoints, numDim + 1))
        dataSet[:, :-1] = X
        centroids = dataSet[np.random.randint(numPoints, size=k), :]
        # centroids = dataSet[0:2, :]         
        # Randomly assign labels to initial centorid给初始中心随机分配标签
        centroids[:, -1] = range(1, k + 1)
        iterations = 0
        oldCentroids = None
        while not shouldStop(oldCentroids, centroids, iterations, maxIt):
            print("iteration: \n", iterations)
            print("dataSet: \n", dataSet)
            print("centroids: \n", centroids)
            # Save old centroids for convergence test. Book keeping.
            oldCentroids = np.copy(centroids)
            iterations += 1
            updateLabels(dataSet, centroids)
            centroids = getCentroids(dataSet, k)
        return dataSet

In \[10\]:

x1 = np.array([1, 1])
    x2 = np.array([2, 1])
    x3 = np.array([4, 3])
    x4 = np.array([5, 4])
    testX = np.vstack((x1, x2, x3, x4))
    
    result = kmeans(testX, 2, 10)
    print("final result:")
    print(result)

iteration: 
     0
    dataSet: 
     [[1. 1. 0.]
     [2. 1. 0.]
     [4. 3. 0.]
     [5. 4. 0.]]
    centroids: 
     [[1. 1. 1.]
     [4. 3. 2.]]
    minDist: 0.0
    minDist: 1.0
    minDist: 0.0
    minDist: 1.4142135623730951
    iteration: 
     1
    dataSet: 
     [[1. 1. 1.]
     [2. 1. 1.]
     [4. 3. 2.]
     [5. 4. 2.]]
    centroids: 
     [[1.5 1.  1. ]
     [4.5 3.5 2. ]]
    minDist: 0.5
    minDist: 0.5
    minDist: 0.7071067811865476
    minDist: 0.7071067811865476
    final result:
    [[1. 1. 1.]
     [2. 1. 1.]
     [4. 3. 2.]
     [5. 4. 2.]]

转载于:https://www.cnblogs.com/xinmomoyan/p/10706514.html

[1542450-20190414165806310-1760859880.png]: /images/20211223/33826741eb754986a3f76fa0ad61018d.png
[1542450-20190414165851446-1359454516.png]: /images/20211223/9e8848d9a5144e8aaa415f6ba320217f.png
[1542450-20190414170030426-786273303.png]: /images/20211223/962eff143ede4c37b82c335421aec009.png