《机器学习实战》 ch10 KMeans学习记录

我终于快把这本书看完了！！！开心！

前面学习到的算法都属于监督学习，数据都会自带标签，而接下来我们会转向无监督学习，目标变量事先不存在，无监督学习在现实生活中应用更为广泛。首先就是聚类和K-Means算法。

这一部分可以看看吴恩达的视频，感觉讲的挺清楚的，当然这本书也不错。

聚类是将相似的对象归到同一簇中，簇内的对象越相似聚类的效果越好。聚类和分类最大的不同是：分类的目标事先已经知道，但聚类不一样。聚类分析试图将相似对象归入同一簇，不相似的对象归入不同的簇，而是否相似则取决于相似度的计算方法。

K-Means是聚类算法的一种，可以发现K个不同的簇，每个簇的中心采用簇中算含数值的均值计算而成。

（1）K-Means聚类方法

K-Means的算法思想如下：

随机选择K个点作为起始质心
当任意一个点的簇分配结果改变时：
    对数据集中的每个数据点：
        对每个质心：
            计算质心与数据点之间的距离
        将数据点分配到距离其最近的簇
    对每一个簇，计算簇中所有点的均值并将其作为质心

这里的距离计算方法选择欧式距离

K-Means实现起来首先需要一些辅助函数，具体代码如下：

from numpy import *


def loadDataSet(fileName):      #general function to parse tab -delimited floats
    dataMat = []                #assume last column is target value
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        fltLine = list(map(float,curLine)) #map all elements to float()
        '''原书用的是python2,python2的map返回的是list
        而python3返回的是iterations，所以要在前面加上list'''
        dataMat.append(fltLine)
    return dataMat


def distEclud(vecA, vecB):
    # 计算两个向量的欧氏距离
    return sqrt(sum(power(vecA - vecB, 2)))  # la.norm(vecA-vecB)

def randCent(dataSet, k):
    # 为给定数据集构造一个包含k个随机质心的集合
    n = shape(dataSet)[1]
    centroids = mat(zeros((k,n)))  # create centroid mat
    for j in range(n):  # create random cluster centers, within bounds of each dimension
        minJ = min(dataSet[:,j]) 
        rangeJ = float(max(dataSet[:,j]) - minJ)
        centroids[:,j] = mat(minJ + rangeJ * random.rand(k,1))
    return centroids

三个函数的具体作用已经在注释中写出，经过测试都是可用的。

K-Means实现的具体代码如下：

def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    # 输入的参数分别为：数据集，簇的数目，计算距离和创建初始质心的函数
    m = shape(dataSet)[0]  # 确定数据集中数据总数目
    clusterAssment = mat(zeros((m,2)))  # 创建一个矩阵来存储每个点的簇分配结果
    # clusterAssment包含两列：一列记录簇索引值，一列存储误差
    centroids = createCent(dataSet, k)
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False
        for i in range(m):#for each data point assign it to the closest centroid
            minDist = 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
        # print(centroids)
        # 更新质心的位置
        for cent in range(k):#recalculate centroids
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]]  # 通过数组过滤得到给定簇的所有点
            centroids[cent,:] = mean(ptsInClust, axis=0)  # 计算所有点的均值
    return centroids, clusterAssment

上图为测试K-Means的结果截图，数据集是给定的，规定了划分4个簇，可以看到一共迭代了四次后退出循环的，每次的结果有四组数值，代表四个簇的质心。

（2）使用后处理来提高聚类性能

K-Means的K值使用户事先设定的，K-Means聚类效果比较差的一个原因是收敛到了局部最小值而非全局最小值。

一种用来度量聚类效果好坏的指标是SSE（误差平方和），SSE值越小表示数据点越接近质心，聚类效果也就越好。聚类的目标是在保持簇数目不变的情况下提高簇的质量。提高聚类的性能的一个方法，就是对生成的簇进行后处理，其中一个方法是将具有最大SSE值的簇分为两个簇，将最大簇包含的点过滤出来并在这些点上运行K-Means算法。

为了保持簇总数目不变，可以将某两个簇进行合并，可以合并最近的质心或者合并两个SSE最小的质心。无论是哪一种方法，否要在可能的两个簇上重复上述的处理过程，直到找到合并最佳的两个簇位置。接下来就是一种运用了这种思想的更好的聚类方法：

（3）二分K-Means方法

二分K-Means方法可以克服K-Means收敛于局部最小值的问题，该算法的实现思想如下：

将所有的点看成一个簇
当簇数目小于k的时候：
    对于每一个簇：
        计算总误差
        在给定的簇上面进行K-Means计算（k = 2）  
        计算将该簇一分为二之后的总误差    
    选择是的误差最小的那个簇进行划分操作

上述是二分K-Means实现的一种做法，还有一种做法是选择SSE最大的簇进行划分，直到簇的数目达到用户指定的K值为止。

二分K-Means的实现代码如下：

def biKmeans(dataSet, k, distMeas=distEclud):
    m = shape(dataSet)[0]
    clusterAssment = mat(zeros((m,2))) # 创建矩阵来存储数据集中的每个点的簇分配结果以及平方误差
    # 创建一个初始簇
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    centList =[centroid0] # 使用list来保存质心
    for j in range(m):  # 计算每个点到质心的误差值
        clusterAssment[j,1] = distMeas(mat(centroid0), dataSet[j,:])**2
    while (len(centList) < k):  # 直到划分出k个簇跳出循环
        lowestSSE = inf
        for i in range(len(centList)):
            # 尝试划分每一簇
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:,0].A==i)[0],:]#get the data points currently in cluster i
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            sseSplit = sum(splitClustAss[:,1])#compare the SSE to the currrent minimum
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:,0].A!=i)[0],1])
            print("sseSplit, and notSplit: ",sseSplit,sseNotSplit)
            if (sseSplit + sseNotSplit) < lowestSSE:  # 误差与剩余数据集的误差值和作为本次划分的误差
                bestCentToSplit = i
                bestNewCents = centroidMat
                bestClustAss = splitClustAss.copy()
                lowestSSE = sseSplit + sseNotSplit
        # 更新簇的分配结果
        bestClustAss[nonzero(bestClustAss[:,0].A == 1)[0],0] = len(centList) #change 1 to 3,4, or whatever
        bestClustAss[nonzero(bestClustAss[:,0].A == 0)[0],0] = bestCentToSplit
        print('the bestCentToSplit is: ',bestCentToSplit)
        print('the len of bestClustAss is: ', len(bestClustAss))
        centList[bestCentToSplit] = bestNewCents[0,:].tolist()[0]#replace a centroid with two best centroids
        centList.append(bestNewCents[1,:].tolist()[0])
        clusterAssment[nonzero(clusterAssment[:,0].A == bestCentToSplit)[0],:]= bestClustAss#reassign new clusters, and SSE
    return mat(centList), clusterAssment  # 返回质心列表和簇分配结果

代码的解释看注释即可。

最后的矩阵为聚类所得到的质心结果。

本来这一章节还有一个实战，但是因为实战里雅虎API的链接已经挂掉了，所以没办法做（我发现这本书里凡是涉及这方面的都有这个通病，大概是因为年代有点久远了吧）

（5）总结

聚类是无监督学习方法的一种，聚类将数据点归到多个簇中，其中相似数据点处于同一簇中，不相似的处在不同的簇中，聚类可以使用多种不同的方法来计算相似度，一种广泛使用的方法是K-Means，K-Means有效，但容易出现局部最优的结果，而我们希望得到全局最优，所以可以使用二分K-Means方法进行改进。