机器学习系列--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

  }

}