金沙棋牌游戏官网聚类的几个重要问题,聚类算

原标题:【周末AI课堂】聚类的几个重要问题(代码篇)| 机器学习你会遇到的“坑”

一、关于聚类及相似度、距离的知识点

AI课堂开讲,就差你了!

金沙棋牌游戏官网 1

很多人说,看了再多的文章,可是没有人手把手地教授,还是很难真正地入门AI。为了将AI知识体系以最简单的方式呈现给你,从这个星期开始,芯君邀请AI专业人士开设“周末学习课堂”——每周就AI学习中的一个重点问题进行深度分析,课程会分为理论篇和代码篇,理论与实操,一个都不能少!

金沙棋牌游戏官网 2

来,退出让你废寝忘食的游戏页面,取消只有胡吃海塞的周末聚会吧。未来你与同龄人的差异,也许就从每周末的这堂AI课开启了!

金沙棋牌游戏官网 3

读芯术读者交流群,请加小编微信号:zhizhizhuji。等你。后台回复“周末AI课堂”,查阅相关源代码。

金沙棋牌游戏官网 4

全文共2125字,预计学习时长5分钟

金沙棋牌游戏官网 5

金沙棋牌游戏官网 6

二、k-means算法思想与流程

在《聚类的几个重要问题(理论篇)》中,我们主要讲解了聚类的现实意义、无序属性的距离度量方法、以及几种聚类算法的优劣程度,但我没有对聚类算法做出详细讲解,一方面是因为聚类算法一般都比较简单,另一方面则是聚类算法数量和种类都很多,我不得不以更为宏观讲解其中的重要问题。在本文中,我们会利用几种分布不同的数据来对不同的聚类算法做对比,以及同一聚类算法中,不同参数对聚类算法的影响。

金沙棋牌游戏官网 7

首先,因为聚类的性能标准并不统一,通过数值比较也并不直观,所以我们可以自然的想到,如果我们处理一个分类数据,如果此类数据利用聚类的结果与类别一致,那么就可以说聚类达到了好的效果,通过特征空间的直观对比,我们就可以大致比较不同聚类算法的优劣。在这里,我们的假设是,相似的样本具有相同的类别。

金沙棋牌游戏官网 8

我们构建样例数据:

金沙棋牌游戏官网 9

from sklearn import cluster,datasets

金沙棋牌游戏官网 10

import matplotlib.pyplot as plt

金沙棋牌游戏官网 11

import seaborn as sns

金沙棋牌游戏官网 12

n_samples=1000

金沙棋牌游戏官网 13

X,y=datasets.make_blobs(n_samples=n_samples, random_state=42,centers=5,cluster_std=3)

金沙棋牌游戏官网 14

sns.set(style='darkgrid')

金沙棋牌游戏官网 15

for i,v,l in [[0,'r','class_0'],[1,'b','class_1'],[2,'g','class_2']]:

三、sklearn中对于kmeans算法的参数

plt.scatter(X[y==i][:,0],X[y==i][:,1],c=v,label=l,s=15,edgecolor='k')

金沙棋牌游戏官网 16

plt.legend()

四、代码示例以及应用的知识点简介

plt.show()

(1)make_blobs:聚类数据生成器

金沙棋牌游戏官网 17

金沙棋牌游戏官网 18

如图,样本分布为三个明显的类,但某些蓝色点掺杂到了红色点里面,我们需要特别注意这些点。

sklearn.datasets.make_blobs(n_samples=100,n_features=2,centers=3, cluster_std=1.0,center_box=(-10.0, 10.0),shuffle=True, random_state=None)[source]

我们利用K均值算法需要设置初始的均值向量,也要预先指定好类别数,然后迭代更新这些均值向量,我们指定类别数为3,随机选择均值向量:

金沙棋牌游戏官网 19

from sklearn import datasets

返回值为

import matplotlib.pyplot as plt

金沙棋牌游戏官网 20

import seaborn as sns

金沙棋牌游戏官网 21

from sklearn.cluster import KMeans

金沙棋牌游戏官网 22

n_samples=1000

(2)np.vstack方法作用——堆叠数组

X,y=datasets.make_blobs(n_samples=n_samples,centers=3,random_state=42,cluster_std=3)

详细介绍参照博客链接:

kmean=KMeans(n_clusters=3,init='random')

金沙棋牌游戏官网 23

y_pre=kmean.fit_predict(X)

金沙棋牌游戏官网 24

sns.set(style='darkgrid')

[python]view plaincopy

for i,v,l in [[0,'r','cluster_0'],[1,'b','cluster_1'],[2,'g','cluster_2']]:

#!/usr/bin/env python  

plt.scatter(X[y_pre==i][:,0],X[y_pre==i][:,1],c=v,label=l,s=15,edgecolor='k')

# -*- coding:utf-8 -*-  

plt.legend()

# Author:ZhengzhengLiu  

plt.title('Kmeans for Bolbs')

#k-means聚类算法  

plt.show()

import numpy as np  

金沙棋牌游戏官网 25

import pandas as pd  

如图,聚类的结果大致上只是对于这三个类重新标记了颜色,但在特征空间的同样位置,我们发现原本发生‘’掺杂‘’的点,在利用Kmeans算法之后变得严格分离,这是非常简单就可以预料到的。

import matplotlib as mpl  

如果我们增加指定的类别数会发生什么呢?

import matplotlib.pyplot as plt  

.......

import matplotlib.colors  

kmean=KMeans(n_clusters=4,init='random')

import sklearn.datasets as ds  

.......

from sklearn.cluster import KMeans      #引入kmeans  

金沙棋牌游戏官网 26

#解决中文显示问题  

如图,指定类别数4的Kmeans又强行把某一类拆分出两个类,从kmeans的角度来看,初始的均值向量个数有几个,我们就会分成几类,这也是kmeans算法的缺点之一。

mpl.rcParams['font.sans-serif'] = [u'SimHei']  

那么初始均值向量该如何选择,因为初始化会对我们最后的结果造成一定的影响,因为初始的均值向量完全随机可能会将两个靠得很近的样本当作均值向量,那么这两个均值向量为中心的簇就可能会把本来属于同一类的样本强行划分为两个类。在实际应用中,我们会kmeans中插入一种叫做k-means 的技术,它改变了选择初始均值向量的方法,距离越大的点会有更大的概率被选择为进入最终kmeans的算法。

mpl.rcParams['axes.unicode_minus'] = False  

但我们目前使用的数据是凸形结构的,如果我们选用不是凸形结构的数据会如何呢?我们使用在《核技巧》中提到过的一种环形数据:

#产生模拟数据  

.......

N =1500  

X,y=datasets.make_circles(n_samples=n_samples, factor=.5,noise=.05)

centers =4  

......

#make_blobs:聚类数据生成器  

金沙棋牌游戏官网 27

data,y = ds.make_blobs(N,n_features=2,centers=centers,random_state=28)  

我们利用kmeans算法适应这样的数据会产生什么效果呢?

data2,y2 = ds.make_blobs(N,n_features=2,centers=centers,random_state=28)  

......

data3 = np.vstack((data[y==0][:200],data[y==1][:100],data[y==2][:10],data[y==3][:50]))  

kmean=KMeans(n_clusters=2,init='k-means ')

y3 = np.array([0]*200 [1]*100 [2]*10 [3]*50)  

y_pre=kmean.fit_predict(X)

#模型的构建  

sns.set(style='darkgrid')

km = KMeans(n_clusters=centers,random_state=28)  

for i,v,l in [[0,'r','cluster_0'],[1,'b','cluster_1']]:

km.fit(data,y)  

plt.scatter(X[y_pre==i][:,0],X[y_pre==i][:,1],c=v,label=l,s=15,edgecolor='k')

y_hat = km.predict(data)  

plt.legend()

print("所有样本距离聚簇中心点的总距离和:",km.inertia_)  

plt.title('Kmeans for Circles')

print("距离聚簇中心点的平均距离:",(km.inertia_/N))  

plt.show()

print("聚簇中心点:",km.cluster_centers_)  

金沙棋牌游戏官网 28

y_hat2 = km.fit_predict(data2)  

如图,我们可以看到原本特征空间的环形并没有得到保持,而是分裂为上下两个类别,因为kmeans算法会把所有的数据都当作凸形结构来处理。

y_hat3 = km.fit_predict(data3)  

我们转用密度聚类来处理这个问题,以DBSCAN为例,我们不需要设置类别数,在这方面比kmeans更加灵活,但我们主要需要另外两个参数,一个叫maximum distance,它衡量的是样本要离的多近才能算作邻域,另一个叫做minimum samples,它衡量的是要包含多少个core point才能算作一个簇。此外,传统的kmeans还有一个缺点,只要我们制定了类别数,样本一定会被划分到一个类,如果我们的数据包含噪声的话,kmeans的效果就会受到很大影响。

def expandBorder(a, b):  

表面上来看噪声项是离群点,但在DBSCAN中,可以被定义为无法由core point通过密度可达关系包含的点,这些点不会属于任何一个簇,我们构建DBSCAN,来观察其在circles数据上的表现:

d = (b - a) *0.1  

from sklearn import datasets

return a-d, b d  

import matplotlib.pyplot as plt

#画图  

import seaborn as sns

cm = mpl.colors.ListedColormap(list("rgbmyc"))  

from sklearn.cluster import KMeans

plt.figure(figsize=(15,9),facecolor="w")  

from sklearn.cluster import DBSCAN

plt.subplot(241)  

n_samples=1000

plt.scatter(data[:,0],data[:,1],c=y,s=30,cmap=cm,edgecolors="none")  

X,y=datasets.make_circles(n_samples=n_samples, factor=.5,noise=.05)

x1_min,x2_min = np.min(data,axis=0)  

dbscan=DBSCAN(eps=0.08)

x1_max,x2_max = np.max(data,axis=0)  

y_pre=dbscan.fit_predict(X)

x1_min,x1_max = expandBorder(x1_min,x1_max)  

sns.set(style='darkgrid')

x2_min,x2_max = expandBorder(x2_min,x2_max)  

for i,v,l in [[0,'r','cluster_0'],[1,'b','cluster_1'],[-1,'y','Noisy Samples']]:

plt.xlim((x1_min,x1_max))  

plt.scatter(X[y_pre==i][:,0],X[y_pre==i][:,1],c=v,label=l,s=15,edgecolor='k')

plt.ylim((x2_min,x2_max))  

plt.legend()

plt.title("原始数据")  

plt.title('DBSCAN for Circles')

plt.grid(True)  

plt.show()

plt.subplot(242)  

金沙棋牌游戏官网 29

plt.scatter(data[:,0], data[:, 1], c=y_hat, s=30, cmap=cm, edgecolors='none')  

如图,DBSCAN可以良好的适应circles数据,并且将一些可能的噪声项(黄色点)做了标记。

plt.xlim((x1_min, x1_max))  

但是,DBSCAN对参数非常敏感,我们在这里将邻域参数设置为了0.08,是希望足够小的邻域可以对类别有很好区分,但是太小的话,可能会将同一类的样本划到不同类,太大的话,可能会将不同的类当作一个类。如果对他进行微小调节,我们将会看到聚类结果发生很大的变化:

plt.ylim((x2_min, x2_max))  

......

plt.title(u'K-Means算法聚类结果')  

gammas=[0.01,0.08,0.2,5]

plt.grid(True)  

sns.set(style='darkgrid')

m = np.array(((1, 1), (0.5, 5)))  

for k,j in enumerate(gammas):

data_r = data.dot(m)  

dbscan=DBSCAN(eps=j)

y_r_hat = km.fit_predict(data_r)  

y_pre=dbscan.fit_predict(X)

plt.subplot(243)  

plt.subplot(len(gammas)/2,len(gammas)/2,k 1)

plt.scatter(data_r[:,0], data_r[:, 1], c=y, s=30, cmap=cm, edgecolors='none')  

for i,v,l in [[0,'r','cluster_0'],[1,'b','cluster_1'],[-1,'y','Noisy Samples']]:

x1_min, x2_min = np.min(data_r, axis=0)  

plt.scatter(X[y_pre==i][:,0],X[y_pre==i][:,1],c=v,label=l,s=15,edgecolor='k')

x1_max, x2_max = np.max(data_r, axis=0)  

plt.title('$gamma=$%s'%j)

x1_min, x1_max = expandBorder(x1_min, x1_max)  

plt.show()

x2_min, x2_max = expandBorder(x2_min, x2_max)  

金沙棋牌游戏官网 30

plt.xlim((x1_min, x1_max))  

如图,我们可以看到,当邻域太小的时候,以至于每个类都没有足够的密度可达对象,造成全部的样本都被认为是噪声;当邻域为合适的大小时,大体形状相似,但对噪声的识别会不太一样;而当邻域太大时,所有的点都被当作core points,所以所有的样本都会被当作一个类。

plt.ylim((x2_min, x2_max))  

此外我们还可以利用层次聚类、网格聚类和概率模型聚类,但为了更好的理解降维与聚类的关系,我们主要尝试谱聚类的,谱聚类会对数据做降维,然后再利用kmeans的基本框架完成聚类,那么降维之后真的可以处理非凸结构类型的数据吗?

plt.title(u'数据旋转后原始数据图')  

......

plt.grid(True)  

spectral=SpectralClustering(n_clusters=2,affinity='nearest_neighbors',eigen_solver='arpack')

plt.subplot(244)  

y_pre=spectral.fit_predict(X)

plt.scatter(data_r[:,0], data_r[:, 1], c=y_r_hat, s=30, cmap=cm, edgecolors='none')  

sns.set(style='darkgrid')

plt.xlim((x1_min, x1_max))  

for i,v,l in [[0,'r','cluster_0'],[1,'b','cluster_1']]:

plt.ylim((x2_min, x2_max))  

plt.scatter(X[y_pre==i][:,0],X[y_pre==i][:,1],c=v,label=l,s=15,edgecolor='k')

plt.title(u'数据旋转后预测图')  

plt.legend()

plt.grid(True)  

plt.title('Spectral Clusteringfor Circles')

plt.subplot(245)  

plt.show()

plt.scatter(data2[:,0], data2[:, 1], c=y2, s=30, cmap=cm, edgecolors='none')  

金沙棋牌游戏官网 31

x1_min, x2_min = np.min(data2, axis=0)  

如图,spectral clustering 也可以处理非凸结构的数据,我们得到了与DBSCAN类似的结果。

x1_max, x2_max = np.max(data2, axis=0)  

之所以我特意展示spectral clustering的威力,并不是它是最好的,因为根本不存在“最好”的算法,而是这里面反映出我们在前面的文章《核技巧(kernel trick)》中提到的将一个线性不可分(非凸)变为线性可分(凸),继续再做降维,spectral clustering正是利用了这一思想,我们将会在后面的文章中反复的利用前面的知识。

x1_min, x1_max = expandBorder(x1_min, x1_max)  

金沙棋牌游戏官网 32

x2_min, x2_max = expandBorder(x2_min, x2_max)  

读芯君开扒

plt.xlim((x1_min, x1_max))  

课堂TIPS

plt.ylim((x2_min, x2_max))  

• 谱聚类利用的是一种叫做拉普拉斯特征映射的降维方法,本质上也是非线性的,所以才会有处理非凸结构的能力。

plt.title(u'不同方差的原始数据')  

• 高斯混合模型这里并没有提到,但进行极大似然估计时,会有隐变量需要估计,我们会使用经典的EM算法处理。

plt.grid(True)  

• 很多聚类算法都有不同的变种,以k-means为例,为了解决其需要指定类别数的问题,我们可以把类别数目K当作超参数来处理,然后根据不同K下的silhouette Coefficient来确定K;为了解决初始化聚类中心的问题,除了k-means ,我们还会使用intelligent k-means;为了解决噪声点的影响,我们还有k-medians。

plt.subplot(246)  

金沙棋牌游戏官网 33

plt.scatter(data2[:,0], data2[:, 1], c=y_hat2, s=30, cmap=cm, edgecolors='none')  

留言 点赞 发个朋友圈

plt.xlim((x1_min, x1_max))  

我们一起探讨AI落地的最后一公里

plt.ylim((x2_min, x2_max))  

作者:唐僧不用海飞丝

plt.title(u'不同方差簇数据的K-Means算法聚类结果')  

如需转载,请后台留言,遵守转载规范返回搜狐,查看更多

plt.grid(True)  

责任编辑:

plt.subplot(247)  

plt.scatter(data3[:,0], data3[:, 1], c=y3, s=30, cmap=cm, edgecolors='none')  

x1_min, x2_min = np.min(data3, axis=0)  

x1_max, x2_max = np.max(data3, axis=0)  

x1_min, x1_max = expandBorder(x1_min, x1_max)  

x2_min, x2_max = expandBorder(x2_min, x2_max)  

plt.xlim((x1_min, x1_max))  

plt.ylim((x2_min, x2_max))  

plt.title(u'不同簇样本数量原始数据图')  

plt.grid(True)  

plt.subplot(248)  

plt.scatter(data3[:,0], data3[:, 1], c=y_hat3, s=30, cmap=cm, edgecolors='none')  

plt.xlim((x1_min, x1_max))  

plt.ylim((x2_min, x2_max))  

plt.title(u'不同簇样本数量的K-Means算法聚类结果')  

plt.grid(True)  

plt.tight_layout(2, rect=(0, 0, 1, 0.97))  

plt.suptitle(u'数据分布对KMeans聚类的影响', fontsize=18)  

plt.savefig("k-means聚类算法.png")  

plt.show()  

#运行结果:  

所有样本距离聚簇中心点的总距离和:2592.9990199  

距离聚簇中心点的平均距离:1.72866601327  

聚簇中心点: [[ -7.44342199e 00  -2.00152176e 00]  

[5.80338598e 00   2.75272962e-03]  

[ -6.36176159e 00   6.94997331e 00]  

[4.34372837e 00   1.33977807e 00]]  

金沙棋牌游戏官网 34

金沙棋牌游戏官网 35

金沙棋牌游戏官网 36

金沙棋牌游戏官网 37

金沙棋牌游戏官网 38

金沙棋牌游戏官网 39

金沙棋牌游戏官网 40

金沙棋牌游戏官网 41

金沙棋牌游戏官网 42

金沙棋牌游戏官网 43

金沙棋牌游戏官网 44

金沙棋牌游戏官网 45

金沙棋牌游戏官网 46

金沙棋牌游戏官网 47

金沙棋牌游戏官网 48

代码中用到的知识点:

金沙棋牌游戏官网 49

#!/usr/bin/env python  

# -*- coding:utf-8 -*-  

# Author:ZhengzhengLiu  

#kmean与mini batch kmeans 算法的比较  

import time  

import numpy as np  

import matplotlib as mpl  

import matplotlib.pyplot as plt  

import matplotlib.colors  

from sklearn.cluster import KMeans,MiniBatchKMeans  

from sklearn.datasets.samples_generator import make_blobs  

from sklearn.metrics.pairwise import pairwise_distances_argmin  

#解决中文显示问题  

mpl.rcParams['font.sans-serif'] = [u'SimHei']  

mpl.rcParams['axes.unicode_minus'] = False  

#初始化三个中心  

centers = [[1,1],[-1,-1],[1,-1]]  

clusters = len(centers)#聚类数目为3  

#产生3000组二维数据样本,三个中心点,标准差是0.7  

X,Y = make_blobs(n_samples=300,centers=centers,cluster_std=0.7,random_state=28)  

#构建kmeans算法  

k_means =  KMeans(init="k-means ",n_clusters=clusters,random_state=28)  

t0 = time.time()  

k_means.fit(X)#模型训练  

km_batch = time.time()-t0#使用kmeans训练数据消耗的时间  

print("K-Means算法模型训练消耗时间:%.4fs"%km_batch)  

#构建mini batch kmeans算法  

batch_size =100        #采样集的大小  

mbk = MiniBatchKMeans(init="k-means ",n_clusters=clusters,batch_size=batch_size,random_state=28)  

t0 = time.time()  

mbk.fit(X)  

mbk_batch = time.time()-t0  

print("Mini Batch K-Means算法模型训练消耗时间:%.4fs"%mbk_batch)  

#预测结果  

km_y_hat = k_means.predict(X)  

mbk_y_hat = mbk.predict(X)  

#获取聚类中心点并对其排序  

k_means_cluster_center = k_means.cluster_centers_  

mbk_cluster_center = mbk.cluster_centers_  

print("K-Means算法聚类中心点:n center=",k_means_cluster_center)  

print("Mini Batch K-Means算法聚类中心点:n center=",mbk_cluster_center)  

order = pairwise_distances_argmin(k_means_cluster_center,mbk_cluster_center)  

#画图  

plt.figure(figsize=(12,6),facecolor="w")  

plt.subplots_adjust(left=0.05,right=0.95,bottom=0.05,top=0.9)  

cm = mpl.colors.ListedColormap(['#FFC2CC', '#C2FFCC', '#CCC2FF'])  

cm2 = mpl.colors.ListedColormap(['#FF0000', '#00FF00', '#0000FF'])  

#子图1——原始数据  

plt.subplot(221)  

plt.scatter(X[:,0],X[:,1],c=Y,s=6,cmap=cm,edgecolors="none")  

plt.title(u"原始数据分布图")  

plt.xticks(())  

plt.yticks(())  

plt.grid(True)  

#子图2:K-Means算法聚类结果图  

plt.subplot(222)  

plt.scatter(X[:,0], X[:,1], c=km_y_hat, s=6, cmap=cm,edgecolors='none')  

plt.scatter(k_means_cluster_center[:,0], k_means_cluster_center[:,1],c=range(clusters),s=60,cmap=cm2,edgecolors='none')  

plt.title(u'K-Means算法聚类结果图')  

plt.xticks(())  

plt.yticks(())  

plt.text(-3.8, 3,  'train time: %.2fms' % (km_batch*1000))  

plt.grid(True)  

#子图三Mini Batch K-Means算法聚类结果图  

plt.subplot(223)  

plt.scatter(X[:,0], X[:,1], c=mbk_y_hat, s=6, cmap=cm,edgecolors='none')  

plt.scatter(mbk_cluster_center[:,0], mbk_cluster_center[:,1],c=range(clusters),s=60,cmap=cm2,edgecolors='none')  

plt.title(u'Mini Batch K-Means算法聚类结果图')  

plt.xticks(())  

plt.yticks(())  

plt.text(-3.8, 3,  'train time: %.2fms' % (mbk_batch*1000))  

plt.grid(True)  

plt.savefig("kmean与mini batch kmeans 算法的比较.png")  

plt.show()  

#运行结果:  

K-Means算法模型训练消耗时间:0.2260s  

Mini Batch K-Means算法模型训练消耗时间:0.0230s  

K-Means算法聚类中心点:  

center= [[0.96091862  1.13741775]  

[1.1979318  -1.02783007]  

[-0.98673669 -1.09398768]]  

Mini Batch K-Means算法聚类中心点:  

center= [[1.34304199 -1.01641075]  

[0.83760683  1.01229021]  

[-0.92702179 -1.08205992]]  

金沙棋牌游戏官网 50

五、聚类算法的衡量指标

金沙棋牌游戏官网 51

金沙棋牌游戏官网 52

金沙棋牌游戏官网 53

金沙棋牌游戏官网 54

金沙棋牌游戏官网 55

#!/usr/bin/env python  

# -*- coding:utf-8 -*-  

# Author:ZhengzhengLiu  

#聚类算法评估  

import time  

import numpy as np  

import matplotlib as mpl  

import matplotlib.pyplot as plt  

import matplotlib.colors  

from sklearn.cluster import KMeans,MiniBatchKMeans  

from sklearn import metrics  

from sklearn.metrics.pairwise import pairwise_distances_argmin  

from sklearn.datasets.samples_generator import make_blobs  

#解决中文显示问题  

mpl.rcParams['font.sans-serif'] = [u'SimHei']  

mpl.rcParams['axes.unicode_minus'] = False  

#初始化三个中心  

centers = [[1,1],[-1,-1],[1,-1]]  

clusters = len(centers)#聚类数目为3  

#产生3000组二维数据样本,三个中心点,标准差是0.7  

X,Y = make_blobs(n_samples=300,centers=centers,cluster_std=0.7,random_state=28)  

#构建kmeans算法  

k_means =  KMeans(init="k-means ",n_clusters=clusters,random_state=28)  

t0 = time.time()  

k_means.fit(X)#模型训练  

km_batch = time.time()-t0#使用kmeans训练数据消耗的时间  

print("K-Means算法模型训练消耗时间:%.4fs"%km_batch)  

#构建mini batch kmeans算法  

batch_size =100        #采样集的大小  

mbk = MiniBatchKMeans(init="k-means ",n_clusters=clusters,batch_size=batch_size,random_state=28)  

t0 = time.time()  

mbk.fit(X)  

mbk_batch = time.time()-t0  

print("Mini Batch K-Means算法模型训练消耗时间:%.4fs"%mbk_batch)  

km_y_hat = k_means.labels_  

mbkm_y_hat = mbk.labels_  

k_means_cluster_centers = k_means.cluster_centers_  

mbk_means_cluster_centers = mbk.cluster_centers_  

print ("K-Means算法聚类中心点:ncenter=", k_means_cluster_centers)  

print ("Mini Batch K-Means算法聚类中心点:ncenter=", mbk_means_cluster_centers)  

order = pairwise_distances_argmin(k_means_cluster_centers,  

                                  mbk_means_cluster_centers)  

#效果评估  

### 效果评估  

score_funcs = [  

metrics.adjusted_rand_score,#ARI(调整兰德指数)  

metrics.v_measure_score,#均一性与完整性的加权平均  

metrics.adjusted_mutual_info_score,#AMI(调整互信息)  

metrics.mutual_info_score,#互信息  

]  

## 2. 迭代对每个评估函数进行评估操作  

for score_func in score_funcs:  

    t0 = time.time()  

    km_scores = score_func(Y, km_y_hat)  

print("K-Means算法:%s评估函数计算结果值:%.5f;计算消耗时间:%0.3fs" % (score_func.__name__, km_scores, time.time() - t0))  

    t0 = time.time()  

    mbkm_scores = score_func(Y, mbkm_y_hat)  

print("Mini Batch K-Means算法:%s评估函数计算结果值:%.5f;计算消耗时间:%0.3fsn" % (score_func.__name__, mbkm_scores, time.time() - t0))  

#运行结果:  

K-Means算法模型训练消耗时间:0.6350s  

Mini Batch K-Means算法模型训练消耗时间:0.0900s  

K-Means算法聚类中心点:  

center= [[0.96091862  1.13741775]  

[1.1979318  -1.02783007]  

[-0.98673669 -1.09398768]]  

Mini Batch K-Means算法聚类中心点:  

center= [[1.34304199 -1.01641075]  

[0.83760683  1.01229021]  

[-0.92702179 -1.08205992]]  

K-Means算法:adjusted_rand_score评估函数计算结果值:0.72566;计算消耗时间:0.071s  

Mini Batch K-Means算法:adjusted_rand_score评估函数计算结果值:0.69544;计算消耗时间:0.001s  

K-Means算法:v_measure_score评估函数计算结果值:0.67529;计算消耗时间:0.004s  

Mini Batch K-Means算法:v_measure_score评估函数计算结果值:0.65055;计算消耗时间:0.004s  

K-Means算法:adjusted_mutual_info_score评估函数计算结果值:0.67263;计算消耗时间:0.006s  

Mini Batch K-Means算法:adjusted_mutual_info_score评估函数计算结果值:0.64731;计算消耗时间:0.005s  

K-Means算法:mutual_info_score评估函数计算结果值:0.74116;计算消耗时间:0.002s  

Mini Batch K-Means算法:mutual_info_score评估函数计算结果值:0.71351;计算消耗时间:0.001s  

本文由金沙棋牌游戏官网发布于国际棋牌中心,转载请注明出处:金沙棋牌游戏官网聚类的几个重要问题,聚类算

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。