scala spark 示例代码
1. 导入隐式转换
import spark.implicits._
2. 读取 / 存储 mongodb 数据并转换为对象 df （不 as 转换也是 DataFrame 对象，但一般会习惯转换一下在进行操作）
case class Rating(val uid: Int, val mid: Int, val score: Double, val timestamp: Int) val ratingsDF = spark.read .option("uri", mongoConfig.uri) .option("collection", MONGO_RATINGS_COLLECTION) .format("com.mongodb.spark.sql") .load() .as[Rating] .toDF() count.write .option("uri", mongoConfig.uri) .option("collection", MONGO_MOVIE_SCORE_COUNT) .format("com.mongodb.spark.sql") .mode("overwrite") .save()
3. 将 DataFrame 转换为 sql 表进行操作， 如果例如有时间格式化等功能需要加入 sql 语句中，需要 注册一个 UDF 函数 来操作
//统计以月为单位每个电影的评分数 val simpleDateFormat = new SimpleDateFormat("yyyyMM") //注册一个UDF函数， 用于将timestamp转换成年月形式 spark.udf.register("changeDate", (x:Int) => simpleDateFormat.format(new Date(x*1000L)).toInt) val mouthCountDF = spark.sql("select mid, count(mid) count, changeDate(timestamp) as yearmouth from ratings group by yearmouth,mid order by count desc")
4. 将 2 个 RDD 通过某个字段进行 join
//统计每种电影类别中评分最高的10个电影 val movieWithScore = movieDF.join(avgMoviesDF, Seq("mid", "mid"))
5. 将 list 转化为 RDD
val genres = List("Action", "Adventure", "Animation", "Comedy", "Ccrime", "Documentary", "Drama", "Family", "Fantasy", "Foreign", "History", "Horror", "Music", "Mystery", "Romance", "Science", "Tv", "Thriller", "War", "Western") val genresRDD = spark.sparkContext.makeRDD(genres)
6. 过滤 某个 RDD 中包含另一个 RDD 的数据
genresRDD.cartesian(movieWithScore.rdd) .filter{case (genres, row) => row.getAs[String]("genres").contains(genres) }
7. 如果一个RDD 格式为 RDD[(String, Iterable[(Integer, Double)])], 这样的格式，需要对 rdd 中的迭代器中的某个字段进行排序， 例如 Double 这个字段, 并且只取前 10 条记录
.map{case (genres, item) =>
(GenresRecommendation(genres, item.toList.sortWith(_._2 > _._2).take(10).map(x => Recommendation(x._1, x._2))))
}
8. 推荐算法 用户相似度推荐算法 （根据用户对各个电影的评分，计算出用户除了评分电影外，还有可能对那些电影感兴趣，包含计算的字段就是 用户，电影，评分）
//1.首先需要做一个 ALS训练模型 model，那么久需要创建一个训练集， 训练集 为 Rating（org.apache.spark.mllib.recommendation.Rating） 对象， 字段为 3个，如下，： x._1, x._2, x._3
x._1 为 uid 用户id， x._2 为 mid 电影 id， x._3 为评分 这样的三个字段， 所以需要先将 ratingsRDD 转化成这3个字段的rdd，
val trainData = ratingsRDD.map(x => Rating(x._1, x._2, x._3))
//2.设置训练参数
val (rank, iterations, lambda) = (50, 10, 0.01)
//3.创建训练 ALS模型， 也就是后面要进行相似度计算的时候要以这个model为原模型进行匹配计算
val model = ALS.train(trainData, rank, iterations, lambda)
//4.要使用这个 model 进行计算，还需要有一个格式为 RDD[(Int, Int)] 这样一个待计算的 Rdd，因为 model 模型创建的时候是 uid， mid， score， 所以这个RDD 第一个 Int 应该是uid， 第二个RDD 是 mid
所以要先获得这样一个 RDD， 首先获得一个 RDD[Int] 格式的 userRDD， 然后获得一个 RDD[Int] 格式的 movieRDD， 再做 笛卡尔积 就可以获得 RDD[(Int, Int)]
val userMovies = userRDD.cartesian(movieRDD)
//5.使用 predict 方法计算相似度
val preRatings = model.predict(userMovies)
//转换成我们希望的推荐对象矩阵 （计算出的 preRatings 是一个Rating对象， 通过如下字段就能拿到我们想要的数据， 格式为 RDD[(Int, (Int, Double))]，也就是 RDD[(uid, (mid, score))]）,然后再通过
需求转换成我们想要的格式活对象
val userRecommender = preRatings.map(rating => (rating.user, (rating.product, rating.rating)))
.groupByKey()
.map {
case (uid, recs) => UserRecommender(uid, recs.toList.sortWith(_._2 > _._2).take(20).map(x => Recommenderation(x._1, x._2)))
}.toDF()
9. 电影相似度推荐算法 （电影相似度是 电影矩阵中 uid， mid， score， 用户对很多电影进行过评分，根据用户对电影的喜好计算出那些电影比较相似， 所以还是使用上面的 model 来进行计算）
//1. model.productFeatures 将会获得一个 RDD[(Int, Array[Double])] 的 RDD， 需要将 Array[Double] 转化为 DoubleMatrix
val movieFeatures = model.productFeatures.map { case (mid, freatures) => (mid, new DoubleMatrix(freatures)) }
//电影相识度矩阵计算
val movieRecommender = movieFeatures.cartesian(movieFeatures)
.filter { case (a, b) => a._1 != b._1 }
.map {
case (a, b) =>
val simSocore = this.consinSim(a._2, b._2)
(a._1, (b._1, simSocore))
}.filter(_._2._2 > 0.6)
.groupByKey()
.map {
case (mid, recs) => (MovieRecommender(mid, recs.toList.sortWith(_._2 > _._2).map(x => Recommenderation(x._1, x._2))))
}.toDF()
def consinSim(movie1: DoubleMatrix, movie2: DoubleMatrix): Double = {
movie1.dot(movie2) / (movie1.norm2() * movie2.norm2())
}
