K-Means算法的代码实现（Java）

 

K-Means算法的代码实现（Java）  

2013-03-02 20:28:41|  分类： 数据挖掘 |  标签： |举报 |字号大中小 订阅

//package cn.edu.pku.ss.dm.cluster;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

 

//K-means算法实现

 

public class KMeans {

    //聚类的数目

    final static int ClassCount = 3;

    //样本数目（测试集）

    final static int InstanceNumber = 150; 

    //样本属性数目（测试）

    final static int FieldCount = 5;

   

    //设置异常点阈值参数（每一类初始的最小数目为InstanceNumber/ClassCount^t）

    final static double t = 2.0;

    //存放数据的矩阵

    private float[][] data;

   

    //每个类的均值中心

    private float[][] classData;

   

    //噪声集合索引

    private ArrayList<Integer> noises;

   

    //存放每次变换结果的矩阵

    private ArrayList<ArrayList<Integer>> result;

   

    //构造函数，初始化

    public KMeans()

    {

   //最后一位用来储存结果

   data = new float[InstanceNumber][FieldCount+1];

   classData = new float[ClassCount][FieldCount];

   result = new ArrayList<ArrayList<Integer>>(ClassCount);

   noises = new ArrayList<Integer>();

  

    }

   

 

   /**

    * 主函数入口

    * 测试集的文件名称为“测试集.data”,其中有1000*57大小的数据

    * 每一行为一个样本，有57个属性

    * 主要分为两个步骤

    * 1.读取数据

    * 2.进行聚类

    * 最后统计运行时间和消耗的内存

    * @param args

    */

   public static void main(String[] args) {

      // TODO Auto-generated method stub

       long startTime = System.currentTimeMillis();

       KMeans cluster = new KMeans();

       //读取数据

       cluster.readData("D:/test.txt");

       //聚类过程

       cluster.cluster();

       //输出结果

       cluster.printResult("clusterResult.data");

       long endTime = System.currentTimeMillis();

       System.out.println("Total Time:"+ (endTime - startTime)/1000+"s");

       System.out.println("Memory Consuming:"+(float)(Runtime.getRuntime().totalMemory() -

          Runtime.getRuntime().freeMemory())/1000000 + "MB");

   }

        /*

         * 读取测试集的数据

         *

         * @param trainingFileName 测试集文件名

         */

   public void readData(String trainingFileName)

   {

       try

       {

      FileReader fr = new FileReader(trainingFileName);

      BufferedReader br = new BufferedReader(fr);

      //存放数据的临时变量

      String lineData = null;

      String[] splitData = null;

      int line = 0;

      //按行读取

      while(br.ready())

      {

          //得到原始的字符串

          lineData = br.readLine();

          splitData = lineData.split(",");

          //转化为数据

//        System.out.println("length:"+splitData.length);

          if(splitData.length>1)

          {

             for(int i = 0;i < splitData.length;i++)

             {

//              System.out.println(splitData[i]);

//              System.out.println(splitData[i].getClass());

                if(splitData[i].startsWith("Iris-setosa"))

                {

                   data[line][i] = (float) 1.0;

                }

                else if(splitData[i].startsWith("Iris-versicolor"))

                {

                   data[line][i] = (float) 2.0;

                }

                else if(splitData[i].startsWith("Iris-virginica"))

                {

                   data[line][i] = (float) 3.0;

                }

                else

                {   //将数据截取之后放进数组

                   data[line][i] = Float.parseFloat(splitData[i]);

                }

             }

             line++;

          }

      }

      System.out.println(line);

       }catch(IOException e)

       {

      e.printStackTrace();

       }

   }

   /*

    * 聚类过程，主要分为两步

    * 1.循环找初始点

    * 2.不断调整直到分类不再发生变化

    */

   public void cluster()

   {

       //数据归一化

       normalize();

       //标记是否需要重新找初始点

       boolean needUpdataInitials = true;

      

       //找初始点的迭代次数

       int times = 1;

       //找初始点

       while(needUpdataInitials)

       {

      needUpdataInitials = false;

      result.clear();

      System.out.println("Find Initials Iteration"+(times++)+"time(s)");

     

      //一次找初始点的尝试和根据初始点的分类

      findInitials();

      firstClassify();

     

      //如果某个分类的数目小于特定的阈值，则认为这个分类中的所有样本都是噪声点

      //需要重新找初始点

      for(int i = 0;i < result.size();i++)

      {

          if(result.get(i).size() < InstanceNumber/Math.pow(ClassCount,t))

          {

         needUpdataInitials = true;

         noises.addAll(result.get(i));

          }

      }

       }

      

       //找到合适的初始点后

       //不断的调整均值中心和分类，直到不再发生任何变化

       Adjust();

   }

  

   /*

    * 对数据进行归一化

    * 1.找每一个属性的最大值

    * 2.对某个样本的每个属性除以其最大值

    */

   public void normalize()

   {

       //找最大值

       float[] max = new float[FieldCount];

       for(int i = 0;i < InstanceNumber;i++)

       {

      for(int j = 0;j < FieldCount;j++)

      {

          if(data[i][j] > max[j])

         max[j] = data[i][j];

      }

       }

      

       //归一化

       for(int i = 0;i < InstanceNumber;i++)

       {

      for(int j = 0;j < FieldCount;j++)

      {

          data[i][j] = data[i][j]/max[j];

      }

       }

   }

  

   //关于初始向量的一次找寻尝试

   public void findInitials()

   {

       //a,b为标志距离最远的两个向量的索引

       int i,j,a,b;

       i = j = a = b = 0;

      

       //最远距离

       float maxDis = 0;

      

       //已经找到的初始点个数

       int alreadyCls = 2;

      

       //存放已经标记为初始点的向量索引

       ArrayList<Integer> initials = new ArrayList<Integer>();

      

       //从两个开始

       for(;i < InstanceNumber;i++)

       {

      //噪声点

      if(noises.contains(i))

          continue;

      //long startTime = System.currentTimeMillis();

      j = i + 1;

      for(;j < InstanceNumber;j++)

      {

          //噪声点

          if(noises.contains(j))

         continue;

          //找出最大的距离并记录下来

          float newDis = calDis(data[i],data[j]);

          if(maxDis < newDis)

          {

         a = i;

         b = j;

         maxDis = newDis;

          }

      }

      //long endTime = System.currentTimeMillis();

      //System.out.println(i + "Vector Caculation Time:"+(endTime-startTime)+"ms");

       }

      

       //将前两个初始点记录下来

       initials.add(a);

       initials.add(b);

       classData[0] = data[a];

       classData[1] = data[b];

      

       //在结果中新建存放某样本索引的对象，并把初始点添加进去

       ArrayList<Integer> resultOne = new ArrayList<Integer>();

       ArrayList<Integer> resultTwo = new ArrayList<Integer>();

       resultOne.add(a);

       resultTwo.add(b);

       result.add(resultOne);

       result.add(resultTwo);

      

       //找到剩余的几个初始点

       while(alreadyCls < ClassCount)

       {

      i = j = 0;

      float maxMin = 0;

      int newClass = -1;

     

      //找最小值中的最大值

      for(;i < InstanceNumber;i++)

      {

          float min = 0;

          float newMin = 0;

          //找和已有类的最小值

          if(initials.contains(i))

         continue;

          //噪声点去除

          if(noises.contains(i))

         continue;

          for(j = 0;j < alreadyCls;j++)

          {

         newMin = calDis(data[i],classData[j]);

         if(min == 0 || newMin < min)

             min = newMin;

          }

         

          //新最小距离较大

          if(min > maxMin)

          {

         maxMin = min;

         newClass = i;

          }

      }

      //添加到均值集合和结果集合中

      //System.out.println("NewClass"+newClass);

      initials.add(newClass);

      classData[alreadyCls++] = data[newClass];

      ArrayList<Integer> rslt = new ArrayList<Integer>();

      rslt.add(newClass);

      result.add(rslt);

       }

   }

  

   //第一次分类

   public void firstClassify()

   {

       //根据初始向量分类

       for(int i = 0;i < InstanceNumber;i++)

       {

      float min = 0f;

      int clsId = -1;

      for(int j = 0;j < classData.length;j++)

      {

          //欧式距离

          float newMin = calDis(classData[j],data[i]);

          if(clsId == -1 || newMin <min)

          {

         clsId = j;

         min = newMin;

          }

         

      }

      //本身不再添加

      if(!result.get(clsId).contains(i))

          result.get(clsId).add(i);

       }

   }

   //迭代分类，直到各个类的数据不再变化

   public void Adjust()

   {

       //记录是否发生变化

       boolean change = true;

      

       //循环的次数

       int times = 1;

       while(change)

       {

      //复位

      change = false;

      System.out.println("Adjust Iteration"+(times++)+"time(s)");

                   

      //重新计算每个类的均值 

      for(int i = 0;i < ClassCount; i++){ 

      //原有的数据 

      ArrayList<Integer> cls = result.get(i); 

       

      //新的均值 

      float[] newMean = new float[FieldCount ]; 

       

      //计算均值 

      for(Integer index:cls){ 

       for(int j = 0;j < FieldCount ;j++) 

              newMean[j] += data[index][j]; 

       } 

      for(int j = 0;j < FieldCount ;j++) 

         newMean[j] /= cls.size(); 

      if(!compareMean(newMean, classData[i])){ 

         classData[i] = newMean; 

           change = true; 

           } 

      } 

      //清空之前的数据 

      for(ArrayList<Integer> cls:result) 

       cls.clear(); 

        

      //重新分配 

      for(int i = 0;i < InstanceNumber;i++) 

      { 

       float min = 0f; 

       int clsId = -1; 

       for(int j = 0;j < classData.length;j++){ 

        float newMin = calDis(classData[j], data[i]); 

       if(clsId == -1 || newMin < min){ 

         clsId = j; 

           min = newMin; 

               } 

                 } 

                   data[i][FieldCount] = clsId; 

                    result.get(clsId).add(i); 

              } 

                 

         //测试聚类效果(训练集) 

      //          for(int i = 0;i < ClassCount;i++){ 

      //              int positives = 0; 

      //              int negatives = 0; 

      //              ArrayList<Integer> cls = result.get(i); 

      //              for(Integer instance:cls) 

      //                  if (data[instance][FieldCount - 1] == 1f) 

      //                      positives ++; 

      //                  else 

      //                      negatives ++; 

      //              System.out.println(" " + i + " Positive: " + positives + " Negatives: " + negatives); 

      //          } 

      //          System.out.println(); 

       }

               

               

   } 

          

         /**

           * 计算a样本和b样本的欧式距离作为不相似度

           * 

           * @param a     样本a

           * @param b     样本b

           * @return      欧式距离长度

           */ 

   private float calDis(float[] aVector,float[] bVector)  {

      double dis = 0;

      int i = 0;

               /*最后一个数据在训练集中为结果，所以不考虑  */

                for(;i < aVector.length;i++)

                     dis += Math.pow(bVector[i] - aVector[i],2); 

                dis = Math.pow(dis, 0.5); 

                return (float)dis; 

   }

         

        /**

         * 判断两个均值向量是否相等

         * 

         * @param a 向量a

              * @param b 向量b

         * @return

         */ 

       private boolean compareMean(float[] a,float[] b) 

       { 

             if(a.length != b.length) 

               return false; 

             for(int i =0;i < a.length;i++){ 

             if(a[i] > 0 &&b[i] > 0&& a[i] != b[i]){ 

                  return false; 

                }    

            } 

              return true; 

        } 

          

        /**

         * 将结果输出到一个文件中

         * 

              * @param fileName

              */ 

         public void printResult(String fileName) 

       { 

       FileWriter fw = null; 

            BufferedWriter bw = null; 

            try { 

                  fw = new FileWriter(fileName); 

               bw = new BufferedWriter(fw); 

              //写入文件 

               for(int i = 0;i < InstanceNumber;i++) 

               { 

                  bw.write(String.valueOf(data[i][FieldCount]).substring(0, 1)); 

                   bw.newLine(); 

                } 

               

               //统计每类的数目，打印到控制台 

               for(int i = 0;i < ClassCount;i++) 

             { 

                     System.out.println("第" + (i+1) + "类数目: " + result.get(i).size()); 

              } 

         } catch (IOException e) { 

             e.printStackTrace(); 

           } finally{ 

                 

               //关闭资源 

             if(bw != null) 

                   try { 

                     bw.close(); 

                   } catch (IOException e) { 

                       e.printStackTrace(); 

                  } 

               if(fw != null) 

                    try { 

                        fw.close(); 

                   } catch (IOException e) { 

                         e.printStackTrace(); 

                    } 

             } 

             

        } 

      }