Spark算法初入门-KMeans篇

目录

 

聚类：

K-Means：

依赖分析

补充知识：关于本地向量(Local Vector)

高斯混合-Gaussian mixture

---

聚类：

聚类是一种无监督的学习。聚类常用于探索性分析或作为分层监督学习管道的组成部分。我们在画像系统中对用户分群用到了KMeans。

K-Means：
 

K-means是最常见的聚类算法之一，它将数据点聚类为预定义数量的聚类。该spark.mllib实现包括一个名为kemas||的k-means++方法的并行实现体。视线中包含以下参数：spark.mllib

k是所需簇的数量。注意，可以返回少于k个簇，例如，如果有少于k个不同的点要聚类

maxIterations是要于心的最大迭代次数

initializationMode指定随机初始化或通过k-means||初始化。

运行此参数自spark2.0.0之后无效   ！！！！！注意

epsilon确定我们任务k-means已收敛的距离阈值

initialModel是元祖用于初始化的可选集群中心。如果提供此参数，则仅执行一次运行。

scala的例子：
 首先导入pom依赖：
从maven官网拷贝过来的依赖需要注释掉runtime，不然不参加编译，是不能导包使用的。

具体runtime和其它的意思参见这篇文章-csdn网友-ningbohezhijun-maven scope runtime

 <!--https://mvnrepository.com/artifact/org.apache.spark/spark-mllib-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-mllib_2.11</artifactId>
            <version>2.2.0</version>
            <!--<scope>runtime</scope>-->
        </dependency>

import org.apache.spark.mllib.clustering.KMeans
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.{SparkConf, SparkContext}

/**
  * KMeansDemo
  * k近邻算法获取三位空间中的数据多的归属
  * 测试数据（x,y,z）：
  * 0.0 0.0 0.0
  * 0.1 0.1 0.1
  * 0.2 0.2 0.2
  * 9.0 9.0 9.0
  * 9.1 9.1 9.1
  * 9.2 9.2 9.2
  *
  */
object KMwansDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[3]").setAppName("KMeansDemo")
    val sc = new SparkContext(conf)
    val dataSourceRDD = sc.textFile("C:\\IdeaProjects\\streamingtest\\src\\main\\resources\\kmeans.txt")
    val trainRDD = dataSourceRDD.map(lines => Vectors.dense(lines.split(" ").map(_.toDouble)))

    // trainRDD.foreach(println)
    // 训练数据得到模型
    // 参数一：训练数据（Vectors类型的RDD）
    // 参数二：中心簇数量 0~n
    // 参数三：迭代次数
    val model = KMeans.train(trainRDD, 3, 30)

    // 获取数据模型的中心点
    val clusterCenters = model.clusterCenters

    // 打印数据模型的中间点
    clusterCenters.foreach(println)

    // 计算误差
    val cross = model.computeCost(trainRDD)

    println("误差为：" + cross)

    // 使用模型匹配测试数据获取预测结果
    val res1 = model.predict(Vectors.dense("0.2 0.2 0.2".split(" ").map(_.toDouble)))
    val res2 = model.predict(Vectors.dense("0.25 0.25 0.25".split(" ").map(_.toDouble)))
    val res3 = model.predict(Vectors.dense("0.1 0.1 0.1".split(" ").map(_.toDouble)))
    val res4 = model.predict(Vectors.dense("9 9 9".split(" ").map(_.toDouble)))
    val res5 = model.predict(Vectors.dense("9.1 9.1 9.1".split(" ").map(_.toDouble)))
    val res6 = model.predict(Vectors.dense("9.06 9.06 9.06".split(" ").map(_.toDouble)))

    println("预测结果为：\r\n" + res1 + "\r\n" + res2 + "\r\n" + res3 + "\r\n" + res4 + "\r\n" + res5 + "\r\n" + res6 + "\r\n" + res2)

    /**
      * 这是个三中心点
      * [0.05,0.05,0.05]
      * [9.1,9.1,9.1]
      * [0.2,0.2,0.2]
      * 以下为类簇值
      * 2
      * 2
      * 0
      * 1
      * 1
      * 1
      * 此处结果可以看出输入数据与中心点更靠近的话就属于哪一个簇
      */

    // 使用原始数据进行交叉评估评测
    val crossPredictRes = dataSourceRDD.map {
      lines =>
        val lineVectors = Vectors.dense(lines.split(" ").map(_.toDouble))
        val predictRes = model.predict(lineVectors)
        lineVectors + "====>" + predictRes
    }
    crossPredictRes.foreach(println)

    /**
      * [9.0,9.0,9.0]====>1
      * [0.0,0.0,0.0]====>0
      * [0.1,0.1,0.1]====>0
      * [9.1,9.1,9.1]====>1
      * [0.2,0.2,0.2]====>2
      * [9.2,9.2,9.2]====>1
      */


  }
}

依赖分析

SparkContext是SparkDriver的核心，用于连接Spark集群，创建RDD，累加器，广播变量等。

sparkConf是SparkContext的组件，是sparkContext的配置类，配置信息是以键值对的形式存在。

mllib.clustering是Spark MLlib库中提供的用于做聚类的依赖。

mllib.linalg.Vectors是分别用来保存MLlib的本地向量的，其中包括Dense和Sparse两种分别用来保存稠密向量和稀疏向量。

原文--HuanChan---Spark集群下的K-Means算法

补充知识：关于本地向量(Local Vector)

参考：厦门大学-林子雨老师的网站---Spark入门：MLlib基本数据类型(1)

本地向量保存在单机上，其拥有整形、从0开始的索引值以及浮点型的元素值。MLlib提供了两种类型的本地向量，稠密向量（DenseVector）和稀疏向量（SparseVector），所有向量以org.apache.spark.mllib.linalg.Vector为基类。

比如上面的：

Vectors.dense("0.2 0.2 0.2".split(" ").map(_.toDouble))

创建的就是稠密向量[0.2,0.2,0.2]

稀疏向量怎么创建呢，类似于这样[3,[0,2],[3.0,8.0]]  -

/**
      * Creates a sparse vector providing its index array and value array.
      * 
      * @param size    vector size.
      * @param indices index array, must be strictly increasing.
      * @param values  value array, must have the same length as indices.
      */
    Vectors.sparse(3,Array(0,2),Array(3.0,8.0))
    /**
      * Creates a sparse vector using unordered (index, value) pairs.
      *
      * @param size vector size.
      * @param elements vector elements in (index, value) pairs.
      */
    Vectors.sparse(3,Seq((0,2),(3,8.0)))

当然也可以用元祖的形式：就是上面的第二种，源码里面已经给出。
 

高斯混合-Gaussian mixture

高斯混合模型代表一个复合分布，由此点是从一个绘制k高斯子分部，每一个具有其自己的概率。该spark.mllib实现使用期望最大化算法在给定一组样本的情况下诱导最大似然模型。该事项具有以下参数：
 

k是所需簇的数量

convergenceTol是我们考虑收敛的对数似然的最大变化。

maxIterations是在不达到收敛的情况下执行的最大迭代次数。

initialModel是启动EM算法的可选起点。如果省略该参数，则将数据构造随机起始点。

tips：关于最大化期望算法-看这篇-guoziqing506--最大化期望算法（EM）详解

-场景--最大似然估计的根本目的是根据抽样的样本（数据），反推出最有可能的分布参数（及模型），这是一个非常典型的机器学习的思想。所以在很多领域最大似然估计有着极为广泛的应用。然而，如果已知的数据中含有某些无法观测的隐藏变量时，直接使用最大似然估计时不足以解决问题。这个时候就要依靠最大期望(EM)算法了。

简单的来讲，EM算法是在依赖于无法观测的隐藏变量的概率模型中，寻找参数最大似然估计或者最大后验估计的算法。

 

更多聚类算法-请访问Apache Spark官方网站http://spark.apache.org/docs/latest/mllib-clustering.html#k-means