机器学习 - KMean

Posted 2021-03-06 moonlight-lin

K-Mean（K-均值聚类）算法用于将数据集分成 K 个簇，K 值是由用户给定的
??
优点：容易实现
缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢
??
算法
??随机初始化 k 个簇中心点
??每个样本分到距离最近的簇
??取分到该簇的所有样本的均值做为该簇的新的中心点
??重新分配每个样本到距离最近的簇
??不断迭代直到所有样本所属的簇不再改变
??
代码

# coding=utf-8
import numpy as np


def distEclud(vecA, vecB):
    """
    计算两个向量的距离
    """
    return np.sqrt(sum(np.power(vecA - vecB, 2)))


def randCent(dataSet, k):
    """
    随机初始化簇中心点
    """
    n = np.shape(dataSet)[1]

    # 用于存储 k 个簇中心点
    centroids = np.mat(np.zeros((k, n)))

    # 为 k 个簇中心点的每一个特征赋值
    for j in range(n):
        # 随机产生一个 (k,1) 矩阵，值的范围在该特征的最大和最小值之间
        minJ = min(dataSet[:, j])
        rangeJ = float(max(dataSet[:, j]) - minJ)
        centroids[:, j] = np.mat(minJ + rangeJ * np.random.rand(k, 1))
    return centroids


def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    """
    dataSet - 要进行聚类的数据
    k - 要将数据分成 k 个聚类
    distMeas - 计算向量距离的函数
    createCent - 初始化 K 个簇中心点的函数
    """

    m = np.shape(dataSet)[0]

    # 存储每一个数据属于哪个簇，与簇中心点的距离是多少
    clusterAssment = np.mat(np.zeros((m, 2)))

    # 初始化 K 个簇中心点
    centroids = createCent(dataSet, k)

    # 不断的迭代，直到所有的数据分类不再改变
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False

        # 遍历每一个数据
        for i in range(m):

            # 保存距离最近的簇中心点，及其距离
            minDist = np.inf
            minIndex = -1

            for j in range(k):
                # 计算该数据与不同的簇中心点的距离
                distJI = distMeas(centroids[j, :], dataSet[i, :])

                # 取距离最小的那个簇
                if distJI < minDist:
                    minDist = distJI
                    minIndex = j

            # 只要有一个数据的分类与上次迭代的结果不同，就会继续迭代所有数据
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True

            # 保存该数据所属的簇，以及与簇中心点的距离
            clusterAssment[i, :] = minIndex, minDist ** 2

        for cent in range(k):
            # 获取该簇的所有数据
            ptsInClust = dataSet[np.nonzero(clusterAssment[:, 0].A == cent)[0]]

            # 重新计算该簇的中心点，新的中心点每一个特征的值，是该簇所有数据在该特征的平均值
            centroids[cent, :] = np.mean(ptsInClust, axis=0)

    # 返回 K 个簇中心点，以及所有数据所属簇、与簇中心点的距离
    return centroids, clusterAssment

二分 K-Mean 算法
??簇心随机初始化容易导致 K-Mean 算法效果不好，容易收敛到局部最小值
??
??二分 K-Mean 算法将所有数据初始化为同一个簇，簇中心取所有样本均值，然后开始迭代
??每次迭代都对已有的簇按普通 K-Mean 一分为二，取 SSE（方差和）最小的划分
??共 k - 1 次迭代产生 k 个簇
??

def biKmeans(dataSet, k, distMeas=distEclud):
    """
    二分 K-Mean 算法

    dataSet - 要进行聚类的数据
    k - 要将数据分成 k 个聚类
    distMeas - 计算向量距离的函数
    """
    m = np.shape(dataSet)[0]

    # 存储每一个数据属于哪个簇，与簇中心点的距离是多少
    clusterAssment = np.mat(np.zeros((m, 2)))

    # 初始化簇中心点，只有一个，每个特征值是所有点的平均值
    centroid0 = np.mean(dataSet, axis=0).tolist()[0]
    centList = [centroid0]

    for j in range(m):
        # 初始化所有数据距中心点距离
        clusterAssment[j, 1] = distMeas(np.mat(centroid0), dataSet[j, :]) ** 2

    # 每次迭代增加一个簇
    while len(centList) < k:
        lowestSSE = np.inf
        bestClustAss = bestCentToSplit = bestNewCents = None

        # 遍历每一个簇
        for i in range(len(centList)):
            # 取该簇的所有数据
            ptsInCurrCluster = dataSet[np.nonzero(clusterAssment[:, 0].A == i)[0], :]

            # 使用普通的 K-Mean 算法将该簇再分为两个簇
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)

            # 计算新的 2 个簇总的方差和
            sseSplit = sum(splitClustAss[:, 1])

            # 计算剩下的簇总的方差和
            sseNotSplit = sum(clusterAssment[np.nonzero(clusterAssment[:, 0].A != i)[0], 1])

            # 保存使总方差变小的划分
            if (sseSplit + sseNotSplit) < lowestSSE:
                bestCentToSplit = i
                bestNewCents = centroidMat
                bestClustAss = splitClustAss.copy()
                lowestSSE = sseSplit + sseNotSplit

        # 新划分的一部分数据赋予新的簇
        bestClustAss[np.nonzero(bestClustAss[:, 0].A == 1)[0], 0] = len(centList)

        # 另一部分数据维持原来的簇
        bestClustAss[np.nonzero(bestClustAss[:, 0].A == 0)[0], 0] = bestCentToSplit

        # 改变用于划分的簇的中心点
        centList[bestCentToSplit] = bestNewCents[0, :].tolist()[0]

        # 添加新簇的中心点
        centList.append(bestNewCents[1, :].tolist()[0])

        # 改变用于划分的数据的值
        clusterAssment[np.nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss

    # 返回结果
    return np.mat(centList), clusterAssment