聚类分析java代码 聚类分析代码 python
手写体数字图像聚类实验代码怎么写
本文所有实现代码均来自《Python机器学习及实战》
创新互联主营舟山网站建设的网络公司,主营网站建设方案,成都app软件开发公司,舟山h5小程序开发搭建,舟山网站营销推广欢迎舟山等地区企业咨询
#-*- coding:utf-8 -*-
#分别导入numpy、matplotlib、pandas，用于数学运算、作图以及数据分析
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#第一步：使用pandas读取训练数据和测试数据
digits_train = pd.read_csv('',header=None)
digits_test = pd.read_csv('',header=None)
#第二步：已知原始数据有65个特征值，前64个是像素特征，最后一个是每个图像样本的数字类别
#从训练集和测试集上都分离出64维度的像素特征和1维度的数字目标
X_train = digits_train[np.arange(64)]
y_train = digits_train[64]
X_test = digits_test[np.arange(64)]
y_test = digits_test[64]
#第三步：使用KMeans模型进行训练并预测
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=10)
kmeans.fit(X_train)
kmeans_y_predict = kmeans.predict(X_test)
#第四步：评估KMeans模型的性能
#如何评估聚类算法的性能？
#1.Adjusted Rand Index(ARI) 适用于被用来评估的数据本身带有正确类别的信息，ARI指标和计算Accuracy的方法类似
#2.Silhouette Coefficient(轮廓系数) 适用于被用来评估的数据没有所属类别 同时兼顾了凝聚度和分散度，取值范围[-1,1],值越大，聚类效果越好
from sklearn.metrics import adjusted_rand_score
print 'The ARI value of KMeans is',adjusted_rand_score(y_test,kmeans_y_predict)
#到此为止，手写体数字图像聚类--kmeans学习结束，下面单独讨论轮廓系数评价kmeans的性能
#****************************************************************************************************
#拓展学习：利用轮廓系数评价不同累簇数量(k值)的K-means聚类实例
from sklearn.metrics import silhouette_score
#分割出3*2=6个子图，并且在1号子图作图 subplot(nrows, ncols, plot_number)
plt.subplot(3,2,1)
#初始化原始数据点
x1 = np.array([1,2,3,1,5,6,5,5,6,7,8,9,7,9])
x2 = np.array([1,3,2,2,8,6,7,6,7,1,2,1,1,3])
# a = [1,2,3] b = [4,5,6] zipped = zip(a,b) 输出为元组的列表[(1, 4), (2, 5), (3, 6)]
X = np.array(zip(x1,x2)).reshape(len(x1),2)
#X输出为：array([[1, 1],[2, 3],[3, 2],[1, 2],...,[9, 3]])
#在1号子图作出原始数据点阵的分布
plt.xlim([0,10])
plt.ylim([0,10])
plt.title('Instances')
plt.scatter(x1,x2)
colors = ['b','g','r','c','m','y','k','b']
markers = ['o','s','D','v','^','p','*','+']
clusters = [2,3,4,5,8]
subplot_counter = 1
sc_scores = []
for t in clusters:
subplot_counter += 1
plt.subplot(3,2,subplot_counter)
kmeans_model = KMeans(n_clusters=t).fit(X)
for i,l in enumerate(kmeans_model.labels_):
plt.plot(x1[i],x2[i],color=colors[l],marker=markers[l],ls='None')
plt.xlim([0,10])
plt.ylim([0,10])
sc_score = silhouette_score(X,kmeans_model.labels_,metric='euclidean')
sc_scores.append(sc_score)
#绘制轮廓系数与不同类簇数量的直观显示图
plt.title('K=%s,silhouette coefficient = %0.03f'%(t,sc_score))
#绘制轮廓系数与不同类簇数量的关系曲线
plt.figure() #此处必须空一行，表示在for循环结束之后执行！！！
plt.plot(clusters,sc_scores,'*-') #绘制折线图时的样子
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Coefficient Score')
plt.show()
#****************************************************************************************************
#总结：
#k-means聚类模型所采用的迭代式算法，直观易懂并且非常实用，但是有两大缺陷
#1.容易收敛到局部最优解，受随机初始聚类中心影响，可多执行几次k-means来挑选性能最佳的结果
#2.需要预先设定簇的数量，
k-means聚类算法的java代码实现文本聚类
K-MEANS算法:
k-means 算法接受输入量 k ；然后将n个数据对象划分为 k个聚类以便使得所获得的聚类满足：同一聚类中的对象相似度较高；而不同聚类中的对象相似度较小。聚类相似度是利用各聚类中对象的均值所获得一个“中心对象”（引力中心）来进行计算的。
k-means 算法的工作过程说明如下：首先从n个数据对象任意选择 k 个对象作为初始聚类中心；而对于所剩下其它对象，则根据它们与这些聚类中心的相似度（距离），分别将它们分配给与其最相似的（聚类中心所代表的）聚类；然后再计算每个所获新聚类的聚类中心（该聚类中所有对象的均值）；不断重复这一过程直到标准测度函数开始收敛为止。一般都采用均方差作为标准测度函数. k个聚类具有以下特点：各聚类本身尽可能的紧凑，而各聚类之间尽可能的分开。
具体如下：
输入：k, data[n];
（1） 选择k个初始中心点，例如c[0]=data[0],…c[k-1]=data[k-1];
（2） 对于data[0]….data[n], 分别与c[0]…c[n-1]比较，假定与c[i]差值最少，就标记为i;
（3） 对于所有标记为i点，重新计算c[i]=/标记为i的个数；
（4） 重复(2)(3),直到所有c[i]值的变化小于给定阈值。
算法实现起来应该很容易，就不帮你编写代码了。
k-means算法怎么为对称矩阵进行聚类？
几种典型的聚类融合算法：
1.基于超图划分的聚类融合算法
(1)Cluster-based Similarity Partitioning Algorithm(GSPA)
(2)Hyper Graph-Partitioning Algorithm(HGPA)
(3)Meta-Clustering Algorithm(MCLA)
2.基于关联矩阵的聚类融合算法
Voting-K-Means算法。
3.基于投票策略的聚类融合算法
w-vote是一种典型的基于加权投票的聚类融合算法。
同时还有基于互信息的聚类融合算法和基于有限混合模型的聚类融合算法。
二、基于关联矩阵的聚类融合算法——Voting-K-Means算法
Voting-K-Means算法是一种基于关联矩阵的聚类融合算法，关联矩阵的每一行和每一列代表一个数据点，关联矩阵的元素表示数据集中数据点对共同出现在同一个簇中的概率。
算法过程：
1.在一个数据集上得到若干个聚类成员；
2.依次扫描这些聚类成员，如果数据点i和j在某个聚类成员中被划分到同一个簇中，那么就在关联矩阵对应的位置计数加1；关联矩阵中的元素值越大，说明该元素对应的两个数据点被划分到同一个簇中的概率越大；
3.得到关联矩阵之后，Voting-K-Means算法依次检查关联矩阵中的每个元素，如果它的值大于算法预先设定的阀值，就把这个元素对应的两个数据点划分到同一个簇中。
Voting-K-Means算法的优缺点：
Voting-K-Means算法不需要设置任何参数，在聚类融合的过程中可以自动地的选择簇的个数 并且可以处理任意形状的簇。因为Voting-K-Means算法在聚类融合过程中是根据两个数据点共同出现在同一个簇中的可能性大小对它们进行划分的，所以只要两个数据点距离足够近，它们就会被划分到一个簇中。
Voting-K-Means算法的缺点是时间复杂度较高，它的时间复杂度是O(n^2);需要较多的聚类成员，如果聚类成员达不到一定规模，那么关联矩阵就不能准确反映出两个数据点出现在同一个簇的概率。
package clustering;import java.io.FileWriter;import weka.clusterers.ClusterEvaluation;import weka.clusterers.SimpleKMeans;import weka.core.DistanceFunction;import weka.core.EuclideanDistance;import weka.core.Instances;import weka.core.converters.ConverterUtils.DataSource;import weka.filters.unsupervised.attribute.Remove;public class Votingkmeans2 extends SimpleKMeans { /** 生成的序列号 */ private static final long serialVersionUID = 1557181390469997876L; /** 划分的簇数 */ private int m_NumClusters; /** 每个划分的簇中的实例的数量 */ public int[] m_ClusterSizes; /** 使用的距离函数，这里是欧几里德距离 */ protected DistanceFunction m_DistanceFunction = new EuclideanDistance(); /** 实例的簇号赋值 */ protected int[] m_Assignments; /** 设定聚类成员融合阀值 */ private final static double THREASOD = 0.5; /** 生成一个聚类器 */ public void buildClusterer(Instances data) throws Exception{ final int numinst = data.numInstances(); // 数据集的大小 double [][]association = new double[numinst][numinst]; // 定义并初始化一个关联矩阵 int numIteration = 40; // 设置生成的聚类成员数 final int k = (int)Math.sqrt(numinst); // 设置K-Means聚类算法参数——簇数 for(int i = 0; i numIteration; i++) { if(data.classIndex() == -1) data.setClassIndex(data.numAttributes() - 1); // 索引是从0开始 String[] filteroption = new String[2]; filteroption[0] = "-R"; filteroption[1] = String.valueOf(data.classIndex() + 1);// 索引是从1开始 Remove remove = new Remove(); remove.setOptions(filteroption); remove.setInputFormat(data); /* 使用过滤器模式生成新的数据集；新数据集是去掉类标签之后的数据集 */ Instances newdata = weka.filters.Filter.useFilter(data, remove); /* 生成一个K-Means聚类器 */ SimpleKMeans sm = new SimpleKMeans(); sm.setNumClusters(k); sm.setPreserveInstancesOrder(true); // 保持数据集实例的原始顺序 sm.setSeed(i); // 通过设置不同的种子，设置不同的簇初始中心点，从而得到不同的聚类结果 sm.buildClusterer(newdata); int[] assigm = sm.getAssignments(); // 得到数据集各个实例的赋值 /* 建立关联矩阵 */ for(int j = 0; j numinst; j++) { for(int m = j; m numinst; m++) { if(assigm[j] == assigm[m]) { association[j][m] = association[j][m] + 1.0 / numIteration ; } } } } System.out.println(); /* 将生成的关联矩阵写入.txt文件（注：生成的txt文本文件在e:/result.txt中） */ FileWriter fw = new FileWriter("e://result.txt"); for(int j = 0; j numinst; j++) { for(int m = j; m numinst; m++) { //由于关联矩阵是对称的，为了改进算法的效率，只计算矩阵的上三角 String number = String.format("%8.2f", association[j][m]); fw.write(number); } fw.write("\n"); } /* 处理关联矩阵，分别考虑了两种情况 ：1.关联矩阵中某个元素对应的两个数据点已经被划分到了不同的簇中 * 2.两个数据点中有一个或者两个都没有被划分到某个簇中。 */ int[] flag = new int[numinst]; int[] flagk = new int[k]; int[] finallabel = new int[numinst]; for(int m = 0; m numinst; m++) { for(int n = m; n numinst; n++) { if(association[m][n] THREASOD) { if(flag[m] == 0 flag[n] == 0) { // 两个数据点都没有被划分到某个簇中， int i = 0; // 将他们划分到同一个簇中即可 while (i k flagk[i] == 1) i = i + 1; finallabel[m] = i; finallabel[n] = i; flag[m] = 1; flag[n] = 1; flagk[i] = 1; } else if (flag[m] == 0 flag[n] == 1) { // 两个数据点中有一个没有被划分到某个簇中， finallabel[m] = finallabel[n]; // 将他们划分到同一个簇中即可 flag[m] = 1; } else if (flag[m] == 1 flag[n] == 0) { finallabel[n] = finallabel[m]; flag[n] = 1; } else if (flag[m] == 1 flag[n] == 1 finallabel[m] != finallabel[n]) { // 两个数据点已被划分到了不同的簇中， flagk[finallabel[n]] = 0; // 将它们所在的簇合并 int temp = finallabel[n]; for(int i = 0; i numinst; i++) { if(finallabel[i] == temp) finallabel[i] = finallabel[m]; } } } } } m_Assignments = new int[numinst]; System.out.println("基于关联矩阵的聚类融合算法——Voting-K-Means算法的最终聚类结果"); for(int i = 0; i numinst; i++) { m_Assignments[i] = finallabel[i]; System.out.print(finallabel[i] + " "); if((i+1) % 50 == 0) System.out.println(); } for(int i = 0; i k; i++) { if(flagk[i] == 1) m_NumClusters++; } } /** * return a string describing this clusterer * * @return a description of the clusterer as a string */ public String toString() { return "Voting-KMeans\n"; } public static void main(String []args) { try {String filename="e://weka-data//iris.arff"; Instances data = DataSource.read(filename); Votingkmeans2 vk = new Votingkmeans2(); vk.buildClusterer(data); /* 要生成Voting-K-Means的聚类评估结果包括准确率等需要覆盖重写toString()方法； * 因为没有覆盖重写，所以这里生产的评估结果没有具体内容。 */ ClusterEvaluation eval = new ClusterEvaluation(); eval.setClusterer(vk); eval.evaluateClusterer(new Instances(data)); System.out.println(eval.clusterResultsToString()); } catch (Exception e) { e.printStackTrace(); }}}
分析代码时注意：得到的类成员变量m_Assignments就是最终Voting-K-Means聚类结果；由于是采用了开源机器学习软件Weka中实现的SimpleKMeans聚类算法，初始时要指定簇的个数，这里是数据集大小开根号向下取整；指定的阀值为0.5，即当关联矩阵元素的值大于阀值时，才对该元素对应的两个数据点进行融合，划分到一个簇中，考虑两种情况，代码注释已有，这里不再详述。但聚类融合的实验结果并不理想，莺尾花数据集irsi.arff是数据挖掘实验中最常用的数据集，原数据集共有三个类；但本实验进行四十个聚类成员的融合，其最终聚类结果划分成两个簇；其原因可能有两个：一是算法本身的问题，需要使用其他更加优化的聚类融合算法；二是实现上的问题，主要就在聚类结果的融合上，需要进行一步对照关联矩阵进行逻辑上的分析，找出代码中的问题。关联矩阵文本文件
---------------------
本文来自 Turingkk 的CSDN 博客 ，全文地址请点击：
spark 聚类java实现 如何和前台对接
以前做项目时候写的代码，数据是一维的，多维的也一样，把距离计算的改一改就行int term = Math.abs(dotlist.get(centerIndex[j]).x- dotlist.get(i).x);
[java] view plaincopy
package uestc.dmlab.call;
import java.io.BufferedReader;
import java.io.FileReader;
import java.security.KeyStore.Entry;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class Clustering {
/**
*
* @param fileName
* 文件中每个字段对应一个概率
* @param k
* 聚成k个类
* @param minDistance
* 聚类中心位移小于minDistance时停止迭代
* @return
*/
public static HashMapString, Integer cluster(String fileName, int k,
int minDistance) {
try {
BufferedReader br = new BufferedReader(new FileReader(fileName));
ListDot dotlist = new LinkedListDot();
String line;
int count = 0;// 行数
while ((line = br.readLine()) != null) {
String s[] = line.split(",");
Dot dot = new Dot();
dot.isCenter = false;
dot.isVirtual = false;
dot.name = s[0];
// if(s.length4){
// System.out.println(line);
// }
dot.x = Integer.parseInt(s[3]);
dotlist.add(dot);
count++;
}
if (count k) {
k = count;
}
// 随机初始化k个聚类中心
int centerIndex[] = new int[k]; // 存储k个中心点在dotlist中的索引
int centerNum = k;
while (centerNum 0) {
int index = new Random().nextInt(count);
if (!dotlist.get(index).isCenter) {
centerNum--;
dotlist.get(index).isCenter = true;
centerIndex[centerNum] = index;
}
}
// K个聚类
Cluster[] clusers = new Cluster[k];
boolean flag = true;
while (flag) {
flag = false;
clusers = new Cluster[k];
for (int i = 0; i clusers.length; i++) {
clusers[i] = new Cluster();
}
//System.out.println(clusers.length);
// 找到离第i个点最近的聚类中心
for (int i = 0; i dotlist.size(); i++) {
// 该点不是中心点也不是虚拟点就计算它与所有中心点的距离并取最小值
// if(!dotlist.get(i).isCenter!dotlist.get(i).isVirtual){
if (!dotlist.get(i).isVirtual) {
int distance = Integer.MAX_VALUE;
int c = 0;// 记录离该节点最近的中心点的索引
for (int j = 0; j k; j++) {
int term = Math.abs(dotlist.get(centerIndex[j]).x
- dotlist.get(i).x);
if (distance term) {
distance = term;
c = j;
}
}
clusers[c].dots.add(i);
}
}
// 重新计算聚类中心
for (int i = 0; i k; i++) {
Cluster cluster = clusers[i];
if (cluster.dots.size() 0) { //若该类中有点
int sum = 0;
for (int j = 0; j cluster.dots.size(); j++) {
sum += dotlist.get(cluster.dots.get(j)).x;
}
Dot dot = new Dot();
dot.x = sum / cluster.dots.size();
dot.isCenter = true;
dot.isVirtual = true;
// 新旧聚类中心的距离
int term = Math.abs(dotlist.get(centerIndex[i]).x
- dot.x);
if (term minDistance)
flag = true;
dotlist.add(dot);
centerIndex[i] = dotlist.indexOf(dot); // 第i个聚类的中心改变
}
}
}
// 生成分类映射
HashMapString, Integer map = new HashMapString, Integer();
for (Dot dot : dotlist) {
if (dot.isVirtual == false) {
int className = -1;
for (int i = 0; i k; i++) {
if (clusers[i].dots.contains(dotlist.indexOf(dot)))
className = i;
}
map.put(dot.name, className);
}
}
return map;
} catch (Exception e) {
e.printStackTrace();
}
return new HashMapString, Integer();
}
public static void main(String[] args) {
MapString, Integer map = Clustering.cluster(
"C:/Documents and Settings/Administrator/桌面/123.txt", 2, 0);
IteratorMap.EntryString, Integer it = map.entrySet().iterator();
while(it.hasNext()){
Map.EntryString, Integer entry = it.next();
System.out.println(entry.getKey()+","+entry.getValue());
}
}
}
class Dot {
String name;
int x;
boolean isCenter;
boolean isVirtual;
}
class Cluster {
// 记录了该类中点的索引值
LinkedListInteger dots = new LinkedListInteger();
当前名称：聚类分析java代码 聚类分析代码 python
分享路径：http://shouzuofang.com/article/ddiceoj.html