数据挖掘 k-means离群点检测

k-means离群点检测

改写一种简单的半监督方法，用于离群点检测。使用一种你熟悉的程序设计语言，如C++或Java，实现该方法，并在两种不同的数据集上进行讨论（1）只有一些被标记的正常对象；（2）只有一些被标记的离群点实例。

一、数据集介绍

1、Iris数据集介绍

iris以鸢尾花的特征作为数据来源，数据集包含150个数据集，分为3类，每类50个数据，每个数据包含4个属性，是在数据挖掘、数据分类中非常常用的测试集、训练集。

三类分别为:setosa, versicolor, virginica。

数据包含4个独立的属性,这些属性变量测量植物的花朵,比如萼片和花瓣的长度等。

2、wine数据集介绍

这份数据集包含来自3种不同起源的葡萄酒的共178条记录。13个属性是葡萄酒的13种化学成分。通过化学分析可以来推断葡萄酒的起源。值得一提的是所有属性变量都是连续变量。数据集特征：多变量；记录数：178；领域：物理；属性特征：整数，实数；属性数目：13。

3、abalone数据集介绍

采用UCI数据集中的abalone数据集进行测试。该数据集包括涉及生活领域的8个类别的4177个数据对象，其中含有1个分类型属性，1个整数型属性和6个实数型属性。分类属性数据对象中含有1528个记录为F(父)值，1307个记录为M(母)值，还有1342个记录为I(未成年人)值。

二、算法描述

K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成的，因此把得到紧凑且独立的簇作为最终目标。

2.1算法思路

K-means算法

先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都被分配了，每个聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是以下任何一个：

1)没有（或最小数目）对象被重新分配给不同的聚类。

2)没有（或最小数目）聚类中心再发生变化。

3)误差平方和局部最小。

2.2算法步骤

a.从数据集中随机挑K个数据当簇心；

b.对数据中的所有点求到这K个簇心的距离，假如点Pi离簇心Si最近，那么Pi属于Si对应的簇；

c.根据每个簇的数据，更新簇心，使得簇心位于簇的中心；

d.重复步骤e和步骤f，直到簇心不再移动（或其他条件，如前后两次距离和不超过特定值），继续下一步；

e.计算每个簇的正常半径，即阀值（此程序阀值为每个簇的平均距离与1.5倍标准差之和）；

f.从每个簇中，找出大于阀值的点，即离群点。

三、java 实现

package kmeans;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Kmeans {

/**
* @param args
* @throws IOException
*/

public static List<ArrayList<ArrayList<Double>>>
initHelpCenterList(List<ArrayList<ArrayList<Double>>> helpCenterList,int k){
for(int i=0;i<k;i++){
helpCenterList.add(new ArrayList<ArrayList<Double>>());
}
return helpCenterList;
}

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException{

List<ArrayList<Double>> centers = new ArrayList<ArrayList<Double>>();
List<ArrayList<Double>> newCenters = new ArrayList<ArrayList<Double>>();
List<ArrayList<ArrayList<Double>>> helpCenterList = new ArrayList<ArrayList<ArrayList<Double>>>();

//读入原始数据
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("src/datafile/abaloneNoLabel.data")));
String data = null;
List<ArrayList<Double>> dataList = new ArrayList<ArrayList<Double>>();
while((data=br.readLine())!=null){
//System.out.println(data);
String []fields = data.split(",");
List<Double> tmpList = new ArrayList<Double>();
for(int i=0; i<fields.length;i++)
tmpList.add(Double.parseDouble(fields[i]));
dataList.add((ArrayList<Double>) tmpList);
}
br.close();

//随机确定K个初始聚类中心
Random rd = new Random();
int k=3;
int [] initIndex={59,71,48};
int [] helpIndex = {0,59,130};
int [] givenIndex = {0,1,2};
System.out.println("random centers' index");
for(int i=0;i<k;i++){
int index = rd.nextInt(initIndex[i]) + helpIndex[i];

4000
//int index = givenIndex[i];
System.out.println("index "+index);
centers.add(dataList.get(index));
helpCenterList.add(new ArrayList<ArrayList<Double>>());
}

/*
//注释掉的这部分目的是，取测试数据集最后稳定的三个类簇的聚类中心作为初始聚类中心
centers = new ArrayList<ArrayList<Double>>();
for(int i=0;i<59;i++)
helpCenterList.get(0).add(dataList.get(i));
for(int i=59;i<130;i++)
helpCenterList.get(1).add(dataList.get(i));
for(int i=130;i<178;i++)
helpCenterList.get(2).add(dataList.get(i));
for(int i=0;i<k;i++){

ArrayList<Double> tmp = new ArrayList<Double>();

for(int j=0;j<dataList.get(0).size();j++){
double sum=0;
for(int t=0;t<helpCenterList.get(i).size();t++)
sum+=helpCenterList.get(i).get(t).get(j);
tmp.add(sum/helpCenterList.get(i).size());
}
centers.add(tmp);
}
*/

//输出k个初始中心
System.out.println("original centers:");
for(int i=0;i<k;i++)
System.out.println(centers.get(i));

while(true)
{//进行若干次迭代，直到聚类中心稳定

for(int i=0;i<dataList.size();i++){//标注每一条记录所属于的中心
double minDistance=99999999;
int centerIndex=-1;
for(int j=0;j<k;j++){//离0~k之间哪个中心最近
double currentDistance=0;
for(int t=1;t<centers.get(0).size();t++){//计算两点之间的欧式距离
currentDistance +=  ((centers.get(j).get(t)-dataList.get(i).get(t))/(centers.get(j).get(t)+dataList.get(i).get(t))) * ((centers.get(j).get(t)-dataList.get(i).get(t))/(centers.get(j).get(t)+dataList.get(i).get(t)));
}
if(minDistance>currentDistance){
minDistance=currentDistance;
centerIndex=j;
}
}
helpCenterList.get(centerIndex).add(dataList.get(i));
}

//  System.out.println(helpCenterList);

//计算新的k个聚类中心
for(int i=0;i<k;i++){

ArrayList<Double> tmp = new ArrayList<Double>();

for(int j=0;j<centers.get(0).size();j++){
double sum=0;
for(int t=0;t<helpCenterList.get(i).size();t++)
sum+=helpCenterList.get(i).get(t).get(j);
tmp.add(sum/helpCenterList.get(i).size());
}

newCenters.add(tmp);

}
System.out.println("\nnew clusters' centers:\n");
for(int i=0;i<k;i++)
System.out.println(newCenters.get(i));
//计算新旧中心之间的距离，当距离小于阈值时，聚类算法结束
double distance=0;

for(int i=0;i<k;i++){
for(int j=1;j<centers.get(0).size();j++){//计算两点之间的欧式距离
distance += ((centers.get(i).get(j)-newCenters.get(i).get(j))/(centers.get(i).get(j)+newCenters.get(i).get(j))) * ((centers.get(i).get(j)-newCenters.get(i).get(j))/(centers.get(i).get(j)+newCenters.get(i).get(j)));
}
//System.out.println(i+" "+distance);
}
System.out.println("\ndistance: "+distance+"\n\n");
if(distance==0)//小于阈值时，结束循环
break;
else//否则，新的中心来代替旧的中心，进行下一轮迭代
{
centers = new ArrayList<ArrayList<Double>>(newCenters);
//System.out.println(newCenters);
newCenters = new ArrayList<ArrayList<Double>>();
helpCenterList = new ArrayList<ArrayList<ArrayList<Double>>>();
helpCenterList=initHelpCenterList(helpCenterList,k);
}
}
//输出最后聚类结果
for(int i=0;i<k;i++){
System.out.println("\n\nCluster: "+(i+1)+"   size: "+helpCenterList.get(i).size()+" :\n\n");
for(int j=0;j<helpCenterList.get(i).size();j++)
{
//  System.out.println(helpCenterList.get(i).get(j));
}
}
int dataSetLength=dataList.size();
double[][] distance = new double[k][dataSetLength];
double[] distanceSum=new double[k];
for(int j=0;j<k;j++)
{
for (int i = 0; i < helpCenterList.get(j).size(); i++) {

distance[j][i] = distance(helpCenterList.get(j).get(i), centers.get(j));
distanceSum[j]+= distance[j][i];
}
//每个簇的平均距离
distanceSum[j]/= helpCenterList.get(j).size();
System.err.println(distanceSum[j]);
double radius=distanceSum[j]+1.5*Standardlizerdistance(distance[j],distanceSum[j]);
System.err.println("\n\nCluster: "+(j+1)+" 每个簇的正常半径，即阀值（此程序阀值为每个簇的平均距离与1.5倍标准差之和为： "+radius);
for(int i=0;i<helpCenterList.get(j).size();i++)
{
if(distance[j][i]>radius)
{
System.err.println(helpCenterList.get(j).get(i)+"离群 "+distance[j][i]);
}
//                  else
//                      System.out.println(helpCenterList.get(j).get(i)+"正常半径： "+distance[j][i]);
}

}

}
private static double distance(ArrayList<Double> element, ArrayList<Double> center) {
double currentDistance=0;

for(int t=1;t<element.size();t++){//计算两点之间的欧式距离
currentDistance +=  (element.get(t)-center.get(t))*(element.get(t)-center.get(t));
}

return Math.sqrt(currentDistance);
}
private static double Standardlizerdistance(double[] distance, double x) {
double currentDistance=0;

for(int t=1;t<distance.length;t++){//计算两点之间的欧式距离
currentDistance +=  (distance[t]-x)*(distance[t]-x);
}

return Math.sqrt(currentDistance/distance.length);
}
}