机器学习

k-means简介

k-means是无监督学习下的一种聚类算法，简单说就是不需要数据标签，仅靠特征值就可以将数据分为指定的几类。k-means算法的核心就是通过计算每个数据点与k个质心（或重心）之间的距离，找出与各质心距离最近的点，并将这些点分为该质心所在的簇，从而实现聚类的效果。

k-means具体步骤

1.指定要把数据聚为几类，确定k值；
2.从数据点中随机选择k个点，作为k个簇的初始质心；
3.计算数据点与各质心之间的距离，并将最近的质心所在的簇作为该数据点所属的簇；
4.计算每个簇的数据点的平均值，并将其作为新的质心；
5.重复步骤2-4，直到所有簇的质心不再发生变化，或达到最大迭代次数。

可以看出，k-means算法的步骤很清晰，而且易于实现。虽然这里的k值感觉像是拍脑袋得到的，但是后面会介绍Elbow方法，通过评估得到合理的k值。我们先来感受一下k-means的效果。

代码实现

import random
import math
import matplotlib.pyplot as plt


class KMeans:
    def __init__(self, n_clusters):
        self.n_clusters = n_clusters
        self.centroid_list = []
        self.predict = []

    def get_rand_centroid(self, X):
        # 随机取质心
        centroid_list = []
        while len(centroid_list) < self.n_clusters:
            d = int(random.random() * len(X))
            if X[d] not in centroid_list:
                centroid_list.append(X[d])
        return centroid_list

    @staticmethod
    def get_distance(point, C):
        # 计算两点间距离(欧式距离)
        return math.sqrt((point[0]-C[0])**2 + (point[1]-C[1])**2)

    def get_distributed(self, X):
        # 计算每个点距离最近的质心，并将该点划入该质心所在的簇
        dis_list = [[] for k in range(self.n_clusters)]
        for point in X:
            distance_list = []
            for C in self.centroid_list:
                distance_list.append(self.get_distance(point, C))
            min_index = distance_list.index(min(distance_list))
            dis_list[min_index].append(point)
        return dis_list

    def get_virtual_centroid(self, distributed):
        # 如果有空集，则取其他两个质心的坐标均值
        if [] in distributed:
            index = distributed.index([])
            v_centroid_list = self.centroid_list.copy()
            # 去除空集对应的质心
            v_centroid_list.pop(index)
            # 计算其余两个质心的坐标均值
            x = []
            y = []
            for C in v_centroid_list:
                x.append(C[0])
                y.append(C[1])
            v_centroid_list.insert(index, [round(sum(x) / len(x)), round(sum(y) / len(y))])
        else:
            # 计算每个簇所有点的坐标的算数平均，作为虚拟质心
            v_centroid_list = []
            for distribution in distributed:
                x = []
                y = []
                for point in distribution:
                    x.append(point[0])
                    y.append(point[1])
                v_centroid_list.append([sum(x)/len(x), sum(y)/len(y)])
        return v_centroid_list

    def fit_predict(self, X):
        self.centroid_list = self.get_rand_centroid(X)
        while True:
            # 聚类
            distributed = self.get_distributed(X)
            # 计算虚拟质心
            v_centroid_list = self.get_virtual_centroid(distributed)
            # 如果两次质心相同，说明聚类结果已定
            if sorted(v_centroid_list) == sorted(self.centroid_list):
                break
            # 否则继续训练
            self.centroid_list = v_centroid_list
        # 对结果按照数据集顺序进行分类
        predict = []
        for point in X:
            i = 0
            for dis in distributed:
                if point in dis:
                    predict.append(i)
                i += 1
        self.predict = predict
        return predict

    def plot_clustering(self, X):
        x = []
        y = []
        for point in X:
            x.append(point[0])
            y.append(point[1])
        plt.scatter(x, y, c=self.predict, marker='x')
        plt.show()

# 样本集合
X = [[0.0888, 0.5885],
     [0.1399, 0.8291],
     [0.0747, 0.4974],
     [0.0983, 0.5772],
     [0.1276, 0.5703],
     [0.1671, 0.5835],
     [0.1306, 0.5276],
     [0.1061, 0.5523],
     [0.2446, 0.4007],
     [0.1670, 0.4770],
     [0.2485, 0.4313],
     [0.1227, 0.4909],
     [0.1240, 0.5668],
     [0.1461, 0.5113],
     [0.2315, 0.3788],
     [0.0494, 0.5590],
     [0.1107, 0.4799],
     [0.1121, 0.5735],
     [0.1007, 0.6318],
     [0.2567, 0.4326],
     [0.1956, 0.4280]
    ]

# 初始化kmeans分类器
km = KMeans(3)
# 预测
predict = km.fit_predict(X)
print(predict)
# 绘图
km.plot_clustering(X)

聚类结果如下：

我们采用了几场篮球比赛的球员技术统计数据作为样本，x轴表示助攻数据，y轴表示得分数据，从初步的聚类中，我们可以看出，右下角的一类可看做是助攻很多，而得分较少的球员；左侧这类可看做是助攻较少，但得分相对多一些的球员；而最上面独立的那个类，可看做是得分最多，而且助攻也不少的球员，可理解成MVP球员。这样一来，我们就赋予了这些聚类实际的意义。感觉这个分类结果也挺不错的。
但多跑几次，会发现有时候的分类结果会不太一样，例如没有将MVP球员作为单独的一类：

可以看出，如果首次随机出的质心挨得太近，会导致分类结果不理想（蓝色向下的箭头表示随机的初始质心）。

k-means++

为了解决初始质心不合理而导致分类不准确的问题，我们可以优化质心初始化的步骤，使各个质心相距尽可能的远。k-means++ 算法就是一种为 k-means 寻找初始化质心的算法。它由David Arthur 和 Sergei Vassilvitskii 于2007年提出(论文地址)，主要是对之前步骤1进行进一步优化，具体步骤如下：
1a.随机选出一个点作为质心；
1b.通过计算概率，得到新的质心。其中概率的计算方法如下：

1c.重复1b步，直到凑齐k个质心。

注：原作论文中并未提及如何根据概率值选择质心，我看网上有很多文章使用了“轮盘法”挑选质心，就是计算出各点的概率后，再计算出各点的累计概率值，然后随机一个概率值r，将r落入累计概率区间对应的点作为质心。这里就粗暴一点，直接选取概率最大的那个点（与当前质心最远的点）作为质心。

def k_means_plus(self, X):
    centroid_list = []
    # 随机选出第一个点
    random_1 = int(random.random() * len(X))
    centroid_list.append(X[random_1])
    while len(centroid_list) < self.n_clusters:
        distance_list = []
        for x in X:
            tmp_list = []
            for C in centroid_list:
                tmp_list.append(pow(self.get_distance(x, C), 2))
            # 取距离当前质心最近的距离D(X)^2
            distance_list.append(min(tmp_list))
        # 选取D(X)^2最大的点作为下个质心(概率计算公式中分母相同，可略去)
        max_index = distance_list.index(max(distance_list))
        centroid_list.append(X[max_index])
    return centroid_list

直接拿这个函数替换之前的get_rand_centroid()方法即可。聚类效果如下：

三个初始质心都有较远的距离，从而保证了聚类的准确性。

WCSS - k-means算法的评估标准

由于k-means是一种无监督学习方法，没有一种严格的标准来衡量聚类结果的性能，大部分情况下都是根据人的经验来判断，但是如果数据超过三维，无法可视化的话，就比较尴尬了。所以还是需要有一种方法能够评估k-means的性能。之前不是通过计算距离选取质心吗，我们便可以用所有点到其所属质心的距离加和作为一种衡量方式，这就是WCSS方法（Within-Cluster Sum of Squares），WCSS方法可以将性能进行量化，对于相同的k，WCSS越小，代表总体性能越好。所以我们可以进行N轮训练，取WCSS最小的那个作为最终的聚类。
直接在fit_predict()方法中加入WCSS的计算即可：

def fit_predict(self, X, N=10):
    # 进行N轮训练（默认进行10轮）
    train_num = 0
    # 存放质心与聚类结果
    WCSS_dict = {}
    while train_num < N:
        # self.centroid_list = self.get_rand_centroid(X)
        # 使用k-means++算法选出初始质心
        self.centroid_list = self.k_means_plus(X)
        # 记录初始质心
        self.initial_list = self.centroid_list
        while True:
            # 聚类
            distributed = self.get_distributed(X)
            # 计算虚拟质心
            v_centroid_list = self.get_virtual_centroid(distributed)
            # 如果两次质心相同，说明聚类结果已定
            if sorted(v_centroid_list) == sorted(self.centroid_list):
                break
            # 否则继续训练
            self.centroid_list = v_centroid_list
        # 对结果按照数据集顺序进行分类
        predict = []
        WCSS = 0
        for point in X:
            i = 0
            for dis in distributed:
                if point in dis:
                    predict.append(i)
                    # 计算当前点到其质心的距离，平方后再累加到WCSS中
                    WCSS += pow(self.get_distance(point, self.centroid_list[i]), 2)
                i += 1
        WCSS_dict[WCSS] = [self.centroid_list, predict]
        print("第" + str(train_num+1) + "轮的WCSS为：" + str(WCSS))
        train_num += 1
    # 选出WCSS最小的那个作为最终的聚类
    min_WCSS = min(WCSS_dict.keys())
    last_predict = WCSS_dict[min_WCSS][1]
    self.predict = last_predict
    return last_predict, min_WCSS

# 执行结果：
第1轮的WCSS为：0.04830321200000001
第2轮的WCSS为：0.04830321200000001
第3轮的WCSS为：0.04830321200000001
第4轮的WCSS为：0.04830321200000001
第5轮的WCSS为：0.04751589380952381
第6轮的WCSS为：0.04830321200000001
第7轮的WCSS为：0.04751589380952381
第8轮的WCSS为：0.04830321200000001
第9轮的WCSS为：0.04751589380952381
第10轮的WCSS为：0.04830321200000001

图中用红框标出的点，之前被归为得分较出色的球员，现在被归为了助攻较出色的球员。（红色的*点标注的是最终的质心）

Elbow方法 - 确定k的好办法

最后，我们再来讲一下关于k的取值问题。随着k的增大，即质心的增多，整体的WCSS是逐渐减小的（因为每个点能找到与其距离更近的质心的概率变大了），所以我们可以通过不断增大k，来观察整体的性能：

def elbow(self, k_range=10):
    # 通过elbow方法选择最佳k值
    x = []
    y = []
    for k in range(1, k_range+1):
        self.n_clusters = k
        x.append(k)
        # 取出不同k值下的WCSS
        _, min_WCSS = self.fit_predict(X)
        y.append(min_WCSS)
    plt.plot(x, y)
    plt.xlabel('k')
    plt.ylabel('WCSS')
    plt.show()

从图中可以发现，k从1到4的过程中，聚类性能有着明显的提升，但是再继续增加聚类的个数，性能提升的幅度就没有之前那么明显了，而且，聚类个数太多，也会让数据集变得过于分散，所以，在本例中，k=4是较好的选择。说明一开始根据经验取的k=3并不是最优的。我们再跑一下k=4的聚类：

通过最终的聚类，我们发现，算法将之前得分较多的球员又细分为了两类，黄色这类的得分要比绿色这类更高，所以可看做是真正得分多的球员；而绿色这类的得分并不出众，助攻也不算高，可看做是表现较为一般的球员（毕竟不可能所有的球员都有好的表现）。这样的分类从整体来看也更加符合实际情况。