代码是在weka上二次开发的,但没有使用原来的kmeans代码,只是用了它的数据类Intances,先说下与它相关的几点东西。
一、KMeans算法简介
输入:聚类个数k,以及包含 n个数据对象的数据库。
输出:满足方差最小标准的k个聚类。
处理流程:
(1)从 n个数据对象任意选择 k 个对象作为初始聚类中心.
(2)根据每个聚类对象的均值(中心对象),计算每个对象与这些中心对象的距离;并根据最小距离重新对相应对象进行划分;
(3)重新计算每个(有变化)的聚类的均值。
(4)重复(2)(3),直到聚类不发生改变。
划分为 k个聚类以便使得所获得的聚类满足:同一聚类中的对象相似度较高;而不同聚类中的对象相似度较小。聚类相似度是利用各聚类中对象的均值所获得一个“中心对象”(引力中心)来进行计算的。
k-means 算法的工作过程说明如下:首先从n个数据对象任意选择 k 个对象作为初始聚类中心;而对于所剩下其它对象,则根据它们与这些聚类中心的相似度(距离),分别将它们分配给与其最相似的(聚类中心所代表的)聚类;然后再计算每个所获新聚类的聚类中心(该聚类中所有对象的均值);不断重复这一过程直到标准测度函数开始收敛为止。一般都采用均方差作为标准测度函数. k个聚类具有以下特点:各聚类本身尽可能的紧凑,而各聚类之间尽可能的分开。
二、weka相关介绍
1、Instances
Instances是数据集类,是样本或实例的集合。
Instances有个数据头header,包含除了样本Instance之外的信息,比如attributes的信息。
//data是Instances类型
Instances ins = new Instances(data, 0);
//用data的数据集信息创建一个新的Instances类,但不包含data的样本
2、Instance
Instance是一个接口,对应的是一个样本或实例。
因为不同项目中数据集是不一样的,也就不能固定Instance的具体属性,所以写成接口。在自己的项目中,应该实现这个Instance
3、Attribute
属性类,对应Instance的一列。
每个Attribute保存的是Instance这一列可取的值。
a、如果是属性是数值类型,这个Attribute就用Numeric类型表示
b、如果是String类型,这个Attribute保存了一个向量,向量的每个值是属性可以取到的String值。
所以,Attribute不保存某个Instance的某个属性状态,而是数据集Instances的某个属性的可取范围,也就是这个属性的值域。
所以,虽然Instance能get到某个Attribute,当不能直接从这个Attribute获取这个属性值。属性值可以直接从Instance获取。
//获取第i个属性的值,用String表示
instance.toString(i)
如果属性值是数值类型,可以直接获取,不用toString(i)
//获取第3个属性的值,从0开始计数。返回double
instance.value(3)
4、InstanceQuery
我的数据是在数据库中,所以我就用InstanceQuery这个类,而且可以避免我自己去实现Instance类。
可以参考下官方文档:http://weka.wikispaces.com/Use+WEKA+in+your+Java+code
首先要修改DatabaseUtils.props文档,在weka.experiment包下面。
在Eclipse IDE下没法直接修改,我用2345好压找到文件,修改了保存回去,就ok了。我连的是oracle。
主要是修改DatabaseUtils.props的这两行:
# JDBC driver (comma-separated list)
jdbcDriver=oracle.jdbc.driver.OracleDriver
# database URL
jdbcURL=jdbc:oracle:thin:@192.168.2.67:1521:orcl
然后就是在代码中写了:
public static Instances getData() throws Exception {
InstanceQuery query = getQuery();
String sql = "..............................................................";
Instances data = query.retrieveInstances(sql);
if (data.numInstances() <= 0)
throw new Exception("data size is 0;");
clusterCentroids = new Instances(data, numClusters);
return data;
}
public static InstanceQuery getQuery() {
InstanceQuery query = null;
try {
query = new InstanceQuery();
} catch (Exception e) {
e.printStackTrace();
}
query.setDatabaseURL("jdbc:oracle:thin:@192.168.2.67:1521:orcl");
query.setUsername("...");
query.setPassword("...");
return query;
}
三、代码
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Random;import weka.core.Instance;
import weka.core.Instances;
import weka.core.Utils;
import weka.experiment.InstanceQuery;
public class DisKmeans {
private static int numClusters = 20;
private static int maxInteration = 600;
private static Instances clusterCentroids;
private static Instances[] kmeansResult;
public static void main(String[] args) throws Exception {
Instances data = getData();
System.out.println("start");
System.out.println(data.size());
System.out.println(data.instance(1));
Instance instance = data.instance(1);
for (int i=0; i<instance.numAttributes(); i++) {
// System.out.println(instance.attribute(i).value(0));
System.out.println(instance.toString(i));
}
System.out.println("~~~~~~~~~" + instance.value(3));
getKMeansResult(data);
printClusterResult();
updateToDB();
}
/**
* 获取k个中心点
* @param data
* @return
* @throws Exception
*/
public static Instances getCentroid(Instances data) throws Exception {
System.out.println("-------------聚类中心-----------");
if (data.numInstances() == 0) {// 判断输入的数据文件是否为空。
throw new Exception("输入数据为空值!请检查数据集文件");
}
Random random = new Random(10);
int insIndex = 0;
clusterCentroids = new Instances(data, numClusters);
for (int i=data.numInstances()-1; i>=0 ; i--) {
insIndex = random.nextInt(i);//保证i不会超过数组上线
clusterCentroids.add(data.instance(insIndex));
if (clusterCentroids.numInstances() == numClusters) {
break;
}
}
// System.out.println(clusterCentroids);
printInstances(clusterCentroids);
System.out.println("-----------聚类中心结束-------------");
return clusterCentroids;
}
/**
* 根据初始中心点,对数据进行第一次聚类,结果为初始聚类结果
* @param data
* @param centroids
* @return
*/
public static Instances[] createCluster(Instances data, Instances centroids) {
Instances[] newData = new Instances[centroids.numInstances()];
for (int i=0; i<newData.length; i++) {
//初始化newData数组中的Instances实例。取data的header作为实例头,初始容量为0;
newData[i] = new Instances(data, 0);
newData[i].add(centroids.instance(i));
}
for (int i=0; i<data.numInstances(); i++) {
double[] tempDis = new double[centroids.numInstances()];
for (int j=0; j<centroids.numInstances(); j++) {
if (!equalsInstance(data.instance(i), centroids.instance(j))) { // 重写Instance的equals方法。见EqualsInstance类
// 用欧式距离计算数据中其他实例和中心点实例的距离。
tempDis[j] = computeDistance(data.instance(i),centroids.instance(j));
}
}//end for(j)
int smallIndex = Utils.minIndex(tempDis);
newData[smallIndex].add(data.instance(i));
}//end for(i)
return newData;
}
/**
* 得到cluster的中心点
* @param data
* @return
*/
public static Instance meanCentroid(Instances data) {
double sumValue = 0.0;
double avgValue = 0.0;
if (data.numInstances() <= 0) return null;
if (data.numInstances() == 1) return data.firstInstance();
Instance meanIns = data.firstInstance();
for (int i=3; i<data.numAttributes(); i++) {
for (int j=1; j<data.numInstances(); j++) {
sumValue += data.instance(j).value(i);
}
avgValue = sumValue / data.numInstances();
meanIns.setValue(data.attribute(i), avgValue);
sumValue = 0.0;
avgValue = 0.0;
}
return meanIns;
}
private static Instances updateCentroids(Instances centroids, Instance instance, int index) {
centroids.add(instance);
int temp = centroids.numInstances() - 1;
centroids.swap(index, temp);
centroids.delete(temp);
return centroids;
}
public static Instances[] getKMeansResult(Instances data) throws Exception {
System.out.println("聚类开始");
clusterCentroids = getCentroid(data);//k个中心点
kmeansResult = createCluster(data, clusterCentroids);//第一次聚类
for (int i=0; i<maxInteration; i++) {
Instances newCentroids = new Instances(clusterCentroids);
for (int j=0; j<kmeansResult.length; j++) {
Instances cluster = kmeansResult[j];
Instance tmpIns = meanCentroid(cluster);
newCentroids = updateCentroids(newCentroids, tmpIns, j);
}
System.out.println("迭代......" + (i + 1));
if (equalsInstance(newCentroids, clusterCentroids)) {
System.out.println("中心点集合不再变化!迭代次数" + (i + 1));
break;
}
clusterCentroids = newCentroids;
kmeansResult = createCluster(data, clusterCentroids);//根据中心点,重新聚类
if (i==maxInteration-2 || i==maxInteration-1) {
printInstances(clusterCentroids);
}
}
System.out.println("~~~~~~~~~聚类结束~~~~~~~~~");
printInstances(clusterCentroids);
return kmeansResult;
}
public static void printClusterResult() throws IOException {
// System.out.println("聚类结果:");
int i=0;
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("result.txt")));
for (Instances ins : kmeansResult) {
// System.out.println("cluster " + i++ + ":");
bw.append("cluster " + i++ + ":\n");
@SuppressWarnings("rawtypes")
Enumeration en = ins.enumerateInstances();
while (en.hasMoreElements()) {
// System.out.println(en.nextElement());
bw.append(en.nextElement().toString());
bw.append("\n");
}
// System.out.println();
bw.append("\n");
}
bw.flush();
bw.close();
}
public static Instances getData() throws Exception {
InstanceQuery query = getQuery();
String sql = "...................................................................";
Instances data = query.retrieveInstances(sql);
if (data.numInstances() <= 0)
throw new Exception("data size is 0;");
clusterCentroids = new Instances(data, numClusters);
return data;
}
public static InstanceQuery getQuery() {
InstanceQuery query = null;
try {
query = new InstanceQuery();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
query.setDatabaseURL("jdbc:oracle:thin:@192.168.2.67:1521:orcl");
query.setUsername("...");
query.setPassword("...");
return query;
}
private static double computeDistance(Instance in1, Instance in2) {
double dis = 0.0;
// if ( in1.toString(0).equals(in2.toString(0)) ) {
// dis += 1;
// }
// if ( in1.toString(2).equals(in2.toString(2)) ) {
// dis += 5;
// }
for (int k=3; k<in1.numAttributes(); k++) {
double dicrim = in1.value(k) - in2.value(k);
dis += dicrim*dicrim;
}
return dis;
}
private static boolean equalsInstance(Instance in1, Instance in2) {
return in1.equals(in2);
}
private static boolean equalsInstance(Instances ins1, Instances ins2) {
boolean flag = true;
if (ins1.numInstances() != ins2.numInstances()) return false;
for (int i=0; i<ins1.numInstances(); i++) {
if (computeDistance(ins1.instance(i), ins2.instance(i)) >= 0.0001) {
flag = false;
break;
}
}
return flag;
}
public static void printInstances(Instances instances) {
for (int i=0; i<instances.numInstances(); i++) {
System.out.println(instances.instance(i));
}
}
}
四、其他
1、离散变量:数据中有个有用的离散变量,不方便直接放到kmeans算法中。但一定要用,也是可以的。
2、DatabaseUtils.props文件,在jar包中不方便直接修改,而我用解压工具修改在压缩回去,虽然可行,总觉得不太好。不知道有什么更好的方法?