您的位置: 首页  >  文章  >  spark之CF协同过滤

spark之CF协同过滤

分类: 文章 • 2024-04-17 08:57:26

一）、协同过滤

1.1 概念　　　　　　

　　协同过滤是一种借助"集体计算"的途径。它利用大量已有的用户偏好来估计用户对其未接触过的物品的喜好程度。其内在思想是相似度的定义

1.2 分类

　1.在基于用户的方法的中，如果两个用户表现出相似的偏好（即对相同物品的偏好大体相同），那就认为他们的兴趣类似。要对他们中的一个用户推荐一个未知物品，

　   便可选取若干与其类似的用户并根据他们的喜好计算出对各个物品的综合得分，再以得分来推荐物品。其整体的逻辑是，如果其他用户也偏好某些物品，那这些物品很可能值得推荐。

spark之CF协同过滤

　  2. 同样也可以借助基于物品的方法来做推荐。这种方法通常根据现有用户对物品的偏好或是评级情况，来计算物品之间的某种相似度。 这时，相似用户评级相同的那些物品会被认为更相近。一旦有了物品之间的相似度，便可用用户接触过的物品来表示这个用户，然后找出和这些已知物品相似的那些物品，并将这些物品推荐给用户。同样，与已有物品相似的物品被用来生成一个综合得分，而该得分用于评估未知物品的相似度。

spark之CF协同过滤

二）、矩阵分解　　　　　　　　　　　　

　　Spark推荐模型库当前只包含基于矩阵分解（matrix factorization）的实现，由此我们也将重点关注这类模型。它们有吸引人的地方。首先，这些模型在协同过滤中的表现十分出色。而在Netflix Prize等知名比赛中的表现也很拔尖

1，显式矩阵分解　　　　

　   要找到和“用户 物品”矩阵近似的k维（低阶）矩阵，最终要求出如下两个矩阵：一个用于表示用户的U × k维矩阵，以及一个表示物品的I × k维矩阵。这两个矩阵也称作因子矩阵。它们的乘积便是原始评级矩阵的一个近似。值得注意的是，原始评级矩阵通常很稀疏，但因子矩阵却是稠密的。

　　特点：因子分解类模型的好处在于，一旦建立了模型，对推荐的求解便相对容易。但也有弊端，即当用户和物品的数量很多时，其对应的物品或是用户的因子向量可能达到数以百万计。这将在存储和计算能力上带来挑战。另一个好处是，这类模型的表现通常都很出色。

2，隐式矩阵分解（关联因子分确定，可能随时会变化）

　　隐式模型仍然会创建一个用户因子矩阵和一个物品因子矩阵。但是，模型所求解的是偏好矩阵而非评级矩阵的近似。类似地，此时用户因子向量和物品因子向量的点积所得到的分数，也不再是一个对评级的估值，而是对某个用户对某一物品偏好的估值（该值的取值虽并不严格地处于0到1之间，但十分趋近于这个区间）

3，最小二乘法（Alternating Least Squares    ALS）：解决矩阵分解的最优化方法

　  ALS的实现原理是迭代式求解一系列最小二乘回归问题。在每一次迭代时，固定用户因子矩阵或是物品因子矩阵中的一个，然后用固定的这个矩阵以及评级数据来更新另一个矩阵。之后，被更新的矩阵被固定住，再更新另外一个矩阵。如此迭代，直到模型收敛（或是迭代了预设好的次数）。

三）、Spark下ALS算法的应用

1，数据来源电影集ml-100k

2,代码实现 

      spark中ALS是居于矩阵分解方法，既不是user_base也不是items_base，下面中的代码注释是有问题的，这里是转载的  https://www.cnblogs.com/ksWorld/p/6808092.html 

 

 

  1. package com.spark.milb.study

  2.  

  3. import org.apache.log4j.{Level, Logger}

  4. import org.apache.spark.mllib.evaluation.{RankingMetrics, RegressionMetrics}

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

  6. import org.apache.spark.{SparkConf, SparkContext}

  7. import org.jblas.DoubleMatrix

  8.  

  9. /**

  10. * Created by hadoop on 17-5-3.

  11. * 协同过滤(处理对象movie,使用算法ALS:最小二乘法(实现用户推荐)

  12. * 余弦相似度实现商品相似度推荐

  13. */

  14. object cfTest {

  15. def main(args: Array[String]): Unit = {

  16. Logger.getLogger("org.apache.spark").setLevel(Level.WARN)

  17. Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)

  18. val conf=new SparkConf().setMaster("local").setAppName("AlsTest")

  19. val sc=new SparkContext(conf)

  20. CF(sc,"ml-100k/u.data")

  21. }

  22. def CF(sc:SparkContext,fileName:String): Unit ={

  23. val movieFile=sc.textFile(fileName)

  24. val RatingDatas=movieFile.map(_.split("\t").take(3))

  25. //转为Ratings数据

  26. val ratings=RatingDatas.map(x =>Rating(x(0).toInt,x(1).toInt,x(2).toDouble))

  27. //获取用户评价模型,设置k因子,和迭代次数,隐藏因子lambda,获取模型

  28. /*

  29. *  rank ：对应ALS模型中的因子个数，也就是在低阶近似矩阵中的隐含特征个数。因子个

  30. 数一般越多越好。但它也会直接影响模型训练和保存时所需的内存开销，尤其是在用户

  31. 和物品很多的时候。因此实践中该参数常作为训练效果与系统开销之间的调节参数。通

  32. 常，其合理取值为10到200。

  33. iterations ：对应运行时的迭代次数。ALS能确保每次迭代都能降低评级矩阵的重建误

  34. 差，但一般经少数次迭代后ALS模型便已能收敛为一个比较合理的好模型。这样，大部分

  35. 情况下都没必要迭代太多次（10次左右一般就挺好）。

  36. lambda ：该参数控制模型的正则化过程，从而控制模型的过拟合情况。其值越高，正则

  37. 化越严厉。该参数的赋值与实际数据的大小、特征和稀疏程度有关。和其他的机器学习

  38. 模型一样，正则参数应该通过用非样本的测试数据进行交叉验证来调整。

  39. * */

  40. val model=ALS.train(ratings,50,10,0.01)

  41. //基于用户相似度推荐

  42. println("userNumber:"+model.userFeatures.count()+"\t"+"productNum:"+model.productFeatures.count())

  43. //指定用户及商品,输出预测值

  44. println(model.predict(789,123))

  45. //为指定用户推荐的前N商品

  46. model.recommendProducts(789,11).foreach(println(_))

  47. //为每个人推荐前十个商品

  48. model.recommendProductsForUsers(10).take(1).foreach{

  49. case(x,rating) =>println(rating(0))

  50. }

  51. //基于商品相似度(使用余弦相似度)进行推荐,获取某个商品的特征值

  52. val itemFactory=model.productFeatures.lookup(567).head

  53. val itemVector=new DoubleMatrix(itemFactory)

  54. //求余弦相似度

  55. val sim=model.productFeatures.map{

  56. case(id,factory)=>

  57. val factorVector=new DoubleMatrix(factory)

  58. val sim=cosineSimilarity(factorVector,itemVector)

  59. (id,sim)

  60. }

  61. val sortedsim=sim.top(11)(Ordering.by[(Int,Double),Double]{

  62. case(id,sim)=>sim

  63. })

  64. println(sortedsim.take(10).mkString("\n"))

  65. //模型评估,通过均误差

  66. //实际用户评估值

  67. val actualRatings=ratings.map{

  68. case Rating(user,item,rats) => ((user,item),rats)

  69. }

  70. val userItems=ratings.map{

  71. case(Rating(user,item,rats)) => (user,item)

  72. }

  73. //模型的用户对商品的预测值

  74. val predictRatings=model.predict(userItems).map{

  75. case(Rating(user,item,rats)) =>((user,item),rats)

  76. }

  77. //联合获取rate值

  78. val rates=actualRatings.join(predictRatings).map{

  79. case x =>(x._2._1,x._2._2)

  80. }

  81. //求均方差

  82. val regressionMetrics=new RegressionMetrics(rates)

  83. //越接近0越佳

  84. println(regressionMetrics.meanSquaredError)

  85. //全局平均准确率(MAP)

  86. val itemFactors = model.productFeatures.map { case (id, factor)

  87. => factor }.collect()

  88. val itemMatrix = new DoubleMatrix(itemFactors)

  89. //分布式广播商品的特征矩阵

  90. val imBroadcast = sc.broadcast(itemMatrix)

  91. //计算每一个用户的推荐,在这个操作里，会对用户因子矩阵和电影因子矩阵做乘积，其结果为一个表示各个电影预计评级的向量（长度为

  92. //1682，即电影的总数目）

  93. val allRecs = model.userFeatures.map{ case (userId, array) =>

  94. val userVector = new DoubleMatrix(array)

  95. val scores = imBroadcast.value.mmul(userVector)

  96. val sortedWithId = scores.data.zipWithIndex.sortBy(-_._1)

  97. val recommendedIds = sortedWithId.map(_._2 + 1).toSeq //+1,矩阵从0开始

  98. (userId, recommendedIds)

  99. }

  100. //实际评分

  101. val userMovies = ratings.map{ case Rating(user, product, rating) =>

  102. (user, product)}.groupBy(_._1)

  103. val predictedAndTrueForRanking = allRecs.join(userMovies).map{ case

  104. (userId, (predicted, actualWithIds)) =>

  105. val actual = actualWithIds.map(_._2)

  106. (predicted.toArray, actual.toArray)

  107. }

  108. //求MAP,越大越好吧

  109. val rankingMetrics = new RankingMetrics(predictedAndTrueForRanking)

  110. println("Mean Average Precision = " + rankingMetrics.meanAveragePrecision)

  111. }

  112. //余弦相似度计算

  113. def cosineSimilarity(vec1:DoubleMatrix,vec2:DoubleMatrix):Double={

  114. vec1.dot(vec2)/(vec1.norm2()*vec2.norm2())

  115. }

  116. }

 

以下转载：http://blog.51cto.com/snglw/1662153

总结

      这样，一个简单的基于模型的电影推荐应用就算OK了。

  实时推荐架构分析

        上面，实现了简单的推荐系统应用，但是，仅仅实现用户的定向推荐，在实际应用中价值不是非常大，如果体现价值，最好能够实现实时或者准实时推荐。

        下面，简单介绍下实时推荐的一个架构：

        spark之CF协同过滤

        

        该架构图取自淘宝Spark On Yarn的实时架构，这里，给出一些个人的观点：

        架构图分为三层：离线、近线和在线。

            离线部分：主要实现模型的建立。原始数据通过ETL加工清洗，得到目标数据，目标业务数据结合合适的算法，学习训练模型，得到最佳的模型。

            近线部分：主要使用HBase存储用户行为信息，模型混合系统综合显性反馈和隐性反馈的模型处理结果，将最终的结果推荐给用户。

            在线部分：这里，主要有两种反馈，显性和隐性，个人理解，显性反馈理解为用户将商品加入购物车，用户购买商品这些用户行为；隐性反馈理解为用户在某个商品上停留的时间，用户点击哪些商品这些用户行为。这里，为了实现实时/准实时操作，使用到了Spark Streaming对数据进行实时处理。（有可能是Flume+Kafka+Spark Streaming架构）

相关推荐