一. k-means

1.算法流程

给定数据样本集 $D=\{x_1,x_2,...,x_m\}$ ,k-means欲将 $D$ 划分成K个簇 $C=\{c_1,c_2,...,c_k\}$ 并且簇之间没有交集。其目标是最小化平方误差和：
$\begin{aligned} E=\sum_{i=1}^k\sum_{x\in c_i}||x-u_i||_{2}^2 \end{aligned}$
其中 $u_i=\cfrac{1}{|c_i|}\sum_{x\in c_i}x$ 是簇 $c_i$ 的均值向量（簇的形心）。从几何上理解就是k-means划分的每个簇中的样本都紧紧地挨着簇的形心。想要最小化平方误差和并不容易，找到它的最优解需要考虑所有可能的簇的划分，这是个NP难问题。所以，k-means采用了贪心的策略，通过迭代来找到局部最优解。算法流程如下：

输入数据集D，簇的个数k
从D中随机选择k个不同的样本作为初始均值向量{ $u_1,u_2,...,u_k$ }
REPEAT
初始化k个簇为空 $c_i=\varnothing$
for $i$ 1 to m :
分别计算 $x_i$ 到k个均值向量的距离： $d_{ij}=dist(x_i,u_j),j=1,2,...,k$
找到与 $x_{i}$ 距离最近的均值向量对应的标号： $j^*= min_{j \in [1,k]}\enspace d_{ij}$
将 $x_i$ 添加到对应簇中： $c_{j^*}=c_{j^*} \cup x_i$
end for
for $i$ 1 to k:
更新均值向量： $u_i =\cfrac{1}{|c_i|}\sum_{x\in c_i}x$
end for
UNTIL:所有均值向量收敛，即变化极小
输出: $C=\{c_1,c_2,...,c_k\}$

2.代码实现

python原生实现代码如下：

def kmeans(data,k):
    m,n = data.shape
    #不重复随机抽样，产生k个不同的整数
    r = random.sample(range(0,m),k)
    #初始化均值向量
    u= data[r]
    #初始化K个簇
    clusters =[]
    for i in range(0,k):
        clusters.append([])
    #迭代至均值向量收敛
    while True:
        #遍历所有样本,划分簇
        for i in range(0,m):
            min = 0
            index = -1
            #找到样本最近的中心
            for j in range(0,k):
                dist = math.sqrt((data[i]-u[j]) @ (data[i]-u[j]).T)#计算距离
                if(j == 0):
                    min = dist
                    index =j
                    continue
                if(dist < min):
                    min = dist
                    index = j
            #样本加入对应簇
            clusters[index].append(data[i].tolist())    
        #更新均值
        u_old  = u.copy() 
        for i in range(0,k):
            c  = np.array(clusters[i])
            for j in range(0,n):
                u[i][j] = c[:,j].mean() 
        
        #判断收敛
        delta = (u-u_old) @(u-u_old).T
        if np.all(delta < 1e-6):break
        else: #继续迭代，更新簇
            clusters.clear()#清空
            for i in range(0,k):
                clusters.append([])
    return clusters

k-means算法的时间复杂度是O(mks)，m是数据量，k是聚类簇的个数，s是迭代次数。k-means收敛的较快，适用于大规模数据。

现在产生一个随机数据集：

X=datasets.make_classification(n_samples=200,
                                            n_features=2,
                                            n_informative=2,
                                            n_redundant=0,
                                            n_repeated=0,
                                            n_clusters_per_class=1)[0]
plt.scatter(X[:,0], X[:,1],marker='o',s=10)
plt.show()

数据分布图：
在这里插入图片描述
K-means聚类的结果：

3.K-means缺点

K值要人为给出，需要有先验知识
聚类结果依赖于初始聚类中心的随机选择，可能收敛到局部最优解，而非全局最优
受噪声和离群点的影响极大

二 K-means++

该算法对K-means做了改进，优化了初始聚类中心的随机选择，使其能够收敛于全局最优解。

1.算法流程

主要是初始化聚类中心的流程，其余的流程和K-means一样。

随机选择一个样本做第一个聚类中心
第n个中心的选择与前n-1个中心有关：
计算所有样本到当前已有中心的距离和，选择距离和最大的样本作为新的聚类中心
直到K个中心选择完

这个流程的思想就是想让初始化的聚类中心尽可能散得开一些。

2.代码实现

def initCenters(data,k):
    m,n = data.shape
    centers = np.zeros((k,n))
    #随机选择第一个聚类中心
    first = np.random.randint(0,m)
    centers[0] =data[first,:]
    for t in range(1,k):
        c_size =t
        maxs = 0
        index = -1
        #遍历所有样本，找到最远点
        for i in range(0,m):
            sums = 0.0
            for j in range(0,c_size):
                sums +=math.sqrt((data[i,:]-centers[j,:]) @ (data[i,:]-centers[j,:]).T)
            if sums > maxs:
                maxs = sums
                index = i
        #加入一个聚类中心
        centers[t] = data[index,:]
    
    return centers

def kmeansPlus(data,k):
    m,n = data.shape
    #初始化均值向量
    u=  initCenters(data,k)
    #初始化K个簇
    clusters =[]
    for i in range(0,k):
        clusters.append([])
    #迭代至均值向量收敛
    while True:
        #遍历所有样本,划分簇
        for i in range(0,m):
            min = 0
            index = -1
            #找到样本最近的中心
            for j in range(0,k):
                dist = math.sqrt((data[i]-u[j]) @ (data[i]-u[j]).T)#计算距离
                if(j == 0):
                    min = dist
                    index =j
                    continue
                if(dist < min):
                    min = dist
                    index = j
            #样本加入对应簇
            clusters[index].append(data[i].tolist())    
        #更新均值
        u_old  = u.copy() 
        for i in range(0,k):
            c  = np.array(clusters[i])
            for j in range(0,n):
                u[i][j] = c[:,j].mean() 
        
        #判断收敛
        delta = (u-u_old) @(u-u_old).T
        if np.all(delta < 1e-6):break
        else: #继续迭代，更新簇
            clusters.clear()#清空
            for i in range(0,k):
                clusters.append([])
    return clusters

现在生成一个数据集，比较一下K-means和K-means++的聚类效果：

def showClusters(c1,c2,c3):
    plt.scatter(c1[:,0],c1[:,1],c='r',s=10)
    plt.scatter(c2[:,0],c2[:,1],c='b',s=10)
    plt.scatter(c3[:,0],c3[:,1],c='g',s=10)
    plt.scatter(c1[:,0].mean(),c1[:,1].mean(),marker='*',c=[[0,0,0]],s=50)
    plt.scatter(c2[:,0].mean(),c2[:,1].mean(),marker='*',c=[[0,0,0]],s=50)
    plt.scatter(c3[:,0].mean(),c3[:,1].mean(),marker='*',c=[[0,0,0]],s=50)
    plt.show()
    
X = datasets.make_moons(n_samples=100, noise=0.2, random_state=0)[0]

cls = kmeans(X,3)
c1 = np.array(cls[0])
c2 = np.array(cls[1])
c3 = np.array(cls[2])

showClusters(c1,c2,c3)
cls1 = kmeansPlus(X,3)
c1 = np.array(cls1[0])
c2 = np.array(cls1[1])
c3 = np.array(cls1[2])
showClusters(c1,c2,c3)

上图是K-means聚类的效果，下图是K-means++聚类的效果：
在这里插入图片描述

从上图可以看出，K-means簇内没有那么紧凑，K-means++划分的簇内更紧凑。说明K-means只是局部收敛了，这是由于初始化中心随机选择导致的，对于这个点还有很多优化方法，例如二分K-means和最小生成树k-means，这里不再赘述。

三 K-mediods

1.算法流程

k-means最大的缺点就是受到离群点或噪声的影响极大，这是因为k-means更新中心的方式是计算簇内均值向量，离群点会极大地影响某属性列的均值,从而导致中心点偏离。k-中心点算法解决了这个问题，因为其思想是：尝试用非中心点替代中心点，若替代后总代价减小了，就进行真正替代。 如此，更新的中心点总是某样本，且用总代价衡量，中心点不会偏离簇。
算法流程如下：

输入:数据集D和簇的个数k
随机选择k个不同的样本作为原始中心点
初次划分k个簇
计算初次划分产生的总代价:e
REPEAT
FOR i FROM 0 TO k
随机选择一个非中心点去尝试替代第i个中心
尝试重新划分k个簇:cls_try
计算重新划分产生的总代价:e_try
IF e_try - e < 0
进行真正的替代
进行真正的划分:cls = cls_try
替换e = e_try
THEN :撤销尝试
END IF
END FOR
UNTIL 簇没有发生任何变化

代码实现如下：

#计算总代价
def calcE(clusters,mediods):
    loss = 0.0
    for i in range(0,mediods.shape[0]):
        for x in clusters[i]:
            loss+=math.sqrt((x-mediods[i]) @ (x-mediods[i]).T)
    return loss
#划分簇
def clustersPartition(data,mediods):
    #初始化k个空簇
    clusters =[]
    for i in range(0,mediods.shape[0]):
        clusters.append([])
    #样本离那个中心近就划分到对应簇
    for j in range(0,data.shape[0]):
        mini = float('inf')
        index =  -1
        for i in range(0,mediods.shape[0]):
            dist = math.sqrt((data[j]-mediods[i]) @ (data[j]-mediods[i]).T)
            if(dist<mini):
                mini = dist
                index = i
        clusters[index].append(data[j].tolist())
    
    for i in range(0,mediods.shape[0]):
        clusters[i] = np.array(clusters[i])
    return clusters
#随机挑选一个非中心对象
def  selectRandom(data,mediods):
    m = data.shape[0]
    i = np.random.randint(0,m)
    while i>=m and data[i] in mediods:
        i = random.randint(0,m)
    return data[i]
#k-中心点算法
def kmediods(data,k):
    m,n = data.shape
    #产生k个不同的随机数
    r = random.sample(range(0,m),k)
    #初始化k个中心点
    mediods = data[r]
    #产生k个簇
    clusters = clustersPartition(data,mediods)
    #计算当前总代价
    e = calcE(clusters,mediods)
    #迭代次数和最大迭代次数
    iters = 0
    maxIters = m 
    while iters<maxIters:
        changed = 0
        #尝试替换每个中心
        for i in range(0,k):
            centerOld = mediods[i].copy()
            centerNew = selectRandom(data,mediods)#随机选择一个非中心点
            mediods[i] = centerNew#用非中心点尝试更新中心
            clusters_try = clustersPartition(data,mediods)#尝试划分新的簇
            e_try = calcE(clusters,mediods)#计算更新后的损失
            #若总代价在减小
            if(e_try - e) < 0:
                clusters.clear()
                clusters = clusters_try#更新簇
                e = e_try
                changed+=1#替代次数
            else: 
                mediods[i] = centerOld#撤销尝试
        
        #若一轮过程中所有中心点都没被替换
        if changed == 0:
            iters+=1
    return [clusters,mediods]

做一个小实验，随机产生一个带离群点的数据集，分别对其用k-mediods和k-means进行聚类，观察离群点对两种算法的影响：

def showClusters(c1,c2,c3,centers):
    plt.scatter(c1[:,0],c1[:,1],c='r',s=10)
    plt.scatter(c2[:,0],c2[:,1],c='b',s=10)
    plt.scatter(c3[:,0],c3[:,1],c='g',s=10)
    plt.scatter(centers[:,0],centers[:,1],marker='*',c=[[0,0,0]],s=50)
    plt.show()

moids = [[2,2],[8,2],[0,8]]
X = datasets.make_blobs(n_samples=100, n_features=2, centers=moids,cluster_std=1)[0]
X = np.append(X,[[10,10]],axis=0)#离群点

cls,centers=  kmediods(X,3)
print(calcE(cls,centers))
c1 = cls[0]
c2 = cls[1]
c3 = cls[2]
showClusters(c1,c2,c3,centers)
cls1,centers1 = kmeans(X,3)
print(calcE(cls1,centers1))
c11 = cls1[0]
c21 = cls1[1]
c31 = cls1[2]
showClusters(c11,c21,c31,centers1)

下图分别是k-mediods和k-means的聚类后的总代价以及结果：
请添加图片描述

可以观察到k-means受到离群点的影响，聚类中心严重偏离了簇内样本。但是，并不是说k-mediods一定比k-means好。实际上，k-mediods的时间复杂度比k-means高出许多，只适用于小规模数据，而k-means在大规模数据上的聚类效率高出许多。

K-means及其改进

一. k-means

1.算法流程

2.代码实现

3.K-means缺点

二 K-means++

1.算法流程

2.代码实现

三 K-mediods

1.算法流程

猜你喜欢