2. 程式人生 > >Spark MLlib協同過濾之交替最小二乘法ALS原理與實踐

Spark MLlib協同過濾之交替最小二乘法ALS原理與實踐

阿新 • • 發佈：2018-12-14

        請先閱讀leboop釋出的博文《Apache Mahout之協同過濾原理與實踐 》。

        基於使用者和物品的協同過濾推薦都是建立在一個使用者-物品評分矩陣（user-item-score）展開的，其本質是利用現有資料填充矩陣的缺失項（missing entries），也就是預測評分。基於使用者的協同過濾通過該評分矩陣來度量使用者間的相似度（餘弦相似度，距離相似度，皮爾森相似度，皮爾斯曼相似度等等）；然後，通過使用者間的相似度來尋找被推薦使用者u的k-最近鄰使用者{u1，u2，...，uk}；最後，加權{u1，u2，...，uk}給所有物品的評分來預測u尚未評分的每個物品的評分，按預測評分從高到低得到使用者u的物品推薦列表{p1，p2，...，ph}；現在如果向用戶u推薦一個物品，應當推薦p1，如果推薦兩個物品，應當推薦p1和p2，以此類推。然而，這個演算法並不能很好地適應大規模使用者和物品資料，比如亞馬遜Amazon數千萬使用者和數百萬物品的線上商城，儘管大多數使用者只評分或交易了非常少量的物品，複雜度非常低，但線上環境要求必須在極短的時間內返回結果時，實時計算預測值仍然不可行。為了在不犧牲推薦精準度的情況下在大規模電商網站應用協同過濾推薦演算法，人們想到了基於物品的協同過濾推薦，其思想與基於使用者協同過濾推薦演算法類似，只不過這裡使用的是物品間相似度。而這個可以通過離線預計算構建出一個描述所有物品兩兩間的相似度的物品相似度矩陣。在執行時，如果向用戶u推薦物品p，由於物品p的k-最近鄰{p1，p2，...，pk}已經通過離線計算好，而且這樣的物品數量一般都比較少，所以用他們預測p的評分可以在線上互動應用允許的短時間內完成。

        事實上，在《Apache Mahout之協同過濾原理與實踐 》一文用到的評分矩陣中，只有一個使用者-物品沒有評分。一方面，在實際應用中，由於使用者只會評價或交易少部分物品，評分矩陣一般都非常稀疏。這種情況下的挑戰是用相對少的有效評分得到準確的預測。直接做法就是使用矩陣因子分解從評分模式中抽取出一組潛在的因子（latent factors）並通過這些因子向量描述使用者和物品。另一方面，Apache Mahout是使用MapReduce實現基於使用者和物品的協同過濾推薦演算法，我們知道，MapReduce在叢集各計算節點的迭代計算中會產生很多的磁碟檔案讀寫操作，嚴重影響了演算法的執行效率，而Spark MLlib是基於記憶體的分散式計算框架。所以接下來我們介紹Spark MLlib的協同過濾推薦演算法實現細節。

一、顯示反饋交替最小二乘法（ALS）

1、矩陣因子分解

例如某個使用者-電影/電視劇評分矩陣R_{m\times n}（m和n表示矩陣的行和列）如下：

使用者id/電視劇或電影 大頭兒子和小頭爸爸 火影忍者 百團大戰 泰坦尼克號
1 5 4 ？ ？
2 4 2 ？ ？
3 2 5 3 ？
4 1 ？ ？

4
5 ？ ？ 5 3

我們引入電影/電視劇的4個隱藏特徵（latent factors）家庭生活，浪漫愛情，戰爭歷史，劇情曲折，當然這裡只是為了說明矩陣分解，可能還有其他隱藏特徵。

使用者對隱藏特徵的偏好矩陣U_{m\times k}如下：

使用者id/隱藏因子 家庭生活 浪漫愛情 戰爭歷史 劇情曲折
1 5 1 2 4
2 4 1 2 2
3 2 2 3 5
4 1 4 1 3
5 2 3 5 3

矩陣描述了每個使用者對這些隱藏因子的偏好程度，第i個使用者的特徵向量記作u_{i}=(u_{i1},u_{i2},...,u_{iq},...,u_{ik})，u_{iq}是第i個使用者對第q個隱藏因子的偏好，比如u_{1}=(5,1,2,4)；

電影/電視劇包含隱藏特徵的程度矩陣V_{n\times k}如下：

電視劇或電影/隱藏因子 家庭生活 浪漫愛情 戰爭歷史 劇情曲折
大頭兒子和小頭爸爸 1 0 0 0
火影忍者 0 0 0 1
百團大戰 0 0 1 0
泰坦尼克號 0 1 0 0

矩陣描述了電影/電視劇包含隱藏特徵的程度，第j個物品的特徵向量記作v_{j}=(v_{j1},v_{j2},...,v_{jq},...v_{jk})，其中v_{jq}是第j個物品包含隱藏因子q的程度，比如v_{1}=(1,0,0,0)。

        從上面的這些矩陣我們可以看到，使用者1喜歡家庭生活更多，而電視劇《大頭兒子和小頭爸爸》包含家庭生活特徵，所以使用者1給這部電視劇的評5分也很高。所以我們可以做如下假設，R_{m\times n}矩陣是低秩的（隱藏因子數目k遠遠小於m和n），使用者-物品評分矩陣可以近似等於使用者特徵矩陣與電影特徵矩陣的乘積，如下：

R_{m\times n}\approx U_{m\times k}\cdot V_{n\times k}^{^{T}}        k<<m,n

這種假設是合理的，例如某使用者偏好碳酸飲料，而百世可樂、可口可樂、芬達都是含碳酸比較多的飲料，所以可以推斷該使用者偏好這些飲料。這裡碳酸飲料就是一個隱藏因子。所以預測R_{m\times n}矩陣的缺失項就變成了求解U_{m\times k}和V_{n\times k}。

 

2、交替最小二乘法（ALS）數學推導

        leboop在百度查看了很多關於ALS演算法公式的推導，基本都是直接給定結果，但是結果卻是錯誤的，所以這裡有必要作為糾正再詳細推導一遍。

        滿足R_{m\times n}\approx U_{m\times k}\cdot V_{n\times k}^{^{T}}        k<<m,n條件的U_{m\times k}和V_{n\times k}有很多，究竟哪個才是最優的？當然使等式成立的肯定是最好的，然而由於推薦系統中資料量非常大且計算複雜度高，或者根本不需要這麼精準，所以我們退而求其次，去找到近似解，只要保證R_{m\times n}和U_{m\times k}\cdot V_{n\times k}^{^{T}}的誤差在允許的範圍之內即可。那麼如何度量他們的誤差呢？和空間向量距離類似，只不過這裡是矩陣，我們計算出兩個矩陣中每個項之間的誤差，那麼使誤差之和最小的U_{m\times k}和V_{n\times k}的將是我們需要的。數學表達如下：

C=\sum_{i=1}^{m}\sum_{j=1}^{n}(a_{ij}-u_{i}v_{j}^{T})^2

a_{ij}表示使用者i給物品j的評分，也就是評分矩陣R_{m\times n}的第i行和第j列元素。現在的問題就是求解u_{i}和v_{j}使得

C=\sum_{i=1}^{m}\sum_{j=1}^{n}(a_{ij}-u_{i}v_{j}^{T})^2

最小，為了避免過度擬合，引入正則化因子\lambda(\lambda >0)，優化問題變為

C=\sum_{i=1}^{m}\sum_{j=1}^{n}[(a_{ij}-u_{i}v_{j}^{T})^2+\lambda (\left \|u_{i} \right \|^{2}+\left \| v_{j} \right \|^{2})]

在上式中u_{i}和v_{j}都是未知的，\left \|u_{i} \right \|是u_{i}的範數，可以簡單理解成k維向量的模，也即\left \|u_{i} \right \|^2=u_{i}u_{i}^{T}。交替最小二乘法的思想就是先固定其中一個，比如固定u_{i}，將問題轉換成普通的最小二乘法優化問題，求出另外一個v_{j}，然後固定v_{j}，再求解u_{i}，依次交替進行直到滿足精度要求或者達到指定的迭代次數，交替最小二乘法也因此而得名，所謂顯示反饋是指使用者對感興趣物品有明確的評分，也就是矩陣R_{m\times n}是明確的。

         下面我們先來固定u_{i}，此時上式是關於v_{j}的，先將對j求和部分分成兩部分，一部分只有j，另一部分是除了j的其他項，如下：

C=\sum_{i=1}^{m}[(a_{ij}-u_{i}v_{j}^{T})^2+\sum_{p\neq j}(a_{ip}-u_{i}v_{p}^{T})^2+\lambda nu_{i}u_{i}^{T}+\lambda\sum_{p\neq j} v_{p}v_{p}^{T}+\lambda v_{j}v_{j}^{T}]

兩邊對向量v_{j}求偏導，式子的第二、第三和第四部分對於向量v_{j}是常數，所以實質上只需要對下列式子求偏導即可

\sum_{i=1}^{m}[(a_{ij}-u_{i}v_{j}^{T})^2+\lambda v_{j}v_{j}^{T}]

標量C對向量v_{j}的偏導等於標量C對向量的每個分量偏導，即

\frac{\partial C}{\partial v_{j}}=(\frac{\partial C}{\partial v_{j1}},\frac{\partial C}{\partial v_{j2}},...,\frac{\partial C}{\partial v_{jq}},...,\frac{\partial C}{\partial v_{jk}})

所以，我們關注第q個分量求偏導，上式繼續展開

\sum_{i=1}^{m}[(a_{ij}-\sum_{p=1}^{k} u_{ip}v_{jp})^2+\lambda \sum_{p=1}^{k} v_{jp}^{2}]

有

\\ \frac{\partial C}{\partial v_{jq}}=\sum_{i=1}^{m}[2(a_{ij}-\sum_{p=1}^{k} u_{ip}v_{jp})(-u_{iq})+2\lambda v_{jq}]\\ \frac{\partial C}{\partial v_{jq}}=\sum_{i=1}^{m}[-2(a_{ij}- u_{i}v_{j}^{T})u_{iq}+2\lambda v_{jq}]

再轉回向量，有

\frac{\partial C}{\partial v_{j}}=-2\sum_{i=1}^{m}(a_{ij}-u_{i}v_j^{T})u_{i}+2\lambda\sum_{i=1}^{m} v_{j}

類似於一元函式求極值，我們令

\frac{\partial C}{\partial v_{j}}=0

有

\\-2\sum_{i=1}^{m}(a_{ij}-u_{i}v_j^{T})u_{i}+\sum_{i=1}^{m}2\lambda v_{j}=0\\ \sum_{i=1}^{m}(a_{ij}-v_{j}u_i^{T})u_{i}=\sum_{i=1}^{m}\lambda v_{j}\\ \sum_{i=1}^{m}a_{ij}u_{i}=\sum_{i=1}^{m}(\lambda v_{j}+v_{j}u_{i}^Tu_{i})\\

然後兩邊轉置，有

\sum_{i=1}^{m}a_{ij}u_{i}^{T}=\sum_{i=1}^{m}\lambda v_{j}^T+\sum_{i=1}^{m}u_{i}^{T}u_{i}v_{j}^{T}\\

上面用到了矩陣乘積滿足結合律以及矩陣乘積和矩陣轉置的關係。有

\sum_{i=1}^{m}a_{ij}u_{i}^{T}=[\sum_{i=1}^{m}(\lambda E_{k\times k}+u_{i}^{T}u_{i})]v_{j}^{T}\\

E_{k\times k}是k階單位矩陣，因為

\sum_{i=1}^{m}a_{ij}u_{i}^{T}=(u_{1}^{T},u_{2}^{T},...,u_{m}^{T})\begin{pmatrix} a_{1j}\\ a_{2j}\\ ...\\ a_{mj} \end{pmatrix}=U_{m\times k}^{T}R_{j},   

其中R_j是R_{m\times n}的第j列，且

 \sum_{i=1}^{m}(\lambda E_{k\times k}+u_{i}^{T}u_{i})=\lambda mE_{k\times k}+U_{m\times k}^{T}U_{m\times k}

所以

\\U_{m\times k}^{T}R_{j}=(\lambda mE_{k\times k}+U_{m\times k}^{T}U_{m\times k})v_{j}^{T}\\ v_{j}^{T}=(\lambda mE_{k\times k}+U_{m\times k}^{T}U_{m\times k})^{-1}U_{m\times k}^{T}R_{j}\\

即

V_{n\times k}^{T}=(\lambda mE_{k\times k}+U_{m\times k}^{T}U_{m\times k})^{-1}U_{m\times k}^{T}R_{m\times n}\\

以上以通常多元函式求偏導方法進行的，當然如果你學過矩陣對向量求偏導的知識，可以直接得到這個結果，沒必要這樣繁瑣。

由對稱性，得到

U_{m\times k}^{T}=(\lambda nE_{k\times k}+V_{n\times k}^{T}V_{n\times k})^{-1}V_{n\times k}^{T}R_{m\times n}^{T}}\\

 

如果優化問題變為

min[\sum_{i=1}^{m}\sum_{j=1}^{n}(a_{ij}-u_{i}v_{j}^{T})^2+\lambda (\sum_{i=1}^{m}\left \|u_{i} \right \|^{2}+\sum_{j=1}^{n}\left \| v_{j} \right \|^{2})]

我們有

V_{n\times k}^{T}=(\lambda E_{k\times k}+U_{m\times k}^{T}U_{m\times k})^{-1}U_{m\times k}^{T}R_{m\times n}\\

U_{m\times k}^{T}=(\lambda E_{k\times k}+V_{n\times k}^{T}V_{n\times k})^{-1}V_{n\times k}^{T}R_{m\times n}^{T}}\\

這裡\lambda m或\lambda n就變成了很多文章中寫的\lambda。

 

3、演算法步驟

（1）初始化引數

        首先初始化固定的隱藏因子個數k（根據經驗一般選取50~200），引數\lambda，迭代總次數r和相鄰兩次誤差C，並隨機產生U_{m\times k}^{(s)}（s=0，表示首次迭代）

（2）計算V_{n\times k}^{(s)}

        將\lambda，U_{m\times k}^{(s)}和R_{m\times n}代入公式V_{n\times k}^{T}=(\lambda mE_{k\times k}+U_{m\times k}^{T}U_{m\times k})^{-1}U_{m\times k}^{T}R_{m\times n}\\得到V_{n\times k}^{(s)}

（3）計算U_{m\times k}^{(s+1)}

將\lambda，R_{m\times n}和第（2）步計算出的V_{n\times k}^{(s)}代入公式U_{m\times k}^{T}=(\lambda nE_{k\times k}+V_{n\times k}^{T}V_{n\times k})^{-1}V_{n\times k}^{T}R_{m\times n}^{T}}\\，得到U_{m\times k}^{(s+1)}

（4）迭代

轉向執行第（2）步，直到達到迭代條件（s>=r）或者相鄰兩次誤差小於某個值結束。

 

二、隱士反饋交替最小二乘法（ALS-WR）

1、數學模型

        上面提到顯示反饋交替最小二乘法（ALS）適用於解決有明確評分矩陣的應用場景，實際情況，使用者沒有明確反饋對物品的偏好。我們只能通過使用者的某些行為來推斷他對物品的偏好，例如使用者瀏覽，收藏，或交易過某個物品，我們可以認為該使用者對這個物品可能感興趣。例如，在使用者瀏覽某個物品中，對該物品的點選次數或者在物品所在頁面上的停留時間越長，這時我們可以推使用者對該物品偏好程度更高，但是對於沒有瀏覽該物品，可能是由於使用者不知道有該物品，我們不能確定的推測使用者不喜歡該物品。ALS-WR通過置信度權重c來解決這些問題：對於更確信使用者偏好的項賦以較大的權重，對於沒有反饋的項，賦以較小的權重。ALS-WR模型的形式化說明如下：

min\sum_{i=1}^{m}\sum_{j=1}^{n}[c_{ij}(h_{ij}-u_{i}v_{j}^{T})^2+\lambda (\left \|u_{i} \right \|^{2}+\left \| v_{j} \right \|^{2})]

h_{ij}=\left\{\begin{matrix} 1\:\:\: if\: a_{ij}>0\\ 0\:\:\: if\: a_{ij}=0 \end{matrix}\right.

c_{ij}=1+\alpha a_{ij}

這裡a_{ij}並不是明確的評分，可能是點選某個網頁的次數或者瀏覽某個物品的停留時間等等，\alpha是置信度係數。

 

2、公式推導

        推導與ALS基本相同，固定u_{i}，對v_{j}求偏導，有

\frac{\partial C}{\partial v_{j}}=-2\sum_{i=1}^{m}c_{ij}(h_{ij}-u_{i}v_j^{T})u_{i}+2\lambda\sum_{i=1}^{m} v_{j}

令

\frac{\partial C}{\partial v_{j}}=0

有

\\-2\sum_{i=1}^{m}c_{ij}(h_{ij}-u_{i}v_j^{T})u_{i}+\sum_{i=1}^{m}2\lambda v_{j}=0\\ \sum_{i=1}^{m}c_{ij}(h_{ij}-v_{j}u_i^{T})u_{i}=\sum_{i=1}^{m}\lambda v_{j}\\ \sum_{i=1}^{m}c_{ij}h_{ij}u_{i}=\sum_{i=1}^{m}(\lambda v_{j}+c_{ij}v_{j}u_{i}^Tu_{i})\\

兩邊轉置，得到

\sum_{i=1}^{m}c_{ij}h_{ij}u_{i}^{T}=\sum_{i=1}^{m}\lambda v_{j}^T+\sum_{i=1}^{m}c_{ij}u_{i}^{T}u_{i}v_{j}^{T}\\

（鑑於本人水平有限，暫證明到此，先粘出很多文章給出的結果，以後有時間證明）

V_{n\times k}^{T}=(\lambda E_{k\times k}+U_{m\times k}^{T}C_{m\times m}U_{m\times k})^{-1}U_{m\times k}^{T}C_{m\times m}R_{m\times n}\\

U_{m\times k}^{T}=(\lambda E_{k\times k}+V_{n\times k}^{T}C_{n\times n}V_{n\times k})^{-1}V_{n\times k}^{T}C_{n\times n}R_{m\times n}^{T}}\\

其中C_{m\times m}和C_{n\times n}都是對角矩陣。

 

三、Spark MLlib演算法實現

1、資料準備

資料格式如下：

1,101,5.0
1,102,3.0
1,103,2.5
2,101,2.0
2,102,2.5
2,103,5.0
2,104,2.0
3,101,2.5
3,104,4.0
3,105,4.5
3,107,5.0
4,101,5.0
4,103,3.0
4,104,4.5
4,106,4.0
5,101,4.0
5,102,3.0
5,103,2.0
5,104,4.0
5,105,3.5
5,106,4.0

第一列為使用者id（userId），第二列為物品id（itemId），第三列為使用者給物品的評分，轉換成使用者-物品評分矩陣後，如下：

使用者id/物品id 101 102 103 104 105 106 107
1 5.0 3.0 2.5 ？ ？ ？ ？
2 2.0 2.5 5.0 2.0 ？ ？ ？
3 2.5 ？ ？ 4.0 4.5 ？ 5.0
4 5.0 ？ 3.0 4.5 ？ 4.0 ？
5 4.0 3.0 2.0 4.0 3.5 4.0 ？

2、顯式反饋

        Spark MLlib提供了兩種API，一種基於RDD的，在spark.mllib下，該API已經進入維護狀態，預計在Spark 3.0中放棄維護，最新的是基於DataFrame，該API在spark.ml下。關於RDD和DataFrame，如果想了解更多，可以參見《Spark DataSet和RDD與DataFrame轉換成DataSet》、《Spark DataFrame及RDD與DataSet轉換成DataFrame》和《Spark RDD和DataSet與DataFrame轉換成RDD》。

（1）基於RDD

推薦程式碼如下：

package com.leboop.mllib


import org.apache.spark.mllib.recommendation.{ALS, Rating}
import org.apache.spark.sql.SparkSession

/**
  * 基於RDD的ALS API推薦Demo
  */
object ALSCFDemo {

//  case class Rating(userId: Int, itermId: Int, rating: Float)

  /**
    * 解析資料：將資料轉換成Rating物件
    * @param str
    * @return
    */
  def parseRating(str: String): Rating = {
    val fields = str.split(",")
    assert(fields.size == 3)
    Rating(fields(0).toInt, fields(1).toInt, fields(2).toFloat)
  }

  def main(args: Array[String]): Unit = {
    //定義切入點
    val spark = SparkSession.builder().master("local").appName("ASL-Demo").getOrCreate()
    //讀取資料，生成RDD並轉換成Rating物件
    val ratingsRDD = spark.sparkContext.textFile("data/ratingdata.csv").map(parseRating)
    //隱藏因子數
    val rank=50
    //最大迭代次數
    val maxIter=10
    //正則化因子
    val labmda=0.01
    //訓練模型
    val model=ALS.train(ratingsRDD,rank,maxIter,labmda)
    //推薦物品數
    val proNum=2
    //推薦
    val r=model.recommendProductsForUsers(proNum)
    //列印推薦結果
    r.foreach(x=>{
          println("使用者 "+x._1)
          x._2.foreach(x=>{
            println(" 推薦物品 "+x.product+", 預測評分 "+x.rating)
            println()
          }
          )
          println("===============================")
        }
    )

  }
}

程式執行結果：

使用者 4
 推薦物品 101, 預測評分 4.987222374679642

 推薦物品 104, 預測評分 4.498410352539908

===============================
使用者 1
 推薦物品 101, 預測評分 4.9941397937874825

 推薦物品 104, 預測評分 4.482759123081623

===============================
使用者 3
 推薦物品 107, 預測評分 4.9917963612098415

 推薦物品 105, 預測評分 4.50190214892064

===============================
使用者 5
 推薦物品 101, 預測評分 4.023403087402049

 推薦物品 104, 預測評分 3.9938240731866506

===============================
使用者 2
 推薦物品 103, 預測評分 4.985059400785903

 推薦物品 102, 預測評分 2.4974442131394214

===============================

U_{m\times k}^{(s)}和V_{n\times k}^{(s)}的初始值都是隨機產生的，所以每次執行的結果會有差異。從結果中，我們還看到ALS可能會將使用者已經評分的物品推薦給該使用者，這點與Apache Mahout中基於物品或使用者協同過濾不同，例如在使用者-物品評分矩陣中使用者1已經給物品101評5分，推薦結果中也將結果推薦給了他，預測評分4.98非常接近真實值。

這裡我們可以設定不同的初始引數，那麼如何評估哪種結果好些？我們採用如下的均方根誤差RESM：

RESM=\sqrt{\frac{\sum_{i=1}^{n}(T-\widetilde{T})^{2}}{n}}

T為真實值，\widetilde{T}為預測值。

程式如下：

package com.leboop.mllib


import com.leboop.mllib.ALSCFDemo.rems
import org.apache.spark.mllib.recommendation.{ALS, MatrixFactorizationModel, Rating}
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession

/**
  * 基於RDD的ALS API推薦Demo
  */
object ALSCFDemo {
  /**
    * 解析資料：將資料轉換成Rating物件
    *
    * @param str
    * @return
    */
  def parseRating(str: String): Rating = {
    val fields = str.split(",")
    assert(fields.size == 3)
    Rating(fields(0).toInt, fields(1).toInt, fields(2).toFloat)
  }

  /**
    * @param model 訓練好的模型
    * @param data 真實資料
    * @param n 資料個數
    * @return 誤差
    */
  def rems(model: MatrixFactorizationModel, data: RDD[Rating], n: Long): Double = {
    //預測值 Rating(userId,itermId,rating)
    val preRDD: RDD[Rating] = model.predict(data.map(d => (d.user, d.product)))
    //關聯：組成（預測評分，真實評分）
    val doubleRating = preRDD.map(
      x => ((x.user, x.product), x.rating)
    ).join(
      data.map { x => ((x.user, x.product), x.rating) }
    ).values
    //計算RMES
    math.sqrt(doubleRating.map(x => math.pow(x._1 - x._2, 2)).reduce(_ + _) / n)
  }

  def main(args: Array[String]): Unit = {
    //定義切入點
    val spark = SparkSession.builder().master("local").appName("ASL-Demo").getOrCreate()
    //讀取資料，生成RDD並轉換成Rating物件
    val ratingsRDD = spark.sparkContext.textFile("data/ratingdata.csv").map(parseRating)
    //將資料隨機分成訓練資料和測試資料（權重分別為0.8和0.2）
    val Array(training, test) = ratingsRDD.randomSplit(Array(1, 0))
    //隱藏因子數
    val rank = 50
    //最大迭代次數
    val maxIter = 10
    //正則化因子
    val labmda = 0.01
    //訓練模型
    val model = ALS.train(training, rank, maxIter, labmda)
    //計算誤差
    val remsValue = rems(model, ratingsRDD, ratingsRDD.count)
    println("誤差：  " + remsValue)
  }
}

結果如下：

誤差：  0.011343969370562474

 

（2）基於DataFrame

程式碼如下：

package com.leboop.mllib

import org.apache.spark.ml.evaluation.RegressionEvaluator
import org.apache.spark.ml.recommendation.ALS
import org.apache.spark.sql.SparkSession

/**
  * ASL基於DataFrame的Demo
  */
object ALSDFDemo {
  case class Rating(userId: Int, itemId: Int, rating: Float)
  /**
    * 解析資料：將資料轉換成Rating物件
    * @param str
    * @return
    */
  def parseRating(str: String): Rating = {
    val fields = str.split(",")
    assert(fields.size == 3)
    Rating(fields(0).toInt, fields(1).toInt, fields(2).toFloat)
  }

  def main(args: Array[String]): Unit = {
    //定義切入點
    val spark = SparkSession.builder().master("local").appName("ASL-DF-Demo").getOrCreate()
    //讀取資料，生成RDD並轉換成Rating物件
    import spark.implicits._
    val ratingsDF = spark.sparkContext.textFile("data/ratingdata.csv").map(parseRating).toDF()
    //將資料隨機分成訓練資料和測試資料（權重分別為0.8和0.2）
    val Array(training, test) = ratingsDF.randomSplit(Array(0.8, 0.2))
    //定義ALS，引數初始化
    val als = new ALS().setRank(50)
      .setMaxIter(10)
      .setRegParam(0.01)
      .setUserCol("userId")
      .setItemCol("itemId")
      .setRatingCol("rating")
    //訓練模型
    val model = als.fit(training)

    //推薦:每個使用者推薦2個物品
    val r = model.recommendForAllUsers(2)

    //關閉冷啟動（防止計算誤差不產生NaN）
    model.setColdStartStrategy("drop")
    //預測測試資料
    val predictions = model.transform(test)

    //定義rmse誤差計算器
    val evaluator = new RegressionEvaluator()
      .setMetricName("rmse")
      .setLabelCol("rating")
      .setPredictionCol("prediction")
    //計算誤差
    val rmse = evaluator.evaluate(predictions)

    //列印訓練資料
    training.foreach(x=>println("訓練資料： "+x))
    //列印測試資料
    test.foreach(x=>println("測試資料： "+x))
    //列印推薦結果
    r.foreach(x=>print("使用者 "+x(0)+" ,推薦物品 "+x(1)))
    //列印預測結果
    predictions.foreach(x=>print("預測結果:  "+x))
    //輸出誤差
    println(s"Root-mean-square error = $rmse")
  }
}

執行結果如下（中間部分日誌已經刪除）：

訓練資料： [1,101,5.0]
訓練資料： [1,102,3.0]
訓練資料： [1,103,2.5]
訓練資料： [2,101,2.0]
訓練資料： [2,102,2.5]
訓練資料： [2,104,2.0]
訓練資料： [3,101,2.5]
訓練資料： [3,105,4.5]
訓練資料： [3,107,5.0]
訓練資料： [4,101,5.0]
訓練資料： [4,103,3.0]
訓練資料： [4,104,4.5]
訓練資料： [4,106,4.0]
訓練資料： [5,102,3.0]
訓練資料： [5,103,2.0]
訓練資料： [5,104,4.0]
訓練資料： [5,105,3.5]

測試資料： [2,103,5.0]
測試資料： [3,104,4.0]
測試資料： [5,101,4.0]
測試資料： [5,106,4.0]

使用者 1 ,推薦物品 WrappedArray([101,4.98618], [105,3.477826])
使用者 3 ,推薦物品 WrappedArray([107,4.9931526], [105,4.499714])
使用者 5 ,推薦物品 WrappedArray([104,3.9853115], [105,3.4996033])
使用者 4 ,推薦物品 WrappedArray([101,5.000056], [104,4.5001974])
使用者 2 ,推薦物品 WrappedArray([105,3.0707152], [102,2.4903712])

預測結果:  [5,101,4.0,3.1271331]
預測結果:  [2,103,5.0,1.0486442]
預測結果:  [5,106,4.0,1.8420099]
預測結果:  [3,104,4.0,1.4847627]

Root-mean-square error = 2.615265256309832

 

3、隱式反饋

        與顯式反饋基本相同，這裡需要使用方法setImplicitPrefs()開啟隱式反饋，程式碼如下：

val als = new ALS()
  .setMaxIter(5)
  .setRegParam(0.01)
  .setImplicitPrefs(true)
  .setUserCol("userId")
  .setItemCol("movieId")
  .setRatingCol("rating")

 

4、幾點問題

（1）冷啟動策略

        前面當我們使用已經訓練好的模型model對測試資料進行預測時，可能會碰到測試資料集中的使用者或者物品在訓練資料集中從未出現過。這會出現在兩種情景中：

a、在生產環境中，沒有歷史評分或者模型尚未訓練的新的使用者或者物品（這就是冷啟動問題）

b、在交叉驗證中，資料會被分片成訓練資料和評估資料。當在Spark的CrossValidator 和TrainValidationSplit中使用簡單的隨機分片時，碰到評估資料集中的使用者或者物品沒有出現在訓練資料集中是非常普遍的。

        在Spark中，當用戶或者物品在模型中沒有出現過，預設會在模型中指定它們的預測值為NaN。這在生產環境中是有用的，因為這表明它是一個新的使用者或者物品，然後系統可以使用這個預測做出一個撤退的決策。

        然而，在交叉驗證中這是不希望的，因為任何NaN的預測值都將導致評估測量中產生NaN（例如，我們程式中使用的RegressionEvaluator），會讓模型無法作出選擇。當然，Spark允許使用者通過設定方法coldStartStrategy 的引數為“drop”來刪除預測結果中含有NaN的任何DataFrame行，這樣，評估度量可以在非NaN的資料上進行計算變得有效。

 

（2）ALS中引數說明

numBlocks  

平行計算的使用者或者物品被分塊的個數。預設是10

rank 

模型中隱藏因子的個數，預設是10

maxIter 

程式執行的最大迭代次數，預設是10

regParam 

ALS中的正則化係數，預設是1.0

implicitPrefs 

用來確定使用顯示反饋ALS或者調節到隱式反饋（預設是false，使用顯式反饋）

alpha 

用於隱式反饋ALS變數的引數，置信係數，預設是1.0

nonnegative 

是否使用非負最小二乘法，預設false

 

（3）Spark中的隱式反饋

        spark.ml中的隱式反饋方法來自於Collaborative Filtering for Implicit Feedback Datasets

相關推薦

Spark MLlib協同過濾之交替最小二乘法ALS原理與實踐

        請先閱讀leboop釋出的博文《Apache Mahout之協同過濾原理與實踐 》。         基於使用者和物品的協同過濾推薦都是建立在一個使用者-物品評分矩陣（user-item

最小二乘法的原理與計算

png end 復制代碼 線性 mean 選擇 += 最優 inf https://www.cnblogs.com/xunziji/p/7366580.html 最小二乘法的應用例子 如果某個資產在買入後，第 2-100 天內的收益變化如下圖所示： 這時，我想

Spark MLlib中ALS交替最小二乘法推薦演算法的使用

本文首發於我的個人部落格QIMING.INFO，轉載請帶上鍊接及署名。 ALS(Alternating Least Square)，交替最小二乘法。在機器學習中，特指使用最小二乘法的一種協同推薦演算法。本文通過程式碼來演示用spark執行ALS演算法的一個小例

R語言開發之非線性最小二乘法瞭解下

當對真實世界資料建模進行迴歸分析時，我們觀察到模型的方程很少是給出線性圖的線性方程。 反而是在大多數情況下，現實世界資料模型的方程式涉及更高程度的數學函式，如3或sin函式的指數。 在這種情況下，模型的曲線給出了曲線而不是線性。線性和非線性迴歸的目標是調整模型引數的值以找到最

ALS（Alternating Least Squares） 交替最小二乘法概述

ALS（Alternating Least Squares）演算法是基於矩陣分解的協同過濾演算法中的一種，在sOven 的oryx框架中，推薦演算法便是採用的這種演算法。 首先說矩陣分解，這裡的矩陣分解可以理解為，將一個m×n的矩陣S分解為一個m×k的矩陣X和n× k的矩陣

Spark機器學習(10)：ALS交替最小二乘算法

mllib 測試 con 相互 idt color ted 個人 使用 1. Alternating Least Square ALS(Alternating Least Square)，交替最小二乘法。在機器學習中，特指使用最小二乘法的一種協同推薦算法。如下圖所示，u表

Spark機器學習(java)：ALS交替最小二乘演算法

楔子 Spark機器學習，推薦電影，採用ALS交替最小二乘演算法 Spark中ml和mllib的區別 Spark機器學習(10)：ALS交替最小二乘演算法 demo import java.io.Serializable; import org.apach

非線性最小二乘法之Gauss Newton、L-M、Dog-Leg原理簡介與實現

double func(const VectorXd& input, const VectorXd& output, const VectorXd& params, double objInd

線性迴歸之最小二乘法舉例推導及python實現

1 核心思想 通過最小化方差，使得擬合結果無限接近目標結果。 2 通過一元線性方程舉例說明 3 通過python實現一元線性擬合 import matplotlib.pyplot as plt import random # 用於儲存x,y擬合數據 x = []

【機器學習筆記】線性迴歸之最小二乘法

線性迴歸    線性迴歸（Linear Regreesion）就是對一些點組成的樣本進行線性擬合，得到一個最佳的擬合直線。 最小二乘法    線性迴歸的一種常用方法是最小二乘法，它通過最小化誤差的平方和尋找資料的最佳函式匹配。 代數推導    假設擬合函式為 y

常用演算法之：1、最小二乘法（1）

深度學習發展到如今的地位，離不開下面這 6 段程式碼。本文介紹了這些程式碼的創作者及其完成這些突破性成就的故事背景。每個故事都有簡單的程式碼示例，讀者們可以在 FloydHub 和 GitHub 找到相關程式碼。 最小二乘法 所有的深度學習演算法都始於下面這個數學公式（

ALS(alternating least squares)交替最小二乘

  ALS演算法是2008年以來，用的比較多的協同過濾演算法。它已經整合到Spark的Mllib庫中，使用起來比較方便。 1 矩陣分解   使用者對物品的打分行為可以表示成一個評分矩陣A(m*n)，表示m個使用者對n各物品的打分情況。如下圖所示。

機器學習之最小二乘法：背後的假設和原理

1 最小二乘法相關理論 我們先從最基本但很典型的線性迴歸演算法之最小二乘法說起吧，它背後的假設和原理您瞭解嗎？本系列帶來細細體會OLS這個演算法涉及的相關理論和演算法。 參考推送： 似然函式求權重引數 似然函式的確是求解類似問題的常用解決方法，包

PCL: Surface模組之MovingLeastSquares（滑動最小二乘法）

inline void setUpsamplingMethod(UpsamplingMethodmethod)  這個函式比較特殊，他會呼叫不同的列舉變數， 每個列舉變數有對應的幾個不同的函式，因此這裡我將一一解釋。經過試驗證明：這個upsampling函式只能增加密度較小區域的密度對於holes的填補卻

機器學習之--梯度下降和最小二乘法算線性回歸

http 線性 nbsp mat 需要 圖片 span 數據 .com o1 = 0 o2 = 0 o3 = 0 a = 0.002 x = [1,3,5,3,5,7,2,6,7,3,6,9,4,8,9,6,5,3,3,2,7,1,1,1,2,2,2,3,3,3

R語言中如何使用最小二乘法

一次函數 python 散點圖 博客 如何 這裏只是介紹下R語言中如何使用最小二乘法解決一次函數的線性回歸問題。 代碼如下：(數據同上一篇博客)(是不是很簡單????)> x<-c(6.19,2.51,7.29,7.01,5.7,2.66,3.98,2.5,9.1

Python中如何使用最小二乘法

python 技術 如何 模型 平面 之所以說”使用”而不是”實現”，是因為python的相關類庫已經幫我們實現了具體算法，而我們只要學會使用就可以了。隨著對技術的逐漸掌握及積累，當類庫中的算法已經無法滿足自身需求的時候，我們也可以嘗試通過自己的方式實現各種算法。 言

機器學習-最小二乘法

red num class cat blank height mar 感覺 時間 一、引言 這段時間學習《機器學習》，學到第5章的“Logistic回歸”，感覺相當吃力。追本溯源，從“Logistic回歸”到“線性回歸”，再到“最小二乘法”。最終定格到了《高等數學》（第六版

Regularized least-squares classification（正則化最小二乘法分類器）取代SVM

得出 ack 提高 kernel sys 風險 重要 ref height 在機器學習或者是模式識別其中有一種重要的分類器叫做：SVM 。這個被廣泛的應用於各個領域。可是其計算的復雜度以及訓練的速度是制約其在實時的計算機應用的主要原因。因此也非常非常多的算法

最小二乘法和最大似然估計的聯系和區別（轉）

enc bsp 聯系 角度 tro span nbsp sdn .science 對於最小二乘法，當從模型總體隨機抽取n組樣本觀測值後，最合理的參數估計量應該使得模型能最好地擬合樣本數據，也就是估計值和觀測值之差的平方和最小。而對於最大似然法，當從模型總體隨機抽取n組樣本觀