电影推荐系统项目
基础环境搭建
如果机器的配置不足，推荐采用一台虚拟机进行配置，而非完全分布式，将该虚拟机CPU的内存设置的尽可能大，推荐为CPU > 4、MEM > 4GB

MongoDB（单节点）环境配置

// 通过WGET下载Linux版本的MongoDB

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel62-3.4.3.tgz

// 将压缩包解压到指定目录

tar xvf mongodb-linux-x86_64-rhel62-3.4.3.tgz 

// 将解压后的文件移动到最终的安装目录

mv mongodb-linux-x86_64-rhel62-3.4.3 mongodb

// 在安装目录下创建data文件夹用于存放数据和日志

mkdir /export/servers/mongodb/data/

// 在data文件夹下创建db文件夹，用于存放数据

mkdir /export/servers/mongodb/data/db/

// 在data文件夹下创建logs文件夹，用于存放日志

mkdir /export/servers/mongodb/data/logs/

// 在logs文件夹下创建log文件

 touch /export/servers/mongodb/data/logs/mongodb.log

// 在data文件夹下创建mongodb.conf配置文件

touch /export/servers/mongodb/data/mongodb.conf

// 在mongodb.conf文件中输入如下内容

vim /export/servers/mongodb/data/mongodb.conf

#端口号port = 27017
#数据目录
dbpath =/export/servers/mongodb/data/db
#日志目录
logpath = /export/servers/mongodb/data/logs/mongodb.log
#设置后台运行
fork = true
#日志输出方式
logappend = true
#开启认证
#auth = true

完成MongoDB的安装后，启动MongoDB服务器：
// 启动MongoDB服务器

/export/servers/mongodb/bin/mongod -config /export/servers/mongodb/data/mongodb.conf

// 访问MongoDB服务器

/export/servers/mongodb/bin/mongo

// 停止MongoDB服务器

 /export/servers/mongodb/bin/mongod -shutdown -config /export/servers/mongodb/data/mongodb.conf

Redis（单节点）环境配置

// 通过WGET下载REDIS的源码

wget http://download.redis.io/releases/redis-4.0.2.tar.gz 

// 将源代码解压到安装目录

tar xvf redis-4.0.2.tar.gz

// 进入Redis源代码目录，编译安装

cd redis-4.0.2/

// 安装GCC

sudo yum install gcc

// 编译源代码

make MALLOC=libc

// 编译安装

sudo make install

// 修改配置文件中以下内容

sudo vim /export/servers/redis-4.0.2/redis.conf

daemonize yes   #37行  #是否以后台daemon方式运行，默认不是后台运行
pidfile /var/run/redis/redis.pid   #41行  #redis的PID文件路径（可选）
bind 0.0.0.0    #64行  #绑定主机IP，默认值为127.0.0.1，我们是跨机器运行，所以需要更改
logfile /var/log/redis/redis.log   #104行  #定义log文件位置，模式log信息定向到stdout，输出到/dev/null（可选）
dir /usr/local/rdbfile  #188行  #本地数据库存放路径，默认为./，编译安装默认存在在/usr/local/bin下（可选）

创建目录

mkdir -p /var/log/redis
touch /var/log/redis/redis.log
mkdir -p /usr/local/rdbfile

在安装完Redis之后，启动Redis
// 启动Redis服务器

redis-server /export/servers/redis-4.0.2/redis.conf

// 连接Redis服务器

 redis-cli

// 停止Redis服务器

redis-cli shutdown

ElasticSearch（单节点）环境配置

// 通过Wget下载ElasticSearch安装包

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.6.2.tar.gz

修改Linux配置参数：
// 修改文件数配置，在文件末尾添加如下配置

sudo vim /etc/security/limits.conf 

* soft nofile 65536
* hard nofile 131072
* soft nproc 2048
* hard nproc 4096

// 修改* soft nproc 1024 为 * soft nproc 4096

vim /etc/security/limits.d/20-nproc.conf 

* soft nproc 4096     #将该条目修改成2048

// 在文件末尾添加：

sudo vim /etc/sysctl.conf 

vm.max_map_count=655360

// 在文件末尾添加：

sudo sysctl -p

添加新用户

adduser es

配置ElasticSearch：
// 解压ElasticSearch到安装目录

tar -xf elasticsearch-5.6.2.tar.gz

// 进入ElasticSearch安装目录

cd elasticsearch-5.6.2/

// 创建ElasticSearch数据文件夹data

 mkdir /export/servers/elasticsearch-5.6.2/data/

// 创建ElasticSearch日志文件夹logs

mkdir  /export/servers/elasticsearch-5.6.2/logs/

// 修改ElasticSearch配置文件

 vim  /export/servers/elasticsearch-5.6.2/config/elasticsearch.yml

cluster.name: es-cluster  #设置集群的名称
node.name: es-node   #修改当前节点的名称
path.data:  /export/servers/elasticsearch-5.6.2/data  #修改数据路径
path.logs:  /export/servers/elasticsearch-5.6.2/logs  #修改日志路径
bootstrap.memory_lock: false   #设置ES节点允许内存交换
bootstrap.system_call_filter: false   #禁用系统调用过滤器
network.host: node01    #设置当前主机名称
discovery.zen.ping.unicast.hosts: ["node01"]   #设置集群的主机列表

完成ElasticSearch的配置后：
// 启动ElasticSearch服务

/export/servers/elasticsearch-5.6.2/bin/elasticsearch -d

// 访问ElasticSearch服务

curl http://node01:9200/

{"name" : "es-node","cluster_name" : "es-cluster","cluster_uuid" : "VUjWSShBS8KM_EPJdIer6g","version" : {"number" : "5.6.2","build_hash" : "57e20f3","build_date" : "2017-09-23T13:16:45.703Z","build_snapshot" : false,"lucene_version" : "6.6.1"},"tagline" : "You Know, for Search"
}

// 停止ElasticSearch服务

 jps

 kill -9

Azkaban（单节点）环境配置

// 解压azkaban-solo-server-3.36.0.tar.gz到安装目录

tar -xf azkaban-solo-server-3.36.0.tar.gz 

// 启动Azkaban Solo单节点服务

/export/servers/azkaban-solo-server-3.36.0/bin/azkaban-solo-start.sh

注意关闭防火墙

systemctl stop firewalld.service 
systemctl disable firewalld.service 

// 访问azkaban服务，通过浏览器代开http://ip:8081，通过用户名：azkaban，密码azkaban登录。
azkaban服务
// 关闭Azkaban服务

/export/servers/azkaban-solo-server-3.36.0/bin/azkaban-solo-shutdown.sh

Spark（单节点）环境配置

// 通过wget下载zookeeper安装包

wget https://d3kbcqa49mib13.cloudfront.net/spark-2.1.1-bin-hadoop2.7.tgz 

// 将spark解压到安装目录

 tar xf spark-2.1.1-bin-hadoop2.7.tgz 

// 进入spark安装目录

 cd spark-2.1.1-bin-hadoop2.7/

// 复制slave配置文件

 cp ./conf/slaves.template ./conf/slaves    

// 修改slave配置文件

 vim ./conf/slaves

node01  #在文件最后将本机主机名进行添加

// 复制Spark-Env配置文件

cp ./conf/spark-env.sh.template ./conf/spark-env.sh 

vim   ./conf/spark-env.sh 

SPARK_MASTER_HOST=node01       #添加spark master的主机名
SPARK_MASTER_PORT=7077        #添加spark master的端口号
export JAVA_HOME=/export/servers/jdk1.8.0_144

安装完成之后，启动Spark
// 启动Spark集群

sbin/start-all.sh

// 访问Spark集群，浏览器访问http://node01:8080
spark集群
// 关闭Spark集群

sbin/stop-all.sh

Zookeeper（单节点）环境配置

// 通过wget下载zookeeper安装包

wget http://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.4.10/zookeeper-3.4.10.tar.gz 

// 将zookeeper解压到安装目录

tar -xf zookeeper-3.4.10.tar.gz

// 进入zookeeper安装目录

cd zookeeper-3.4.10/

// 创建data数据目录

 mkdir data/

// 复制zookeeper配置文件

cp ./conf/zoo_sample.cfg ./conf/zoo.cfg   

// 修改zookeeper配置文件

 vim conf/zoo.cfg

dataDir=/export/servers/zookeeper-3.4.10/data  #将数据目录地址修改为创建的目录

// 启动Zookeeper服务

/export/servers/zookeeper-3.4.10/bin/zkServer.sh    start

// 查看Zookeeper服务状态

/export/servers/zookeeper-3.4.10/bin/zkServer.sh status

// 关闭Zookeeper服务

 bin/zkServer.sh stop

Flume-ng（单节点）环境配置

// 通过wget下载zookeeper安装包

wget http://www.apache.org/dyn/closer.lua/flume/1.8.0/apache-flume-1.8.0-bin.tar.gz

// 解压到安装目录

tar -xf apache-flume-1.7.0-bin.tar.gz

// 等待项目部署时使用

Kafka（单节点）环境配置

// 通过wget下载zookeeper安装包

 wget http://mirrors.tuna.tsinghua.edu.cn/apache/kafka/0.10.2.1/kafka_2.11-0.10.2.1.tgz 

// 将kafka解压到安装目录

tar -xf kafka_2.12-0.10.2.1.tgz

// 进入kafka安装目录

cd kafka_2.12-0.10.2.1/   

// 修改kafka配置文件

 vim config/server.properties

host.name=node01            #修改主机名
port=9092                         #修改服务端口号
zookeeper.connect=node01:2181     #修改Zookeeper服务器地址

// 启动kafka服务 !!! 启动之前需要启动Zookeeper服务

 /export/servers/kafka_2.12-0.10.2.1/bin/kafka-server-start.sh -daemon ./config/server.properties

// 关闭kafka服务

/export/servers/kafka_2.12-0.10.2.1/bin/kafka-server-stop.sh

// 创建topic

/export/servers/kafka_2.12-0.10.2.1/bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 1 --partitions 1 --topic recommender

// kafka-console-producer

 /export/servers/kafka_2.12-0.10.2.1/bin/kafka-console-producer.sh --broker-list node01:9092 --topic recommender

// kafka-console-consumer

 /export/servers/kafka_2.12-0.10.2.1/bin/kafka-console-consumer.sh --bootstrap-server node01:9092 --topic recommender

Apache环境配置

// 安装HTTPD

sudo yum install httpd

// 启动HTTPD

 sudo service httpd start

// 关闭HTTPD

sudo service httpd stop

// 访问Apache服务器,通过浏览器访问http://ip:80
apache服务器

Tomcat环境配置

// 通过wget下载tomcat服务器安装包

 wget http://mirror.bit.edu.cn/apache/tomcat/tomcat-8/v8.5.23/bin/apache-tomcat-8.5.23.tar.gz

// 将tomcat安装包解压到安装目录下

tar -xf apache-tomcat-8.5.23.tar.gz

// 启动tomcat服务

 /export/servers/apache-tomcat-8.5.23/bin/startup.sh

// 关闭tomcat服务

/export/servers/apache-tomcat-8.5.23/bin/shutdown.sh

// 访问tomcat服务，浏览器打开http://ip:8080
开发环境配置
安装IDEA（略）
Postman安装
安装nodejs
在 https://nodejs.org/en/download/ 中下载对应版本的NodeJS，并安装：
验证安装结果
安装AngularJS CLI
在命令行执行：npm install -g @angular/cli
验证安装：
安装完成之后，请重新启动操作系统
业务数据初始化
初始化数据
Movies数据集
mid,name,descri,timelong,issue,shoot,language,genres,actors,directors
1^Toy Story (1995)^ ^81 minutes^March 20, 2001¹⁹⁹⁵English ^Adventure|Animation|Children|Comedy|Fantasy ^Tom Hanks|Tim Allen|Don Rickles|Jim Varney|Wallace Shawn|John Ratzenberger|Annie Potts|John Morris|Erik von Detten|Laurie Metcalf|R. Lee Ermey|Sarah Freeman|Penn Jillette|Tom Hanks|Tim Allen|Don Rickles|Jim Varney|Wallace Shawn ^John Lasseter

Movie数据集有10个字段，每个字段之间通过“^”符号进行分割。
字段名 字段类型 字段描述 字段备注
mid Int 电影的ID
name String 电影的名称
descri String 电影的描述
timelong String 电影的时长
shoot String 电影拍摄时间
issue String 电影发布时间
language Array[String] 电影语言 每一项用“|”分割
genres Array[String] 电影所属类别 每一项用“|”分割
director Array[String] 电影的导演 每一项用“|”分割
actors Array[String] 电影的演员 每一项用“|”分割

Ratings数据集
userId,movieId,rating,timestamp
1,31,2.5,1260759144

Rating数据集有4个字段，每个字段之间通过“，”分割
字段名 字段类型 字段描述 字段备注
uid Int 用户的ID
mid Int 电影的ID
score Double 电影的分值
timestamp Long 评分的时间

Tag数据集
userId,movieId,tag,timestamp
1,31,action,1260759144

Rating数据集有4个字段，每个字段之间通过“，”分割
字段名 字段类型 字段描述 字段备注
uid Int 用户的ID
mid Int 电影的ID
tag String 电影的标签
timestamp Long 标签的时间

数据初始化到MongoDB
启动MongoDB数据库（略）
设计思路
主要通过Spark SQL提供的write方法进行数据的分布式插入。
Maven依赖：

<mongodb-spark.version>2.0.0</mongodb-spark.version>
<casbah.version>3.1.1</casbah.version>

org.mongodb.spark mongo-spark-connector_2.11 ${mongodb-spark.version} org.mongodb casbah-core_2.11 ${casbah.version}

核心代码

private def storeDataInMongo(movies: DataFrame, ratings: DataFrame)(implicit mongoConf: MongoConfig): Unit = {

val mongoClient = MongoClient(MongoClientURI(mongoConf.uri))

mongoClient(mongoConf.db)(MOVIES_COLLECTION_NAME).dropCollection()
mongoClient(mongoConf.db)(RATINGS_COLLECTION_NAME).dropCollection()
mongoClient(mongoConf.db)(TAGS_COLLECTION_NAME).dropCollection()

movies
.write
.option(“uri”, mongoConf.uri)
.option(“collection”, MOVIES_COLLECTION_NAME)
.mode(“overwrite”)
.format(“com.mongodb.spark.sql”)
.save()

ratings
.write.option(“uri”, mongoConf.uri)
.option(“collection”, RATINGS_COLLECTION_NAME)
.mode(“overwrite”)
.format(“com.mongodb.spark.sql”)
.save()

tags
.write.option(“uri”, mongoConf.uri)
.option(“collection”, TAGS_COLLECTION_NAME)
.mode(“overwrite”)
.format(“com.mongodb.spark.sql”)
.save()
mongoClient(mongoConf.db)(MOVIES_COLLECTION_NAME).createIndex(MongoDBObject(“mid” -> 1))
mongoClient(mongoConf.db)(RATINGS_COLLECTION_NAME).createIndex(MongoDBObject(“mid” -> 1))
mongoClient(mongoConf.db)(RATINGS_COLLECTION_NAME).createIndex(MongoDBObject(“uid” -> 1))

mongoClient(mongoConf.db)(TAGS_COLLECTION_NAME).createIndex(MongoDBObject(“mid” -> 1))
mongoClient(mongoConf.db)(TAGS_COLLECTION_NAME).createIndex(MongoDBObject(“uid” -> 1))

}

数据初始化到ElasticSearch
启动ElasticSearch服务器（略）
设计思路
主要通过Spark SQL提供的write方法进行数据的分布式插入。
Maven依赖：

<elasticsearch-spark.version>5.6.2</elasticsearch-spark.version>
<elasticsearch.version>5.6.2</elasticsearch.version>

org.elasticsearch elasticsearch-spark-20_2.11 ${elasticsearch-spark.version} org.apache.hive hive-service org.elasticsearch.client transport ${elasticsearch.version}

核心代码

private def storeMoiveDataInES(products: DataFrame)(implicit esConf: ESConfig): Unit = {

val options = Map(“es.nodes” -> esConf.httpHosts,
“es.http.timeout” -> “100m”,
“es.mapping.id” -> “mid”)
val indexName = esConf.index
val typeName = s"$indexName/$ES_MOVIE_INDEX_NAME"

var settings:Settings = Settings.builder().put(“cluster.name”,esConf.clusterName).build()
val esClient = new PreBuiltTransportClient(settings)
esConf.transportHosts.split(";")
.foreach { case ES_HOST_PORT_REGEX(host: String, port: String) => esClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port.toInt)) }

if (esClient.admin().indices().exists(new IndicesExistsRequest(esConf.index)).actionGet().isExists) {
esClient.admin().indices().delete(new DeleteIndexRequest(esConf.index)).actionGet()
}
esClient.admin().indices().create(new CreateIndexRequest(esConf.index)).actionGet()

movies.toDF()
.write.options(options)
.mode(“overwrite”)
.format(“org.elasticsearch.spark.sql”)
.save(typeName)
}

离线推荐服务建设
离线推荐服务
离线推荐服务是综合用户所有的历史数据，利用设定的离线统计算法和离线推荐算法周期性的进行结果统计与保存，计算的结果在一定时间周期内是固定不变的，变更的频率取决于算法调度的频率。
离线推荐服务主要计算一些可以预先进行统计和计算的指标，为实时计算和前端业务相应提供数据支撑。
离线推荐服务主要分为统计性算法、基于ALS的协同过滤推荐算法以及基于ElasticSearch的内容推荐算法。
离线统计服务
电影平均得分统计
根据历史数据中所有用户对电影的评分，周期性的计算每个电影的平均得分。
实现思路：
通过Spark SQL读取保存在MongDB中的Rating数据集，通过执行以下SQL语句实现对于电影的平均分统计：
val averageMovieScoreDF = spark.sql(“select mid, avg(score) as avg from ratings group by mid”)

统计完成之后将生成的新的DataFrame写出到MongoDB的AverageMoviesScore集合中。
每个类别优质电影统计
根据提供的所有电影类别，分别计算每种类型的电影集合中评分最高的10个电影。
实现思路：
在计算完整个电影的平均得分之后，将影片集合与电影类型做笛卡尔积，然后过滤掉电影类型不符合的条目，将DataFrame输出到MongoDB的GenresTopMovies集合中。
val genresTopMovies = genresRdd.cartesian(moviesWithSocreDF.rdd).filter{
case (genres,row) => {
row.getAsString.toLowerCase().contains(genres.toLowerCase)
}
}.map{
case (genres,row) => {
(genres,(row.getAsInt,row.getAsDouble))
}
}.groupByKey()
.map{
case (genres,items) => {
GenresRecommendation(genres,items.toList.sortWith(_._2 > _._2).slice(0,10).map(x=>Recommendation(x._1,x._2)))
}
}.toDF

最热电影统计
根据听得评分类型，按月为单位计算最近时间的月份里面评分数最多的电影集合。
实现思路：
通过Spark SQL读取评分数据集，通过UDF函数将评分的数据时间修改为月，然后统计每月电影的评分数。统计完成之后将数据写入到MongoDB的RateMoreMoviesRecently数据集中。
优质电影统计
根据提供的所有电影类别，分别计算每种类型的电影集合中评分最高的10个电影。
实现思路：
通过Spark SQL读取评分数据集，统计所有评分中评分数最多的电影，然后按照从大到小排序，将最终结果写入大MongoDB的RateMoreMovies数据集中。
协同过滤推荐
系统过滤算法（略）
项目采用ALS作为协同过滤算法，分别根据MongoDB中的用户评分表和电影数据集计算用户电影推荐矩阵以及电影相似度矩阵。
用户电影推荐矩阵
通过ALS训练出来的Model来计算所有当前用户电影的推荐矩阵，主要思路如下：
UserId和MovieID做笛卡尔积，产生（uid，mid）的元组
通过模型预测（uid，mid）的元组。
将预测结果通过预测分值进行排序。
返回分值最大的K个电影，作为当前用户的推荐。
最后生成的数据结构如下：将数据保存到MongoDB的UserRecs表中

核心代码如下：
val recommendations = model.predict(userRating)
.filter(_.rating > 0)
.groupBy(p => p.user)
.map{ case (uid, predictions) =>
val recommendations = predictions.toSeq.sorted(RatingOrder)
.take(MAX_RECOMMENDATIONS)
.map(p => Recommendation(p.product, p.rating))

UserRecommendation(uid, recommendations)

}.toDF()

电影相似度矩阵
通过ALS计算电影见相似度矩阵，该矩阵用于查询当前电影的相似电影并为实时推荐系统服务。
离线计算的ALS 算法，算法最终会为用户、电影分别生成最终的特征矩阵，分别是表示用户特征矩阵的U(m x k)矩阵，每个用户由 k个特征描述；表示物品特征矩阵的V(n x k)矩阵，每个物品也由 k 个特征描述。
V(n x k)表示物品特征矩阵，每一行是一个 k 维向量，虽然我们并不知道每一个维度的特征意义是什么，但是k 个维度的数学向量表示了该行对应电影的特征。
所以，每个电影用V(n x k)每一行的 向量表示其特征，于是任意两个电影 p：特征向量为 ，电影q：特征向量为 之间的相似度sim(p,q)可以使用 和 的余弦值来表示：

数据集中任意两个电影间相似度都可以由公式计算得到，电影与电影之间的相似度在一段时间内基本是固定值。最后生成的数据保存到MongoDB的MovieRecs表中。

核心代码如下：
val movieRecommendation = productsVectorRdd.cartesian(productsVectorRdd)
.filter{ case ((movieId1, vector1), (movieId2, vector2)) => movieId1 != movieId2 }
.map{case ((movieId1, vector1), (movieId2, vector2)) =>
val sim = cosineSimilarity(vector1, vector2)
(movieId1, movieId2, sim)
}.filter(_._3 >= minSimilarity)
.groupBy(p => p._1)
.map{ case (mid:Int, predictions:Iterable[(Int,Int,Double)]) =>
val recommendations = predictions.toSeq.sorted(RatingOrder)
.take(maxRecs)
.map(p => Recommendation(p._2, p._3.toDouble))
MovieRecommendation(mid, recommendations)
}.toDF()

基于内容的推荐
基于内容的推荐通常是给定一篇文档信息，然后给用户推荐与该文档相识的文档。Lucene的api中有实现查询文章相似度的接口，叫MoreLikeThis。Elasticsearch封装了该接口，通过Elasticsearch的More like this查询接口，我们可以非常方便的实现基于内容的推荐。
在本项目中ElasticSearch除了提供基础的模糊检索功能外，主要提供了电影之间基于More like this查询相似度之间的功能，使电影依据演员、导演、名称、描述、标签等进行相似度计算，返回查询电影的相似电影集合。
由于该功能已有ES进行实现，故该功能不用提前计算或者实时计算，只是需要在业务服务器查询推荐集合的时候，将结果集按照业务规则进行合并即可。
核心算法如下：
// 基于内容的推荐算法
private List findContentBasedMoreLikeThisRecommendations(int mid, int maxItems) {
MoreLikeThisQueryBuilder query = QueryBuilders.moreLikeThisQuery(new String[]{“id”},
new String[]{“name”, “descri”, “genres”, “actors”, “directors”, “tags”},
new MoreLikeThisQueryBuilder.Item[]{new MoreLikeThisQueryBuilder.Item(Constant.ES_INDEX, Constant.ES_MOVIE_TYPE, String.valueOf(mid))});

return parseESResponse(esClient.prepareSearch().setQuery(query).setSize(maxItems).execute().actionGet());

}

private List parseRecs(Document document, int maxItems) {
List recommendations = new ArrayList<>();
if (null == document || document.isEmpty())
return recommendations;
ArrayList recs = document.get(“recs”, ArrayList.class);
for (Document recDoc : recs) {
recommendations.add(new Recommendation(recDoc.getInteger(“rid”), recDoc.getDouble(“r”)));
}
Collections.sort(recommendations, new Comparator() {
@Override
public int compare(Recommendation o1, Recommendation o2) {
return o1.getScore() > o2.getScore() ? -1 : 1;
}
});
return recommendations.subList(0, maxItems > recommendations.size() ? recommendations.size() : maxItems);
}

实时推荐服务建设
实时推荐服务
实时计算与离线计算应用于推荐系统上最大的不同在于实时计算推荐结果应该反映最近一段时间用户近期的偏好，而离线计算推荐结果则是根据用户从第一次评分起的所有评分记录来计算用户总体的偏好。
用户对物品的偏好随着时间的推移总是会改变的。比如一个用户u 在某时刻对电影p 给予了极高的评分，那么在近期一段时候，u 极有可能很喜欢与电影p 类似的其他电影；而如果用户u 在某时刻对电影q 给予了极低的评分，那么在近期一段时候，u 极有可能不喜欢与电影q 类似的其他电影。所以对于实时推荐，当用户对一个电影进行了评价后，用户会希望推荐结果基于最近这几次评分进行一定的更新，使得推荐结果匹配用户近期的偏好，满足用户近期的口味。
如果实时推荐继续采用离线推荐中的ALS 算法，由于算法运行时间巨大，不具有实时得到新的推荐结果的能力；并且由于算法本身的使用的是评分表，用户本次评分后只更新了总评分表中的一项，使得算法运行后的推荐结果与用户本次评分之前的推荐结果基本没有多少差别，从而给用户一种推荐结果一直没变化的感觉，很影响用户体验。
另外，在实时推荐中由于时间性能上要满足实时或者准实时的要求，所以算法的计算量不能太大，避免复杂、过多的计算造成用户体验的下降。鉴于此，推荐精度往往不会很高。实时推荐系统更关心推荐结果的动态变化能力，只要更新推荐结果的理由合理即可，至于推荐的精度要求则可以适当放宽。
所以对于实时推荐算法，主要有两点需求：
（1）用户本次评分后、或最近几个评分后系统可以明显的更新推荐结果；
（2）计算量不大，满足响应时间上的实时或者准实时要求；
实时推荐算法设计
当用户u 对电影p 进行了评分，将触发一次对u 的推荐结果的更新。由于用户u 对电影p 评分，对于用户u 来说，他与p 最相似的电影们之间的推荐强度将发生变化，所以选取与电影p 最相似的K 个电影作为候选电影。
每个候选电影按照“推荐优先级”这一权重作为衡量这个电影被推荐给用户u 的优先级。
这些电影将根据用户u 最近的若干评分计算出各自对用户u 的推荐优先级，然后与上次对用户u 的实时推荐结果的进行基于推荐优先级的合并、替换得到更新后的推荐结果。
具体来说：
首先，获取用户u 按时间顺序最近的K 个评分，记为RK；获取电影p 的最相似的K 个电影集合，记为S；
然后，对于每个电影q∈S ，计算其推荐优先级E_uq，计算公式如下：

其中：

R_r表示用户u 对电影r 的评分；
sim(q,r)表示电影q 与电影r 的相似度，设定最小相似度为0.6，当电影q和电影r 相似度低于0.6 的阈值，则视为两者不相关并忽略；
sim_sum 表示q 与RK 中电影相似度大于最小阈值的个数；
incount 表示RK 中与电影q 相似的、且本身评分较高（>=3）的电影个数；
recount 表示RK 中与电影q 相似的、且本身评分较低（❤️）的电影个数；
公式的意义如下：
首先对于每个候选电影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 相似的、且本身评分较低（❤️）的电影个数记为 recount，计算lgmax{recount,1}作为电影 q 的“削弱因子”，意义在于电影q 与u 的最近K 个评分中的n 个低评分(❤️)电影相似，则电影q 的优先级被削减lgmax{incount,1}。如果电影 q 与 u 的最近 K 个评分中相似的低评分电影越多，也就是说n 越大，则电影q 更不应该被推荐，所以推荐优先级被减弱的幅度较大；如果电影q 与u 的最近K 个评分中相似的低评分电影越少，也就是n 越小，则推荐优先级被减弱的幅度较小；
最后，将增强因子增加到上述的预测评分中，并减去削弱因子，得到最终的q 电影对于u 的推荐优先级。在计算完每个候选电影q 的E_uq后，将生成一组<电影q 的ID, q 的推荐优先级>的列表updatedList：

而在本次为用户u 实时推荐之前的上一次实时推荐结果Rec 也是一组<电影m,m 的推荐优先级>的列表，其大小也为K：

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

其中，i表示updated_S 与Rec 的电影集合中的每个电影，topK 是一个函数，表示从 Rec ∪ updated _ S中选择出最大的 K 个电影，cmp = E_ui 表示topK 函数将推荐优先级E_ui值最大的K 个电影选出来。最终，NewRec 即为经过用户u 对电影p 评分后触发的实时推荐得到的最新推荐结果。
总之，实时推荐算法流程流程基本如下：
（1）用户u 对电影p 进行了评分，触发了实时推荐的一次计算；
（2）选出电影p 最相似的K 个电影作为集合S；
（3）获取用户u 最近时间内的K 条评分，包含本次评分，作为集合RK；
（4）计算电影的推荐优先级，产生<qID,>集合updated_S；
将updated_S 与上次对用户u 的推荐结果Rec 利用公式(4-4)进行合并，产生新的推荐结果NewRec；作为最终输出。

实时推荐算法的实现
实时推荐算法的前提：
在Redis集群中存储了每一个用户最近对电影的K次评分。实时算法可以快速获取。
离线推荐算法已经将电影相似度矩阵提前计算到了MongoDB中。
Kafka已经获取到了用户实时的评分数据。
算法过程如下：
实时推荐算法输入为一个评分<userId, movieId, rate, timestamp>，而执行的核心内容包括：获取userId 最近K 次评分、获取movieId 最相似K 个电影、计算候选电影的推荐优先级、更新对userId 的实时推荐结果。
获取用户的K次最近评分
业务服务器在接收用户评分的时候，默认会将该评分情况以userId, movieId, rate, timestamp的格式插入到Redis中该用户对应的队列当中，在实时算法中，只需要通过Redis客户端获取相对应的队列内容即可。
def getUserRecentRatings(jedis: Jedis, K: Int, userId: Int, movieId: Int, score: Double): Array[(Int, Double)] = {
jedis.lrange(“uid:”+userId.toString,0,K).map{ line =>
val attr = line.asInstanceOf[String].split("😊
(attr(0).toInt, attr(1).toDouble)
}.toArray
}

获取当前电影最相似的K个电影
在离线算法中，已经预先将电影的相似度矩阵进行了计算，所以每个电影movieId 的最相似的K 个电影很容易获取：从MongoDB中读取MovieRecs数据，从movieId 在simHash 对应的子哈希表中获取相似度前K 大的那些电影。输出是数据类型为Array[Int]的数组，表示与movieId 最相似的电影集合，并命名为candidateMovies 以作为候选电影集合。
def getSimilarMovies(mostSimilarMovies: scala.collection.Map[Int, Array[Int]], collectionForRatingRecords: MongoCollection, movieId: Int, userId: Int, K: Int): Array[Int] = {

val similarMoviesBeforeFilter = mostSimilarMovies.getOrElse(movieId, ArrayInt)

val query = MongoDBObject(“uid” -> userId)

val hasRated = collectionForRatingRecords.find(query).toArray.map(.get(“mid”).toString.toInt).toSet
similarMoviesBeforeFilter.filter(hasRated.contains() == false)

}
电影推荐优先级计算
对于候选电影集合simiHash和userId 的最近K 个评分recentRatings，算法内容如下：
def createUpdatedRatings(simiHash: scala.collection.Map[Int, scala.collection.Map[Int, Double]], recentRatings: Array[(Int, Double)], candidateMovies: Array[Int]): Array[(Int, Double)] = {

val allSimilars = mutable.ArrayBuffer(Int, Double)

val increaseCounter = mutable.MapInt, Int
val reduceCounter = mutable.MapInt, Int

for (cmovieId <- candidateMovies; (rmovieId, rate) <- recentRatings) {
val sim = getSimilarityBetween2Movies(simiHash, rmovieId, cmovieId)
if (sim > minSimilarity) {
allSimilars += ((cmovieId, sim * rate))
if (rate >= 3.0) {
increaseCounter(cmovieId) = increaseCounter.getOrElse(cmovieId, 0) + 1
} else {
reduceCounter(cmovieId) = reduceCounter.getOrElse(cmovieId, 0) + 1
}
}
}
allSimilars.toArray.groupBy{case (movieId, value) => movieId}
.map{ case (movieId, simArray) =>
(movieId, simArray.map(_._2).sum / simArray.length + log(increaseCounter.getOrElse[Int](movieId, 1)) - log(reduceCounter.getOrElse[Int](movieId, 1)))
}.toArray
}
其中，allSimilars 是用于存储中间结果的数组；increaseCounter 为哈希表，key=每个候选电影q，value=RK 中与电影q 相似的、且本身评分较高（>=3）的电影个数，value 初始值=0；reduceCounter 为哈希表，key=每个候选电影q，value=RK 中与电影q 相似的、且本身评分较低（❤️）的电影个数，value 初始值=0；
算法首先对候选电影集合simiHash， userId 的最近K 次评分recentRatings 进行了遍历，对于每个候选电影p、每个评分<q,rate>：
a.用电影p 的ID、q 的ID 查询simHash，获取电影p、q 的相似度sim；
b.如果sim >= 0.6，说明p、q 电影相关，则将临时元组(p,rate x sim)存入数组allSimilars 中；
c.如果rate >= 3.0，说明q 电影得到了userId 较高的评分，则incount[p]+=1；否则，即rate < 3.0，说明q 电影得到了userId 较低的评分，则：recount[p]+=1；
d.遍历完成后，allSimilars 数组的每个元素是元组(p,v)，从上面得知p 表示候选电影，v 表示公式中的sim(q, r) x Rr；
e.接下来，将allSimilars 按照每个元组元素的p 来将p 值相同的元组的v值合并成数组array；不同的p 将拥有不同的array，<p,array>将组成一个新数组tmpSimilars：

Val tmpSimilars = allSimilars.toArray.groupBy{case (movieId, value) => movieId}
f.对于新数组tmpSimilars 的每一项<p,array>而言，对array 计算：array.sum / array.length 即表示其电影p 对应公式的 部分，而log(increaseCounter [p]) 即 表 示 其 电 影 p 对 应 公 式的 lgmax{incount,1}，且log(reduceCounter[p])即表示其电影 p 对应公式的lgmax{recount,1}，所以，接下来从tmpSimilars 计算<p, >数组：
tmpSimilars
.map{ case (movieId, simArray) =>
(movieId, simArray.map(_._2).sum / simArray.length + log(increaseCounter.getOrElse[Int](movieId, 1)) - log(reduceCounter.getOrElse[Int](movieId, 1)))
}.toArray

更新实时推荐结果
当计算出候选电影的推荐优先级的数组updatedRecommends<movieId, E>后，这个数组将被发送到Web 后台服务器，与后台服务器上userId 的上次实时推荐结果recentRecommends<movieId, E>进行合并、替换并选出优先级E 前K大的电影作为本次新的实时推荐。具体而言：
a.合并：将updatedRecommends 与recentRecommends 并集合成为一个新的<movieId, E>数组；
b.替换（去重）：当updatedRecommends 与recentRecommends 有重复的电影movieId 时，recentRecommends 中movieId 的推荐优先级由于是上次实时推荐的结果，于是将作废，被替换成代表了更新后的updatedRecommends的movieId 的推荐优先级；
c.选取TopK：在合并、替换后的<movieId, E>数组上，根据每个movie 的推荐优先级，选择出前K 大的电影，作为本次实时推荐的最终结果。

整体计算过程

（1）首先Spark 实时计算程序利用KafkaUtils 工具获取Kafka 集群得到的消息，生成DStream；
（2）对于DStream 中每个RDD：RDD-0、对于每个RDD-0 中的每个数据条目，进行简单的数据格式化产生每条记录为<userId,movieId,rate,timestamp>的新RDD：RDD-1；
（3）对于RDD-1 中每条<userId,movieId,rate,timestamp>记录：
a.根据userId，从MongoDB 中获取userId 最近的K 次评分记录recentRatings；
b. 根据movieId ， 从广播变量中获取与movieId 最相似K 个电影集
candidateMovies；
c.对于每个电影q ∈ candidateMovies，利用公式计算出其推荐优先级 ,产生<qId, > 的列表，updatedRecommends；
d.将updatedRecommends与MongoDB中上一次的推荐结果进行合并，按照推荐优先级进行排序并更新；
冷启动问题处理
整个推荐系统更多的是依赖于用于的偏好信息进行电影的推荐，那么就会存在一个问题，对于新注册的用户是没有任何偏好信息记录的，那这个时候推荐就会出现问题，导致没有任何推荐的项目出现。
处理这个问题一般是通过当用户首次登陆时，为用户提供交互式的窗口来获取用户对于物品的偏好。
在本项目中，当用户第一次登陆的时候，系统会询问用户对于影片类别的偏好。如下：

当获取用户的偏好之后，对应于需要通过用户偏好信息获取的推荐结果，则更改为通过对影片的类型的偏好的推荐。

综合业务服务建设
后台架构

后台服务通过Spring框架进行创建，主要负责后台数据和前端业务的交互。项目主要分为REST接口服务层、业务服务层、业务模型以及工具组件等组成。
REST接口服务层，主要通过Spring MVC为UI提供了通讯接口，主要包括用户接口、推荐接口、评分接口、查询接口、标签接口以及统计接口。
服务层主要实现了整体系统的业务逻辑，提供了包含电影相对应操作的服务、评分层面的服务、推荐层面的服务、标签层面的服务以及用户层面的服务。
业务模型方面，将推荐、业务请求以及具体业务数据进行模型创建。
工具组件层面，提供了对Redis、ES、MongoDB的客户端以及项目常量定义。
用户可视化建设
前端架构
AngularJS框架：

电影推荐系统前端框架：

创建与运行项目
详细文档参考：https://angular.cn/guide/quickstart
创建项目骨架
在CMD中相对应的目录中执行：ng new my-app my-app 为项目的名称：

【Src主文件夹】
你的应用代码位于src文件夹中。 所有的Angular组件、模板、样式、图片以及你的应用所需的任何东西都在那里。 这个文件夹之外的文件都是为构建应用提供支持用的。

【根目录文件夹】
src/文件夹是项目的根文件夹之一。 其它文件是用来帮助你构建、测试、维护、文档化和发布应用的。它们放在根目录下，和src/平级

添加项目依赖
在CMD中项目目录中执行：npm install bootstrap --save 添加bootstrap依赖。

在CMD中项目目录中执行：npm install jquery --save 添加bootstrap依赖。

在CMD中项目目录中执行：npm install systemjs --save 添加bootstrap依赖。

创建模块、组件与服务
在CMD中项目目录中执行：ng g module AppRouting来创建新模块。

在CMD中项目目录中执行：ng g component home来创建新组件。

在CMD中项目目录中执行：ng g service service/login来创建新服务组件。

调试项目
在CMD中项目目录中执行：ng serve –p 3000 启动整个应用程序。

访问http://localhost:4200

当你修改了后台代码的时候，浏览器自动Reload。
发布项目
在CMD中项目目录中执行：ng build 来打包发布整个应用程序。

会在目录下生成dist文件夹，该文件夹就是最终的发布程序。

程序部署与运行
发布项目
编译项目：执行root项目的clean package阶段

编译完成如下：

安装前端项目
将website-release.tar.gz解压到/var/www/html目录下，将里面的文件放在根目录，如下：

启动Apache服务器，访问http://IP:80
安装业务服务器
将BusinessServer.war，放到tomcat的webapp目录下，并将解压出来的文件，放到ROOT目录下：

启动Tomcat服务器。
Kafka配置与启动
启动Kafka
在kafka中创建两个Topic，一个为log，一个为recommender
启动kafkaStream程序，用于在log和recommender两个topic之间进行数据格式化。
[bigdata@linux ~]$ java -cp kafkastream.jar com.atguigu.kafkastream.Application linux:9092 linux:2181 log recommender

Flume配置与启动
在flume安装目录下的conf文件夹下，创建log-kafka.properties
agent.sources = exectail
agent.channels = memoryChannel
agent.sinks = kafkasink

For each one of the sources, the type is defined

agent.sources.exectail.type = exec
agent.sources.exectail.command = tail -f /home/bigdata/cluster/apache-tomcat-8.5.23/logs/catalina.out
agent.sources.exectail.interceptors=i1
agent.sources.exectail.interceptors.i1.type=regex_filter
agent.sources.exectail.interceptors.i1.regex=.+MOVIE_RATING_PREFIX.+

The channel can be defined as follows.

agent.sources.exectail.channels = memoryChannel

Each sink’s type must be defined

agent.sinks.kafkasink.type = org.apache.flume.sink.kafka.KafkaSink
agent.sinks.kafkasink.kafka.topic = log
agent.sinks.kafkasink.kafka.bootstrap.servers = linux:9092
agent.sinks.kafkasink.kafka.producer.acks = 1
agent.sinks.kafkasink.kafka.flumeBatchSize = 20

#Specify the channel the sink should use
agent.sinks.kafkasink.channel = memoryChannel

Each channel’s type is defined.

agent.channels.memoryChannel.type = memory

Other config values specific to each type of channel(sink or source)

can be defined as well

In this case, it specifies the capacity of the memory channel

agent.channels.memoryChannel.capacity = 10000

启动flume
[bigdata@linux apache-flume-1.7.0-kafka]$ bin/flume-ng agent -c ./conf/ -f ./conf/log-kafka.properties -n agent

部署流式计算服务
提交SparkStreaming程序：
[bigdata@linux spark-2.1.1-bin-hadoop2.7]$ bin/spark-submit --class com.atguigu.streamingRecommender.StreamingRecommender streamingRecommender-1.0-SNAPSHOT.jar

Azkaban调度离线算法
创建调度项目

创建两个job文件如下：
Azkaban-stat.job:
type=command
command=/home/bigdata/cluster/spark-2.1.1-bin-hadoop2.7/bin/spark-submit --class com.atguigu.offline.RecommenderTrainerApp
offlineRecommender-1.0-SNAPSHOT.jar
Azkaban-offline.job:
type=command
command=/home/bigdata/cluster/spark-2.1.1-bin-hadoop2.7/bin/spark-submit --class com.atguigu.statisticsRecommender.StatisticsApp
statisticsRecommender-1.0-SNAPSHOT.jar

将Job文件打成ZIP包上传到azkaban：

如下：

分别为每一个任务定义指定的时间，即可：

定义完成之后，点击Scheduler即可。