spark基于物品的推荐_大数据项目之电影推荐系统（下）

一、实时推荐服务建设

1、实时推荐服务

实时计算与离线计算应用于推荐系统上最大的不同在于实时计算推荐结果应该
反映最近一段时间用户近期的偏好，而离线计算推荐结果则是根据用户从第一次评
分起的所有评分记录来计算用户总体的偏好。
用户对物品的偏好随着时间的推移总是会改变的。比如一个用户 u 在某时刻对
电影 p 给予了极高的评分，那么在近期一段时候，u 极有可能很喜欢与电影 p 类
似的其他电影；而如果用户 u 在某时刻对电影 q 给予了极低的评分，那么在近期一
段时候，u 极有可能不喜欢与电影 q 类似的其他电影。所以对于实时推荐，当用户
对一个电影进行了评价后，用户会希望推荐结果基于最近这几次评分进行一定的更
新，使得推荐结果匹配用户近期的偏好，满足用户近期的口味。
如果实时推荐继续采用离线推荐中的 ALS 算法，由于算法运行时间巨大，不
具有实时得到新的推荐结果的能力；并且由于算法本身的使用的是评分表，用户本
次评分后只更新了总评分表中的一项，使得算法运行后的推荐结果与用户本次评分
之前的推荐结果基本没有多少差别，从而给用户一种推荐结果一直没变化的感觉，
很影响用户体验。
另外，在实时推荐中由于时间性能上要满足实时或者准实时的要求，所以算法的计算量不能太大，避免复杂、过多的计算造成用户体验的下降。鉴于此，推荐精
度往往不会很高。实时推荐系统更关心推荐结果的动态变化能力，只要更新推荐结
果的理由合理即可，至于推荐的精度要求则可以适当放宽。

所以对于实时推荐算法，主要有两点需求：

（1）用户本次评分后、或最近几个评分后系统可以明显的更新推荐结果；

（2）计算量不大，满足响应时间上的实时或者准实时要求；

2、实时推荐算法设计

当用户 u 对电影 p 进行了评分，将触发一次对 u 的推荐结果的更新。由于用
户 u 对电影 p 评分，对于用户 u 来说，他与 p 最相似的电影们之间的推荐强度将
发生变化，所以选取与电影 p 最相似的 K 个电影作为候选电影。
每个候选电影按照“推荐优先级”这一权重作为衡量这个电影被推荐给用户 u
的优先级。
这些电影将根据用户 u 最近的若干评分计算出各自对用户 u 的推荐优先级，然
后与上次对用户 u 的实时推荐结果的进行基于推荐优先级的合并、替换得到更新后
的推荐结果。
具体来说：
首先，获取用户 u 按时间顺序最近的 K 个评分，记为 RK；获取电影 p 的最
相似的 K 个电影集合，记为 S；

sim(q,r)表示电影 q 与电影 r 的相似度，设定最小相似度为 0.6，当电影 q 和

电影 r 相似度低于 0.6 的阈值，则视为两者不相关并忽略；

sim_sum 表示 q 与 RK 中电影相似度大于最小阈值的个数；

incount 表示 RK 中与电影 q 相似的、且本身评分较高（>=3）的电影个数；

recount 表示 RK 中与电影 q 相似的、且本身评分较低（<3）的电影个数；

公式的意义如下：

首先对于每个候选电影 q，从 u 最近的 K 个评分中，找出与 q 相似度较高（>=0.6）的 u 已评分电影们，对于这些电影们中的每个电影 r，将 r 与 q 的相似 度乘以用户 u 对 r 的评分，将这些乘积计算平均数，作为用户 u 对电影 q 的评分 预测即

然后，将 u 最近的 K 个评分中与电影 q 相似的、且本身评分较高（>=3）的
电影个数记为 incount，计算 lgmax{incount,1}作为电影 q 的“增强因子”，意义
在于电影 q 与 u 的最近 K 个评分中的 n 个高评分(>=3)电影相似，则电影 q 的
优先级被增加 lgmax{incount,1}。如果电影 q 与 u 的最近 K 个评分中相似的高评
分电影越多，也就是说 n 越大，则电影 q 更应该被推荐，所以推荐优先级被增强
的幅度较大；如果电影 q 与 u 的最近 K 个评分中相似的高评分电影越少，也就是
n 越小，则推荐优先级被增强的幅度较小；
而后，将 u 最近的 K 个评分中与电影 q 相似的、且本身评分较低（<3）的电
影个数记为 recount，计算 lgmax{recount,1}作为电影 q 的“削弱因子”，意义在
于电影 q 与 u 的最近 K 个评分中的 n 个低评分(<3)电影相似，则电影 q 的优先
级被削减 lgmax{incount,1}。如果电影 q 与 u 的最近 K 个评分中相似的低评分电
影越多，也就是说 n 越大，则电影 q 更不应该被推荐，所以推荐优先级被减弱的
幅度较大；如果电影 q 与 u 的最近 K 个评分中相似的低评分电影越少，也就是 n 越
小，则推荐优先级被减弱的幅度较小；
最后，将增强因子增加到上述的预测评分中，并减去削弱因子，得到最终的 q 电
影对于 u 的推荐优先级。在计算完每个候选电影 q 的
后，将生成一组<电影 q 的 ID, q 的推荐优先级>的列表 updatedList：

而在本次为用户 u 实时推荐之前的上一次实时推荐结果 Rec 也是一组<电影

m,m 的推荐优先级>的列表，其大小也为 K：

接下来，将 updated_S 与本次为 u 实时推荐之前的上一次实时推荐结果 Rec进行基于合并、替换形成新的推荐结果 NewRec：

总之，实时推荐算法流程流程基本如下：

（1）用户 u 对电影 p 进行了评分，触发了实时推荐的一次计算；

（2）选出电影 p 最相似的 K 个电影作为集合 S；

（3）获取用户 u 最近时间内的 K 条评分，包含本次评分，作为集合 RK；

（4）计算电影的推荐优先级，产生<qID,>集合 updated_S；

将 updated_S 与上次对用户 u 的推荐结果 Rec 利用公式(4-4)进行合并，产生

新的推荐结果 NewRec；作为最终输出。

我们在 recommender 下新建子项目 StreamingRecommender，引入 spark、scala、

mongo、redis 和 kafka 的依赖:

MovieRecommendSystemrecommenderpom.xml

 <dependencies>
    <!-- Spark 的依赖引入 -->
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.11</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-sql_2.11</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-streaming_2.11</artifactId>
    </dependency>
    <!-- 引入 Scala -->
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
    </dependency>
    <!-- 加入 MongoDB 的驱动 -->
    <!-- 用于代码方式连接 MongoDB -->
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>casbah-core_2.11</artifactId>
            <version>2.8.0</version>
        </dependency>
        <!-- 用于 Spark 和 MongoDB 的对接 -->
        <dependency>
            <groupId>org.mongodb.spark</groupId>
            <artifactId>mongo-spark-connector_2.11</artifactId>
            <version>${mongodb-spark.version}</version>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!-- kafka -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>0.10.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
    </dependencies>

代码中首先定义样例类和一个连接助手对象（用于建立 redis 和 mongo 连接）， 并在 StreamingRecommender 中定义一些常量：