电商推荐系统（项目架构设计）数据加载准备，实时推荐算法MongoDB，Redis，Spark，Zookeeper，Flume-ng，Kafka工具环境搭建

最新推荐文章于 2024-05-16 15:24:24 发布

长岛山没有雪

最新推荐文章于 2024-05-16 15:24:24 发布

阅读量1.1k

点赞数 2

文章标签：大数据数据库

本文链接：https://blog.csdn.net/D32618666604/article/details/132091217

版权

3.2.1 Products数据集

数据格式：

productId,name,categoryIds, amazonId, imageUrl, categories, tags

例如：

3982^Fuhlen 富勒 M8眩光舞者时尚节能无线鼠标(草绿)(眩光.悦动.时尚炫舞鼠标 12个月免换电池高精度光学寻迹引擎超细微接收器10米传输距离)^1057,439,736^B009EJN4T2^https://images-cn-4.ssl-images-amazon.com/images/I/31QPvUDNavL._SY300_QL70_.jpg^外设产品|鼠标|电脑/办公^富勒|鼠标|电子产品|好用|外观漂亮

Product数据集有7个字段，每个字段之间通过“^”符号进行分割。其中的categoryIds、amazonId对于内容特征没有实质帮助，我们只需要其它5个字段：

字段名	字段类型	字段描述	字段备注
productId	Int	商品ID
name	String	商品名称
categories	String	商品分类	每一项用“\|”分割
imageUrl	String	商品图片URL
tags	String	UGC标签	每一项用“\|”分割

2.Ratings数据集

数据格式：

userId,prudcutId,rating,timestamp

例如：

4867,457976,5.0,1395676800

Rating数据集有4个字段，每个字段之间通过“，”分割。

字段名	字段类型	字段描述	字段备注
userId	Int	用户ID
produtId	Int	商品ID
score	Double	评分值
timestamp	Long	评分的时间

3 日志管理配置文件

log4j对日志的管理，需要通过配置文件来生效。在src/main/resources下新建配置文件log4j.properties，写入以下内容：

log4j.rootLogger=info, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p --- [%50t] %-80c(line:%5L) : %m%n

1. 1. 数据初始化到MongoDB

1.数据加载程序主体实现

我们会为原始数据定义几个样例类，通过SparkContext的textFile方法从文件中读取数据，并转换成DataFrame，再利用Spark SQL提供的write方法进行数据的分布式插入。

在DataLoader/src/main/scala下新建package，命名为com.atguigu.recommender，新建名为DataLoader的scala class文件。

程序主体代码如下：

DataLoader/src/main/scala/com.atguigu.recommerder/DataLoader.scala

// 定义样例类

case class Product(productId: Int, name: String, imageUrl: String, categories: String,

tags: String)

case class Rating(userId: Int, productId: Int, score: Double, timestamp: Int)

case class MongoConfig(uri:String, db:String)

object DataLoader {

// 以window下为例，需替换成自己的路径，linux下为 /YOUR_PATH/resources/products.csv

val PRODUCT_DATA_PATH = " YOUR_PATH\\resources\\products.csv"

val RATING_DATA_PATH = " YOUR_PATH\\resources\\ratings.csv"

val MONGODB_PRODUCT_COLLECTION = "Product"

val MONGODB_RATING_COLLECTION = "Rating"

// 主程序的入口

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

// 定义用到的配置参数

val config = Map(

"spark.cores" -> "local[*]",

"mongo.uri" -> "mongodb://localhost:27017/recommender",

"mongo.db" -> "recommender"

)

// 创建一个SparkConf配置

val sparkConf = new

SparkConf().setAppName("DataLoader").setMaster(config("spark.cores"))

// 创建一个SparkSession

val spark = SparkSession.builder().config(sparkConf).getOrCreate()

// 在对DataFrame和Dataset进行操作许多操作都需要这个包进行支持

import spark.implicits._

// 将Product、Rating数据集加载进来

val productRDD = spark.sparkContext.textFile(PRODUCT_DATA_PATH)

//将ProdcutRDD装换为DataFrame

val productDF = productRDD.map(item =>{

val attr = item.split("\\^")

Product(attr(0).toInt,attr(1).trim,attr(4).trim,attr(5).trim,attr(6).trim)

}).toDF()

val ratingRDD = spark.sparkContext.textFile(RATING_DATA_PATH)

//将ratingRDD转换为DataFrame

val ratingDF = ratingRDD.map(item => {

val attr = item.split(",")

Rating(attr(0).toInt,attr(1).toInt,attr(2).toDouble,attr(3).toInt)

}).toDF()

// 声明一个隐式的配置对象

implicit val mongoConfig =

MongoConfig(config.get("mongo.uri").get,config.get("mongo.db").get)

// 将数据保存到MongoDB中

storeDataInMongoDB(productDF, ratingDF)

// 关闭Spark

spark.stop()

}

2. 将数据写入MongoDB

接下来，实现storeDataInMongo方法，将数据写入mongodb中：

def storeDataInMongoDB(productDF: DataFrame, ratingDF:DataFrame)

(implicit mongoConfig: MongoConfig): Unit = {

//新建一个到MongoDB的连接

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

// 定义通过MongoDB客户端拿到的表操作对象

val productCollection = mongoClient(mongoConfig.db)(MONGODB_PRODUCT_COLLECTION)

val ratingCollection = mongoClient(mongoConfig.db)(MONGODB_RATING_COLLECTION)

//如果MongoDB中有对应的数据库，那么应该删除

productCollection.dropCollection()

ratingCollection.dropCollection()

//将当前数据写入到MongoDB

productDF

.write

.option("uri",mongoConfig.uri)

.option("collection",MONGODB_PRODUCT_COLLECTION)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

ratingDF

.write

.option("uri",mongoConfig.uri)

.option("collection",MONGODB_RATING_COLLECTION)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

//对数据表建索引

productCollection.createIndex(MongoDBObject("productId" -> 1))

ratingCollection.createIndex(MongoDBObject("userId" -> 1))

ratingCollection.createIndex(MongoDBObject("productId" -> 1))

//关闭MongoDB的连接

mongoClient.close()

}

1. 离线推荐服务建设

1. 1. 离线推荐服务

离线推荐服务是综合用户所有的历史数据，利用设定的离线统计算法和离线推荐算法周期性的进行结果统计与保存，计算的结果在一定时间周期内是固定不变的，变更的频率取决于算法调度的频率。

离线推荐服务主要计算一些可以预先进行统计和计算的指标，为实时计算和前端业务相应提供数据支撑。

离线推荐服务主要分为统计推荐、基于隐语义模型的协同过滤推荐以及基于内容和基于Item-CF的相似推荐。我们这一章主要介绍前两部分，基于内容和Item-CF的推荐在整体结构和实现上是类似的，我们将在第7章详细介绍。

1. 1. 离线统计服务

1. 1. 1. 统计服务主体框架

在recommender下新建子项目StatisticsRecommender，pom.xml文件中只需引入spark、scala和mongodb的相关依赖：

<groupId>org.apache.spark</groupId>

<artifactId>spark-core_2.11</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-sql_2.11</artifactId>

</dependency>

<groupId>org.scala-lang</groupId>

<artifactId>scala-library</artifactId>

</dependency>

<groupId>org.mongodb</groupId>

<artifactId>casbah-core_2.11</artifactId>

<version>${casbah.version}</version>

</dependency>

<groupId>org.mongodb.spark</groupId>

<artifactId>mongo-spark-connector_2.11</artifactId>

<version>${mongodb-spark.version}</version>

</dependency>

</dependencies>

在resources文件夹下引入log4j.properties，然后在src/main/scala下新建scala 单例对象com.atguigu.statistics.StatisticsRecommender。

同样，我们应该先建好样例类，在main()方法中定义配置、创建SparkSession并加载数据，最后关闭spark。代码如下：

src/main/scala/com.qingtaishuju.statistics/StatisticsRecommender.scala

case class Rating(userId: Int, productId: Int, score: Double, timestamp: Int)

case class MongoConfig(uri:String, db:String)

object StatisticsRecommender {

val MONGODB_RATING_COLLECTION = "Rating"

//统计的表的名称

val RATE_MORE_PRODUCTS = "RateMoreProducts"

val RATE_MORE_RECENTLY_PRODUCTS = "RateMoreRecentlyProducts"

val AVERAGE_PRODUCTS = "AverageProducts"

// 入口方法

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

val config = Map(

"spark.cores" -> "local[*]",

"mongo.uri" -> "mongodb://localhost:27017/recommender",

"mongo.db" -> "recommender"

)

//创建SparkConf配置

val sparkConf = new SparkConf().setAppName("StatisticsRecommender").setMaster(config("spark.cores"))

//创建SparkSession

val spark = SparkSession.builder().config(sparkConf).getOrCreate()

val mongoConfig = MongoConfig(config("mongo.uri"),config("mongo.db"))

//加入隐式转换

import spark.implicits._

//数据加载进来

val ratingDF = spark

.read

.option("uri",mongoConfig.uri)

.option("collection",MONGODB_RATING_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[Rating]

.toDF()

//创建一张名叫ratings的表

ratingDF.createOrReplaceTempView("ratings")

//TODO: 不同的统计推荐结果

spark.stop()

}

1. 1. 1. 历史热门商品统计

根据所有历史评分数据，计算历史评分次数最多的商品。

实现思路：

通过Spark SQL读取评分数据集，统计所有评分中评分数最多的商品，然后按照从大到小排序，将最终结果写入MongoDB的RateMoreProducts数据集中。

//统计所有历史数据中每个商品的评分数

//数据结构 -> productId,count

val rateMoreProductsDF = spark.sql("select productId, count(productId) as count from ratings group by productId ")

rateMoreProductsDF

.write

.option("uri",mongoConfig.uri)

.option("collection",RATE_MORE_PRODUCTS)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

1. 1. 1. 最近热门商品统计

根据评分，按月为单位计算最近时间的月份里面评分数最多的商品集合。

实现思路：

通过Spark SQL读取评分数据集，通过UDF函数将评分的数据时间修改为月，然后统计每月商品的评分数。统计完成之后将数据写入到MongoDB的RateMoreRecentlyProducts数据集中。

//统计以月为单位拟每个商品的评分数

//数据结构 -》 productId,count,time

//创建一个日期格式化工具

val simpleDateFormat = new SimpleDateFormat("yyyyMM")

//注册一个UDF函数，用于将timestamp装换成年月格式 1260759144000 => 201605

spark.udf.register("changeDate",(x:Int) => simpleDateFormat.format(new Date(x * 1000L)).toInt)

// 将原来的Rating数据集中的时间转换成年月的格式

val ratingOfYearMonth = spark.sql("select productId, score, changeDate(timestamp) as yearmonth from ratings")

// 将新的数据集注册成为一张表

ratingOfYearMonth.createOrReplaceTempView("ratingOfMonth")

val rateMoreRecentlyProducts = spark.sql("select productId, count(productId) as count ,yearmonth from ratingOfMonth group by yearmonth,productId order by yearmonth desc, count desc")

rateMoreRecentlyProducts

.write

.option("uri",mongoConfig.uri)

.option("collection",RATE_MORE_RECENTLY_PRODUCTS)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

1. 1. 1. 商品平均得分统计

根据历史数据中所有用户对商品的评分，周期性的计算每个商品的平均得分。

实现思路：

通过Spark SQL读取保存在MongDB中的Rating数据集，通过执行以下SQL语句实现对于商品的平均分统计：

//统计每个商品的平均评分

val averageProductsDF = spark.sql("select productId, avg(score) as avg from ratings group by productId ")

averageProductsDF

.write

.option("uri",mongoConfig.uri)

.option("collection",AVERAGE_PRODUCTS)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

统计完成之后将生成的新的DataFrame写出到MongoDB的AverageProducts集合中。

1. 1. 协同过滤服务

1. 1. 1. 用户商品推荐列表

通过ALS训练出来的Model来计算所有当前用户商品的推荐列表，主要思路如下：

userId和productId做笛卡尔积，产生（userId，productId）的元组
通过模型预测（userId，productId）对应的评分。
将预测结果通过预测分值进行排序。
返回分值最大的K个商品，作为当前用户的推荐列表。

最后生成的数据结构如下：将数据保存到MongoDB的UserRecs表中

新建recommender的子项目OfflineRecommender，引入spark、scala、mongo和jblas的依赖：

<groupId>org.scalanlp</groupId>

<artifactId>jblas</artifactId>

<version>${jblas.version}</version>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-core_2.11</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-sql_2.11</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-mllib_2.11</artifactId>

</dependency>

<groupId>org.scala-lang</groupId>

<artifactId>scala-library</artifactId>

</dependency>

<groupId>org.mongodb</groupId>

<artifactId>casbah-core_2.11</artifactId>

<version>${casbah.version}</version>

</dependency>

<groupId>org.mongodb.spark</groupId>

<artifactId>mongo-spark-connector_2.11</artifactId>

<version>${mongodb-spark.version}</version>

</dependency>

</dependencies>

同样经过前期的构建样例类、声明配置、创建SparkSession等步骤，可以加载数据开始计算模型了。

核心代码如下：

src/main/scala/com.qingtaishuju.offline/OfflineRecommender.scala

case class ProductRating(userId: Int, productId: Int, score: Double, timestamp: Int)

case class MongoConfig(uri:String, db:String)

// 标准推荐对象，productId,score

case class Recommendation(productId: Int, score:Double)

// 用户推荐列表

case class UserRecs(userId: Int, recs: Seq[Recommendation])

// 商品相似度（商品推荐）

case class ProductRecs(productId: Int, recs: Seq[Recommendation])

object OfflineRecommmeder {

// 定义常量

val MONGODB_RATING_COLLECTION = "Rating"

// 推荐表的名称

val USER_RECS = "UserRecs"

val PRODUCT_RECS = "ProductRecs"

val USER_MAX_RECOMMENDATION = 20

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

// 定义配置

val config = Map(

"spark.cores" -> "local[*]",

"mongo.uri" -> "mongodb://localhost:27017/recommender",

"mongo.db" -> "recommender"

)

// 创建spark session

val sparkConf = new SparkConf().setMaster(config("spark.cores")).setAppName("OfflineRecommender")

val spark = SparkSession.builder().config(sparkConf).getOrCreate()

implicit val mongoConfig = MongoConfig(config("mongo.uri"),config("mongo.db"))

import spark.implicits._

//读取mongoDB中的业务数据

val ratingRDD = spark

.read

.option("uri",mongoConfig.uri)

.option("collection",MONGODB_RATING_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[ProductRating]

.rdd

.map(rating=> (rating.userId, rating.productId, rating.score)).cache()

//用户的数据集 RDD[Int]

val userRDD = ratingRDD.map(_._1).distinct()

val prodcutRDD = ratingRDD.map(_._2).distinct()

//创建训练数据集

val trainData = ratingRDD.map(x => Rating(x._1,x._2,x._3))

// rank 是模型中隐语义因子的个数, iterations 是迭代的次数, lambda 是ALS的正则化参

val (rank,iterations,lambda) = (50, 5, 0.01)

// 调用ALS算法训练隐语义模型

val model = ALS.train(trainData,rank,iterations,lambda)

//计算用户推荐矩阵

val userProducts = userRDD.cartesian(productRDD)

// model已训练好，把id传进去就可以得到预测评分列表RDD[Rating] (userId,productId,rating)

val preRatings = model.predict(userProducts)

val userRecs = preRatings

.filter(_.rating > 0)

.map(rating => (rating.user,(rating.product, rating.rating)))

.groupByKey()

.map{

case (userId,recs) => UserRecs(userId,recs.toList.sortWith(_._2 >

_._2).take(USER_MAX_RECOMMENDATION).map(x => Recommendation(x._1,x._2)))

}.toDF()

userRecs.write

.option("uri",mongoConfig.uri)

.option("collection",USER_RECS)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

//TODO：计算商品相似度矩阵

// 关闭spark

spark.stop()

}

1. 1. 1. 商品相似度矩阵

通过ALS计算商品相似度矩阵，该矩阵用于查询当前商品的相似商品并为实时推荐系统服务。

离线计算的ALS 算法，算法最终会为用户、商品分别生成最终的特征矩阵，分别是表示用户特征矩阵的U(m x k)矩阵，每个用户由 k个特征描述；表示物品特征矩阵的V(n x k)矩阵，每个物品也由 k 个特征描述。

V(n x k)表示物品特征矩阵，每一行是一个 k 维向量，虽然我们并不知道每一个维度的特征意义是什么，但是k 个维度的数学向量表示了该行对应商品的特征。

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

核心代码如下：

//计算商品相似度矩阵

//获取商品的特征矩阵，数据格式 RDD[(scala.Int, scala.Array[scala.Double])]

val productFeatures = model.productFeatures.map{case (productId,features) =>

(productId, new DoubleMatrix(features))

}

// 计算笛卡尔积并过滤合并

val productRecs = productFeatures.cartesian(productFeatures)

.filter{case (a,b) => a._1 != b._1}

.map{case (a,b) =>

val simScore = this.consinSim(a._2,b._2) // 求余弦相似度

(a._1,(b._1,simScore))

}.filter(_._2._2 > 0.6)

.groupByKey()

.map{case (productId,items) =>

ProductRecs(productId,items.toList.map(x => Recommendation(x._1,x._2)))

}.toDF()

productRecs

.write

.option("uri", mongoConfig.uri)

.option("collection",PRODUCT_RECS)

.mode("overwrite")

.format("com.mongodb.spark.sql")

.save()

其中，consinSim是求两个向量余弦相似度的函数，代码实现如下：

//计算两个商品之间的余弦相似度

def consinSim(product1: DoubleMatrix, product2:DoubleMatrix) : Double ={

product1.dot(product2) / ( product1.norm2() * product2.norm2() )

}

1. 1. 1. 模型评估和参数选取

在上述模型训练的过程中，我们直接给定了隐语义模型的rank,iterations,lambda三个参数。对于我们的模型，这并不一定是最优的参数选取，所以我们需要对模型进行评估。通常的做法是计算均方根误差（RMSE），考察预测评分与实际评分之间的误差。

RMSE=1Nt=1N(observedt-predictedt)2

有了RMSE，我们可以就可以通过多次调整参数值，来选取RMSE最小的一组作为我们模型的优化选择。

在scala/com.atguigu.offline/下新建单例对象ALSTrainer，代码主体架构如下：

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

val config = Map(

"spark.cores" -> "local[*]",

"mongo.uri" -> "mongodb://localhost:27017/recommender",

"mongo.db" -> "recommender"

)

//创建SparkConf

val sparkConf = new SparkConf().setAppName("ALSTrainer").setMaster(config("spark.cores"))

//创建SparkSession

val spark = SparkSession.builder().config(sparkConf).getOrCreate()

val mongoConfig = MongoConfig(config("mongo.uri"),config("mongo.db"))

import spark.implicits._

//加载评分数据

val ratingRDD = spark

.read

.option("uri",mongoConfig.uri)

.option("collection",OfflineRecommender.MONGODB_RATING_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[ProductRating]

.rdd

.map(rating => Rating(rating.userId,rating.productId,rating.score)).cache()

// 将一个RDD随机切分成两个RDD，用以划分训练集和测试集

val splits = ratingRDD.randomSplit(Array(0.8, 0.2))

val trainingRDD = splits(0)

val testingRDD = splits(1)

//输出最优参数

adjustALSParams(trainingRDD, testingRDD)

//关闭Spark

spark.close()

}

其中adjustALSParams方法是模型评估的核心，输入一组训练数据和测试数据，输出计算得到最小RMSE的那组参数。代码实现如下：

// 输出最终的最优参数

def adjustALSParams(trainData:RDD[Rating], testData:RDD[Rating]): Unit ={

// 这里指定迭代次数为5，rank和lambda在几个值中选取调整

val result = for(rank <- Array(100,200,250); lambda <- Array(1, 0.1, 0.01, 0.001))

yield {

val model = ALS.train(trainData,rank,5,lambda)

val rmse = getRMSE(model, testData)

(rank,lambda,rmse)

}

// 按照rmse排序

println(result.sortBy(_._3).head)

}

计算RMSE的函数getRMSE代码实现如下：

def getRMSE(model:MatrixFactorizationModel, data:RDD[Rating]):Double={

val userProducts = data.map(item => (item.user,item.product))

val predictRating = model.predict(userProducts)

val real = data.map(item => ((item.user,item.product),item.rating))

val predict = predictRating.map(item => ((item.user,item.product),item.rating))

// 计算RMSE

sqrt(

real.join(predict).map{case ((userId,productId),(real,pre))=>

// 真实值和预测值之间的差

val err = real - pre

err * err

}.mean()

)

}

运行代码，我们就可以得到目前数据的最优模型参数。

1. 实时推荐服务建设

1. 1. 实时推荐服务

实时计算与离线计算应用于推荐系统上最大的不同在于实时计算推荐结果应该反映最近一段时间用户近期的偏好，而离线计算推荐结果则是根据用户从第一次评分起的所有评分记录来计算用户总体的偏好。

用户对物品的偏好随着时间的推移总是会改变的。比如一个用户u 在某时刻对商品p 给予了极高的评分，那么在近期一段时候，u 极有可能很喜欢与商品p 类似的其他商品；而如果用户u 在某时刻对商品q 给予了极低的评分，那么在近期一段时候，u 极有可能不喜欢与商品q 类似的其他商品。所以对于实时推荐，当用户对一个商品进行了评价后，用户会希望推荐结果基于最近这几次评分进行一定的更新，使得推荐结果匹配用户近期的偏好，满足用户近期的口味。

如果实时推荐继续采用离线推荐中的ALS 算法，由于算法运行时间巨大，不具有实时得到新的推荐结果的能力；并且由于算法本身的使用的是评分表，用户本次评分后只更新了总评分表中的一项，使得算法运行后的推荐结果与用户本次评分之前的推荐结果基本没有多少差别，从而给用户一种推荐结果一直没变化的感觉，很影响用户体验。

另外，在实时推荐中由于时间性能上要满足实时或者准实时的要求，所以算法的计算量不能太大，避免复杂、过多的计算造成用户体验的下降。鉴于此，推荐精度往往不会很高。实时推荐系统更关心推荐结果的动态变化能力，只要更新推荐结果的理由合理即可，至于推荐的精度要求则可以适当放宽。

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

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

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

1. 1. 实时推荐模型和代码框架

1. 1. 1. 算法设计

当用户u 对商品p 进行了评分，将触发一次对u 的推荐结果的更新。由于用户u 对商品p 评分，对于用户u 来说，他与p 最相似的商品们之间的推荐强度将发生变化，所以选取与商品p 最相似的K 个商品作为候选商品。

每个候选商品按照“推荐优先级”这一权重作为衡量这个商品被推荐给用户u 的优先级。

这些商品将根据用户u 最近的若干评分计算出各自对用户u 的推荐优先级，然后与上次对用户u 的实时推荐结果的进行基于推荐优先级的合并、替换得到更新后的推荐结果。

具体来说：

首先，获取用户u 按时间顺序最近的K 个评分，记为RK；获取商品p 的最相似的K 个商品集合，记为S；

然后，对于每个商品q S ，计算其推荐优先级，计算公式如下：

其中：

表示用户u 对商品r 的评分；

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：

其中，i表示updated_S 与Rec 的商品集合中的每个商品，topK 是一个函数，表示从 Rec updated _ S中选择出最大的 K 个商品，cmp = 表示topK 函数将推荐优先级值最大的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；作为最终输出。

1. 1. 1. 模块框架

我们在recommender下新建子项目StreamingRecommender，引入spark、scala、mongo、redis和kafka的依赖:

<groupId>org.apache.spark</groupId>

<artifactId>spark-core_2.11</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-sql_2.11</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-streaming_2.11</artifactId>

</dependency>

<groupId>org.scala-lang</groupId>

<artifactId>scala-library</artifactId>

</dependency>

<groupId>org.mongodb</groupId>

<artifactId>casbah-core_2.11</artifactId>

<version>${casbah.version}</version>

</dependency>

<groupId>org.mongodb.spark</groupId>

<artifactId>mongo-spark-connector_2.11</artifactId>

<version>${mongodb-spark.version}</version>

</dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</dependency>

<groupId>org.apache.kafka</groupId>

<artifactId>kafka-clients</artifactId>

</dependency>

<groupId>org.apache.spark</groupId>

<artifactId>spark-streaming-kafka-0-10_2.11</artifactId>

<version>${spark.version}</version>

</dependency>

</dependencies>

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

src/main/scala/com.atguigu.streaming/StreamingRecommender.scala

// 连接助手对象

object ConnHelper extends Serializable{

lazy val jedis = new Jedis("localhost")

lazy val mongoClient = MongoClient(MongoClientURI("mongodb://localhost:27017/recommender"))

}

case class MongConfig(uri:String,db:String)

// 标准推荐

case class Recommendation(productId:Int, score:Double)

// 用户的推荐

case class UserRecs(userId:Int, recs:Seq[Recommendation])

//商品的相似度

case class ProductRecs(productId:Int, recs:Seq[Recommendation])

object StreamingRecommender {

val MAX_USER_RATINGS_NUM = 20

val MAX_SIM_PRODUCTS_NUM = 20

val MONGODB_STREAM_RECS_COLLECTION = "StreamRecs"

val MONGODB_RATING_COLLECTION = "Rating"

val MONGODB_PRODUCT_RECS_COLLECTION = "ProductRecs"

//入口方法

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

}

实时推荐主体代码如下：

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

val config = Map(

"spark.cores" -> "local[*]",

"mongo.uri" -> "mongodb://localhost:27017/recommender",

"mongo.db" -> "recommender",

"kafka.topic" -> "recommender"

)

//创建一个SparkConf配置

val sparkConf = new SparkConf().setAppName("StreamingRecommender").setMaster(config("spark.cores"))

val spark = SparkSession.builder().config(sparkConf).getOrCreate()

val sc = spark.sparkContext

val ssc = new StreamingContext(sc,Seconds(2))

implicit val mongConfig = MongConfig(config("mongo.uri"),config("mongo.db"))

import spark.implicits._

// 广播商品相似度矩阵

//装换成为 Map[Int, Map[Int,Double]]

val simProductsMatrix = spark

.read

.option("uri",config("mongo.uri"))

.option("collection",MONGODB_PRODUCT_RECS_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[ProductRecs]

.rdd

.map{recs =>

(recs.productId,recs.recs.map(x=> (x.productId,x.score)).toMap)

}.collectAsMap()

val simProductsMatrixBroadCast = sc.broadcast(simProductsMatrix)

//创建到Kafka的连接

val kafkaPara = Map(

"bootstrap.servers" -> "localhost:9092",

"key.deserializer" -> classOf[StringDeserializer],

"value.deserializer" -> classOf[StringDeserializer],

"group.id" -> "recommender",

"auto.offset.reset" -> "latest"

)

val kafkaStream = KafkaUtils.createDirectStream[String,String](ssc,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe[String,String](Array(config("kafka.topic")),kafkaPara))

// UID|MID|SCORE|TIMESTAMP

// 产生评分流

val ratingStream = kafkaStream.map{case msg=>

var attr = msg.value().split("\\|")

(attr(0).toInt,attr(1).toInt,attr(2).toDouble,attr(3).toInt)

}

// 核心实时推荐算法

ratingStream.foreachRDD{rdd =>

rdd.map{case (userId,productId,score,timestamp) =>

println(">>>>>>>>>>>>>>>>")

//获取当前最近的M次商品评分

val userRecentlyRatings = getUserRecentlyRating(MAX_USER_RATINGS_NUM,userId,ConnHelper.jedis)

//获取商品P最相似的K个商品

val simProducts = getTopSimProducts(MAX_SIM_PRODUCTS_NUM,productId,userId,simProductsMatrixBroadCast.value)

//计算待选商品的推荐优先级

val streamRecs = computeProductScores(simProductsMatrixBroadCast.value,userRecentlyRatings,simProducts)

//将数据保存到MongoDB

saveRecsToMongoDB(userId,streamRecs)

}.count()

}

//启动Streaming程序

ssc.start()

ssc.awaitTermination()

}

1. 1. 实时推荐算法的实现

实时推荐算法的前提：

在Redis集群中存储了每一个用户最近对商品的K次评分。实时算法可以快速获取。
离线推荐算法已经将商品相似度矩阵提前计算到了MongoDB中。
Kafka已经获取到了用户实时的评分数据。

算法过程如下：

实时推荐算法输入为一个评分<userId, productId, rate, timestamp>，而执行的核心内容包括：获取userId 最近K 次评分、获取productId 最相似K 个商品、计算候选商品的推荐优先级、更新对userId 的实时推荐结果。

1. 1. 1. 获取用户的K次最近评分

import scala.collection.JavaConversions._

/**

* 获取当前最近的M次商品评分

* @param num 评分的个数

* @param userId 谁的评分

* @return

def getUserRecentlyRating(num:Int, userId:Int,jedis:Jedis): Array[(Int,Double)] ={

//从用户的队列中取出num个评分

jedis.lrange("userId:"+userId.toString, 0, num).map{item =>

val attr = item.split("\\:")

(attr(0).trim.toInt, attr(1).trim.toDouble)

}.toArray

}

1. 1. 1. 获取当前商品最相似的K个商品

在离线算法中，已经预先将商品的相似度矩阵进行了计算，所以每个商品productId 的最相似的K 个商品很容易获取：从MongoDB中读取ProductRecs数据，从productId 在simHash 对应的子哈希表中获取相似度前K 大的那些商品。输出是数据类型为Array[Int]的数组，表示与productId 最相似的商品集合，并命名为candidateProducts 以作为候选商品集合。

/**

* 获取当前商品K个相似的商品

* @param num 相似商品的数量

* @param productId 当前商品的ID

* @param userId 当前的评分用户

* @param simProducts 商品相似度矩阵的广播变量值

* @param mongConfig MongoDB的配置

* @return

def getTopSimProducts(num:Int, productId:Int, userId:Int, simProducts:scala.collection.Map[Int,scala.collection.immutable.Map[Int,Double]])(implicit mongConfig: MongConfig): Array[Int] ={

//从广播变量的商品相似度矩阵中获取当前商品所有的相似商品

val allSimProducts = simProducts.get(productId).get.toArray

//获取用户已经观看过得商品

val ratingExist = ConnHelper.mongoClient(mongConfig.db)(MONGODB_RATING_COLLECTION).find(MongoDBObject("userId" -> userId)).toArray.map{item =>

item.get("productId").toString.toInt

}

//过滤掉已经评分过得商品，并排序输出

allSimProducts.filter(x => !ratingExist.contains(x._1)).sortWith(_._2 > _._2).take(num).map(x => x._1)

}

1. 1. 1. 商品推荐优先级计算

对于候选商品集合simiHash和userId 的最近K 个评分recentRatings，算法代码内容如下：

/**

* 计算待选商品的推荐分数

* @param simProducts 商品相似度矩阵

* @param userRecentlyRatings 用户最近的k次评分

* @param topSimProducts 当前商品最相似的K个商品

* @return

def computeProductScores(

simProducts:scala.collection.Map[Int,scala.collection.immutable.Map[Int,Doub

le]],userRecentlyRatings:Array[(Int,Double)],topSimProducts: Array[Int]):

Array[(Int,Double)] ={

//用于保存每一个待选商品和最近评分的每一个商品的权重得分

val score = scala.collection.mutable.ArrayBuffer[(Int,Double)]()

//用于保存每一个商品的增强因子数

val increMap = scala.collection.mutable.HashMap[Int,Int]()

//用于保存每一个商品的减弱因子数

val decreMap = scala.collection.mutable.HashMap[Int,Int]()

for (topSimProduct <- topSimProducts; userRecentlyRating <- userRecentlyRatings){

val simScore = getProductsSimScore(simProducts,userRecentlyRating._1,topSimProduct)

if(simScore > 0.6){

score += ((topSimProduct, simScore * userRecentlyRating._2 ))

if(userRecentlyRating._2 > 3){

increMap(topSimProduct) = increMap.getOrDefault(topSimProduct,0) + 1

}else{

decreMap(topSimProduct) = decreMap.getOrDefault(topSimProduct,0) + 1

}

score.groupBy(_._1).map{case (productId,sims) =>

(productId,sims.map(_._2).sum / sims.length + log(increMap.getOrDefault(productId, 1)) - log(decreMap.getOrDefault(productId, 1)))

}.toArray.sortWith(_._2>_._2)

}

其中，getProductSimScore是取候选商品和已评分商品的相似度，代码如下：

/**

* 获取当个商品之间的相似度

* @param simProducts 商品相似度矩阵

* @param userRatingProduct 用户已经评分的商品

* @param topSimProduct 候选商品

* @return

def getProductsSimScore(

simProducts:scala.collection.Map[Int,scala.collection.immutable.Map[Int,Double]], userRatingProduct:Int, topSimProduct:Int): Double ={

simProducts.get(topSimProduct) match {

case Some(sim) => sim.get(userRatingProduct) match {

case Some(score) => score

case None => 0.0

}

case None => 0.0

}

而log是对数运算，这里实现为取10的对数（常用对数）：

//取10的对数

def log(m:Int):Double ={

math.log(m) / math.log(10)

}

1. 1. 1. 将结果保存到mongoDB

saveRecsToMongoDB函数实现了结果的保存：

/**

* 将数据保存到MongoDB userId -> 1, recs -> 22:4.5|45:3.8

* @param streamRecs 流式的推荐结果

* @param mongConfig MongoDB的配置

def saveRecsToMongoDB(userId:Int,streamRecs:Array[(Int,Double)])(implicit mongConfig: MongConfig): Unit ={

//到StreamRecs的连接

val streaRecsCollection = ConnHelper.mongoClient(mongConfig.db)(MONGODB_STREAM_RECS_COLLECTION)

streaRecsCollection.findAndRemove(MongoDBObject("userId" -> userId))

streaRecsCollection.insert(MongoDBObject("userId" -> userId, "recs" ->

streamRecs.map( x => MongoDBObject("productId"->x._1,"score"->x._2)) ))

}

1. 1. 1. 更新实时推荐结果

当计算出候选商品的推荐优先级的数组updatedRecommends<productId, E>后，这个数组将被发送到Web 后台服务器，与后台服务器上userId 的上次实时推荐结果recentRecommends<productId, E>进行合并、替换并选出优先级E 前K大的商品作为本次新的实时推荐。具体而言：

a.合并：将updatedRecommends 与recentRecommends 并集合成为一个新的<productId, E>数组；

b.替换（去重）：当updatedRecommends 与recentRecommends 有重复的商品productId 时，recentRecommends 中productId 的推荐优先级由于是上次实时推荐的结果，于是将作废，被替换成代表了更新后的updatedRecommends的productId 的推荐优先级；

c.选取TopK：在合并、替换后的<productId, E>数组上，根据每个product 的推荐优先级，选择出前K 大的商品，作为本次实时推荐的最终结果。

1. 实时系统联调

1. 1. 启动实时系统的基本组件

我们的系统实时推荐的数据流向是：业务系统 -> 日志 -> flume 日志采集 -> kafka streaming数据清洗和预处理 -> spark streaming 流式计算。在我们完成实时推荐服务的代码后，应该与其它工具进行联调测试，确保系统正常运行。

1. 1. 启动zookeeper

bin/zkServer.sh start

1. 1. 启动kafka

bin/kafka-server-start.sh -daemon ./config/server.properties

1. 1. 构建Kafka Streaming程序

在recommender下新建module，KafkaStreaming，主要用来做日志数据的预处理，过滤出需要的内容。pom.xml文件需要引入依赖：

<groupId>org.apache.kafka</groupId>

<artifactId>kafka-streams</artifactId>

</dependency>

<groupId>org.apache.kafka</groupId>

<artifactId>kafka-clients</artifactId>

</dependency>

</dependencies>

<build>

<finalName>kafkastream</finalName>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-assembly-plugin</artifactId>

<mainClass>com.atguigu.kafkastream.Application</mainClass>

</manifest>

</archive>

<descriptorRef>jar-with-dependencies</descriptorRef>

</descriptorRefs>

</configuration>

<id>make-assembly</id>

<phase>package</phase>

<goals>

<goal>single</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

在src/main/java下新建java类com.atguigu.kafkastreaming.Application

public class Application {

public static void main(String[] args){

String brokers = "localhost:9092";

String zookeepers = "localhost:2181";

// 定义输入和输出的topic

String from = "log";

String to = "recommender";

// 定义kafka streaming的配置

Properties settings = new Properties();

settings.put(StreamsConfig.APPLICATION_ID_CONFIG, "logFilter");

settings.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, brokers);

settings.put(StreamsConfig.ZOOKEEPER_CONNECT_CONFIG, zookeepers);

StreamsConfig config = new StreamsConfig(settings);

// 拓扑建构器

TopologyBuilder builder = new TopologyBuilder();

// 定义流处理的拓扑结构

builder.addSource("SOURCE", from)

.addProcessor("PROCESS", () -> new LogProcessor(), "SOURCE")

.addSink("SINK", to, "PROCESS");

KafkaStreams streams = new KafkaStreams(builder, config);

streams.start();

}

这个程序会将topic为“log”的信息流获取来做处理，并以“recommender”为新的topic转发出去。

流处理程序 LogProcess.java

public class LogProcessor implements Processor<byte[],byte[]> {

private ProcessorContext context;

public void init(ProcessorContext context) {

this.context = context;

}

public void process(byte[] dummy, byte[] line) {

String input = new String(line);

// 根据前缀过滤日志信息，提取后面的内容

if(input.contains("PRODUCT_RATING_PREFIX:")){

System.out.println("product rating coming!!!!" + input);

input = input.split("PRODUCT_RATING_PREFIX:")[1].trim();

context.forward("logProcessor".getBytes(), input.getBytes());

}

public void punctuate(long timestamp) {

}

public void close() {

}

完成代码后，启动Application。

1. 1. 配置并启动flume

在flume的conf目录下新建log-kafka.properties，对flume连接kafka做配置：

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

/mnt/d/Projects/BigData/ECommerceRecommenderSystem/businessServer/src/main/log/agent.log

agent.sources.exectail.interceptors=i1

agent.sources.exectail.interceptors.i1.type=regex_filter

# 定义日志过滤前缀的正则

agent.sources.exectail.interceptors.i1.regex=.+PRODUCT_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 = localhost: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：

./bin/flume-ng agent -c ./conf/ -f ./conf/log-kafka.properties -n agent -Dflume.root.logger=INFO,console

1. 1. 启动业务系统后台

将业务代码加入系统中。注意在src/main/resources/ 下的 log4j.properties中，log4j.appender.file.File的值应该替换为自己的日志目录，与flume中的配置应该相同。

启动业务系统后台，访问localhost:8088/index.html；点击某个商品进行评分，查看实时推荐列表是否会发生变化。

1. 冷启动问题处理

整个推荐系统更多的是依赖于用于的偏好信息进行商品的推荐，那么就会存在一个问题，对于新注册的用户是没有任何偏好信息记录的，那这个时候推荐就会出现问题，导致没有任何推荐的项目出现。

处理这个问题一般是通过当用户首次登陆时，为用户提供交互式的窗口来获取用户对于物品的偏好，让用户勾选预设的兴趣标签。

当获取用户的偏好之后，就可以直接给出相应类型商品的推荐。

1. 其它形式的离线相似推荐服务

1. 1. 基于内容的相似推荐

原始数据中的tag文件，是用户给商品打上的标签，这部分内容想要直接转成评分并不容易，不过我们可以将标签内容进行提取，得到商品的内容特征向量，进而可以通过求取相似度矩阵。这部分可以与实时推荐系统直接对接，计算出与用户当前评分商品的相似商品，实现基于内容的实时推荐。为了避免热门标签对特征提取的影响，我们还可以通过TF-IDF算法对标签的权重进行调整，从而尽可能地接近用户偏好。

基于以上思想，加入TF-IDF算法的求取商品特征向量的核心代码如下：

// 载入商品数据集

val productTagsDF = spark

.read

.option("uri",mongoConfig.uri)

.option("collection",MONGODB_PRODUCT_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[Product]

.map(x => (x.productId, x.name, x.genres.map(c => if(c == '|') ' ' else c)))

.toDF("productId", "name", "tags").cache()

// 实例化一个分词器，默认按空格分

val tokenizer = new Tokenizer().setInputCol("tags").setOutputCol("words")

// 用分词器做转换

val wordsData = tokenizer.transform(productTagsDF)

// 定义一个HashingTF工具

val hashingTF = new HashingTF().setInputCol("words").setOutputCol("rawFeatures").setNumFeatures(200)

// 用 HashingTF 做处理

val featurizedData = hashingTF.transform(wordsData)

// 定义一个IDF工具

val idf = new IDF().setInputCol("rawFeatures").setOutputCol("features")

// 将词频数据传入，得到idf模型（统计文档）

val idfModel = idf.fit(featurizedData)

// 用tf-idf算法得到新的特征矩阵

val rescaledData = idfModel.transform(featurizedData)

// 从计算得到的 rescaledData 中提取特征向量

val productFeatures = rescaledData.map{

case row => ( row.getAs[Int]("productId"),row.getAs[SparseVector]("features").toArray )

}

.rdd

.map(x => {

(x._1, new DoubleMatrix(x._2) )

})

然后通过商品特征向量进而求出相似度矩阵，就可以在商品详情页给出相似推荐了；通常在电商网站中，用户浏览商品或者购买完成之后，都会显示类似的推荐列表。

得到的相似度矩阵也可以为实时推荐提供基础，得到用户推荐列表。可以看出，基于内容和基于隐语义模型，目的都是为了提取出物品的特征向量，从而可以计算出相似度矩阵。而我们的实时推荐系统算法正是基于相似度来定义的。

1. 1. 基于物品的协同过滤相似推荐

基于物品的协同过滤（Item-CF），只需收集用户的常规行为数据（比如点击、收藏、购买）就可以得到商品间的相似度，在实际项目中应用很广。

我们的整体思想是，如果两个商品有同样的受众（感兴趣的人群），那么它们就是有内在相关性的。所以可以利用已有的行为数据，分析商品受众的相似程度，进而得出商品间的相似度。我们把这种方法定义为物品的“同现相似度”，公式如下：

其中，Ni 是购买商品 i （或对商品 i 评分）的用户列表，Nj 是购买商品 j 的用户列表。

核心代码实现如下：

val ratingDF = spark.read

.option("uri", mongoConfig.uri)

.option("collection", MONGODB_RATING_COLLECTION)

.format("com.mongodb.spark.sql")

.load()

.as[Rating]

.map(x=> (x.userId, x.productId, x.score) )

.toDF("userId", "productId", "rating")

// 统计每个商品的评分个数，并通过内连接添加到 ratingDF 中

val numRatersPerProduct = ratingDF.groupBy("productId").count()

val ratingWithCountDF = ratingDF.join(numRatersPerProduct, "productId")

// 将商品评分按 userId 两两配对，可以统计两个商品被同一用户做出评分的次数

val joinedDF = ratingWithCountDF.join(ratingWithCountDF, "userId")

.toDF("userId", "product1", "rating1", "count1", "product2", "rating2", "count2")

.select("userId", "product1", "count1", "product2", "count2")

joinedDF.createOrReplaceTempView("joined")

val cooccurrenceDF = spark.sql(

"""

|select product1

|, product2

|, count(userId) as coocount

|, first(count1) as count1

|, first(count2) as count2

|from joined

|group by product1, product2

""".stripMargin

).cache()

val simDF = cooccurrenceDF.map{ row =>

// 用同现的次数和各自的次数，计算同现相似度

val coocSim = cooccurrenceSim( row.getAs[Long]("coocount"), row.getAs[Long]("count1"), row.getAs[Long]("count2") )

( row.getAs[Int]("product1"), ( row.getAs[Int]("product2"), coocSim ) )

}

.rdd

.groupByKey()

.map{

case (productId, recs) =>

ProductRecs( productId,

recs.toList

.filter(x=>x._1 != productId)

.sortWith(_._2>_._2)

.map(x=>Recommendation(x._1,x._2))

.take(MAX_RECOMMENDATION)

)

}

.toDF()

其中，计算同现相似度的函数代码实现如下：

def cooccurrenceSim(cooCount: Long, count1: Long, count2: Long): Double ={

cooCount / math.sqrt( count1 * count2 )

}

1. 项目运行预览

长岛山没有雪

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
电商推荐系统（项目架构设计）数据加载准备，实时推荐算法MongoDB，Redis，Spark，Zookeeper，Flume-ng，Kafka工具环境搭建

然后，将u 最近的K 个评分中与商品q 相似的、且本身评分较高（>=3）的商品个数记为 incount，计算lgmax{incount,1}作为商品 q 的“增强因子”，意义在于商品q 与u 的最近K 个评分中的n 个高评分(>=3)商品相似，则商品q 的优先级被增加lgmax{incount,1}。并且由于算法本身的使用的是评分表，用户本次评分后只更新了总评分表中的一项，使得算法运行后的推荐结果与用户本次评分之前的推荐结果基本没有多少差别，从而给用户一种推荐结果一直没变化的感觉，很影响用户体验。
复制链接

扫一扫

电商推荐系统（项目架构设计）数据加载准备，实时推荐算法MongoDB，Redis，Spark，Zookeeper，Flume-ng，Kafka工具环境搭建

3.2.1 Products数据集

2.Ratings数据集

3 日志管理配置文件

1.数据加载程序主体实现

2. 将数据写入MongoDB

统计服务主体框架

历史热门商品统计

最近热门商品统计

商品平均得分统计

用户商品推荐列表

商品相似度矩阵

模型评估和参数选取

算法设计

模块框架

获取用户的K次最近评分

获取当前商品最相似的K个商品

商品推荐优先级计算

更新实时推荐结果