来自：宋天龙《PYTHON数据分析与数据化运营》，以下内容比较简陋，方便日后翻阅。
1. 业务场景
某天业务部门拿了一些数据找到数据部门，这些数据是关于客户的，苦于没有分析入手点，希望数据部门通过对这些数据的分析，给业务部门一些启示、建议。
数据源特征如下：
user_id用户ID列，整数型
AVG_ORDERS:平均用户订单数量，浮点型
AVG_MONEY:平均订单价值，浮点型
IS_ACTIVE:是否活跃 字符串
SEX:性别，0，1，1表示未知，男，女

分析：

IS_ACTIVE是字符串型分类变量，SEX是分类型变量，均需要对其onehotencode处理；

AVG_ORDERS和AVG_MONEY有明显的量纲差异，需要归一化；

但是使用onehotencoder后IS_ACTIVE和SEX的特征被分开了，最后输出的结果可能会比较凌乱，不符合业务原始变量分析的需求。

下面使用另外一种方法：

直接对IS_ACTIVE和SEX分类特征计算，只是不能用距离来判断相似度，而是计算类别内的分类特征值的出现频率。
2. python实现
1.导入库,读取数据
import pandas as pd # panda库
import numpy as np
import matplotlib.pyplot as plt  # 导入matplotlib库
from sklearn.preprocessing import MinMaxScaler # 标准化库
from sklearn.cluster import KMeans  # 导入sklearn聚类模块
from sklearn.metrics import silhouette_score, calinski_harabasz_score  # 效果评估模块
import matplotlib.pyplot as plt # 图形库
# 读取数据
raw_data = pd.read_csv('cluster.txt')  # 导入数据文件
print(raw_data.head())


2.数据处理、模型训练
模型训练和评估的数据只是标准化的两列
# 数据标准化
numeric_features = raw_data.iloc[:,1:3] # 数值型特征
scaler = MinMaxScaler()
scaled_numeric_features = scaler.fit_transform(numeric_features)
print(scaled_numeric_features[:,:2])
# 训练聚类模型
n_clusters = 3  # 设置聚类数量
model_kmeans = KMeans(n_clusters=n_clusters, random_state=0)  # 建立聚类模型对象
model_kmeans.fit(scaled_numeric_features)  # 训练聚类模型


3.评估模型
# 模型效果指标评估
# 总样本量,总特征数
n_samples, n_features = raw_data.iloc[:,1:].shape
print('samples: %d \t features: %d' % (n_samples, n_features))
# 非监督式评估方法，还是训练的两列
silhouette_s = silhouette_score(scaled_numeric_features, model_kmeans.labels_, metric='euclidean')  # 平均轮廓系数
calinski_harabaz_s = calinski_harabaz_score(scaled_numeric_features, model_kmeans.labels_)  # Calinski和Harabaz得分
unsupervised_data = {'silh':[silhouette_s],'c&h':[calinski_harabasz_s]}
unsupervised_score = pd.DataFrame.from_dict(unsupervised_data)
print('\n','unsupervised score:','\n','-'*60)
print(unsupervised_score)



第一个指标大于0.5说明聚类质量较优。
4.结果合并分析
对于分类变量可以根据非分类变量训练得到的标签对其计算每一类别的频数
# 合并数据和特征
# 获得每个样本的聚类类别
kmeans_labels = pd.DataFrame(model_kmeans.labels_,columns=['labels']) 
# 组合原始数据与标签
kmeans_data = pd.concat((raw_data,kmeans_labels),axis=1)
print(kmeans_data.head())
# 计算不同聚类类别的样本量和占比
label_count = kmeans_data.groupby(['labels'])['SEX'].count()  # 计算频数
label_count_rate = label_count/ kmeans_data.shape[0] # 计算占比
kmeans_record_count = pd.concat((label_count,label_count_rate),axis=1)
kmeans_record_count.columns=['record_count','record_rate']
print(kmeans_record_count.head())
# 计算不同聚类类别数值型特征
kmeans_numeric_features = kmeans_data.groupby(['labels'])['AVG_ORDERS','AVG_MONEY'].mean()
print(kmeans_numeric_features.head())

# 计算不同聚类类别分类型特征
active_list = []
sex_gb_list = []
unique_labels = np.unique(model_kmeans.labels_)
print('标签：',unique_labels)
for each_label in unique_labels:
    each_data = kmeans_data[kmeans_data['labels']==each_label]

    active_list.append(each_data.groupby(['IS_ACTIVE'])['USER_ID'].count()/each_data.shape[0])
    sex_gb_list.append(each_data.groupby(['SEX'])['USER_ID'].count()/each_data.shape[0])

kmeans_active_pd = pd.DataFrame(active_list)
kmeans_sex_gb_pd = pd.DataFrame(sex_gb_list)
kmeans_string_features = pd.concat((kmeans_active_pd,kmeans_sex_gb_pd),axis=1)
kmeans_string_features.index = unique_labels
kmeans_string_features.columns=['不活跃','活跃','未知','男','女']
print(kmeans_string_features.head())

# 合并所有类别的分析结果
features_all = pd.concat((kmeans_record_count,kmeans_numeric_features,kmeans_string_features),axis=1)
print(features_all.head())


5.可视化展示
# part 1 全局配置
fig = plt.figure(figsize=(10, 7))
titles = ['RECORD_RATE','AVG_ORDERS','AVG_MONEY','IS_ACTIVE','SEX'] # 共用标题
line_index,col_index = 3,5 # 定义网格数
ax_ids = np.arange(1,16).reshape(line_index,col_index) # 生成子网格索引值
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
    
# part 2 画出三个类别的占比
pie_fracs = features_all['record_rate'].tolist()
for ind in range(len(pie_fracs)):
    ax = fig.add_subplot(line_index, col_index, ax_ids[:,0][ind])
    init_labels = ['','',''] # 初始化空label标签
    init_labels[ind] = 'cluster_{0}'.format(ind) # 设置标签
    init_colors = ['lightgray', 'lightgray', 'lightgray']
    init_colors[ind] = 'g' # 设置目标面积区别颜色
    ax.pie(x=pie_fracs, autopct='%3.0f %%',labels=init_labels,colors=init_colors)
    ax.set_aspect('equal') # 设置饼图为圆形
    if ind == 0:
        ax.set_title(titles[0])
    
# part 3  画出AVG_ORDERS均值
avg_orders_label = 'AVG_ORDERS'
avg_orders_fraces = features_all[avg_orders_label]
for ind, frace in enumerate(avg_orders_fraces):
    ax = fig.add_subplot(line_index, col_index, ax_ids[:,1][ind])
    ax.bar(x=unique_labels,height=[0,avg_orders_fraces[ind],0])# 画出柱形图
    ax.set_ylim((0, max(avg_orders_fraces)*1.2))
    ax.set_xticks([])
    ax.set_yticks([])
    if ind == 0:# 设置总标题
        ax.set_title(titles[1])
    # 设置每个柱形图的数值标签和x轴label
    ax.text(unique_labels[1],frace+0.4,s='{:.2f}'.format(frace),ha='center',va='top')
    ax.text(unique_labels[1],-0.4,s=avg_orders_label,ha='center',va='bottom')
        
# part 4  画出AVG_MONEY均值
avg_money_label = 'AVG_MONEY'
avg_money_fraces = features_all[avg_money_label]
for ind, frace in enumerate(avg_money_fraces):
    ax = fig.add_subplot(line_index, col_index, ax_ids[:,2][ind])
    ax.bar(x=unique_labels,height=[0,avg_money_fraces[ind],0])# 画出柱形图
    ax.set_ylim((0, max(avg_money_fraces)*1.2))
    ax.set_xticks([])
    ax.set_yticks([])
    if ind == 0:# 设置总标题
        ax.set_title(titles[2])
    # 设置每个柱形图的数值标签和x轴label
    ax.text(unique_labels[1],frace+4,s='{:.0f}'.format(frace),ha='center',va='top')
    ax.text(unique_labels[1],-4,s=avg_money_label,ha='center',va='bottom')
        
# part 5  画出是否活跃
axtivity_labels = ['不活跃','活跃']
x_ticket = [i for i in range(len(axtivity_labels))]
activity_data = features_all[axtivity_labels]
ylim_max = np.max(np.max(activity_data))
for ind,each_data in enumerate(activity_data.values):
    ax = fig.add_subplot(line_index, col_index, ax_ids[:,3][ind])
    ax.bar(x=x_ticket,height=each_data) # 画出柱形图
    ax.set_ylim((0, ylim_max*1.2))
    ax.set_xticks([])
    ax.set_yticks([])    
    if ind == 0:# 设置总标题
        ax.set_title(titles[3])
    # 设置每个柱形图的数值标签和x轴label
    activity_values = ['{:.1%}'.format(i) for i in each_data]
    for i in range(len(x_ticket)):
        ax.text(x_ticket[i],each_data[i]+0.05,s=activity_values[i],ha='center',va='top')
        ax.text(x_ticket[i],-0.05,s=axtivity_labels[i],ha='center',va='bottom')
        
# part 6  画出性别分布
sex_data = features_all.iloc[:,-3:]
x_ticket = [i for i in range(len(sex_data))]
sex_labels = ['SEX_{}'.format(i) for i in range(3)]
ylim_max = np.max(np.max(sex_data))
for ind,each_data in enumerate(sex_data.values):
    ax = fig.add_subplot(line_index, col_index, ax_ids[:,4][ind])
    ax.bar(x=x_ticket,height=each_data) # 画柱形图
    ax.set_ylim((0, ylim_max*1.2))
    ax.set_xticks([])
    ax.set_yticks([])
    if ind == 0: # 设置标题
       ax.set_title(titles[4])    
    # 设置每个柱形图的数值标签和x轴label
    sex_values = ['{:.1%}'.format(i) for i in each_data]
    for i in range(len(x_ticket)):
        ax.text(x_ticket[i],each_data[i]+0.1,s=sex_values[i],ha='center',va='top')
        ax.text(x_ticket[i],-0.1,s=sex_labels[i],ha='center',va='bottom')
    
plt.tight_layout(pad=0.8) #设置默认的间距


6.结果分析

K-means算法：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xvV44zrK-1573127992123)(https://img-blog.csdn.net/20171220143951780?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvSEhUTkFO/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)]

关于步骤：参考之前的博客

关于代码与数据：暂时整理代码如下：后期会附上github地址，上传原始数据与代码完整版，

各种聚类算法的对比：参考连接

Kmeans算法的缺陷
1.聚类中心的个数K 需要事先给定，但在实际中这个 K 值的选定是非常难以估计的，很多时候，事先并不知道给定的数据集应该分成多少个类别才最合适

2.Kmeans需要人为地确定初始聚类中心，不同的初始聚类中心可能导致完全不同的聚类结果。
#!usr/bin/env python
#_*_ coding:utf-8 _*_
import random
import math
'''
kMeans:2列数据对比，带有head
'''
#1.load data
def importData():
   f = lambda name,b,d: [name, float(b), float(d)]

   with open('birth-death-rates.csv', 'r') as inputFile:
          return [f(*line.strip().split('\t')) for line in inputFile]

写入文件类型


**#2. calculate Distance **
def euclideanDistance(x,y):
    return math.sqrt(sum([(a-b)**2 for (a,b) in zip(x,y)]))

#L=points,
def partition(points, k, means, d=euclideanDistance):
   # print('means={}'.format(means))
   thePartition = [[] for _ in means]  # list of k empty lists

   indices = range(k)
   # print('indices={}'.format(indices))

   for x in points:
    
      #index为indices索引，调用d函数，计算每个值与聚类中心的距离，将其分类
      closestIndex = min(indices, key=lambda index: d(x, means[index]))#实现X与每个Y直接的求解：key=lambda index: d(x, means[index])
    
      thePartition[closestIndex].append(x)

   return thePartition


#3.寻找收敛点
def mean(points):
   ''' assume the entries of the list of points are tuples;
       e.g. (3,4) or (6,3,1). '''

   n = len(points)
   # print(tuple(float(sum(x)) / n for x in zip(*points)))   #*points将【[1，2]，[2，3]】分割出来【1，2】
   return tuple(float(sum(x)) / n for x in zip(*points))  #将最开始的[[4, 1], [1, 5]] 经过处理变成[（4, 1）,（1, 5）]


def kMeans(points, k, initialMeans, d=euclideanDistance):
   oldPartition = []
   newPartition = partition(points, k, initialMeans, d)

   while oldPartition != newPartition:
      oldPartition = newPartition
      newMeans = [mean(S) for S in oldPartition]
      newPartition = partition(points, k, newMeans, d)

   return newPartition




#0.函数调用初始中心点
if __name__ == "__main__":
   L = [x[1:] for x in importData()] # remove names
   # print (str(L).replace('[','{').replace(']', '}'))
   import matplotlib.pyplot as plt
   '''
   plt.scatter(*zip(*L))
   plt.show()
   '''
   import random
   k = 3
   partition = kMeans(L, k, random.sample(L, k))  #L是集合，K分类个数，random.sample(L, k)中心点
   plt.scatter(*zip(*partition[0]), c='b')#[[],[],[]]
   plt.scatter(*zip(*partition[1]), c='r')
   plt.scatter(*zip(*partition[2]), c='g')
   plt.show()



 

Index 目录索引
写在前面
谱聚类简介
数据集
代码实现步骤详述
图像预处理
谱聚类操作
聚类后的图像对应还原操作

写在前面
最近要做一个基于无监督学习的传统图像分类，需要使用到聚类分析方法，但看到网上大多数都是关于点集的案例分析，基于自然图像的聚类分析实在是难觅，于是乎花了将近一周时间，参照着 Programming Computer Vision with Python 这本书以及相关文章进行了研究，并实现了MNIST图像的谱聚类小案例（代码已在GitHub开源），以记录之。
谱聚类简介
谱聚类是从图论中演化出来的算法，后来在聚类中得到了广泛的应用。它的主要思想是把所有的数据看做空间中的点，这些点之间可以用边连接起来。距离较远的两个点之间的边权重值较低，而距离较近的两个点之间的边权重值较高，通过对所有数据点组成的图进行切图，让切图后不同的子图间边权重和尽可能的低，而子图内的边权重和尽可能的高，从而达到聚类的目的。谱聚类的聚类效果通常优于传统的聚类算法（如K-Means算法）。
数据集
本案例使用MNIST手写数字图像数据集，首先选取合适的图像，并整理如下图所示：


代码实现步骤详述
图像预处理
由于谱聚类对图像尺寸和文件名有要求，所以首先对图像进行灰度化和resize操作，分别对应项目中的grayscale_processing.py和picture_resize.py这两个代码文件。
谱聚类操作
在项目中的spectral_clustering.py代码文件中，进行图像的谱聚类。代码如下：
# -*- coding: utf-8 -*-
from PCV.tools import imtools, pca
from PIL import Image, ImageDraw
from pylab import *
from scipy.cluster.vq import *
import os
import random


# imlist = imtools.get_imlist('./dir_my')
imlist = imtools.get_imlist('./dir_my_gray_rescale')
imnbr = len(imlist)

# Load images, run PCA.
immatrix = array([array(Image.open(im)).flatten() for im in imlist], 'f')
V, S, immean = pca.pca(immatrix)

# Project on 2 PCs.
projected = array([dot(V[[0, 1]], immatrix[i] - immean)
                   for i in range(imnbr)])  # P131 Fig6-3左图
#projected = array([dot(V[[1, 2]], immatrix[i] - immean) for i in range(imnbr)])  # P131 Fig6-3右图

n = len(projected)
# compute distance matrix
S = array([[sqrt(sum((projected[i]-projected[j])**2))
            for i in range(n)] for j in range(n)], 'f')
# create Laplacian matrix
rowsum = sum(S, axis=0)
D = diag(1/sqrt(rowsum))
I = identity(n)
L = I - dot(D, dot(S,D))
# compute eigenvectors of L
U, sigma, V = linalg.svd(L)
k = 3
# create feature vector from k first eigenvectors
# by stacking eigenvectors as columns
features = array(V[:k]).T
# k-means
features = whiten(features)
centroids, distortion = kmeans(features,k)
code, distance = vq(features, centroids)

# plot clusters 绘制聚类簇
for c in range(k):
    ind = where(code == c)[0]   # where函数返回数组的索引值
    figure()   # 创建figure实例
    gray()
    for i in range(minimum(len(ind), 39)):
        # print(imlist[ind[i]])   # ./dir_my_gray_rescale\5.jpg
        im = Image.open(imlist[ind[i]])
        # print("im:%s" % im)  # im:<PIL.JpegImagePlugin.JpegImageFile image mode=L size=28x28 at 0x241B9DD2EF0>
        image_name = imlist[ind[i]].split("\\")[1]  # image_name: 5.jpg
        image_name_real = image_name.split(".")[0]  # image_name_real: 1_1
        image_name_new = image_name_real + ".png"
        # print(image_name_new)   # image_name_new: 1_1.png
        # print("image_name: %s" % image_name)
        # print("image_name_real: %s" % image_name_real)
        subplot(4, 10, i+1)
        imshow(array(im))   # 绘图
        # print("array(im)的值为%s" % array(im))

        # 使用imsave()函数保存图像
        pre_savename = "./dir_classfied_my/%02d/" % c   # "./dir/00"
        # savename = os.path.join(pre_savename, str(random.randint(0, 10000000)))
        savename = os.path.join(pre_savename, image_name_new)
        imsave(savename, array(im))

        axis('equal')
        axis('off')
show()

聚类后的MNIST图像数据如下图所示：






在实现了聚类之后，编写代码实现聚类后图像的分门别类，效果图如下：







通过观察可以发现，基于无监督的谱聚类进行图像分类还是有一定的效果的，而且通过对比实验发现，待分类的图像数据越多，分类越精确。
聚类后的图像对应还原操作
由于在聚类操作前对数据进行了图像预处理操作，所以如果要保持原来的图像，需要对其进行还原操作，还原的方法有很多种，这里依据图像名来进行，于是乎编写代码如下（对应项目中的returned.py代码文件）：
import os
import glob
import shutil


PATH_0 = './dir_my/'  # 存放原始图像的文件夹路径
PATH_1 = './dir_classfied_my/'  # 存放根据聚类效果来对原始图像重新排布的原始图像文件夹路径
# 1、先遍历图像处理前总文件夹的图像文件
for filename_0 in os.listdir(r"./dir_my"):      # listdir的参数是文件夹的路径
    # print(filename_0)        #此时的filename是文件夹中文件的名称
    for filename_1 in os.listdir(r"./dir_classfied_my"):
        # print(filename_1)  #  filename_1: 00 01 02
        for filename_2 in os.listdir(r"./dir_classfied_my/%s" % filename_1):
            # print(filename_2)    # filename_2: '1_2.jpg'

            paths = PATH_0 + filename_1 + '/' + filename_2
            # print(paths)
            if filename_2 == filename_0:
                shutil.copy(os.path.join(PATH_0, filename_0), os.path.join(PATH_1, filename_1, filename_0))

这里一心想实现最终效果，所以并没有过多考虑时间复杂度的问题 [手动狗头]，代码还有很大的优化空间。
这篇文章写出来，希望能帮助到有需要的人们，同时也是为了日后需要时的查阅方便。文章中项目的代码已开源，点击这里即可查看，如果有帮助到你，请动动你的小手在GitHub上点亮☆ Star。
写到这里，差不多本文就要结束了。如果有问题可以在下方留言区留言交流，错误之处也欢迎小伙伴们的批评指正。如果我的这篇文章帮助到了你，那我也会感到很高兴，一个人能走多远，在于与谁同行。



Python计算机视觉编程 - 第六章 图像聚类 ↩︎

本文案例的GitHub代码 ↩︎

谱聚类（spectral clustering）原理总结 ↩︎

立即学习:https://edu.csdn.net/course/play/27362/368000?utm_source=blogtoedu
在已知结果类别的时候使用分类分析方法。

当未知结果类别，我们可以去根据对象的属性聚类推测可能的结果类别

K-means

以最小误差函数的值为最小为目标，按照预先设定的划分类别数量，采用距离作为相似性的评价指标，认为两个对象距离越近，相似度越大。

计算步骤：

1从样本选取k个对象为样本中心

2分别计算样本到聚类中心的距离，进行分配

3所有对象分配好，计算误差平方和SSE

4重新选择样本中心，计算新的误差平方和sse

5与上次作比较找到误差平方和较小得分类结果

6当聚类中心不发生变化，停止并输出聚类结果

SSE计算方法：

距离计算方法：物理距离：欧几里得距离

曼哈顿距离：所有坐标差得绝对值和

聚类质量评估方法：

误差平方和SSE作为度量聚类质量得目标函数。

每个点到聚类中心的距离的平方和

聚类不是目标，只是处理

之后对聚类结果进行处理

:1各分群的特点？

:2对不同分区可采用的处理措施？

 

k-中心点

 

多层次聚类

 

 

 

已知类别选择分类：

未知类别选择聚类：