py2.7《机器学习实战》利用k-means聚类算法对未标数据分组

一、支持函数

from numpy import *
def loadDataSet(fileName):
    dataMat = []
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        fltLine = map(float,curLine)
        dataMat.append(fltLine)
    return  dataMat

def distEclud(vecA,vecB):
    return sqrt(sum(power(vecA-vecB,2)))

def randCent(dataSet , k):#K个随机质心
    n = shape(dataSet)[1]
    centroids = mat(zeros((k,n))) #k个
    for j in range(n):
        minJ = min(dataSet[:,j]) #找到边界最小值
        rangeJ = float(max(dataSet[:,j])-minJ)#最大减最小得到区间
        centroids[:,j] = minJ + rangeJ*random.rand(k,1)
        #生成0~1的随机数,rand(k,1)代表生成k行1列的随机矩阵，因为是2维的，所以相当于生成k组x，y
    return centroids

二、K-均值聚类算法

def kMeans(dataSet , k ,distMeas = distEclud ,createCent = randCent):
    m = shape(dataSet)[0] #数据总数
    clusterAssment = mat(zeros((m,2))) #簇分配结果矩阵，一维代表簇索引值，二维代表误差（当前点到簇质心的距离）
    centroids = createCent(dataSet,k)#随机质心
    clusterChanged = True
    while clusterChanged: #迭代：计算质心->分配
        clusterChanged = False
        for i in range(m):
            minDist = inf ; minIndex = -1
            for j in range(k): #遍历所有数据，找到距离每个点最近的质心，即第i个点距离第j个质心最近
                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):#遍历质心更新取值
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A == cent)[0]]
            centroids[cent,:] = mean(ptsInClust,axis=0) #axis沿列进行均值计算
    return centroids,clusterAssment

测试函数：

import kMeans
from numpy import *
datamat = mat(kMeans.loadDataSet('testSet.txt'))
myCentroids , clustAssing = kMeans.kMeans(datamat,4) #每次给出四个质心，三次迭代后收敛

输出样例：

[[-3.42377839 -2.30177844]
 [ 1.26773955 -3.3363673 ]
 [ 2.29481868 -3.09999664]
 [ 2.98365297  0.08363438]]
[[-3.231108   -0.45641674]
 [ 0.33258533 -3.763162  ]
 [ 2.87672686 -3.077605  ]
 [ 2.07919597  2.55993866]]
[[-3.23765394 -0.14691848]
 [-0.49980667 -3.24985483]
 [ 3.17437012 -2.75441347]
 [ 1.98283629  3.1465235 ]]
[[-3.23825903  0.3056831 ]
 [-1.5931908  -3.3212249 ]
 [ 3.17437012 -2.75441347]
 [ 1.98283629  3.1465235 ]]
[[-2.90972572  2.13857161]
 [-3.11105621 -3.07045705]
 [ 2.926737   -2.70147753]
 [ 1.98283629  3.1465235 ]]
[[-2.46154315  2.78737555]
 [-3.38237045 -2.9473363 ]
 [ 2.80293085 -2.7315146 ]
 [ 2.6265299   3.10868015]]

三、二分K-均值算法

K-均值算法会有可能局部收敛，所以为了改进提出了二分K-均值算法

算法思想是，将所有点当做一个簇，然后不断二分化(k=2)，先选择哪个簇取决于对其划分是否可以最大程度的降低SSE（误差平方和）的值，这样就是优先的划分该簇了

因此这里的循环是重复执行k-均值算法的

def biKmeans(dataSet, k, distMeas=distEclud):
    m = shape(dataSet)[0]
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    centList = [centroid0]  # 簇
    for j in range(m):  # calc initial Error
        clusterAssment[j, 1] = distMeas(mat(centroid0), dataSet[j, :]) ** 2
    while (len(centList) < k):
        lowestSSE = inf
        for i in range(len(centList)):  # 遍历每一个簇
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:, 0].A == i)[0], :]  # 看成小数据集放入kmeans里得到两个质心和误差
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            sseSplit = sum(splitClustAss[:, 1])  # 对比是否划分
            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)  # 如果决定了就划分
        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]  # 更新划分数据集
        centList.append(bestNewCents[1, :].tolist()[0])  # 质心加入centList
        clusterAssment[nonzero(clusterAssment[:, 0].A == bestCentToSplit)[0], :] = bestClustAss  # 分配结果
    return mat(centList), clusterAssment
    clusterAssment = mat(zeros((m,2)))#创建矩阵存储每个点的簇分配结果以及平方误差