K-means聚类算法

源：https://segmentfault.com/a/1190000010863236

K-means算法简介

K-means是机器学习中一个比较常用的算法，属于无监督学习算法，其常被用于数据的聚类，只需为它指定簇的数量即可自动将数据聚合到多类中，相同簇中的数据相似度较高，不同簇中数据相似度较低。

K-menas的优缺点：

优点：

• 原理简单

• 速度快

• 对大数据集有比较好的伸缩性

缺点：

• 需要指定聚类 数量K

• 对异常值敏感

• 对初始值敏感

K-means的聚类过程

其聚类过程类似于梯度下降算法，建立代价函数并通过迭代使得代价函数值越来越小

• 适当选择c个类的初始中心；

• 在第k次迭代中，对任意一个样本，求其到c个中心的距离，将该样本归到距离最短的中心所在的类；

• 利用均值等方法更新该类的中心值；

• 对于所有的c个聚类中心，如果利用（2）（3）的迭代法更新后，值保持不变，则迭代结束，否则继续迭代。

例子代码实现

from sklearn.cluster import KMeans
from sklearn.externals import joblib
from sklearn import cluster
import numpy as np
import matplotlib.pyplot as plt
 
data = np.random.rand(100,2)
estimator=KMeans(n_clusters=3)
res=estimator.fit_predict(data)
lable_pred=estimator.labels_
centroids=estimator.cluster_centers_
inertia=estimator.inertia_
#print res
print lable_pred
print centroids
print inertia
 
for i in range(len(data)):
    if int(lable_pred[i])==0:
        plt.scatter(data[i][0],data[i][1],color='red')
    if int(lable_pred[i])==1:
        plt.scatter(data[i][0],data[i][1],color='black')
    if int(lable_pred[i])==2:
        plt.scatter(data[i][0],data[i][1],color='blue')
plt.show()

输出

基于numpy实现，源：https://blog.csdn.net/iphilo/article/details/80735944

import numpy as np
import matplotlib.pyplot as plt

'''标志位统计递归运行次数'''
flag = 0

'''欧式距离'''
def ecludDist(x, y):
    return np.sqrt(sum(np.square(np.array(x) - np.array(y))))

'''曼哈顿距离'''
def manhattanDist(x, y):
    return np.sum(np.abs(x - y))

'''夹角余弦'''
def cos(x, y):
    return np.dot(x, y)/(np.linalg.norm(x) * np.linalg.norm(y))

'''计算簇的均值点'''
def clusterMean(dataset):
    return sum(np.array(dataset)) / len(dataset)

'''生成随机均值点'''
def randCenter(dataset, k):
    temp = []
    while len(temp) < k:
        index = np.random.randint(0, len(dataset)-1)
        if  index not in temp:
            temp.append(index)
    return np.array([dataset[i] for i in temp])

'''以数据集的前k个点为均值点'''
def orderCenter(dataset, k):
    return np.array([dataset[i] for i in range(k)])

'''聚类'''
def kMeans(dataset, dist, center, k):
    global flag
    #all_kinds用于存放中间计算结果
    all_kinds = []
    for _ in range(k):
        temp = []
        all_kinds.append(temp)
    #计算每个点到各均值点的距离  
    for i in dataset:
        temp = []
        for j in center:
            temp.append(dist(i, j))
        all_kinds[temp.index(min(temp))].append(i)
    #打印中间结果    
    for i in range(k):
        print('第'+str(i)+'组:', all_kinds[i], end='\n')
    flag += 1
    print('************************迭代'+str(flag)+'次***************************')
    #更新均值点
    center_ = np.array([clusterMean(i) for i in all_kinds])
    if (center_ == center).all():
        print('结束')
        for i in range(k):
            print('第'+str(i)+'组均值点：', center_[i], end='\n')
            plt.scatter([j[0] for j in all_kinds[i]], [j[1] for j in all_kinds[i]], marker='*')
        plt.grid()
        plt.show()
    else:
        #递归调用kMeans函数
        center = center_
        kMeans(dataset, dist, center, k)

def main(k):
    '''生成随机点''' 
    x = [np.random.randint(0, 50) for _ in range(50)]
    y = [np.random.randint(0, 50) for _ in range(50)]
    points = [[i,j] for i, j in zip(x, y)]
    plt.plot(x, y, 'b.')
    plt.show()
    initial_center = randCenter(dataset=points, k=k)
    kMeans(dataset=points, dist=ecludDist, center=initial_center, k=k)

if __name__ == '__main__':
    main(3)