机器学习系列--kmeans分类算法

简介

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

 

算法

核心思想

通过迭代寻找k个类簇的一种划分方案，使得用这k个类簇的均值来代表相应各类样本时所得的总体误差最小。

k个聚类具有以下特点：各聚类本身尽可能的紧凑，而各聚类之间尽可能的分开。k-means算法的基础是最小误差平方和准则

 

步骤

将样本聚类成k个簇，其中k是用户给定的，其求解过程非常直观简单

1.随机选取k个聚类质心点

2.重复下面过程直到收敛

对于每一个样例 i，计算其应该属于的类

 

对于每一个类 j，重新计算该类的质心

 

伪代码

1.创建k个点作为初始的质心点（随机选择）

2.当任意一个点的簇分配结果发生改变时

对数据集中的每一个数据点
              对每一个质心
                     计算质心与数据点的距离
              将数据点分配到距离最近的簇(分组)
对每一个簇，计算簇中所有点的均值，并将均值作为质心 （新的均值等于原均值时候跳出迭代输出划分）

 

特点

各聚类本身尽可能的紧凑，而各聚类之间尽可能的分开

 k-means算法的基础是最小误差平方和准则

μc(i)表示第i个聚类的均值

各类簇内的样本越相似，其与该类均值间的误差平方越小，对所有类所得到的误差平方求和，即可验证分为k类时，各聚类是否是最优的。

 

代码

spark2

Scala2.11

1.原生sparkcore

object KmeansTest {
    val k=2  //类个数
    val dim=2   //数据集维度
    val shold=0.0000000001  //阀值用于判断聚类中心偏移量
    val centers=new Array[Vector[Double]](k)    //聚类中心点（迭代更新）
    /**
      * 数据
      * 1.658985, 4.285136
      * -3.453687, 3.424321
      * 4.838138, -1.151539
      * -5.379713, -3.362104
      *
      * @param sc
      * @return
      */
    def loadDataSet(sc:SparkContext): Array[Vector[Double]] ={
        val file = sc.textFile("")
        val res=file.map(t=>{
            val value=t.split(" ").map(x=>{x.toDouble})
            var vector = Vector[Double]()
            for(i <- 0 until dim)
                vector ++= Vector(value(i))
            vector
        }).collect()
        res
    }

    /**
      *
      * 随机初始化聚类中心
      * k个聚类中心
      * 初始化中心点如下：
        3
        Vector(-5.379713, -3.362104)
       初始化中心点如下：
        4
        Vector(0.972564, 2.924086)
      * */
    def initialCenters(points:Array[Vector[Double]]): Unit ={
        val pointsNum=points.length
        val random = new Random()
        var index=0
        var flag=true
        var temp=0
        val array=new ListBuffer[Int]
        while(index < k){
            val temp: Int = random.nextInt(pointsNum)
            flag=true
            if(array.contains(temp)){
                flag=false
            }else{
                if(flag){
                    array.append(temp)
                    index+=1
                }
            }
        }

        for(i <- centers.indices){
            centers(i)=points(array(i))
            println("初始化中心点如下：")
            println(array(i))
            println(centers(i))
        }
    }

    /**
      * 迭代做聚类
      * @param points 随机下标
      * @param centers 中心点
      */
    def kmeans(points:Array[Vector[Double]],centers:Array[Vector[Double]]): Unit  = {
        var bool = true
        var newCenters = Array[Vector[Double]]()
        var move = 0.0
        var currentCost = 0.0 //当前的代价函数值
        var newCost = 0.0
        //根据每个样本点最近的聚类中心进行groupBy分组，最后得到的cluster是Map[Vector[Double],Array[Vector[Double]]]
        //Map中的key就是聚类中心，value就是依赖于该聚类中心的点集
        while(bool){//迭代更新聚类中心，直到最优
            move = 0.0
            //
            currentCost = computeCost(points,centers)
            val cluster = points.groupBy(v => closestCenter(centers,v))//聚类中心
            newCenters =
              centers.map(oldCenter => {
                  cluster.get(oldCenter) match {//找到该聚类中心所拥有的点集
                      case Some(pointsInThisCluster) =>
                          //均值作为新的聚类中心
                          vectorDivide(pointsInThisCluster.reduceLeft((v1,v2) => vectorAdd(v1,v2)),pointsInThisCluster.length)
                      case None => oldCenter
                  }
              })
            for(i <- centers.indices){
                //move += math.sqrt(vectorDis(newCenters(i),centers(i)))
                centers(i) = newCenters(i)
            }
            println("新的代价函数值：" + newCost)
            if(math.sqrt(vectorDis(Vector(currentCost),Vector(newCost))) < shold)
                bool = false
            newCost = computeCost(points,centers)//新的代价函数值
            println("当前代价函数值：" + currentCost)
        }//while-end
        println("寻找到的最优中心点如下：")
        for(i <- centers.indices){
            println(centers(i))
        }
    }
    /**
      * 输出聚类结果
      * @param points
      * @param centers
      */
    def printResult(points:Array[Vector[Double]],centers:Array[Vector[Double]]): Unit  = {
        //将每个点的聚类中心用centers中的下标表示，属于同一类的点拥有相同的下标
        val pointsNum = points.length
        val pointsLabel = new Array[Int](pointsNum)
        var closetCenter = Vector[Double]()
        println("聚类结果如下：")
        for(i <- 0 until pointsNum){
            closetCenter = centers.reduceLeft((c1,c2) => if (vectorDis(c1,points(i)) < vectorDis(c2,points(i))) c1 else c2)
            pointsLabel(i) = centers.indexOf(closetCenter)
            println(points(i) + "-----------" + pointsLabel(i))
        }

    }

    /**
      * 找到某样本点所属的聚类中心
      * @param centers
      * @param v
      * @return
      */
    def closestCenter(centers:Array[Vector[Double]],v:Vector[Double]):Vector[Double] = {
        centers.reduceLeft((c1,c2) =>
            if(vectorDis(c1,v) < vectorDis(c2,v)) c1 else c2
        )
    }
    /**
      * 计算代价函数（每个样本点到聚类中心的距离之和不再有很大变化）
      * @param points
      * @param centers
      * @return
      */
    def computeCost(points:Array[Vector[Double]],centers:Array[Vector[Double]]):Double = {
        //cluster:Map[Vector[Double],Array[Vector[Double]]
        //类分组
        val cluster = points.groupBy(v => closestCenter(centers,v))
        //欧式距离
        var costSum = 0.0

        for(i <- centers.indices){
            println(cluster.get(centers(i)).toBuffer)
            cluster.get(centers(i)) match{
                case Some(subSets) =>
                    for(j <- subSets.indices){
                        costSum += (vectorDis(centers(i),subSets(j)) * vectorDis(centers(i),subSets(j)))
                    }
                case None => costSum = costSum
            }
        }
        costSum
    }
    //--------------------------自定义向量间的运算-----------------------------
    //--------------------------向量间的欧式距离-----------------------------
    def vectorDis(v1: Vector[Double], v2: Vector[Double]):Double = {
        var distance = 0.0
        for(i <- v1.indices){
            distance += (v1(i) - v2(i)) * (v1(i) - v2(i))
        }
        distance = math.sqrt(distance)
        distance
    }
    //--------------------------向量加法-----------------------------
    def vectorAdd(v1:Vector[Double],v2:Vector[Double]):Vector[Double] = {
        var v3 = v1
        for(i <-  v1.indices){
            v3 = v3.updated(i,v1(i) + v2(i))
        }
        v3
    }
    //--------------------------向量除法-----------------------------
    def vectorDivide(v:Vector[Double],num:Int):Vector[Double] = {
        var r = v
        for(i <- v.indices){
            r = r.updated(i,r(i) / num)
        }
        r
    }

    def main(args: Array[String]): Unit = {
        val sparkConf = new SparkConf().setMaster("local[2]").setAppName("KmeansTest")
        val sc=new SparkContext(sparkConf)
        val rows=loadDataSet(sc)
        //ArrayBuffer(Vector(1.658985, 4.285136), Vector(-3.453687, 3.424321),
        // Vector(4.838138, -1.151539), Vector(-5.379713, -3.362104))
        initialCenters(rows)

        /**
          * 寻找到的最优中心点如下：
            Vector(-2.3914716666666664, 1.4491176666666667)
            Vector(4.838138, -1.151539)
            聚类结果如下：
            Vector(1.658985, 4.285136)-----------0
            Vector(-3.453687, 3.424321)-----------0
            Vector(4.838138, -1.151539)-----------1
            Vector(-5.379713, -3.362104)-----------0
          */
        kmeans(rows,centers)
        printResult(rows,centers)
    }
}

 

2.sparkmllib

object KmeansTest2 {
  def main(args: Array[String]): Unit = {
    val sparkConf=new SparkConf().setAppName("KmeansTest2").setMaster("local[2]")
    val sc=new SparkContext(sparkConf)

    val data=sc.textFile("")

    val parsedData=data.map(s=>Vectors.dense(s.split(" ").map(_.toDouble)))

    val numClusters=2
    val numIterations=30
    val model=KMeans.train(parsedData,numClusters,numIterations)

    // 数据模型的中心点
    println("Cluster centres:")
    for(c <- model.clusterCenters) {
      println("  " + c.toString)
    }

    // 使用误差平方之和来评估数据模型
    val cost = model.computeCost(parsedData)
    println("Within Set Sum of Squared Errors = " + cost)

    // 使用模型测试单点数据
    /*println("Vectors 7.3 1.5 10.9 is belong to cluster:" + model.predict(Vectors.dense("1.5 10.9".split(" ")
      .map(_.toDouble))))
    println("Vectors 4.2 11.2 2.7 is belong to cluster:" + model.predict(Vectors.dense("11.2 2.7".split(" ")
      .map(_.toDouble))))
    println("Vectors 18.0 4.5 3.8 is belong to cluster:" + model.predict(Vectors.dense("14.5 73.8".split(" ")
      .map(_.toDouble))))*/

    // 返回数据集和结果
    val result = data.map {
      line =>
        val linevectore = Vectors.dense(line.split(" ").map(_.toDouble))
        val prediction = model.predict(linevectore)
        line + " " + prediction
    }.collect.foreach(println)

    sc.stop

  }
}