sklearn
# 聚类前
X = np.random.rand(100, 2)
plt.scatter(X[:, 0], X[:, 1], marker='o')
plt.show()

# 聚类后
kmeans = KMeans(n_clusters=2).fit(X)
label_pred = kmeans.labels_
plt.scatter(X[:, 0], X[:, 1], c=label_pred)
plt.show()

k均值聚类
# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt
import numpy as np


def distEclud(vecA, vecB):
    '''
    欧氏距离计算函数
    :param vecA:
    :param vecB:

    :return: float
    '''
    dist = 0.0
    # ========= show me your code ==================
    # here
    dist = np.sqrt(np.sum(vecA - vecB)**2 )
    # ========= show me your code ==================
    return dist

def randCent(dataMat, k):
    '''
    为给定数据集构建一个包含K个随机质心的集合,
    随机质心必须要在整个数据集的边界之内,这可以通过找到数据集每一维的最小和最大值来完成
    然后生成0到1.0之间的随机数并通过取值范围和最小值,以便确保随机点在数据的边界之内
    :param np.dataMat:
    :param k:

    :return: np.dataMat
    '''
    # 获取样本数与特征值
    m, n = np.shape(dataMat)
    # 初始化质心,创建(k,n)个以零填充的矩阵
    centroids = np.mat(np.zeros((k, n)))
    print(centroids)
    # ========= show me your code ==================
    # 循环遍历特征值
    # here
    for i in range(n - 1):
        mindata = dataMat[:, i].min()
        maxdata = dataMat[:, i].max()
        diffdata = maxdata - mindata
        centroids[i] = mindata + np.random.random(k) * diffdata
    # ========= show me your code ==================
    # 返回质心
    return centroids.A

def kMeans(dataMat, k, distMeas=distEclud):
    '''
    创建K个质心,然后将每个点分配到最近的质心,再重新计算质心。
    这个过程重复数次,直到数据点的簇分配结果不再改变为止
    :param dataMat: 数据集
    :param k: 簇的数目
    :param distMeans: 计算距离
    :return:
    '''
    # 获取样本数和特征数
    m, n = np.shape(dataMat)
    # 初始化一个矩阵来存储每个点的簇分配结果
    # clusterAssment包含两个列:一列记录簇索引值,第二列存储误差(误差是指当前点到簇质心的距离,后面会使用该误差来评价聚类的效果)
    clusterAssment = np.mat(np.zeros((m, 2)))
    # 创建质心,随机K个质心
    centroids = randCent(dataMat, k)

    # 初始化标志变量,用于判断迭代是否继续,如果True,则继续迭代
    clusterChanged = True
    while clusterChanged:
        clusterChanged = False
        # 遍历所有数据找到距离每个点最近的质心,
        # 可以通过对每个点遍历所有质心并计算点到每个质心的距离来完成
        for i in range(m):
            minDist = float("inf")
            minIndex = -1
            for j in range(k):
                # 计算数据点到质心的距离
                # 计算距离是使用distMeas参数给出的距离公式,默认距离函数是distEclud
                distJI = distMeas(centroids[j, :], dataMat[i, :])
                # 如果距离比minDist(最小距离)还小,更新minDist(最小距离)和最小质心的index(索引)
                if distJI < minDist:
                    minDist = distJI
                    minIndex = j
            # 如果任一点的簇分配结果发生改变,则更新clusterChanged标志
            # ========= show me your code ==================
            # here
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            # ========= show me your code ==================
                # 更新簇分配结果为最小质心的index(索引),minDist(最小距离)的平方
                clusterAssment[i, :] = minIndex, minDist ** 2
            print(centroids)
            # 遍历所有质心并更新它们的取值
            # ========= show me your code ==================
            # here
            for j in range(k):
                pointsInCluster = dataMat[np.nonzero(clusterAssment[:, 0].A == j)[0]]  # 获取簇类所有的点
                centroids[j, :] = np.mean(pointsInCluster, axis=0)   # 对矩阵的行求均值
            # ========= show me your code ==================

        # 返回所有的类质心与点分配结果
        return centroids, clusterAssment
if __name__ == '__main__':
    X = np.random.rand(100, 2)
# 运行Kmeans，假设有两聚类中心
    center,label_pred = kMeans(X, k=2)
# 将标签转化成易绘图的形式
    label = label_pred[:, 0].A.reshape(-1)
# 将结果可视化
    plt.scatter(X[:, 0], X[:, 1], c=label)
    plt.scatter(center[0, 0], center[0, 1], marker="*", s=100)
    plt.scatter(center[1, 0], center[1, 1], marker="*", s=100)
    plt.show()



参考文献： 西瓜书 维基百科 机器学习实战https://www.zybuluo.com/rianusr/note/1199877http://ddrv.cn/a/66611https://blog.csdn.net/zhouxianen1987/article/details/68945844http://ddrv.cn/a/66611https://zhuanlan.zhihu.com/p/29538307

非监督学习：聚类、降维
聚类：K-means
1.随意画出聚类中心
2.分配
3.优化
连接集群中心，画等距垂直于两集群连线的线

优化：移动中心

再分配，再优化········直至两个类的正确中心位置


很有意思的k-means可视化工具 http://www.naftaliharris.com/blog/visualizing-k-means-clustering/
聚类算法 http://scikit-learn.org/stable/modules/clustering.html
k-means http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html
使用k-means       一开始就要确定聚类数量，工作原理各点之间的距离
n_clusters 聚类数量，默认8
max_iter 最大迭代数
n_init 控制算法的初始化次数（？？？？）

k-means局限性：对于一个固定的数据集，一个固定数量的簇中心，预测出的结果是不同的（初始聚类中心的位置决定）
K-means的最初中心点选择对最后的分类效果有很大关系，比如下图出现的聚类，就有很大的问题


k-means均值聚类迷你项目

1. 可以在 k_means/k_means_cluster.py 中找到初始代码，该代码会读入电子邮件 + 财务 (E+F) 数据集，让我们为聚类做好准备。首先你将基于两个财务特征开始执行 K-means，请查看代码并确定代码使用哪些特征进行聚类。
运行代码，这将创建数据的散点图
salary  、exercised_stock_options

2.在 financial_features 数据上部署 k-均值聚类，并将 2 个聚类指定为参数。将聚类预测存储到名为 pred 的列表，以便脚本底部的 Draw()命令正常工作
### cluster here; create predictions of the cluster labels
### for the data and store them to a list called pred

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=2).fit(finance_features)
pred = kmeans.predict(finance_features)

3.向特征列表（features_list）中添加第三个特征：“total_payments”。现在使用 3 个，而不是 2 个输入特征重新运行聚类（很明显，我们仍然可以只显示原来的 2 个维度）。将聚类绘图与使用 2 个输入特征获取的绘图进行比较。是否有任何点切换群集？多少个点？这种使用 3 个牲的新聚类无法通过肉眼加以猜测——必须通过 k-均值算法才能识别它。
### the input features we want to use 
### can be any key in the person-level dictionary (salary, director_fees, etc.) 
feature_1 = "salary"
feature_2 = "exercised_stock_options"
feature_3 = "total_payments"
poi  = "poi"
features_list = [poi, feature_1, feature_2, feature_3]
data = featureFormat(data_dict, features_list )
poi, finance_features = targetFeatureSplit( data )


### in the "clustering with 3 features" part of the mini-project,
### you'll want to change this line to 
### for f1, f2, _ in finance_features:
### (as it's currently written, the line below assumes 2 features)
for f1, f2, _ in finance_features:
    plt.scatter( f1, f2)
plt.show()

4.
本例中使用的“exercised_stock_options”特征取的最大值和最小值是什么？34348384、3285
本例中使用的“salary”特征取的最大值和最小值是什么？1111258、477
（注意：如果查看 finance_features，会发现有些“NaN”值已被清理并被零值取代——因此尽管那些值可能看起来像是最小值，但却具有欺骗性，因此它们更像是你不具有其相关信息而必须填入一个数字的点。对于此问题，请返回 data_dict 并查找显示的最大值和最小值，忽略所有“NaN”条目。）
stocklist = []
salarylist = []
for item in data_dict:
    stock = data_dict[item]['exercised_stock_options']
    salary = data_dict[item]['salary']
    if stock != 'NaN':
        stocklist.append(stock)
    if salary != 'NaN':
        salarylist.append(salary)

print 'max stock:',np.max(stocklist)
print 'min stock:',np.min(stocklist)
print 'max salary:',np.max(salarylist)
print 'min salary:',np.min(salarylist)
5.特征缩放之后的效果图以及和原图有变化的点

文章目录
1 概述
2 性能度量
2.1 外部指标
2.2 内部指标
3 距离计算
3.1 有序属性的距离
3.1.1 闵可夫斯基距离
3.1.2 欧氏距离（L2范数）
3.1.3 曼哈顿距离（L1范数）
3.2 无序属性的距离
3.3 混合属性的距离
3.4 非度距离
4 原型算法
4.1 kmeans算法
4.2 学习向量量化（LVQ）
4.3 高斯混合聚类
整合代码

1 概述
kmeans：可看作高斯混合聚类在混合成分方差相等，且每个样本仅指派给一个混合成分时的特例

常用聚类算法：


k-medoids：


k-modes


Fuzzy C-means(soft clustering)


kernel k-means


spectral clustering


LVQ、LVQ2、LVQ3（学习向量量化）


DBSCAN、OPTICS、DENCLUE、AGNES…（基于密度聚类）


集成聚类


异常检测


2 性能度量
2.1 外部指标

将聚类结果与某个参考模型进行比较

将样本两两配对考虑：






聚类C
聚类C*（参考模型）




a
same
same


b
same
different


c
different
same


d
different
different


常用的聚类性能度量外部指标：

Jaccard系数（Jaccard Coefficient,JC）

$JC=\frac{a}{a+b+c}$

FM指数

$FMI=\sqrt{\frac{a}{a+b}*\frac{a}{a+c}}$

Rand指数（RI）

$RI=\frac{2(a+d)}{m(m-1)}$
以上三个外部指标均在[0,1]区间，且越大越好。
2.2 内部指标
聚类结果的簇划分为

$\{C_1,C_2,...,C_k\}$

定义：

$avg(C)=\frac{2}{|C|(|C|-1)}\sum_{1≤i<j≤|C|}dist(x_i,x_j)$


DBI越小越好，DI越大越好

除此之外，还有F值、互信息、平均廓宽等。
3 距离计算
3.1 有序属性的距离
3.1.1 闵可夫斯基距离
$dist_{mk}(x_i,x_j)=(\sum_{u=1}^{n}|x_{iu}-x_{ju}|^p)^{\frac{1}{p}}$
3.1.2 欧氏距离（L2范数）
$dist_{ed}(x_i,x_j)=||x_i-x_j||_2=(\sum_{u=1}^{n}|x_{iu}-x_{ju}|^2)^{\frac{1}{2}}$
3.1.3 曼哈顿距离（L1范数）
$dist_{man}(x_i,x_j)=||x_i-x_j||_1=\sum_{u=1}^{n}|x_{iu}-x_{ju}|$
3.2 无序属性的距离
VDM距离：

$VDM_p(a,b)=\sum_{i=1}^{k}|\frac{m_{u,a,i}}{m_{u,a}}-\frac{m_{u,b,i}}{m_{u,b}}|^p$
3.3 混合属性的距离
闵可夫斯基和VDM结合可以处理混合属性。

3.4 非度距离
现实中存在一些无法直接用相似度度量的距离，例如：

不少情况下，我们需要基于数据样本来确定合适的距离公式，可以通过“距离度量学习”来实现。
4 原型算法
4.1 kmeans算法

从D中随机选择k个样本作为初始均值向量
计算每个样本与均值向量的距离，并给每个样本做簇标记
计算并更新均值向量
重复操作2，直至均值向量基本不变或达到所需迭代次数

4.2 学习向量量化（LVQ）

4.3 高斯混合聚类
高斯混合聚类采用概率模型来表达聚类原型。
多元高斯分布的概率密度函数：

$p(x)=\frac{1}{(2\pi)^{\frac{n}{2}}|\sum|^{\frac{1}{2}}}e^{-\frac{1}{2}(x-\mu)^T\sum^{-1}(x-\mu)}$
E：计算x_i由各个混合成分生成的后验概率
M：求新均值向量、新协方差矩阵、新混合系数，并更新μ和Σ。
继续迭代，满足条件时终止。
更新每个高斯混合成的均值mu（由加权平均估计）：

$\mu_i=\frac{\sum_{j=1}^{m}\gamma_{ji}x_j}{\sum_{j=1}^{m}\gamma_{ji}}$

更新gamma（由最大似然LL(D)对gamma的偏导数为0）：

$\sum_i=\frac{\sum_{j=1}^{m}\gamma_{ji}(x_j-\mu_i)(x_j-\mu_i)^T}{\sum_{j=1}^m\gamma_{ji}}$

更新每个高斯成分的混合系数alpha（由该成分的平均后验概率确定）：

$\alpha_i=\frac{1}{m}\sum_{j=1}^m\gamma_{ji}$
整合代码

参考文章——GMM高斯混合聚类

import numpy as np
import matplotlib.pyplot as plt
 
def multiGaussian(x,mu,sigma):
    return 1/((2*np.pi)*pow(np.linalg.det(sigma),0.5))*np.exp(-0.5*(x-mu).dot(np.linalg.pinv(sigma)).dot((x-mu).T))
 
def computeGamma(X,mu,sigma,alpha,multiGaussian):
    n_samples=X.shape[0]
    n_clusters=len(alpha)
    gamma=np.zeros((n_samples,n_clusters))
    p=np.zeros(n_clusters)
    g=np.zeros(n_clusters)
    for i in range(n_samples):
        for j in range(n_clusters):
            p[j]=multiGaussian(X[i],mu[j],sigma[j])
            g[j]=alpha[j]*p[j]
        for k in range(n_clusters):
            gamma[i,k]=g[k]/np.sum(g)
    return gamma
 
class MyGMM():
    def __init__(self,n_clusters,ITER=50):
        self.n_clusters=n_clusters
        self.ITER=ITER
        self.mu=0
        self.sigma=0
        self.alpha=0
      
    def fit(self,data):
        n_samples=data.shape[0]
        n_features=data.shape[1]
        '''
        mu=data[np.random.choice(range(n_samples),self.n_clusters)]
        '''
        alpha=np.ones(self.n_clusters)/self.n_clusters
        
        mu=np.array([[.403,.237],[.714,.346],[.532,.472]])
        
        sigma=np.full((self.n_clusters,n_features,n_features),np.diag(np.full(n_features,0.1)))
        for i in range(self.ITER):
            gamma=computeGamma(data,mu,sigma,alpha,multiGaussian)
            alpha=np.sum(gamma,axis=0)/n_samples
            for i in range(self.n_clusters):
                mu[i]=np.sum(data*gamma[:,i].reshape((n_samples,1)),axis=0)/np.sum(gamma,axis=0)[i]
                sigma[i]=0
                for j in range(n_samples):
                    sigma[i]+=(data[j].reshape((1,n_features))-mu[i]).T.dot((data[j]-mu[i]).reshape((1,n_features)))*gamma[j,i]
                sigma[i]=sigma[i]/np.sum(gamma,axis=0)[i]
        self.mu=mu
        self.sigma=sigma
        self.alpha=alpha
        
    def predict(self,data):
        pred=computeGamma(data,self.mu,self.sigma,self.alpha,multiGaussian)
        cluster_results=np.argmax(pred,axis=1)
        return cluster_results

西瓜实验：
import pandas as pd
data = pd.read_csv(r'C:\Users\Asus\Desktop\jobs\machine learning\寒假机器学习笔记\datasets4.0.csv')
data=data.values
 
model1=MyGMM(3)
model1.fit(data)
result=model1.predict(data)
plt.scatter(data[:,0],data[:,1],c=result)
plt.scatter(model1.mu[:,0],model1.mu[:,1],marker='x',color='red')

点与聚类匹配（K均值算法）

步骤：


  
分配 
  
将点按照离聚类中心的距离分好 
  
  

  
  
优化  
  
移动使聚类中心到这些点的总二次距离降到最小 
  
  

  
  
3.重复上述步骤
  
  



可视化工具中来看具体操作：

随机放中心，对点按距离分类



移动中心至其点的总二次距离最小的位置，再次对点分类



再次移动中心至点的总二次距离最小的位置 





SKlearn Clustering

Method name —— K-Means

注意：必须在一开始就表明要查找的聚类数（最具挑战性的工作）

k-means文档

需要注意的参数：

n_clusters（聚类数量，默认为8） 

根据自己的需要反复调整（基本需要调整）最重要的参数
max_iter=300 

在查找聚类时，需要进行迭代，将各个点分配到矩心，然后移动矩心，然后重新分配这些点，重新移动矩心。max_iter表示进行迭代的次数，300一般足够了。
n_init=10 控制算法初始化的次数，提出聚类的次数 

k-means聚类有一个挑战——完全取决于初始状况，你有时最终会得到不同的聚类结果，然后，你需要多次重复该算法。尽管任意这些聚类可能都不对，但所有聚类的集合总会有满足你要求的聚类。 

如果觉得你的聚类特别容易出现糟糕或艰难的初始化过程，就需要调整这个参数
class sklearn.cluster.KMeans(n_clusters=8, init=’k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=’auto’, verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm=’auto’)



K-均值的局限

同一个训练集训练出的模型总是会预测出同样的结果吗？


  
不是 

  K-均值是爬山算法，他非常依赖于你的初始聚类中心所处的位置

局部最小值：取决于聚类中心点的最初设定
例子1：



在这个例子中，如果你在最初的假设中选择了这三个聚类中心，你将很难离开这些点。



因此我们必须意识到，在聚类中，这是一个局部的爬山算法，它可以为你提供一个次优解。如果你对它再次进行拆分，就可以得到更好的解

例子2：

如果以两个聚类中心对这组数据进行初始化处理，这里存不存在一个局部最小值？有没有稳定的解？



这里也是存在不好的局部最小值的！！


  
你可以把这些聚类中心设置的正好位于彼此的上方，分割线如下图所示，所有上方的点与上方的聚类中心相关联，下方的点与下方的聚类中心相关联




如果你的越多的聚类中心，就能找到越多的局部最小值


  
但是特殊的情况其实存在，所以得用这个将算法多次运行


19.你的聚类算法将会用到哪些特征？

散点图：


20.部署聚类


代码：



feature_1 = "salary"
feature_2 = "exercised_stock_options"
poi  = "poi"
features_list = [poi, feature_1, feature_2]
data = featureFormat(data_dict, features_list )
poi, finance_features = targetFeatureSplit( data )

from sklearn.cluster import KMeans
import numpy as np 
Kmeans = KMeans(n_clusters=2).fit(finance_features)
pred=Kmeans.predict(finance_features)


21.使用3个聚类特征，有测试点移动到不同的聚类中吗？


代码：



feature_1 = "salary"
feature_2 = "exercised_stock_options"
feature_3 = "total_payments"
poi  = "poi"
features_list = [poi, feature_1, feature_2, feature_3]
data = featureFormat(data_dict, features_list )
poi, finance_features = targetFeatureSplit( data )

from sklearn.cluster import KMeans
import numpy as np 
Kmeans = KMeans(n_clusters=2).fit(finance_features)
pred=Kmeans.predict(finance_features)

### in the "clustering with 3 features" part of the mini-project,
### you'll want to change this line to 
### for f1, f2, _ in finance_features:
### (as it's currently written, the line below assumes 2 features)
for f1, f2, f3 in finance_features:
    plt.scatter( f1, f2, f3 )
plt.show()

22.股票期权范围
import numpy as np 
stocklist=[]
for item in data_dict:
    stock = data_dict[item]['exercised_stock_options']
    if stock != 'NaN':
        stocklist.append(stock)

stocklist = np.array(stocklist)
print "max:",np.max(stocklist)
print "min:",np.min(stocklist)


  
max: 34348384 

  min: 3285


23.薪酬范围
salarylist=[]
for item in data_dict:
    stock = data_dict[item]['salary']
    if stock != 'NaN':
        salarylist.append(stock)

salarylist = np.array(salarylist)
print "max:",np.max(salarylist)
print "min:",np.min(salarylist)


  
max: 1111258 

  min: 477


24.练习: 聚类更改