Spark大数据分析与实战：基于Spark MLlib 实现音乐推荐

原创

已于 2022-09-15 16:45:11 修改 · 1.8w 阅读

179

185 ·

CC 4.0 BY-SA版权

JohnZhuang666

文章标签：

#MLlib #spark #auc #推荐系统 #scala

于 2021-06-26 16:29:32 首次发布

本文介绍了基于Spark MLlib利用Audioscrobbler数据集实现音乐推荐的过程，包括数据处理、AUC评分计算，旨在优化推荐结果的多样性。通过实验，展示了如何计算和应用最优参数进行用户和艺术家推荐，并讨论了AUC在评估模型性能中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spark大数据分析与实战：基于Spark MLlib 实现音乐推荐

基于Spark MLlib 实现音乐推荐

一、实验背景：

熟悉 Audioscrobbler 数据集

基于该数据集选择合适的 MLlib 库算法进行数据处理

进行音乐推荐（或用户推荐）

二、实验目的：

计算AUC评分最高的参数

利用AUC评分最高的参数，给用户推荐艺术家

对多个用户进行艺术家推荐

利用AUC评分最高的参数，给艺术家推荐喜欢他的用户

三、实验步骤：

安装Hadoop和Spark
启动Hadoop与Spark
将文件上传到 HDFS
实现音乐推荐

四、实验过程：

1、安装Hadoop和Spark

具体的安装过程在我以前的博客里面有，大家可以通过以下链接进入操作：

Hadoop的安装：https://blog.csdn.net/weixin_47580081/article/details/108647420
Scala及Spark的安装：https://blog.csdn.net/weixin_47580081/article/details/114250894

提示：如果IDEA未构建Spark项目，可以转接到以下的博客：

IDEA使用Maven构建Spark项目：https://blog.csdn.net/weixin_47580081/article/details/115435536

2、启动Hadoop与Spark

查看3个节点的进程

master 在这里插入图片描述
slave1

slave2

3、将文件上传到 HDFS

Shell命令：

[root@master ~]# cd /opt/data/profiledata_06-May-2005/
[root@master profiledata_06-May-2005]# ls
[root@master profiledata_06-May-2005]# hadoop dfs -put artist_alias.txt artist_data.txt user_artist_data.txt /spark/input

在这里插入图片描述

4、实现音乐推荐

源代码：

package com.John.SparkProject

import org.apache.spark.SparkConf
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.ml.recommendation.{
   
   ALS, ALSModel}
import org.apache.spark.sql.functions._
import org.apache.spark.sql.{
   
   DataFrame, Dataset, SparkSession}

import scala.collection.mutable.ArrayBuffer
import scala.util.Random


/**
 * @author John
 * @Date 2021/5/25 12:49
 */
object project02 {
   
   
  def main(args: Array[String]): Unit = {
   
   

    /**
     * 前期环境配置以及数据准备
     */
    // 创建一个SparkSession对象
    val conf = new SparkConf()
      .setMaster("local[2]")
      .setAppName("Project02_RecommenderApp")
      .set("spark.sql.crossJoin.enabled", "true")
    val spark = new SparkSession.Builder()
      .config(conf)
      .getOrCreate()

    import spark.implicits._
    // 导入 artist_data.txt 文件 (每个艺术家的 ID 和对应的名字)
    // 字段名分别是: artistid artist_name
    val rawArtistData = spark.read.textFile("hdfs://192.168.254.122:9000/spark/input/artist_data.txt")
    val artistIdDF = transformArtistData(rawArtistData)
    val artistIdDFtest = transformArtistData1(rawArtistData)

    // 导入 artist_alias.txt 文件 (将拼写错误的艺术家 ID 或ID 变体对应到该艺术家的规范 ID)
    // 字段名分别是: badid goodid
    val rawAliasData = spark.read.textFile("hdfs://192.168.254.122:9000/spark/input/artist_alias.txt")
    val artistAlias = transformAliasData(rawAliasData).collect().toMap

    // 导入 user_artist_data.txt 文件 (用户音乐收听数据)
    // 字段名分别是 userid artistid playcount
    val rawUserArtistData = spark.read.textFile("hdfs://192.168.254.122:9000/spark/input/user_artist_data.txt")

    // 整合数据
    val allDF = transformUserArtistData(spark, rawUserArtistData, artistAlias)
    allDF.persist()

    // 拆分训练集和测试集
    val Array(trainDF, testDF) = allDF.randomSplit(Array(0.9, 0.1))
    trainDF.persist()

    // 查看一下指定 user 听过的艺术家
    allDF.join(artistIdDFtest,"artist").select("name").filter("user='2093760'").show(5)

    /**
     * 根据题目要求参数
     * 给用户推荐艺术家
     */
    //        // 根据题目要求构建模型
    //        val als = new ALS()
    //              .setSeed(Random.nextLong())
    //              .setImplicitPrefs(true)
    //              .setRank(10) // 模型潜在因素个数
    //              .setRegParam(0.01) // 正则化参数
    //              .setAlpha(1.0) // 管理偏好观察值的 基线置信度
    //              .setMaxIter(5) // 最大迭代次数
    //              .setUserCol("user")
    //              .setItemCol("artist")
    //              .setRatingCol("count")
    //              .setPredictionCol("prediction")
    //        // 用训练数据训练模型
    //        val model = als.fit(trainDF)
    //        // 释放缓存资源
    //        trainDF.unpersist()
    //        // 开始推荐
    //        val userID = 2093760
    //        val artistNum = 5
    //        val recommendDF = recommend(model, userID, artistNum, artistIdDF)
    //
    //        val strings = recommendDF.map(_.mkString("|")).collect()
    //        println(strings.toBuffer)

    /**
     * 计算AUC评分最高的参数
     * 原理:循环指定参数暴力计算，根据AUC计算出评分最高的参数进行建模
     */
    //    // 艺术家id数据，用于AUC评分
    //    val allArtistIds = allDF.select("artist").as[Int].distinct().collect()
    //    val bAllArtistIds = spark.sparkContext.broadcast(allArtistIds)
    //
    //    // 网格搜索
    //    val evaluations =
    //    // 利用for循环，生成不同的超参数配置
    //      for (rank <- Seq(5, 30);
    //           regParam <- Seq(4.0, 0.0001);
    //           alpha <- Seq(1.0, 40.0))
    //        yield {
   
   
    //          // 构建模型
    //          val als = new ALS()
    //            .setSeed(Random.nextLong())
    //            .setImplicitPrefs(true)
    //            .setRank(rank)
    //            .setRegParam(regParam)
    //            .setAlpha(alpha)
    //            .setMaxIter(5)
    //            .setUserCol("user")
    //            .setItemCol("artist")
    //            .setRatingCol("count")
    //            .setPredictionCol("prediction")
    //          val model = als.fit(trainDF)
    //          val auc = areaUnderCurve(testDF, bAllArtistIds, model.transform)
    //          // 释放资源
    //          model.userFactors.unpersist()
    //          model.itemFactors.unpersist()
    //          (auc, (rank, regParam, alpha))
    //        }
    //    // 按评分降序输出各参数信息
    //    evaluations.sorted.reverse.foreach(println)
    //        (0.9134340440577203,(30,4.0,40.0)) // 最优参数
    //        (0.9124295941963009,(30,4.0,1.0))
    //        (0.9121292259762062,(30,1.0E-4,40.0))
    //        (0.9111586767382363,(5,4.0,40.0))
    //        (0.9097682726329872,(5,1.0E-4,40.0))
    //        (0.9089218752871897,(5,4.0,1.0))
    //        (0.9038315464345514,(5,1.0E-4,1.0))
    //        (0.8951870697645603,(30,1.0E-4,1.0))

    /**
     * 利用AUC评分最高的参数
     * 给用户推荐艺术家
     */
    //    // 利用AUC评分最高的参数进行模型构建
    //    val als = new ALS()
    //      .setSeed(Random.nextLong())
    //      .setImplicitPrefs(true)
    //      .setRank(30) // 模型潜在因素个数
    //      .setRegParam(4.0) // 正则化参数
    //      .setAlpha(40.0) // 管理偏好观察值的 基线置信度
    //      .setMaxIter(5) // 最大迭代次数
    //      .setUserCol("user")
    //      .setItemCol("artist")
    //      .setRatingCol("count")
    //      .setPredictionCol("prediction")
    //    // 训练模型
    //    val model = als.fit(trainDF)
    //    // 释放缓存资源
    //    trainDF.unpersist()
    //    // 开始推荐
    //    val userID = 2093760
    //    val artistNum = 5
    //    val recommendDF = recommend(model, userID, artistNum, artistIdDF)
    //    recommendDF.show()
    //
    //    val strings = recommendDF.map(_.mkString("|")).collect()
    //    println(strings.toBuffer)

    /**
     * 用测试数据对10个用户进行推荐
     */
//    // 利用AUC评分最高的参数进行模型构建
//    val als = new ALS()
//      .setSeed(Random.nextLong())
//      .setImplicitPrefs(true)
//      .setRank(30) // 模型潜在因素个数
//      .setRegParam(4.0) // 正则化参数
//      .setAlpha(40.0) // 管理偏好观察值的 基线置信度
//      .setMaxIter(5) // 最大迭代次数
//      .setUserCol("user")
//      .setItemCol("artist")
//      .setRatingCol("count")
//      .setPredictionCol("prediction")
//    // 训练模型
//    val model = als.fit(trainDF)
//    //用测试数据对100个用户进行推荐
//    val someUsers = testDF.select("user").as[Int].distinct.take(10)
//    // 推荐
//    someUsers.map { user =>
//      val recommendDF = recommend(model, user, 5, artistIdDF)
//      val strings = recommendDF.map(_.mkString("|")).collect()
//      (user, strings.toBuffer)
//    }.foreach(println)


    /**
     * 利用AUC评分最高的参数