机器学习实战笔记-利用K均值聚类算法对未标注数据分组

Posted 2020-10-15 kevincong

聚类是一种无监督的学习，它将相似的对象归到同一个簇中。它有点像全自动分类。聚类方法几乎可以应用于所有对象，簇内的对象越相似，聚类的效果越好
簇识别给出聚类结果的含义。假定有一些数据，现在将相似数据归到一起，簇识别会告诉我们这些簇到底都是些什么。聚类与分类的最大不同在于，分类的目标事先巳知，而聚类则不一样。因为其产生的结果与分类相同，而只是类别没有预先定义，聚类有时也被称为无监督分类（unsupervised classification )。
聚类分析试图将相似对象归人同一簇，将不相似对象归到不同簇。相似这一概念取决于所选择的相似度计算方法

10.1K-均值聚类算法

K-均值聚类
优点：容易实现。
缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢。
适用数据类型：数值型数据。

K-均值是发现给定数据集的k个簇的算法。簇个数k是用户给定的，每一个簇通过其质心( centroid) , 即簇中所有点的中心来描述。
K-均值算法的工作流程是这样的。首先，随机确定k个初始点作为质心。然后将数据集中的每个点分配到一个簇中，具体来讲，为每个点找距其最近的质心，并将其分配给该质心所对应的簇。这一步完成之后，每个簇的质心更新为该簇所有点的平均值。

上述过程的伪代码表示如下：
创建k个点作为起始质心（经常是随机选择）
当任意一个点的簇分配结果发生改变时
??对数据集中的每个数据点
????对每个质心
??????计算质心与数据点之间的距离
????将数据点分配到距其最近的簇
??对每一个簇，计算簇中所有点的均值并将均值作为质心

K-均值聚类的一般流程
(1)收集数据：使用任意方法。
⑵准备数据：需要数值型数据来计算距离，也可以将标称型数据映射为二值型数据再用于距离计算。
(3)分析数据：使用任意方法。
(4)训练算法：不适用于无监督学习，即无监督学习没有训练过程。
(5)测试算法：应用聚类算法、观察结果。可以使用量化的误差指标如误差平方和（后面会介绍）来评价算法的结果。
(6)使用算法：可以用于所希望的任何应用。通常情况下，簇质心可以代表整个簇的数据来做出决策。

K-均值聚类支持函数(即完成K均值聚类的一些辅助函数),代码如下:

from numpy import *

#general function to parse tab -delimited floats
 #assume last column is target value
def loadDataSet(fileName):     
    dataMat = []               
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split(‘\t‘)
        #笔者使用的是python3，需要将map映射后的结果转化为list
        #map all elements to float()
        fltLine = list(map(float,curLine)) 
        dataMat.append(fltLine)
    return dataMat

#样本距离计算函数
def distEclud(vecA, vecB):
    return sqrt(sum(power(vecA - vecB, 2))) #la.norm(vecA-vecB)
#创建簇中心矩阵,初始化为k个在数据集的边界内随机分布的簇中心
def randCent(dataSet, k):
    n = shape(dataSet)[1]
    #create centroid mat 
    centroids = mat(zeros((k,n)))
    #create random cluster centers, within bounds of each dimension
    for j in range(n):
        #求出数据集中第j列的最小值(即第j个特征)
        minJ = min(dataSet[:,j])
        #用第j个特征最大值减去最小值得出特征值范围
        rangeJ = float(max(dataSet[:,j]) - minJ)
        #创建簇矩阵的第J列,random.rand(k,1)表示产生(10,1)维的矩阵，其中每行值都为0-1中的随机值
        #可以这样理解,每个centroid矩阵每列的值都在数据集对应特征的范围内,那么k个簇中心自然也都在数据集范围内
        centroids[:,j] = mat(minJ + rangeJ * random.rand(k,1))
    return centroids

测试截图如下:

K -均值聚类算法,代码如下:

#distMeas为距离计算函数
#createCent为初始化随机簇心函数
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    m = shape(dataSet)[0]
    #create mat to assign data points to a centroid, also holds SE of each point
    #创建一个(m,2)维矩阵，第一列存储每个样本对应的簇心，第二列存储样本到簇心的距离
    clusterAssment = mat(zeros((m,2)))
    #用createCent()函数初始化簇心矩阵
    centroids = createCent(dataSet, k)
    #保存迭代中clusterAssment是否更新的状态,如果未更新，那么退出迭代，表示收敛
    #如果更新，那么继续迭代，直到收敛
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False
        #for each data point assign it to the closest centroid
        #对每个样本找出离样本最近的簇心
        for i in range(m):
            #minDist保存最小距离
            #minIndex保存最小距离对应的簇心
            minDist = inf; minIndex = -1
            #遍历簇心，找出离i样本最近的簇心
            for j in range(k):
                distJI = distMeas(centroids[j,:],dataSet[i,:])
                if distJI < minDist:
                    minDist = distJI; minIndex = j
            #如果clusterAssment更新，表示对应样本的簇心发生变化，那么继续迭代
            if clusterAssment[i,0] != minIndex: clusterChanged = True
            #更新clusterAssment,样本到簇心的距离
            clusterAssment[i,:] = minIndex,minDist**2
        print(centroids)
        #遍历簇心,更新簇心为对应簇中所有样本的均值
        for cent in range(k):#recalculate centroids
            #利用数组过滤找出簇心对应的簇(数组过滤真是好东西！)
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]]#get all the point in this cluster
            #对簇求均值,赋给对应的centroids簇心
            centroids[cent,:] = mean(ptsInClust, axis=0) #assign centroid to mean 
    return centroids, clusterAssment

代码测试截图如下:

绘制测试截图:

paint函数为笔者写的绘图函数:

def paint(xArr,yArr,xArr1,yArr1):
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xArr,yArr,c=‘blue‘)
    ax.scatter(xArr1,yArr1,c=‘red‘)
    plt.show()

效果如下(其中红色的点为簇心):

可以看到，经过3次迭代之后K-均值算法收敛

10.2 使用后处理来提高聚类性能

考虑图10-2中的聚类结果，这是在一个包含三个簇的数据集上运行K-均值算法之后的结果，但是点的簇分配结果值没有那么准确。K-均值算法收敛但聚类效果较差的原因是，K-均值算法收敛到了局部最小值，而非全局最小值（局部最小值指结果还可以但并非最好结果，全局最小值是可能的最好结果)。
一种用于度量聚类效果的指标是SSE(Sum of Squared Error,误差平方和），对应clusterAssment矩阵的第一列之和。SSE值越小表示数据点越接近于它们的质心，聚类效果也越好。因为对误差取了平方，因此更加重视那些远离中心的点。一种肯定可以降低SSE值的方法是增加簇的个数，但这违背了聚类的目标。聚类的目标是在保持簇数目不变的情况下提高簇的质量。
那么如何对结果进行改进？你可以对生成的簇进行后处理，一种方法是将具有最大SSE值的簇划分成两个簇。具体实现时可以将最大簇包含的点过滤出来并在这些点上运行K-均值聚类算法，其中的K为2。

为了保持簇总数不变，可以将某两个簇进行合并。从图10-2中很明显就可以看出，应该将图下部两个出错的簇质心进行合并。可以很容易对二维数据上的聚类进行可视化，但是如果遇到40维的数据应该如何去做？
有两种可以量化的办法：合并最近的质心，或者合并两个使得SSE增幅最小的质心。第一种思路通过计算所有质心之间的距离，然后合并距离最近的两个点来实现。第二种方法需要合并两个簇然后计算总SSE值。必须在所有可能的两个簇上重复上述处理过程，直到找到合并最佳的两个簇为止。接下来将讨论利用上述簇划分技术得到更好的聚类结果的方法。

10.3 二分K-均值算法

为克服K-均值算法收敛于局部最小值的问题，有人提出了另一个称为二分K均值（bisectingK-means)的算法, 该算法首先将所有点作为一个簇，然后将该簇一分为二。之后选择其中一个簇继续进行划分，选择哪一个簇进行划分取决于对其划分是否可以最大程度降低SSE的值。上述基于SSE的划分过程不断重复，直到得到用户指定的簇数目为止。

二分K-均值算法的伪代码形式如下：
将所有点看成一个簇
当簇数目小于k时
对于每一个簇
??计算总误差
??在给定的簇上面进行K-均值聚类（k=2)
??计算将该簇一分为二之后的总误差
选择使得误差最小的那个簇进行划分操作

另一种做法是选择SSE最大的簇进行划分，直到簇数目达到用户指定的数目为止。这个做法听起来并不难实现。下面就来看一下该算法的实际效果。

二分K均值聚类算法,代码如下:

#distMeas为距离计算函数
def biKmeans(dataSet, k, distMeas=distEclud):
    m = shape(dataSet)[0]
    #(m,2)维矩阵,第一列保存样本所属簇,第二列保存样本到簇中心的距离
    clusterAssment = mat(zeros((m,2)))
    #取数据集特征均值作为初始簇中心
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    #centList保存簇中心数组,初始化为一个簇中心
    #create a list with one centroid
    centList =[centroid0] 
    #calc initial Error
    for j in range(m):
        clusterAssment[j,1] = distMeas(mat(centroid0), dataSet[j,:])**2
    #迭代，直到簇中心集合长度达到k
    while (len(centList) < k):
    #初始化最小误差
        lowestSSE = inf
        #迭代簇中心集合，找出找出分簇后总误差最小的那个簇进行分解
        for i in range(len(centList)):
            #get the data points currently in cluster i
            #获取属于i簇的数据集样本
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:,0].A==i)[0],:]
            #对该簇进行k均值聚类
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            #获取该簇分类后的误差和
            sseSplit = sum(splitClustAss[:,1])#compare the SSE to the currrent minimum
            #获取不属于该簇的样本集合的误差和，注意矩阵过滤中用的是!=i
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:,0].A!=i)[0],1])
            #打印该簇分类后的误差和和不属于该簇的样本集合的误差和
            print("sseSplit, and notSplit: ",sseSplit,sseNotSplit)
            #两误差和相加即为分簇后整个样本集合的误差和,找出簇中心集合中能让分簇后误差和最小的簇中心，保存最佳簇中心(bestCentToSplit),最佳分簇中心集合(bestNewCents),以及分簇数据集中样本对应簇中心及距离集合(bestClustAss),最小误差(lowestSSE)
            if (sseSplit + sseNotSplit) < lowestSSE:
                bestCentToSplit = i
                bestNewCents = centroidMat
                bestClustAss = splitClustAss.copy()
                lowestSSE = sseSplit + sseNotSplit
        #更新用K-means获取的簇中心集合，将簇中心换为len(centList)和bestCentToSplit,以便之后调整clusterAssment(总样本集对应簇中心与和簇中心距离的矩阵)时一一对应
        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))
        #更新簇中心集合,注意与bestClustAss矩阵是一一对应的
        centList[bestCentToSplit] = bestNewCents[0,:].tolist()[0]#replace a centroid with two best centroids 
        centList.append(bestNewCents[1,:].tolist()[0])
        #reassign new clusters, and SSE
        clusterAssment[nonzero(clusterAssment[:,0].A == bestCentToSplit)[0],:]= bestClustAss
    return mat(centList), clusterAssment

二分K值最重要的是记住要将最佳分簇集合与clusterAssment一一对应
测试代码如下:

datMat3 = mat(loadDataSet(‘testSet2.txt‘))
centList,myNewAssments = biKmeans(datMat3,3)
print(centList)
xArr = datMat3[:,0].flatten().A[0]
yArr = datMat3[:,1].flatten().A[0]
xArr1 = centList[:,0].flatten().A[0]
yArr1 = centList[:,1].flatten().A[0]
#paint为笔者自己写的绘图函数
paint(xArr,yArr,xArr1,yArr1)

def paint(xArr,yArr,xArr1,yArr1):
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xArr,yArr,c=‘blue‘)
    ax.scatter(xArr1,yArr1,c=‘red‘)
    plt.show()

测试截图如下:

上述函数可以运行多次，聚类会收敛到全局最小值，而原始的别的!!3 ()函数偶尔会陷人局部最小值。

10.4 示例：对地图上的点进行聚类

假如有这样一种情况：你的朋友Drew希望你带他去城里庆祝他的生日。由于其他一些朋友也会过来，所以需要你提供一个大家都可行的计划。Drew给了你一些他希望去的地址。这个地址列表很长，有70个位置。我把这个列表保存在文件portland-Clubs.txt中，该文件和源代码一起打包。这些地址其实都在俄勒冈州的波特兰地区。
也就是说，一晚上要去70个地方！你要决定一个将这些地方进行聚类的最佳策略，这样就可以安排交通工具抵达这些簇的质心，然后步行到每个簇内地址。Drew的清单中虽然给出了地址，但是并没有给出这些地址之间的距离远近信息。因此，你要得到每个地址的纬度和经度，然后对这些地址进行聚类以安排你的行程。

示例：对于地理数据应用二分K-均值算法
(1)收集数据：使用Yahoo!PlaceFinder API收集数据
(2)准备数据：只保留经纬度信息
(3)分析数据：使用Matplotlib来构建一个二维数据图，其中包含簇与地图
(4)训练算法：训练不适用无监督学习
(5)测试算法：使用10.4节中的biKmeans( )函教
(6)使用算法| 最后的输出是包含簇及簇中心的地图

10.4.1 Yahoo! PlaceFinder API

Yahoo! PlaceFinderAPI，代码如下:

import urllib
import json
def geoGrab(stAddress, city):
    #create a dict and constants for the goecoder
    apiStem = ‘http://where.yahooapis.com/geocode?‘  
    #请求参数字典
    params = {}
    params[‘flags‘] = ‘J‘#JSON return type
    params[‘appid‘] = ‘aaa0VN6k‘
    params[‘location‘] = ‘%s %s‘ % (stAddress, city)
    #url编码请求参数,化为x1=xx&x2=xx形式
    url_params = urllib.urlencode(params)
     #print url_params
    yahooApi = apiStem + url_params     
    print(yahooApi)
    #请求api
    c=urllib.urlopen(yahooApi)
    #获取json格式的数据
    return json.loads(c.read())

from time import sleep
def massPlaceFind(fileName):
    fw = open(‘places.txt‘, ‘w‘)
    #对文件中的每个样本调用geoGrab()获取json数据,解析后写入源文件
    for line in open(fileName).readlines():
        line = line.strip()
        lineArr = line.split(‘\t‘)
        retDict = geoGrab(lineArr[1], lineArr[2])
        if retDict[‘ResultSet‘][‘Error‘] == 0:
            lat = float(retDict[‘ResultSet‘][‘Results‘][0][‘latitude‘])
            lng = float(retDict[‘ResultSet‘][‘Results‘][0][‘longitude‘])
            print("%s\t%f\t%f" % (lineArr[0], lat, lng))
            fw.write(‘%s\t%f\t%f\n‘ % (line, lat, lng))
        else: print("error fetching")
        sleep(1)
    fw.close()

测试代码如下:

geoResults = geoGrab(‘1 VA Center‘, ‘Augusta, ME‘)
print(geoResults)

由于主要不是为了调用YahooAPI，因此笔者没有实际调用API获取数据，理解这个过程就可以了，首先获取数据，然后调用二分K均值聚类对地址聚类分析。

10.4.2 对地理坐标进行聚类
这个例子中要聚类的俱乐部给出的信息为经度和维度，但这些信息对于距离计算还不够。在北极附近每走几米的经度变化可能达到数10度 ；而在赤道附近走相同的距离，带来的经度变化可能只是零点几。可以使用球面余弦定理来计算两个经纬度之间的距离

球面距离计算及簇绘图函数,代码如下:

#利用球面余弦定理计算指定(经度，纬度)两点的距离
def distSLC(vecA, vecB):#Spherical Law of Cosines
    a = sin(vecA[0,1]*pi/180) * sin(vecB[0,1]*pi/180)
    b = cos(vecA[0,1]*pi/180) * cos(vecB[0,1]*pi/180) *                       cos(pi * (vecB[0,0]-vecA[0,0]) /180)
    return arccos(a + b)*6371.0 #pi is imported with numpy

import matplotlib
import matplotlib.pyplot as plt
def clusterClubs(numClust=5):
    datList = []
    #读取数据集，存储在datList中
    for line in open(‘places.txt‘).readlines():
        lineArr = line.split(‘\t‘)
        datList.append([float(lineArr[4]), float(lineArr[3])])
    datMat = mat(datList)
    #调用二分K聚类获取簇中心集合以及clustAssing矩阵
    myCentroids, clustAssing = biKmeans(datMat, numClust, distMeas=distSLC)
    fig = plt.figure()
    rect=[0.1,0.1,0.8,0.8]
    scatterMarkers=[‘s‘, ‘o‘, ‘^‘, ‘8‘, ‘p‘,                     ‘d‘, ‘v‘, ‘h‘, ‘>‘, ‘<‘]
    axprops = dict(xticks=[], yticks=[])
    ax0=fig.add_axes(rect, label=‘ax0‘, **axprops)
    imgP = plt.imread(‘Portland.png‘)
    ax0.imshow(imgP)
    ax1=fig.add_axes(rect, label=‘ax1‘, frameon=False)
    #迭代簇集合,根据不同的marker画出对应的簇
    for i in range(numClust):
        ptsInCurrCluster = datMat[nonzero(clustAssing[:,0].A==i)[0],:]
        markerStyle = scatterMarkers[i % len(scatterMarkers)]
        ax1.scatter(ptsInCurrCluster[:,0].flatten().A[0], ptsInCurrCluster[:,1].flatten().A[0], marker=markerStyle, s=90)
    #画出所有簇中心
    ax1.scatter(myCentroids[:,0].flatten().A[0], myCentroids[:,1].flatten().A[0], marker=‘+‘, s=300)
    plt.show()

测试代码如下:

kMeans.clusterClubs(5)

测试截图如下:

10.5 本章小结

聚类是一种无监督的学习方法。所谓无监督学习是指事先并不知道要寻找的内容，即没有目标变量。聚类将数据点归到多个簇中，其中相似数据点处于同一簇，而不相似数据点处于不同簇中。聚类中可以使用多种不同的方法来计算相似度。
一种广泛使用的聚类算法是K-均值算法，其中K是用户指定的要创建的簇的数目。K-均值聚类算法以K个随机质心开始。算法会计算每个点到质心的距离。每个点会被分配到距其最近的簇质心，然后紧接着基于新分配到簇的点更新簇质心。以上过程重复数次，直到簇质心不再改变。这个简单的算法非常有效但是也容易受到初始簇质心的影响。为了获得更好的聚类效果，可以使用另一种称为二分K-均值的聚类算法。二分K-均值算法首先将所有点作为一个簇，然后使用K-均值算法(K = 2 ) 对其划分。下一次迭代时，选择有最大误差的簇进行划分。该过程重复直到K个簇创建成功为止。二分K-均值的聚类效果要好于K-均值算法。
K-均值算法以及变形的K-均值算法并非仅有的聚类算法, 另外称为层次聚类的方法也被广泛使用

版权声明：本文为博主原创文章，未经博主允许不得转载。