【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