【Todo】【转载】Spark学习 & 机器学习（实战部分）-监督学习、分类与回归

时间 2019-11-29

标签 Todo 转载 spark 学习机器实战部分监督分类回归栏目 Spark 繁體版

原文原文链接

理论原理部分能够看这一篇：http://www.cnblogs.com/charlesblc/p/6109551.htmlhtml

这里是实战部分。参考了 http://www.cnblogs.com/shishanyuan/p/4747778.htmljava

采用了三个案例，分别对应聚类、回归和协同过滤的算法。git

我以为很好，须要每个都在实际系统中试一下。github

更多api介绍能够参考 http://spark.apache.org/docs/2.0.1/ml-guide.html算法

1.1 聚类实例

1.1.1 算法说明

聚类（Cluster analysis）有时也被翻译为簇类，其核心任务是：将一组目标object划分为若干个簇，每一个簇之间的object尽量类似，簇与簇之间的object尽量相异。聚类算法是机器学习（或者说是数据挖掘更合适）中重要的一部分，除了最为简单的K-Means聚类算法外，比较常见的还有层次法（CURE、CHAMELEON等）、网格算法（STING、WaveCluster等），等等。数据库

较权威的聚类问题定义：所谓聚类问题，就是给定一个元素集合D，其中每一个元素具备n个可观察属性，使用某种算法将D划分红k个子集，要求每一个子集内部的元素之间相异度尽量低，而不一样子集的元素相异度尽量高。其中每一个子集叫作一个簇。apache

K-means聚类属于无监督学习，以往的回归、朴素贝叶斯、SVM等都是有类别标签y的，也就是说样例中已经给出了样例的分类。而聚类的样本中却没有给定y，只有特征x，好比假设宇宙中的星星能够表示成三维空间中的点集(a,b,c)。聚类的目的是找到每一个样本x潜在的类别y，并将同类别y的样本x放在一块儿。好比上面的星星，聚类后结果是一个个星团，星团里面的点相互距离比较近，星团间的星星距离就比较远了。json

监督学习与无监督学习的内容能够看这里：

https://www.zhihu.com/question/23194489api

这个问题能够回答得很简单：是否有监督（supervised），就看输入数据是否有标签（label）。输入数据有标签，则为有监督学习，没标签则为无监督学习。（我理解，特征是input, 标签是output）网络

最简单也最广泛的一类机器学习算法就是分类（classification）。对于分类，输入的训练数据有特征（feature），有标签（label）。所谓的学习，其本质就是找到特征和标签间的关系（mapping）。这样当有特征而无标签的未知数据输入时，咱们就能够经过已有的关系获得未知数据标签。

在上述的分类过程当中，若是全部训练数据都有标签，则为有监督学习（supervised learning）。若是数据没有标签，显然就是无监督学习（unsupervised learning）了，也即聚类（clustering）。(注：也能够理解为，聚类是没有标签输入的分类) 但有监督学习并不是全是分类，还有回归（regression）。

目前分类算法的效果广泛仍是不错的（研究者们天天都在outperform其余人……），相对来说，聚类算法就有些惨不忍睹了。确实，无监督学习自己的特色使其难以获得如分类同样近乎完美的结果。

这时各位可能要问，既然分类如此之好，聚类如此之不靠谱（分类<(￣︶￣)/，聚类└(T_T;)┘），那为什么咱们还能够容忍聚类的存在？由于在实际应用中，标签的获取经常须要极大的人工工做量，有时甚至很是困难。例如在天然语言处理（NLP）中，Penn Chinese Treebank在2年里只完成了4000句话的标签……

这时有人可能会想，难道有监督学习和无监督学习就是非黑即白的关系吗？有没有灰呢？Good idea。灰是存在的。两者的中间带就是半监督学习（semi-supervised learning）。

对于半监督学习，其训练数据的一部分是有标签的，另外一部分没有标签，而没标签数据的数量经常极大于有标签数据数量（这也是符合现实状况的）。隐藏在半监督学习下的基本规律在于：数据的分布必然不是彻底随机的，经过一些有标签数据的局部特征，以及更多没标签数据的总体分布，就能够获得能够接受甚至是很是好的分类结果。（此处大量忽略细节(￣ε￣；)）

所以，learning家族的总体构造是这样的：
有监督学习（分类，回归）
↕
半监督学习（分类，回归），transductive learning（不懂怎么翻译，直推式学习？）（分类，回归）
↕
半监督聚类（有标签数据的标签不是肯定的，相似于：确定不是xxx，极可能是yyy）
↕
无监督学习（聚类）

另外，还有以下回答也不错：

机器（计算机）学习分为有监督和无监督两个类，基本上能够从他们会不会获得一个特定的标签（label）输出来区分。

有监督学习(Supervised Learning)：
先来问题化地解释一下有监督学习：你有一些问题和他们的答案，你要作的有监督学习就是学习这些已经存在的问题和他们的答案。而后你就具有了经验了，这就是学习过成果。而后在你接受到一个新的不知道答案的问题的时候，你能够根据学习的结果，得出答案。

咱们有一个样本数据集，若是对于每个单一的数据根据它的特征向量咱们要去判断它的标签（算法的输出值），那么就是有监督学习。通俗的说，有监督学习就是比无监督学习多了一个能够表达这个数据特质的标签。
咱们再来看有监督学习，分为两个大类：
1.回归分析(Regression Analysis)：回归分析，其数据集是给定一个函数和它的一些坐标点，而后经过回归分析的算法，来估计原函数的模型，求出一个最符合这些已知数据集的函数解析式。而后它就能够用来预估其它未知输出的数据了，你输入一个自变量它就会根据这个模型解析式输出一个因变量，这些自变量就是特征向量，因变量就是标签。 并且标签的值是创建在连续范围的。
2.分类（Classification）：其数据集，由特征向量和它们的标签组成，当你学习了这些数据以后，给你一个只知道特征向量不知道标签的数据，让你求它的标签是哪个？其和回归的主要区别就是输出结果是离散的仍是连续的。

无监督学习（Unsupervised Learning)：
“Because we don't give it the answer, it's unsupervised learning”。
仍是先来问题化地解释一下无监督学习：咱们有一些问题，可是不知道答案，咱们要作的无监督学习就是按照他们的性质把他们自动地分红不少组，每组的问题是具备相似性质的（好比数学问题会汇集在一组，英语问题会汇集在一组，物理........）。

全部数据只有特征向量没有标签，可是能够发现这些数据呈现出聚群的结构，本质是一个类似的类型的会汇集在一块儿。把这些没有标签的数据分红一个一个组合，就是聚类（Clustering）。好比Google新闻，天天会搜集大量的新闻，而后把它们所有聚类，就会自动分红几十个不一样的组（好比娱乐，科技，政治......），每一个组内新闻都具备类似的内容结构。
无监督学习还有一个典型的例子就是鸡尾酒会问题（声音的分离），在这个酒会上有两种声音，被两个不一样的麦克风在不一样的地方接收到，而能够利用无监督学习来分离这两种不一样的声音。注意到这里是无监督学习的缘由是，事先并不知道这些声音中有哪些种类（这里的种类就是标签的意思）。

上面能够看出，回归分析的标准答案是连续的，分类的答案是离散的。

回归(regression)与分类(classification)的区别也能够参考这篇文章：

https://my.oschina.net/zzw922cn/blog/544221?p=1

1.回归问题的应用场景

回归问题一般是用来预测一个值，如预测房价、将来的天气状况等等，例如一个产品的实际价格为500元，经过回归分析预测值为499元，咱们认为这是一个比较好的回归分析。一个比较常见的回归算法是线性回归算法（LR）。另外，回归分析用在神经网络上，其最上层是不须要加上softmax函数的，而是直接对前一层累加便可。回归是对真实值的一种逼近预测。

2.分类问题的应用场景

分类问题是用于将事物打上一个标签，一般结果为离散值。例如判断一幅图片上的动物是一只猫仍是一只狗，分类一般是创建在回归之上，分类的最后一层一般要使用softmax函数进行判断其所属类别。分类并无逼近的概念，最终正确结果只有一个，错误的就是错误的，不会有相近的概念。最多见的分类方法是逻辑回归，或者叫逻辑分类。

注：Softmax能够看这里：

http://blog.csdn.net/acdreamers/article/details/44663305

广义线性模型的一个重要例子，它能够当作是Logistic回归的扩展，即softmax回归。
 
咱们知道Logistic回归只能进行二分类，由于它的随机变量的取值只能是0或者1，那么若是咱们面对多分类问题怎么
办？好比要将一封新收到的邮件分为垃圾邮件，我的邮件，仍是工做邮件；根据病人的病情预测病人属于哪一种病；对于
诸如MNIST手写数字分类（MNIST是一个手写数字识别库，相见：http://yann.lecun.com/exdb/mnist/）。诸
如此类问题都涉及到多分类，那么今天要讲的softmax回归能解决这类问题。

3.如何选择模型

下面一幅图能够告诉实际应用中咱们如何选择合适的模型。

再回到本文的主题，机器学习实战

回到参考这篇文章： http://www.cnblogs.com/shishanyuan/p/4747778.html

与分类不一样，分类是示例式学习，要求分类前明确各个类别，并断言每一个元素映射到一个类别。

而聚类是观察式学习，在聚类前能够不知道类别甚至不给定类别数量，是无监督学习的一种。目前聚类普遍应用于统计学、生物学、数据库技术和市场营销等领域，相应的算法也很是多。

1.1.2 实例介绍

在该实例中将介绍K-Means算法，K-Means属于基于平方偏差的迭代重分配聚类算法，其核心思想十分简单：

l随机选择K个中心点；

l计算全部点到这K个中心点的距离，选择距离最近的中心点为其所在的簇；

l简单地采用算术平均数（mean）来从新计算K个簇的中心；

l重复步骤2和3，直至簇类再也不发生变化或者达到最大迭代值；

l输出结果。

注，个人理解：就是先选K个点，而后把点都分到K个簇里面；而后对相同的簇的点，从新计算这个簇里面的中心点；而后再对全部的点，用这个中心点进行计算。

K-Means算法的结果好坏依赖于对初始聚类中心的选择，容易陷入局部最优解，对K值的选择没有准则可依循，对异常数据较为敏感，只能处理数值属性的数据，聚类结构可能不平衡。

来一个实例吧。按照注释，能够看出步骤。

package com.spark.my

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

/**
  * Created by baidu on 16/11/28.
  */
object Kmeans {
  def main(args: Array[String]) {

    //Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
    val conf = new SparkConf()
    val sc = new SparkContext(conf)

    println("Begin text")
    // 装载数据集
    val text = sc.textFile("hdfs://master.Hadoop:8390/kmeans/kmeans_data.txt")
    val parsedData = text.map(s=>Vectors.dense(s.split(' ').map(_.toDouble)))

    println("Begin kmeans")
    // 聚类,2个类,20次迭代
    val numCluster = 2
    val numIterations = 20
    val model = KMeans.train(parsedData, numCluster, numIterations)

    println("Print kmeans centers:")
    // 打印中心点
    for (c <- model.clusterCenters) {
      println(" " + c.toString)
    }

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

    // 使用模型测试单点数据
    println("Vectors 0.2 0.2 0.2 is belongs to cluster:" + model.predict(Vectors.dense("0.2 0.2 0.2".split(' ').map(_.toDouble))))
    println("Vectors 0.25 0.25 0.25 is belongs to cluster:" + model.predict(Vectors.dense("0.25 0.25 0.25".split(' ').map(_.toDouble))))
    println("Vectors 8 8 8 is belongs to cluster:" + model.predict(Vectors.dense("8 8 8".split(' ').map(_.toDouble))))


    // 交叉评估 Cross Validation
    // 由于聚类是无监督学习,是否是交叉验证很差弄?
    val testdata = text.map(s=>Vectors.dense(s.split(' ').map(_.toDouble)))
    val result1 = model.predict(testdata)
    result1.saveAsTextFile("hdfs://master.Hadoop:8390/kmeans-result1")

    // 交叉评估2, 返回数据集和结果
    val result2 = text.map {
      line=>
        val oldline = Vectors.dense(line.split(' ').map(_.toDouble))
        val predict = model.predict(oldline)
        line + " " + predict
    }.saveAsTextFile("hdfs://master.Hadoop:8390/kmeans-result2")

    sc.stop()
    println("All elements done")

  }
}

而后在m42n05机器上面建一个文件 kmeans_data.txt，内容：

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

放到hadoop上：

$ hadoop fs -mkdir /kmeans
注意，要加 /

$ hadoop fs -put kmeans_data.txt /kmeans

运行命令：

./bin/spark-submit --class com.spark.my.Kmeans --master spark://10.117.146.12:7077 myjars/scala-demo.jar

运行成功。发现打了好多日志呀。看来是要把日志级别调成WARNING。
其中有一些日志以下：

Print kmeans centers:
 [0.1,0.1,0.1]
 [9.099999999999998,9.099999999999998,9.099999999999998]


Within Set Sum of Squared Errors = 0.11999999999994547
Vectors 0.2 0.2 0.2 is belongs to cluster:0
Vectors 0.25 0.25 0.25 is belongs to cluster:0
Vectors 8 8 8 is belongs to cluster:1

而后用hadoop命令看输出文件：

$ hadoop fs -ls /kmeans-result1
Found 3 items
-rw-r--r--   3 work supergroup          0 2016-12-12 00:26 /kmeans-result1/_SUCCESS
-rw-r--r--   3 work supergroup          8 2016-12-12 00:26 /kmeans-result1/part-00000
-rw-r--r--   3 work supergroup          4 2016-12-12 00:26 /kmeans-result1/part-00001

$ hadoop fs -cat /kmeans-result1/part-00000
0
0
0
1

$ hadoop fs -cat /kmeans-result1/part-00001
1
1

再看kmeans-result2:

$ hadoop fs -cat /kmeans-result2/part-00000
0.0 0.0 0.0 0
0.1 0.1 0.1 0
0.2 0.2 0.2 0
9.0 9.0 9.0 1

$ hadoop fs -cat /kmeans-result2/part-00001
9.1 9.1 9.1 1
9.2 9.2 9.2 1

能够merge一下的：

$ hdfs dfs -getmerge hdfs://master.Hadoop:8390/kmeans-result2 /home/work/data/kmeans-result2

$ cat /home/work/data/kmeans-result2
0.0 0.0 0.0 0
0.1 0.1 0.1 0
0.2 0.2 0.2 0
9.0 9.0 9.0 1
9.1 9.1 9.1 1
9.2 9.2 9.2 1

好了，这样基本的聚类算法就实战完成了。

回归算法实例

1.2.1 算法说明

线性回归是利用称为线性回归方程的函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析方法，只有一个自变量的状况称为简单回归，大于一个自变量状况的叫作多元回归，在实际状况中大多数都是多元回归。

线性回归（Linear Regression）问题属于监督学习（Supervised Learning）范畴，又称分类（Classification）或概括学习（Inductive Learning）。

这类分析中训练数据集中给出的数据类型是肯定的。机器学习的目标是，对于给定的一个训练数据集，经过不断的分析和学习产生一个联系属性集合和类标集合的分类函数（Classification Function）或预测函数）Prediction Function），这个函数称为分类模型（Classification Model——或预测模型（Prediction Model）。经过学习获得的模型能够是一个决策树、规格集、贝叶斯模型或一个超平面。经过这个模型能够对输入对象的特征向量预测或对对象的类标进行分类。

回归问题中一般使用最小二乘（Least Squares）法来迭代最优的特征中每一个属性的比重，经过损失函数（Loss Function）或错误函数（Error Function)定义来设置收敛状态，即做为梯度降低算法的逼近参数因子。

最小二乘法可见：http://www.cnblogs.com/iamccme/archive/2013/05/15/3080737.html

咱们以最简单的一元线性模型来解释最小二乘法。什么是一元线性模型呢？监督学习中，若是预测的变量是离散的，咱们称其为分类（如决策树，支持向量机等），若是预测的变量是连续的，咱们称其为回归。回归分析中，若是只包括一个自变量和一个因变量，且两者的关系可用一条直线近似表示，这种回归分析称为一元线性回归分析。若是回归分析中包括两个或两个以上的自变量，且因变量和自变量之间是线性关系，则称为多元线性回归分析。对于二维空间线性是一条直线；对于三维空间线性是一个平面，对于多维空间线性是一个超平面...

对于一元线性回归模型, 假设从整体中获取了n组观察值（X1，Y1），（X2，Y2）， …，（Xn，Yn）。对于平面中的这n个点，可使用无数条曲线来拟合。要求样本回归函数尽量好地拟合这组值。综合起来看，这条直线处于样本数据的中心位置最合理。 选择最佳拟合曲线的标准能够肯定为：使总的拟合偏差（即总残差）达到最小。有如下三个标准能够选择：

        （1）用“残差和最小”肯定直线位置是一个途径。但很快发现计算“残差和”存在相互抵消的问题。
        （2）用“残差绝对值和最小”肯定直线位置也是一个途径。但绝对值的计算比较麻烦。
        （3）最小二乘法的原则是以“残差平方和最小”肯定直线位置。用最小二乘法除了计算比较方便外，获得的估计量还具备优良特性。这种方法对异常值很是敏感。

最小二乘法与梯度降低法

最小二乘法跟梯度降低法都是经过求导来求损失函数的最小值，那它们有什么区别呢。

相同

　　1.本质相同：两种方法都是在给定已知数据（independent & dependent variables）的前提下对dependent variables算出出一个通常性的估值函数。而后对给定新数据的dependent variables进行估算。
　　2.目标相同：都是在已知数据的框架内，使得估算值与实际值的总平方差尽可能更小（事实上未必必定要使用平方），估算值与实际值的总平方差的公式为：

不一样
　　1.实现方法和结果不一样：最小二乘法是直接对求导找出全局最小，是非迭代法。
而梯度降低法是一种迭代法，先给定一个，而后向降低最快的方向调整，在若干次迭代以后找到局部最小。梯度降低法的缺点是到最小点的时候收敛速度变慢，而且对初始点的选择极为敏感，其改进大可能是在这两方面下功夫。

上面这个仍是讲的不太好，更好的对比是看：https://www.zhihu.com/question/20822481

最小二乘法的目标：求偏差的最小平方和，对应有两种：线性和非线性。线性最小二乘的解是closed-form即

而非线性最小二乘没有closed-form，一般用迭代法求解。

这下懂了，非线性压根没有除了迭代法以外的最小二乘法。（或者有下面的高斯-牛顿法）

梯度降低是迭代法的一种，能够用于求解最小二乘问题（线性和非线性均可以）。高斯-牛顿法是另外一种常常用于求解非线性最小二乘的迭代法（必定程度上可视为标准非线性最小二乘求解方法）。

还有一种叫作Levenberg-Marquardt的迭代法用于求解非线性最小二乘问题，就结合了梯度降低和高斯-牛顿法。

因此若是把最小二乘看作是优化问题的话，那么梯度降低是求解方法的一种，上面的公式是求解线性最小二乘的一种，高斯-牛顿法和Levenberg-Marquardt则能用于求解非线性最小二乘。

1.2.2 实例介绍

该例子给出了如何导入训练集数据，将其解析为带标签点的RDD，而后使用了LinearRegressionWithSGD 算法来创建一个简单的线性模型来预测标签的值，最后计算了均方差来评估预测值与实际值的吻合度。

线性回归分析的整个过程能够简单描述为以下三个步骤：

（1）寻找合适的预测函数，即上文中的 h(x) ，用来预测输入数据的判断结果。这个过程是很是关键的，须要对数据有必定的了解或分析，知道或者猜想预测函数的“大概”形式，好比是线性函数仍是非线性函数，如果非线性的则没法用线性回归来得出高质量的结果。

（2）构造一个Loss函数（损失函数），该函数表示预测的输出（h）与训练数据标签之间的误差，能够是两者之间的差（h-y）或者是其余的形式（如平方差开方）。综合考虑全部训练数据的“损失”，将Loss求和或者求平均，记为 J(θ) 函数，表示全部训练数据预测值与实际类别的误差。

（3）显然， J(θ) 函数的值越小表示预测函数越准确（即h函数越准确），因此这一步须要作的是找到 J(θ) 函数的最小值。找函数的最小值有不一样的方法，Spark中采用的是梯度降低法（stochastic gradient descent，SGD)。

关于梯度降低法，能够参考：http://www.cnblogs.com/maybe2030/p/5089753.html?utm_source=tuicool&utm_medium=referral

SGD实际是随机梯度降低法。

1.2.3程序代码

注意，写的过程当中发现，LinearRegressionWithSGD is deprecated，而推荐使用 ml库。看了ml库和mllib库的区别，在于ml面向的dataset，mllib面向的是RDD，dataset是比RDD更高层级的抽象。后面再看，此次仍是用mllib。

package com.spark.my

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.mllib.regression.{LabeledPoint, LinearRegressionWithSGD}
import org.apache.spark.mllib.linalg.Vectors

/**
  * Created by baidu on 16/11/28.
  */
object MyRegression {
  def main(args: Array[String]) {

    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
    val conf = new SparkConf()
    val sc = new SparkContext(conf)

    println("Begin text")
    // 装载数据集
    val text = sc.textFile("hdfs://master.Hadoop:8390/regression/lpsa.data")
    val parsedData = text.map{
      line =>
        val parts = line.split(',')
        LabeledPoint(parts(0).toDouble, Vectors.dense(parts(1).split(' ').map(_.toDouble)))
    }

    println("Begin regression")
    // Building the model
    val numIterations = 100
    val model = LinearRegressionWithSGD.train(parsedData, numIterations)

    println("Evaluating the model and compute training error")
    // 用偏差平方之和来评估
    val valueAndPreds = parsedData.map{
      point =>
        val pred = model.predict(point.features)
        (point.label, pred)
    }

    val MSE = valueAndPreds.map{
      case(v, p) =>
        math.pow((v-p), 2)
    }.reduce(_+_) / valueAndPreds.count()
    println("Training Mean Squared Error = " + MSE)

    sc.stop()
    println("All elements done")

  }
}

数据示例以下：

-0.4307829,-1.63735562648104 -2.00621178480549 -1.86242597251066 -1.02470580167082 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306
-0.1625189,-1.98898046126935 -0.722008756122123 -0.787896192088153 -1.02470580167082 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306
-0.1625189,-1.57881887548545 -2.1887840293994 1.36116336875686 -1.02470580167082 -0.522940888712441 -0.863171185425945 0.342627053981254 -0.155348103855541
-0.1625189,-2.16691708463163 -0.807993896938655 -0.787896192088153 -1.02470580167082 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306
0.3715636,-0.507874475300631 -0.458834049396776 -0.250631301876899 -1.02470580167082 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306
0.7654678,-2.03612849966376 -0.933954647105133 -1.86242597251066 -1.02470580167082 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306
0.8544153,-0.557312518810673 -0.208756571683607 -0.787896192088153 0.990146852537193 -0.522940888712441 -0.863171185425945 -1.04215728919298 -0.864466507337306

能够看出，第一列是结果数据lable，和后面的用逗号分隔；后面的用空格分隔。

把数据传到Hadoop上：

$ hadoop fs -mkdir /regression
$ hadoop fs -put lpsa.data /regression
$ hadoop fs -ls /regression
Found 1 items
-rw-r--r--   3 work supergroup      10395 2016-12-12 15:52 /regression/lpsa.data

准备好jar包后，运行命令：

./bin/spark-submit --class com.spark.my.MyRegression --master spark://10.117.146.12:7077 myjars/scala-demo.jar

此次精简日志后，方便查看多了。所有日志以下：

$ ./bin/spark-submit --class com.spark.my.MyRegression --master spark://10.117.146.12:7077 myjars/scala-demo.jar
16/12/12 15:55:02 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
16/12/12 15:55:03 INFO util.log: Logging initialized @1665ms
16/12/12 15:55:03 INFO server.Server: jetty-9.2.z-SNAPSHOT
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@34a75079{/jobs,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@346a361{/jobs/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@107ed6fc{/jobs/job,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@1643d68f{/jobs/job/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@186978a6{/stages,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@2e029d61{/stages/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@482d776b{/stages/stage,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@4052274f{/stages/stage/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@132ddbab{/stages/pool,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@297ea53a{/stages/pool/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@acb0951{/storage,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@5bf22f18{/storage/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@267f474e{/storage/rdd,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@7a7471ce{/storage/rdd/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@28276e50{/environment,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@62e70ea3{/environment/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@3efe7086{/executors,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@675d8c96{/executors/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@741b3bc3{/executors/threadDump,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@2ed3b1f5{/executors/threadDump/json,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@63648ee9{/static,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@68d6972f{/,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@45be7cd5{/api,null,AVAILABLE}
16/12/12 15:55:03 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@7651218e{/stages/stage/kill,null,AVAILABLE}
16/12/12 15:55:03 INFO server.ServerConnector: Started ServerConnector@4f5ebbd{HTTP/1.1}{0.0.0.0:4040}
16/12/12 15:55:03 INFO server.Server: Started @1790ms
16/12/12 15:55:04 INFO handler.ContextHandler: Started o.s.j.s.ServletContextHandler@77e2a6e2{/metrics/json,null,AVAILABLE}
Begin text
Begin regression
16/12/12 15:55:05 INFO mapred.FileInputFormat: Total input paths to process : 1
16/12/12 15:55:07 WARN regression.LinearRegressionWithSGD: The input data is not directly cached, which may hurt performance if its parent RDDs are also uncached.
16/12/12 15:55:07 WARN netlib.BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeSystemBLAS
16/12/12 15:55:07 WARN netlib.BLAS: Failed to load implementation from: com.github.fommil.netlib.NativeRefBLAS
16/12/12 15:55:10 WARN regression.LinearRegressionWithSGD: The input data was not directly cached, which may hurt performance if its parent RDDs are also uncached.
Evaluating the model and compute training error Training Mean Squared Error = 6.207597210613578
16/12/12 15:55:10 INFO server.ServerConnector: Stopped ServerConnector@4f5ebbd{HTTP/1.1}{0.0.0.0:4040}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@7651218e{/stages/stage/kill,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@45be7cd5{/api,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@68d6972f{/,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@63648ee9{/static,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@2ed3b1f5{/executors/threadDump/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@741b3bc3{/executors/threadDump,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@675d8c96{/executors/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@3efe7086{/executors,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@62e70ea3{/environment/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@28276e50{/environment,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@7a7471ce{/storage/rdd/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@267f474e{/storage/rdd,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@5bf22f18{/storage/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@acb0951{/storage,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@297ea53a{/stages/pool/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@132ddbab{/stages/pool,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@4052274f{/stages/stage/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@482d776b{/stages/stage,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@2e029d61{/stages/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@186978a6{/stages,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@1643d68f{/jobs/job/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@107ed6fc{/jobs/job,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@346a361{/jobs/json,null,UNAVAILABLE}
16/12/12 15:55:10 INFO handler.ContextHandler: Stopped o.s.j.s.ServletContextHandler@34a75079{/jobs,null,UNAVAILABLE}
All elements done

而原示例的偏差也是6.2左右。

1.3 协同过滤实例

由于协同过滤内容比较多，就新开一篇文章啦： http://www.cnblogs.com/charlesblc/p/6165201.html

能够移步上面的页面。

(完)