无监督学习
1、简介
无监督学习是一种对不含标记的数据建立模型的机器学习范式。最常见的无监督学习方法是聚类,就是讲无标记的数据分成几种集群，这些集群通常是根据某种相似度指标进行的，如欧氏距离（Euclidean distance),常用领域有：数据挖掘、医学影像、股票市场分析、计算机视觉、市场细分等。
2、用k-means算法聚类数据
k-means算法常用数据的不同属性将输入数据划分成k组。分组是使用最优化的技术实现的，即让各组的数据点与该组中心点的距离平方和最小化。例子如下：
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
def load_data(input_file):
X = []
with open(input_file, ‘r‘) as f:
for line in f.readlines():
data = [float(x) for x in line.split(‘,‘)]
X.append(data)
return np.array(X)
# 1、获取数据并可视化
input_file = ‘data_multivar.txt‘
data = load_data(input_file)
x_min,x_max=min(data[:,0])-1,max(data[:,0])+1
y_min,y_max=min(data[:,1])-1,max(data[:,1])+1
‘‘‘
plt.figure()
plt.scatter(data[:,0], data[:,1],
facecolors=‘none‘, edgecolors=‘k‘)
plt.xlim(x_min,x_max)
plt.ylim(y_min,y_max)
plt.show()
‘‘‘
# 2、获取k-means对象，并训练
kmeans=KMeans(n_clusters=4,init=‘k-means++‘,n_init=10)
kmeans.fit(data)
# 3、获取边界
step_size=0.01
x_values,y_values=np.meshgrid(np.arange(x_min,x_max,step_size),np.arange(y_min,y_max,step_size))
predict_labels=kmeans.predict(np.c_[x_values.ravel(),y_values.ravel()])
predict_labels=predict_labels.reshape(x_values.shape)
# 4、画出边界
plt.figure()
plt.clf()
plt.imshow(predict_labels, interpolation=‘nearest‘,
extent=(x_values.min(), x_values.max(), y_values.min(), y_values.max()),
cmap=plt.cm.Paired,
aspect=‘auto‘, origin=‘lower‘)
plt.scatter(data[:,0], data[:,1],
facecolors=‘none‘, edgecolors=‘k‘)
centero=kmeans.cluster_centers_
plt.scatter(centero[:,0],centero[:,1],linewidths=5,facecolor=‘black‘)
plt.xlim(x_min,x_max)
plt.ylim(y_min,y_max)
plt.show()图片显示如下：
3、用矢量量化压缩图片
k-means聚类的主要应用之一就是矢量量化。矢量量化就是“四舍五入”（rounding off）的N维版本。在处理数字等一维数据时，会用四舍五入技术减少存储空间。矢量量化被广泛应用于图片压缩，用比原始图像更少的比特数来存储每个像素，从而实现图像图片。
import argparse
# 1、创建一个函数，用来解析输入参数，输入参数为图片和每个像素被压缩的比特数。
def build_arg_parser():
parser = argparse.ArgumentParser(description=‘输入图片‘)
parser.add_argument(‘--input-file‘, dest=‘input_file‘, required=True, help=‘输入图片‘)
parser.add_argument(‘--num-bits‘, dest=‘num_bits‘, type=int, required=False, help=‘比特数‘)
return parser
# 2、压缩输入图片
def compress_img(img, num_cluster):
print(img)
X = img.reshape(-1, 1)
print(X)
kmeans = KMeans(n_clusters=num_cluster, n_init=4, random_state=5)
kmeans.fit(X)
contrid = kmeans.cluster_centers_.squeeze()
labels = kmeans.labels_
input_compress = np.choose(labels, contrid).reshape(img.shape)
return input_compress
# 3、查看压缩算法对图片质量的影响
def plot_image(img,title):
vmin=img.min()
vmax=img.max()
plt.figure()
plt.title(title)
plt.imshow(img,cmap=plt.cm.gray,vmin=vmin,vmax=vmax)
if __name__ == ‘__main__‘:
args = build_arg_parser().parse_args()
input_file=args.input_file
num_bits=args.num_bits
if not 1<=num_bits<=8:
raise TypeError(‘比特数应该在1和8之间‘)
num_clusters=np.power(2,num_bits)
compression_rate=round(100*(8.0-args.num_bits)/8.0,2)
input_image=misc.imread(input_file,True).astype(np.uint8)
plot_image(input_image,‘image‘)
input_compress=compress_img(input_image,num_clusters)
plot_image(input_compress,‘rate=‘+str(compression_rate)+‘%‘)
plt.show()4、建立均值漂移聚类模型
均值漂移是一种非常强大的无监督学习算法，用于集群数据点。该算法把数据点的分布看成是概率密度函数（probability-density function），希望在特征空间中根据函数分布特征找出数据点的“模式”（mode），这些“模式”就对应于一群群局部最密集（local maxima）分布的点。该算法的优点在于它无需事先确定集群的数量。例子如下：
# 均值漂移聚类模型
from sklearn.cluster import MeanShift,estimate_bandwidth
# 1、获取数据
X=load_data(‘data_multivar.txt‘)
# 2、通过指定输入参数创建均值漂移模型
bandwidth=estimate_bandwidth(X,quantile=0.1,n_samples=len(X))
meanshift=MeanShift(bandwidth=bandwidth,bin_seeding=True)
# 3、训练模型
meanshift.fit(X)
# 4、提取标记
labels=meanshift.labels_
# 5、获取集群中心点，并打印数量
centroids=meanshift.cluster_centers_
num_clusters=len(np.unique(labels))
print(labels)
print(centroids)
print(num_clusters,len(centroids))
# 6、可视化
markers=‘.*xv‘
plt.figure()
for i,marker in zip(range(len(markers)),markers):
plt.scatter(X[labels==i,0],X[labels==i,1],marker=marker,color=‘k‘)
centroid=centroids[i]
plt.plot(centroid[0],centroid[1],marker=‘o‘,markersize=15,markeredgecolor=‘k‘,markerfacecolor=‘k‘)
plt.title(‘显示‘)
plt.show()5、用凝聚层次聚类进行分组
层次聚类:一组聚类算法，通过不断的分解或合并集群来构建树状集群（tree-like clusters)，其结构可用一棵树表示。该算法可自上而下，也可自下而上。
凝聚层次聚类：即自下而上的算法，每一个数据点被看做一个单独的子集，而让这些子集不断的合并，直到所有集合合并为一个巨型集群。相反，自上而下则是分解。直到所有集群变为一个单独的数据点。
def get_spiral(t,noise_amplitude=0.5):# 获取呈螺旋状的数据
r=t
x=r*np.cos(t)
y=r*np.sin(t)
return add_noise(x,y,noise_amplitude)
def get_rose(t,noise_amplitude=0.02):# 获取呈螺旋状的数据
k=5
r=np.cos(k*t)+0.25
x=r*np.cos(t)
y=r*np.sin(t)
return add_noise(x,y,noise_amplitude)
def get_hypotrochoid(t, noise_amplitude=0):
a, b, h = 10.0, 2.0, 4.0
x = (a - b) * np.cos(t) + h * np.cos((a - b) / b * t)
y = (a - b) * np.sin(t) - h * np.sin((a - b) / b * t)
return add_noise(x, y, 0)
def add_noise(x,y,amplitude):# 添加噪音
X=np.concatenate((x,y))
X+=amplitude*np.random.randn(2,X.shape[1])
return X.T
from sklearn.cluster import AgglomerativeClustering
def perform_clustering(X,connectivity,title,num_clusters=3,linkage=‘ward‘):# 设置层次凝聚模型
plt.figure()
model=AgglomerativeClustering(linkage=linkage,n_clusters=num_clusters,connectivity=connectivity)
model.fit(X)
labels=model.labels_
markers=‘.vx‘
for i,marker in zip(range(num_clusters),markers):
plt.scatter(X[labels==i,0],X[labels==i,1],s=50,facecolor=‘none‘,marker=marker,color=‘k‘)
plt.title(title)
from sklearn.neighbors import kneighbors_graph
if __name__==‘__main__‘:
# 生成样本数据
n_samples=500
np.random.seed(2)
t=2.5*np.pi*(1+2*np.random.rand(1,n_samples))
X=get_spiral(t)
# X = get_rose(t)
# X = get_hypotrochoid(t)
connectivity=None
perform_clustering(X,connectivity,‘没有连接‘)
connectivity=kneighbors_graph(X,10,include_self=False)
perform_clustering(X,connectivity,‘knei连接‘)# 可让连接在一起的数据组合在一起
plt.show()6、评价聚类算法的聚类效果
轮廓系数（Sihouette Coefficient）系数：得分=(x-y)/max(x,y)，其中x表示在同一个集群中某个数据点与其他数据点的平均距离，y表示某个数据点与最近的另一个集群的所有点的平均距离，使用例子如下：
from sklearn import metrics
data=load_data(‘data_perf.txt‘)# 加载数据
scores=[]
range_values=np.arange(2,10)
for i in range_values:# 分别分i个集群
kmean=KMeans(n_clusters=i,n_init=10,init=‘k-means++‘)
kmean.fit(data)
score=metrics.silhouette_score(data,kmean.labels_,metric=‘euclidean‘,sample_size=len(data))
scores.append(score)
plt.figure()
plt.bar(range_values,scores,width=0.6,color=‘k‘,align=‘center‘)
plt.show()
plt.figure()
plt.scatter(data[:,0],data[:,1],color=‘k‘)
xmin,xmax=min(data[:,0])-1,max(data[:,0])+1
ymin,ymax=min(data[:,1])-1,max(data[:,1])+1
plt.xlim(xmin,xmax)
plt.ylim(ymin,ymax)
plt.show()7、用DBSCAN算法自动估算集群数量
DBSCAN（Density-Based Spatial Clustering of Applications with Noise）：带噪声的基于密度的聚类方法，将数据点看成是紧密集群的若干组，若某个点属于一个集群，那会有许多点也属于同一个集群，该方法里面有一个epsilon参数，可控制该点到其他点的最大距离。若两点间距离超过epsilon，则他们不可能在一个集群中。该方法主要有点是它可以处理异常值，若某些点位于数据稀疏距离，则将其作为异常点，而不会强制将他们放入一个集群中。例子如下：
# 1、获取数据
X=load_data(‘data_perf.txt‘)
# 2、初始化参数
eps_grid=np.linspace(0.3,1.2,num=10)
silhouette_scores=[]
eps_best=eps_grid[0]
silhouette_scores_max=-1
model_best=None
labels_best=None
# 3、以此执行所有参数
from sklearn.cluster import DBSCAN
from sklearn import metrics
for eps in eps_grid:
model=DBSCAN(eps=eps,min_samples=5).fit(X)
labels=model.labels_
silhouette_score=round(metrics.silhouette_score(X,labels),4)
silhouette_scores.append(silhouette_score)
# 获取指标的最佳得分
if silhouette_score>silhouette_scores_max:
silhouette_scores_max=silhouette_score
eps_best=eps
model_best=model
labels_best=labels
# 4、画出条形图
plt.figure()
plt.bar(eps_grid,silhouette_scores,width=0.05,color=‘k‘,align=‘center‘)
plt.show()
# 5、由于可能会有某些点还没有分配集群，所以这里删除未分配而获取集群的数量
offset=0
if -1 in labels:
offset=1
num_clusters=len(set(labels))-offset
# 6、提取核心样本
model = model_best
labels = labels_best
mask_core=np.zeros(labels.shape,dtype=np.bool)# 初始化全部点的分配
mask_core[model.core_sample_indices_]=True# model.core_sample_indices_表示分配后的数据位置为True
# 7、数据可视化
from itertools import cycle
plt.figure()
labels_uniq=set(labels)
markers=cycle(‘vo^s<>‘)
for cur_label,marker in zip(labels_uniq,markers):
if cur_label==-1:
marker=‘.‘
cur_mask=(labels==cur_label)# 获取当前某个数据集的集合的索引
cur_data=X[cur_mask&mask_core]# 当前数据集中正常的数据
plt.scatter(cur_data[:,0],cur_data[:,1],marker=marker,edgecolors=‘black‘,s=96,facecolors=‘none‘)
cur_data=X[cur_mask&-mask_core]# 当前数据集中异常数据
plt.scatter(cur_data[:,0],cur_data[:,1],marker=marker,edgecolors=‘black‘,s=32)
plt.show()
8、近邻传播聚类
近邻传播聚类（Affinity Propagation）：找出数据中每个集群的代表性数据点，找到数据点间的相似性度量值，并把所有数据点看成潜在的代表性数据点，也称取样器（exemplar）。具体查看如下链接：http://blog.csdn.net/u010161379/article/details/51636926
9、建立客户细分模型
市场细分对广告投放、库存管理、配送策略的实施、大众传媒等市场行为都非常有用。在不同类型商品的销售数据中，为客户提供最优的销售和分销策略，例子如下：
# 1、获取数据
import csv
input_file=‘wholesale.csv‘
file_reader=csv.reader(open(input_file,‘r‘),delimiter=‘,‘)
X=[]
for count,row in enumerate(file_reader):
if not count:
names=row[2:]
continue
X.append([float(x) for x in row[2:]])
X=np.array(X)
# 2、使用均值漂移训练数据
from sklearn.cluster import MeanShift,estimate_bandwidth
bandwidth=estimate_bandwidth(X,quantile=0.8,n_samples=len(X))
model=MeanShift(bandwidth=bandwidth,bin_seeding=True)
model.fit(X)
labels=model.labels_
clucenters=model.cluster_centers_
num_centers=len(clucenters)
# 3、打印集群中心
print(‘\t‘.join([name[:3] for name in names]))
print(‘\t‘.join([str(clucenter) for clucenter in clucenters]))
# 4、把milk与groceries的聚类结果可视化
centriods_milk_groceries=clucenters[:,1:3]
plt.figure()
plt.scatter(centriods_milk_groceries[:,0],centriods_milk_groceries[:,1],color=‘k‘,s=100,facecolor=‘none‘)
offset=0.2
plt.xlim(centriods_milk_groceries[:,0].min()-offset*centriods_milk_groceries[:,0].ptp(),centriods_milk_groceries[:,0].max()+offset*centriods_milk_groceries[:,0].ptp())
plt.xlim(centriods_milk_groceries[:,1].min()-offset*centriods_milk_groceries[:,1].ptp(),centriods_milk_groceries[:,1].max()+offset*centriods_milk_groceries[:,1].ptp())
plt.show()