【educoder 机器学习】k-means

k-means是属于机器学习里面的非监督学习，通常是大家接触到的第一个聚类算法，其原理非常简单，是一种典型的基于距离的聚类算法。

聚类算法中，将相似的数据划分为一个集合，一个集合称为一个簇。 k-means（k均值）聚类，之所以称为k均值，是因为它可以发现k个簇，且每个簇的中心采用簇中所含值的均值计算而成。

本实训项目将基于Python语言搭建出一个k-means模型，并基于sklean实现对红酒数据进行聚类。

第1关：距离度量

任务描述

本关任务：复习教材，使用Python编写一个能计算样本间欧式距离与曼哈顿距离的方法。

#encoding=utf8    
import numpy as np

def distance(x,y,p=2):
    '''
    input:x(ndarray):第一个样本的坐标
          y(ndarray):第二个样本的坐标
          p(int):等于1时为曼哈顿距离，等于2时为欧氏距离
    output:distance(float):x到y的距离      
    ''' 
    #********* Begin *********#
    #distance = np.linalg.norm(x-y, p)
    if p == 1:
        distance = np.abs(x-y).sum()#绝对值
    if p == 2:
        distance = np.sqrt(np.square(x-y).sum())
    return distance
    #********* End *********#

第2关：什么是质心（均值向量）

#encoding=utf8
import numpy as np
#计算样本间距离
def distance(x, y, p=2):
    '''
    input:x(ndarray):第一个样本的坐标
          y(ndarray):第二个样本的坐标
          p(int):等于1时为曼哈顿距离，等于2时为欧氏距离
    output:distance(float):x到y的距离      
    '''
    #********* Begin *********#    
    if p == 1:
        distance = np.abs(x-y).sum()
    if p == 2:
        distance = np.sqrt(np.square(x-y).sum())
    return distance
    #********* End *********#
    
#计算质心(均值向量)
def cal_Cmass(data):
    '''
    input:data(ndarray):数据样本
    output:mass(ndarray):数据样本质心
    '''
    #********* Begin *********#
    Cmass = np.mean(data,axis=0)#np.mean()中的axis=0是指对列进行求均值，axis=1是指对行求均值
    #********* End *********#
    return Cmass

#计算每个样本到质心的距离，并按照从小到大的顺序排列
def sorted_list(data,Cmass):
    '''
    input:data(ndarray):数据样本
          Cmass(ndarray):数据样本质心
    output:dis_list(list):排好序的样本到质心距离
    '''
    #********* Begin *********#
    distance_list = []#把每个样本到质心的距离放到列表里
    #Cmass = cal_Cmass(data)(质心已知，无须计算)
    for d in data:#计算每个样本到质心的距离
        distance_list.append(distance(d, Cmass, p=2))
    dis_list = sorted(distance_list)#排序
    #********* End *********#
    return dis_list

第3关：k-means算法流程

任务描述

本关任务：复习教材，使用Python实现k-means算法，并根据红酒的13个特征对红酒数据进行聚类。

#encoding=utf8
import numpy as np

# 计算一个样本与数据集中所有样本的欧氏距离的平方
def euclidean_distance(one_sample, X):#one_sample：测试样本，X：所有样本
    #将测试样本变成只有1行
    one_sample = one_sample.reshape(1, -1)#reshape(1,-1)将one_sample转化成1行
    #计算测试样本与每一个训练样本的欧氏距离
    #(np.tile(one_sample, (X.shape[0], 1))将测试样本沿y轴复制，使其行数等于训练样本行数)
    '''
    np.tile(a,(2,1))第一个参数为Y轴扩大倍数，第二个为X轴扩大倍数。
    本例中X轴扩大一倍便为不复制。
    '''
    distances = np.power(np.tile(one_sample, (X.shape[0], 1)) - X, 2).sum(axis=1)#axis=1表示按行相加(把每一行的数据相加得到一个数)
    return distances

class Kmeans():
    """Kmeans聚类算法.
    算法过程如下：
    （1）随机选取K个数据作为质心（聚类中心）。
    （2）计算每个数据到每个质心的距离，并把它归到最近的质心的簇。
    （3）重新计算已经得到的各个簇的质心。
    （4）迭代（2）~（3步直至新的质心与原质心相等或小于指定阈值，算法结束。
    Parameters:
    -----------
    k: int
        聚类的数目.
    max_iterations: int
        最大迭代次数. 
    varepsilon: float
        判断是否收敛, 如果上一次的所有k个聚类中心与本次的所有k个聚类中心的差都小于varepsilon, 
        则说明算法已经收敛
    """
    def __init__(self, k=2, max_iterations=500, varepsilon=0.0001):
        self.k = k
        self.max_iterations = max_iterations
        self.varepsilon = varepsilon
        #：从每堆种子里选出来的数都是不会变的，从不同的堆里选随机种子每次都不一样
        np.random.seed(1)#第一堆
    # 从所有样本中随机选取self.k样本作为初始的聚类中心
    def init_random_centroids(self, X):
        n_samples, n_features = np.shape(X)
        centroids = np.zeros((self.k, n_features))#初始化：k行，n_features列
        for i in range(self.k):
            centroid = X[np.random.choice(range(n_samples))]#随机选择
            centroids[i] = centroid
        return centroids
    # 返回距离该样本最近的一个中心索引[0, self.k)
    def _closest_centroid(self, sample, centroids):
        distances = euclidean_distance(sample, centroids)
        closest_i = np.argmin(distances)#给出水平方向最小值的下标
        return closest_i
    # 将所有样本进行归类，归类规则就是将该样本归类到与其最近的中心
    def create_clusters(self, centroids, X):
        clusters = [[] for _ in range(self.k)]
         #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)
        #组合为一个索引序列，
        #同时列出数据和数据下标，一般用在 for 循环当中
        for sample_i, sample in enumerate(X):
            #返回距离该样本最近的一个中心索引
            centroid_i = self._closest_centroid(sample, centroids)
            clusters[centroid_i].append(sample_i)
        return clusters
    # 对中心进行更新
    def update_centroids(self, clusters, X):
        n_features = np.shape(X)[1]
        centroids = np.zeros((self.k, n_features))
        #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)
        #组合为一个索引序列，
        #同时列出数据和数据下标，一般用在 for 循环当中
        for i, cluster in enumerate(clusters):
            centroid = np.mean(X[cluster], axis=0)
            centroids[i] = centroid
        return centroids
    # 将所有样本进行归类，其所在的类别的索引就是其类别标签
    def get_cluster_labels(self, clusters, X):
        y_pred = np.zeros(np.shape(X)[0])
        for cluster_i, cluster in enumerate(clusters):
            for sample_i in cluster:
                y_pred[sample_i] = cluster_i
        return y_pred
 
    #********* Begin *********#
    
    # 对整个数据集X进行Kmeans聚类，返回其聚类的标签
    def predict(self, X):
        # 从所有样本中随机选取self.k样本作为初始的聚类中心
        centroids = self.init_random_centroids(X)
        # 迭代，直到算法收敛(上一次的聚类中心和这一次的聚类中心几乎重合)或者达到最大迭代次数
        for i in range(self.max_iterations):
                # 将所有进行归类，归类规则就是将该样本归类到与其最近的中心
                clusters = self.create_clusters(centroids, X)
                temp_centroids = centroids
                # 计算新的聚类中心
                centroids = self.update_centroids(clusters, X)
                # 如果聚类中心几乎没有变化，说明算法已经收敛，退出迭代
                difference = centroids - temp_centroids
                if difference.any() < self.varepsilon:
                    break
        y_pred = self.get_cluster_labels(clusters, X)
        return y_pred
    #********* End *********#
 

第4关：sklearn中的k-means

#encoding=utf8
from sklearn.cluster import KMeans

def kmeans_cluster(data):
    '''
    input:data(ndarray):样本数据
    output:result(ndarray):聚类结果
    '''
    #********* Begin *********#
    kmeans = KMeans(n_clusters=3,random_state=888)
    result = kmeans.fit_predict(data)
    #********* End *********# 
    return result