spark：聚类分析KMeans--47

监督学习从给定的训练数据集中学习出一个函数（模型），当新的数据到来时，可以根据这个函数（模型）预测结果。监督学习的训练集要求是包括输入和输出，也可以说是特征和目标。训练集中的目标是由人标注（标量) 的。常见的监督学习算法包括回归分析和统计分类。
– 二元分类是ML 要解决的基本问题，将测试数据分成两个类。如垃圾邮件的判别、房贷是否允许等等问题的判断。
– 多元分类是二元分类的逻辑延伸。例如，在因特网的流分类的情况下，根据问题的网页可以被归类为体育，新闻，技术，或成人/ 色情，依此类推。
无监督学习与监督学习相比，训练集没有人为标注的结果。常见的无监督学习算法有聚类。

半监督学习介于监督学习与无监督学习之间。增强学习通过观察来学习做成如何的动作。每个动作都会对环境有所影响，学习对象根据观察到的周围环境的反馈来做出判断。

//

随手笔记：

xx.parquet文件：一种面向列存储的文件格式

case class 隐式转换：

val a = b.parquetFile(-------------------).sqlcontext.sql(---------------------).map(t => "Name" + t(0)).collect().foreach(println)

xx.json文件：NoSQL数据库、MongDB数据库

val a = b.jsonFile(---------------).------------------

放入缓存：SQLcontext.cacheTable("xx")

放入缓存：SQLcontext.sql("CACHE TABLE.xx")

ThriftServer和CLI是一个JDBC/ODBC接口，用于访问其它机器上的sparkSQL数据

spark是一个快速的内存计算框架，也是一个并行运算的框架

spark优化：

1.如何充分利用硬件资源

2.如何利用好分布式系统的并行运算

///

 K-Means 是聚类的一个算法，是一个无监督学习，目标是将一部分实体根据某种意义上的相似度和另一部分实体聚在一起。聚类通常被用于探索性的分析。
算法：
– 1 选择K 个点作为初始中心(1.随机选择 2.Kmeans||（Kmeans++的变种）)
– 2 将每个点指派到最近的中心, 形成K 个簇( 聚类)（计算每个点到中心点的距离（例xi，ji，zi）、再计算这些距离的平均值（x1+x2+```+xi）/i，将平均值做为新的中心点，重新计算中心点）
– 3 重新计算每个簇的中心
– 4 重复2-3 直至中心不发生变化（结束条件：1.迭代次数到达设置的次数 2.在某一次迭代后所有run的Kmeans算法都收敛）
距离：
– 绝对值距离
– 欧氏距离
– 闵可夫斯基距离
– 切比雪夫距离
– 马氏距离

MLlib K-Means 的实现中包含一个 k-means++ 方法的并行化变体 kmeans|| 。
 MLlib 里面的实现有如下的参数：
– k 是所需的类簇的个数。
– maxIterations 是最大的迭代次数。
– initializationMode 这个参数决定了是用随机初始化还是通过 k-means|| 进行初始化。
– runs 是跑 k-means 算法的次数（ k-mean 算法不能保证能找出最优解，如果在给定的数据
集上运行多次，算法将会返回最佳的结果）。
– initializiationSteps 决定了 k-means|| 算法的步数。
– epsilon 决定了判断 k-means 是否收敛的距离阀值。

MLlib中K-Means原理：

在同一个数据集上，跑多个KMeans算法（每个称为一个run），返回效果最好的那个聚类的类簇中心

/

package llf

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

import scala.collection.mutable.ListBuffer

/**
 * Created by sendoh on 2015/6/7.
 */
object LKmeans {
  def main(args: Array[String]): Unit ={
    //在终端屏蔽不必要的日志
    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
    Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)
    if (args.length != 3){
      println("Usage: java -jar code.jar dependency_jars file_location save_location")
      System.exit(0)
    }
    val jars = ListBuffer[String]()
    args(0).split(',').map(jars += _)
    //运行环境
    val conf = new SparkConf().setAppName("LKmeans").setMaster("local[3]").setSparkHome("/usr/local/spark-1.2.0-bin-hadoop2.4").setJars(jars)
    val sc = new SparkContext(conf)
    //装载数据
    val data = sc.textFile("hdfs://localhost:9000/datatnt/testkmeans2.txt")
    val parsedData = data.map(x => Vectors.dense(x.split(' ').map(_.toDouble)))
    //将数据集聚类，初定K值为2，经过30次迭代形成数据模型
    val KClusters = 2
    val numIterations = 30
    val model = KMeans.train(parsedData, KClusters, numIterations)
    //数据模型的中心点
    println("Cluster centers: ")
    for (c <- model.clusterCenters){
      println(" " + c.toString)
    }
    //用误差平方之和评估数据模型
    val cost = model.computeCost(parsedData)
    println("Within Set Sum of Squared Erroes = " + cost)
    //用模型测试单点数据
    println("Vectors 0.2 0.2 0.2 is belongs to clusters: " + model.predict(Vectors.dense("0.2 0.2 0.2".split(' ').map(_.toDouble))))
    println("Vectors 0.3 0.3 0.3 is belongs to clusters: " + model.predict(Vectors.dense("0.3 0.3 0.3".split(' ').map(_.toDouble))))
    println("Vectors 2 2 2 is belongs to clusters: " + model.predict(Vectors.dense("2 2 2".split(' ').map(_.toDouble))))
    println("Vectors 3 3 3 is belongs to clusters: " + model.predict(Vectors.dense("3 3 3".split(' ').map(_.toDouble))))
    //交叉评估a，只返回结果
    val testdata = data.map(x => Vectors.dense(x.split(' ').map(_.toDouble)))
    val resulta = model.predict(testdata)
    resulta.saveAsTextFile("hdfs://localhost:9000/outdatatnt/testkmeansRa")
    //交叉评估b，返回数据集和结果
    val resultb = data.map{ x =>
      val linevectore = Vectors.dense(x.split(' ').map(_.toDouble))
      val prediction = model.predict(linevectore)
      x + " " + prediction
    }.saveAsTextFile("hdfs://localhost:9000/outdatatnt/testkmeansRb")
    sc.stop()
  }

}