【Spark】Spark MLlib 相关操作记录

最新推荐文章于 2024-07-17 11:13:52 发布
最新推荐文章于 2024-07-17 11:13:52 发布
阅读量83 收藏
点赞数
文章标签： spark spark-ml 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44664746/article/details/132434558
版权

Spark MLlib

MLlib 由一些通用的学习算法和工具组成，包括分类、回归、聚类、协同过滤、降维等。

基本数据类型

稠密向量和稀疏向量

scala> import org.apache.spark.ml.linalg.{Vector, Vectors}
import org.apache.spark.ml.linalg.{Vector, Vectors}

// 创建一个稠密本地向量
scala> val dv = Vectors.dense(2.0,0.0,8.0)
dv: org.apache.spark.ml.linalg.Vector = [2.0,0.0,8.0]

// 创建一个稀疏本地向量
// 参数：（向量长度，非零元素索引，非零元素值）
scala> val svl = Vectors.sparse(3,Array(0,2),Array(2,8.0))
svl: org.apache.spark.ml.linalg.Vector = (3,[0,2],[2.0,8.0])
// 参数：（向量长度，Seq((索引，值)）
scala> val sv2 = Vectors.sparse(3,Seq((0,2.0),(2,8.0)))
sv2: org.apache.spark.ml.linalg.Vector = (3,[0,2],[2.0,8.0])

标注点：带有标签的本地向量

scala> import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.ml.linalg.Vectors

scala>  import org.apache.spark.ml.feature.LabeledPoint
import org.apache.spark.ml.feature.LabeledPoint

scala> val pos = LabeledPoint(1.0,Vectors.dense(2.0,0.0,8.0))
pos: org.apache.spark.ml.feature.LabeledPoint = (1.0,[2.0,0.0,8.0])

scala> val neg = LabeledPoint(0.0,Vectors.sparse(3,Array(0,2),Array(2.0,8.0)))
neg: org.apache.spark.ml.feature.LabeledPoint = (0.0,(3,[0,2],[2.0,8.0]))

稠密矩阵与稀疏矩阵

scala> import org.apache.spark.ml.linalg.{Matrix,Matrices}
import org.apache.spark.ml.linalg.{Matrix, Matrices}

scala> val dm = Matrices.dense(3,2,Array(1.0,3.0,5.0,2.0,4.0,6.0))
dm: org.apache.spark.ml.linalg.Matrix =
1.0  2.0
3.0  4.0
5.0  6.0

scala> val sm = Matrices.sparse(3,2,Array(0,1,3),Array(0,2,1),Array(9,6,8))
sm: org.apache.spark.ml.linalg.Matrix =
3 x 2 CSCMatrix
(0,0) 9.0
(2,1) 6.0
(1,1) 8.0
机器学习流水线工作过程

PipelineStage 称为工作流阶段，包括转换器和评估器。对特定问题转换器和评估器，可以按照具体处理逻辑组织PipelineStage创建流水线。

val pipeline = new Pipeline().setStages(Array(stage1,stage2,stage3,...))

在流水线中，上一个 PipelineStage 的输出恰好是下一个 PipelineStage 的输入。调用 fit() 方法以流的方式训练源数据。

特征提取

指利用已有特征计算出一个抽象程度更高的特征集

示例代码展示TF-IDF特征提取过程

scala> import org.apache.spark.ml.feature.{HashingTF,IDF,Tokenizer}
import org.apache.spark.ml.feature.{HashingTF, IDF, Tokenizer}
                                                                                                   scala> val sentenceData = spark.createDataFrame(Seq((0,"I heard about Spark and I love Spark"),(0,"I wish Java could use case classes"),(1,"Logistic regression models are neat"))).toDF("label","sent")
sentenceData: org.apache.spark.sql.DataFrame = [label: int, sentence: string]

scala> val tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words")
tokenizer: org.apache.spark.ml.feature.Tokenizer = tok_1ab95f066343

scala> val wordsData = tokenizer.transform(sentenceData)
wordsData: org.apache.spark.sql.DataFrame = [label: int, sentence: string ... 1 more field]

scala> wordsData.show(false)
+-----+------------------------------------+---------------------------------------------+
|label|sentence                            |words                                        |
+-----+------------------------------------+---------------------------------------------+
|0    |I heard about Spark and I love Spark|[i, heard, about, spark, and, i, love, spark]|
|0    |I wish Java could use case classes  |[i, wish, java, could, use, case, classes]   |
|1    |Logistic regression models are neat |[logistic, regression, models, are, neat]    |
+-----+------------------------------------+---------------------------------------------+

scala> val hashingTF = new HashingTF().setInputCol("words").
																setOutputCol("rawFeatures").
																setNumFeatures(2000)
hashingTF: org.apache.spark.ml.feature.HashingTF = HashingTF: uid=hashingTF_dcddae8df8e5, binary=false, numFeatures=2000

scala> val featurizedData = hashingTF.transform(wordsData)
featurizedData: org.apache.spark.sql.DataFrame = [label: int, sentence: string ... 2 more fields]

scala> featurizedData.select("words","rawFeatures").show(false)
+---------------------------------------------+--------------------------------------------+
|words                                        |rawFeatures                                 |
+---------------------------------------------+--------------------------------------------+
|[i, heard, about, spark, and, i, love, spark]|(2000,[240,...,1756],[1.0,...,2.0])         |
|[i, wish, java, could, use, case, classes]   |(2000,[80,...,1967],[1.0,...,1.0])          |
|[logistic, regression, models, are, neat]    |(2000,[286,...,1871],[1.0,...,1.0])         |
+---------------------------------------------+--------------------------------------------+
scala> val idf = new IDF().setInputCol("rawFeatures").setOutputCol("features")
idf: org.apache.spark.ml.feature.IDF = idf_8133a2bcb73e

scala> val idfModel = idf.fit(featurizedData)
idfModel: org.apache.spark.ml.feature.IDFModel = IDFModel: uid=idf_8133a2bcb73e, numDocs=3, numFeatures=2000

scala> val rescaledData = idfModel.transform(featurizedData)
rescaledData: org.apache.spark.sql.DataFrame = [label: int, sentence: string ... 3 more fields]

scala> rescaledData.select("features","label").show(false)
+----------------------------------------------------------------------------------+-----+
|                               features                                           |label|                                                                                                                                                                  
+----------------------------------------------------------------------------------+-----+
|(2000,[240,...,1756],[0.6931471805599453,...,0.5753641449035617])                 |0    |
|(2000,[80,...,1967],[0.6931471805599453,...,0.6931471805599453])                  |0    |
|(2000,[286,...,1871],[0.6931471805599453,...,0.6931471805599453])                 |1    |
+----------------------------------------------------------------------------------+-----+
特征转换
scala> val df1 = spark.createDataFrame(Seq((0,"a"),(1,"b"),(2,"c"),(3,"a"),(4,"a"),(5,"c"))).toDF("d","category")
df1: org.apache.spark.sql.DataFrame = [id: int, category: string]

//1.StringIndexer:标签按频率由大到小排序
scala> val indexer = new StringIndexer().
													setInputCol("category").setOutputCol("categoryIndex")
indexer: org.apache.spark.ml.feature.StringIndexer = strIdx_72ea498afd7f

scala> val indexed1 = indexer.fit(df1).transform(df1)
indexed1: org.apache.spark.sql.DataFrame = [id: int, category: string ... 1 more field]

scala> indexed1.show()
+---+--------+-------------+
| id|category|categoryIndex|
+---+--------+-------------+
|  0|       a|          0.0|
|  1|       b|          2.0|
|  2|       c|          1.0|
|  3|       a|          0.0|
|  4|       a|          0.0|
|  5|       c|          1.0|
+---+--------+-------------+

//2.IndexToString: 把标签索引的一列重新映射到原有的字符型标签
scala> import org.apache.spark.ml.feature.IndexToString
import org.apache.spark.ml.feature.IndexToString
                                                                                                   scala> val tostring = new IndexToString().
													setInputCol("categoryIndex").setOutputCol("originalCategory")
tostring: org.apache.spark.ml.feature.IndexToString = idxToStr_351b80092567

scala> val indexString = tostring.transform(indexed1)
indexString: org.apache.spark.sql.DataFrame = [id: int, category: string ... 2 more fields]

scala> indexString.select("id","originalCategory").show()
+---+----------------+
| id|originalCategory|
+---+----------------+
|  0|               a|
|  1|               b|
|  2|               c|
|  3|               a|
|  4|               a|
|  5|               c|
+---+----------------+

//3.VectorIndexer
scala> val data = Seq(Vectors.dense(-1.0,1.0,1.0),
                  Vectors.dense(-1.0,3.0,1.0),
                  Vectors.dense(0.0,5.0,1.0))
data: Seq[org.apache.spark.ml.linalg.Vector] = List([-1.0,1.0,1.0], [-1.0,3.0,1.0], [0.0,5.0,1.0])

scala> val df = spark.createDataFrame(data.map(Tuple1.apply)).toDF("features")
df: org.apache.spark.sql.DataFrame = [features: vector]

scala> val indexer = new VectorIndexer().
     | 								setInputCol("features").
     | 								setOutputCol("indexed").
     | 								setMaxCategories(2)
indexer: org.apache.spark.ml.feature.VectorIndexer = vecIdx_8edbc07a5050

scala> val indexerModel = indexer.fit(df)
indexerModel: org.apache.spark.ml.feature.VectorIndexerModel = VectorIndexerModel: uid=vecIdx_8edbc07a5050, numFeatures=3, handleInvalid=error

scala> val cateFeatures = indexerModel.categoryMaps.keys.toSet
cateFeatures: scala.collection.immutable.Set[Int] = Set(0, 2)

scala> println(s"Chose ${cateFeatures.size} categorical fearures: "+ cateFeatures.mkString(","))
Chose 2 categorical fearures: 0,2

scala> val indexed = indexerModel.transform(df)
indexed: org.apache.spark.sql.DataFrame = [features: vector, indexed: vector]

scala> indexed.show()
+--------------+-------------+
|      features|      indexed|
+--------------+-------------+
|[-1.0,1.0,1.0]|[1.0,1.0,0.0]|
|[-1.0,3.0,1.0]|[1.0,3.0,0.0]|
| [0.0,5.0,1.0]|[0.0,5.0,0.0]|
+--------------+-------------+
特征选择
scala> val df = spark.createDataFrame(Seq((1,Vectors.dense(0.0,0.0,18.0,1.0),1),
     | (2,Vectors.dense(0.0,1.0,12.0,0.0),0),
     | (3,Vectors.dense(1.0,0.0,15.0,0.1),0))).toDF("id","features","label")
df: org.apache.spark.sql.DataFrame = [id: int, features: vector ... 1 more field]

scala> df.show()
+---+------------------+-----+
| id|          features|label|
+---+------------------+-----+
|  1|[0.0,0.0,18.0,1.0]|    1|
|  2|[0.0,1.0,12.0,0.0]|    0|
|  3|[1.0,0.0,15.0,0.1]|    0|
+---+------------------+-----+

scala> import org.apache.spark.ml.feature.{ChiSqSelector,ChiSqSelectorModel}
import org.apache.spark.ml.feature.{ChiSqSelector, ChiSqSelectorModel}

scala> val selector = new ChiSqSelector().
     | setNumTopFeatures(1).
     | setFeaturesCol("features").
     | setLabelCol("label").
     | setOutputCol("selected-feature")
selector: org.apache.spark.ml.feature.ChiSqSelector = chiSqSelector_f224fa097ab2

scala> val selector_model = selector.fit(df)
selector_model: org.apache.spark.ml.feature.ChiSqSelectorModel = ChiSqSelectorModel: uid=chiSqSelector_f224fa097ab2, numSelectedFeatures=1

scala> val result = selector_model.transform(df)
result: org.apache.spark.sql.DataFrame = [id: int, features: vector ... 2 more fields]

scala> result.show(false)
+---+------------------+-----+----------------+
|id |features          |label|selected-feature|
+---+------------------+-----+----------------+
|1  |[0.0,0.0,18.0,1.0]|1    |[18.0]          |
|2  |[0.0,1.0,12.0,0.0]|0    |[12.0]          |
|3  |[1.0,0.0,15.0,0.1]|0    |[15.0]          |
+---+------------------+-----+----------------+

分类算法

1、Logistic回归

package ac.sict.reid.leo.ml

import org.apache.spark.ml.Pipeline
import org.apache.spark.ml.classification.LogisticRegression
import org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator
import org.apache.spark.ml.feature.{IndexToString, StringIndexer, VectorIndexer}
import org.apache.spark.ml.linalg.{Vector, Vectors}
import org.apache.spark.sql.{Row, SparkSession}

object Logistic {

  case class Iris(features: org.apache.spark.ml.linalg.Vector,label:String)

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

    //TODO 对原始的数据将其封装为DataFrame
    val spark = SparkSession.builder().master("local").appName("logistic").getOrCreate()
    import spark.implicits._
    val data = spark.sparkContext.textFile("data/iris.data")
      .map(_.split(",")).map(
      p => Iris(Vectors.dense(p(0).toFloat, p(1).toFloat, p(2).toFloat, p(3).toFloat), p(4).toString)
    ).toDF()
    print("原始数据结果展示:\n")
    data.show()

    //TODO 构建LR模型
    print("--------------------------------------------\n")
    val labelIndexer = new StringIndexer().setInputCol("label").
    													setOutputCol("indexedLabel").fit(data)
    val featureIndexer = new VectorIndexer().setInputCol("features").
    													setOutputCol("indexedFeatures").fit(data)
    val lr = new LogisticRegression().setLabelCol("indexedLabel").
                        setFeaturesCol("indexedFeatures").
                        setMaxIter(100).					//循环次数：100次
                        setRegParam(0.3).					//规范化项：0.3
                        setElasticNetParam(0.8)		//正则项系数
    println("LogisticRegression parameters:\n" + lr.explainParams() + "\n")

    val labelConverter = new IndexToString().setInputCol("prediction").
    								setOutputCol("predictedLabel").setLabels(labelIndexer.labels)
    val lrPipeline = new Pipeline().
    								setStages(Array(labelIndexer, featureIndexer, lr, labelConverter))
    
    //TODO 划分训练集和测试集
    val Array(trainingData,testData) = data.randomSplit(Array(0.7, 0.3))
    print("--------------------------------------------\n开始训练数据\n")
    val lrPipelineModel = lrPipeline.fit(trainingData)
    val lrPredictions = lrPipelineModel.transform(testData)
    print("--------------------------------------------\n预测结果：\n")
    lrPredictions.select("predictedLabel","label","features","probability").
    					collect().foreach {
      case Row(predictedLabel: String, label: 
               String, features: Vector, prob: Vector) =>
        println(s"($label, $features) --> 
        					prob=$prob, predicted Label = $predictedLabel")
    }
    
    //TODO 模型评估
    print("--------------------------------------------\n模型评估：\n")
    val evaluator = new MulticlassClassificationEvaluator().
    						setLabelCol("indexedLabel").setPredictionCol("prediction")
    val lrAccuracy = evaluator.evaluate(lrPredictions)
    println(lrAccuracy)
  }
}

运行结果

原始数据结果展示:
+--------------------+-----------+
|            features|      label|
+--------------------+-----------+
|[5.09999990463256...|Iris-setosa|
...
|[5.09999990463256...|Iris-setosa|
+--------------------+-----------+
only showing top 20 rows

--------------------------------------------
LogisticRegression parameters:
aggregationDepth: suggested depth for treeAggregate (>= 2) (default: 2)
...

--------------------------------------------
开始训练数据
--------------------------------------------
预测结果：
(Iris-setosa, [4.300000190734863,3.0,1.100000023841858,0.10000000149011612]) --> prob=[0.5838550112961782,0.23381020228934427,0.1823347864144775], predicted Label = Iris-setosa
...
(Iris-virginica, [7.699999809265137,3.799999952316284,6.699999809265137,2.200000047683716]) --> prob=[0.11720205493498893,0.3684655149105844,0.5143324301544265], predicted Label = Iris-virginica
--------------------------------------------
模型评估：
0.5170097445655307

2、决策树分类器

package ac.sict.reid.leo.ml

import org.apache.spark.ml.Pipeline
import org.apache.spark.ml.classification.DecisionTreeClassifier
import org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator
import org.apache.spark.ml.feature.{IndexToString, StringIndexer, VectorIndexer}
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession

object DecisionTree {

  case class Iris(features: org.apache.spark.ml.linalg.Vector,label:String)

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local").appName("logistic").getOrCreate()
    import spark.implicits._
    val data = spark.sparkContext.textFile("data/iris.data")
      .map(_.split(",")).map(
      p => Iris(Vectors.dense(p(0).toFloat, p(1).toFloat, p(2).toFloat, p(3).toFloat), p(4).toString)
    ).toDF()
    print("原始数据结果展示:\n")
    data.show()

    //TODO 构造训练器
    val labelIndexer = new StringIndexer().setInputCol("label").
    						setOutputCol("indexedLabel").fit(data)
    val vectorIndexer = new VectorIndexer().setInputCol("features").
    						setOutputCol("indexedFeatures").fit(data)
    val labelConverter = new IndexToString().setInputCol("prediction").
    						setOutputCol("predictionLabel").setLabels(labelIndexer.labels)
    val treeClassifier = new DecisionTreeClassifier().
    						setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures")
    val pipeline = new Pipeline().setStages(Array(labelIndexer, 
                                                  vectorIndexer, 
                                                  treeClassifier, 
                                                  labelConverter))

    print("--------------------------------------------\n模型训练:\n")
    //TODO 训练
    val Array(trainingData, testData) = data.randomSplit(Array(0.7, 0.3))
    val model = pipeline.fit(trainingData)
    val predictionData = model.transform(testData)
    predictionData.select("predictionLabel","label","features").show()


    print("--------------------------------------------\n")
    //TODO 模型评估
    val evaluator = new MulticlassClassificationEvaluator().
    												setLabelCol("prediction").setLabelCol("indexedLabel")
    val accuracy = evaluator.evaluate(predictionData)
    print("模型评估结果：" + accuracy)

  }
}

运行结果

原始数据结果展示:
+--------------------+-----------+
|            features|      label|
+--------------------+-----------+
|[5.09999990463256...|Iris-setosa|
...
|[5.09999990463256...|Iris-setosa|
+--------------------+-----------+
only showing top 20 rows

--------------------------------------------
模型训练:
+---------------+---------------+--------------------+
|predictionLabel|          label|            features|
+---------------+---------------+--------------------+
|    Iris-setosa|    Iris-setosa|[4.40000009536743...|
|    Iris-setosa|    Iris-setosa|[4.59999990463256...|
|    Iris-setosa|    Iris-setosa|[4.59999990463256...|
...
|Iris-versicolor| Iris-virginica|[5.59999990463256...|
|Iris-versicolor|Iris-versicolor|[5.69999980926513...|
|Iris-versicolor|Iris-versicolor|[5.69999980926513...|
|Iris-versicolor|Iris-versicolor|[5.69999980926513...|
+---------------+---------------+--------------------+
only showing top 20 rows

--------------------------------------------
模型评估结果：0.8788521482052765

3、K-Means聚类

package ac.sict.reid.leo.ml

import ac.sict.reid.leo.ml.DecisionTree.Iris
import org.apache.spark.ml.clustering.KMeans
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession

object kmeans {

  case class Iris(features: org.apache.spark.ml.linalg.Vector,label:String)

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local").appName("logistic").getOrCreate()
    import spark.implicits._
    val data = spark.sparkContext.textFile("data/iris.data")
      .map(_.split(",")).map(
      p => Iris(Vectors.dense(p(0).toFloat, p(1).toFloat, p(2).toFloat, p(3).toFloat), p(4).toString)
    ).toDF()
    print("原始数据结果展示:\n")
    data.show()

    print("--------------------------------------------\n构造模型\n")

    val kMeansModel = new KMeans().setK(3).setFeaturesCol("features").setPredictionCol("prediction").fit(data)

    val result = kMeansModel.transform(data)

    print("--------------------------------------------\n模型训练结果\n")
    result.collect().foreach(row=>{
      println(row(0) + " => cluster: " + row(1))
    })

    print("--------------------------------------------\n查看簇中心\n")
    kMeansModel.clusterCenters.foreach(
      center=>{
        println("Clustering Center:" + center)
      }
    )
  }
}

运行结果

原始数据结果展示:
+--------------------+-----------+
|            features|      label|
+--------------------+-----------+
|[5.09999990463256...|Iris-setosa|
...
|[5.09999990463256...|Iris-setosa|
+--------------------+-----------+
only showing top 20 rows

--------------------------------------------
构造模型
--------------------------------------------
模型训练结果
[5.099999904632568,3.5,1.399999976158142,0.20000000298023224] => cluster: Iris-setosa
[4.900000095367432,3.0,1.399999976158142,0.20000000298023224] => cluster: Iris-setosa
...
[5.900000095367432,3.0,5.099999904632568,1.7999999523162842] => cluster: Iris-virginica
--------------------------------------------
查看簇中心
Clustering Center:[5.9016,2.7483,4.3935,1.433]
Clustering Center:[5.0060,3.4180,1.4639,0.244]
Clustering Center:[6.8499,3.0736,5.7421,2.071]

4、GMM

package ac.sict.reid.leo.ml

import org.apache.spark.ml.clustering.GaussianMixture
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession

object GMM {

  case class Iris(features: org.apache.spark.ml.linalg.Vector,label:String)

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local").appName("logistic").getOrCreate()
    import spark.implicits._
    val data = spark.sparkContext.textFile("data/iris.data")
      .map(_.split(",")).map(
      p => Iris(Vectors.dense(p(0).toFloat, p(1).toFloat, p(2).toFloat, p(3).toFloat), p(4).toString)
    ).toDF()
    print("原始数据结果展示:\n")
    data.show()

    print("--------------------------------------------\n构造模型\n")
    val gm = new GaussianMixture().setK(3).setPredictionCol("prediction").setProbabilityCol("probability")
    val model = gm.fit(data)

    val result = model.transform(data)
    result.select("label","prediction","probability").show()

  }
}

运行结果

原始数据结果展示:
+--------------------+-----------+
|            features|      label|
+--------------------+-----------+
|[5.09999990463256...|Iris-setosa|
...
|[5.09999990463256...|Iris-setosa|
+--------------------+-----------+
only showing top 20 rows

--------------------------------------------
构造模型
+-----------+----------+--------------------+
|      label|prediction|         probability|
+-----------+----------+--------------------+
|Iris-setosa|         2|[4.68224305612849...|
...
|Iris-setosa|         2|[5.09289394664511...|
|Iris-setosa|         2|[8.66429222550741...|
+-----------+----------+--------------------+
only showing top 20 rows

协同过滤算法

在一组兴趣相同的用户或项目进行推荐，根据相似用户的偏好信息，产生目标用户的推荐列表；或者综合相似用户对某一信息的评价，形成系统对该指定用户对此信息的喜好程度预测。

原理

基于用户的协同过滤算法通过不同用户对物品的评分来评测用户之间的相似性，并基于用户之间的相似性做出推荐。基于物品的协同过滤算法通过用户对不同物品的评分来评价物品之间的相似性，并基于物品之间的相似性做出推荐。

ALS算法（交替最小二乘法）

基于矩阵分解。对矩阵R，ALs旨在找到两个低维矩阵P和Q来逼近R。

对逼近R，通过最小化损失函数L完成：
L ( P , Q ) = ∑ u , i ( r u , i − p u T q i ) 2 + λ ( ∣ p u ∣ 2 + ∣ q i ∣ 2 ) L(P,Q)=∑_{u,i}{(r_{u,i}-p_u^Tq_i)}^2 + \lambda(|p_u|^2+|q_i|^2) L(P,Q)=u,i∑​(ru,i​−puT​qi​)2+λ(∣pu​∣2+∣qi​∣2)
对 L(P,Q) 求解思想为：固定一类参数，使其变为单类变量优化问题，利用解析方法进行优化；再反过来，固定先前优化过的参数，再优化另一组参数；此过程迭代进行，直到收敛。
p u = ( Q T Q + λ I ) − 1 Q T r u p_u = (Q^TQ+\lambda I)^{-1}Q^Tr_u pu​=(QTQ+λI)−1QTru​

q i = ( P T P + λ I ) − 1 P T r i q_i = (P^TP+\lambda I)^{-1}P^Tr_i qi​=(PTP+λI)−1PTri​

交替优化P、Q直至均方根误差小于某一预定义阈值。

代码
package ac.sict.reid.leo.ml

import org.apache.spark.ml.recommendation.ALS
import org.apache.spark.sql.SparkSession

object ALS {

  case class Rating(userId:Int,movieId:Int,rating:Float)

  def parseRating(str:String):Rating={
    val fields = str.split("::")
    assert(fields.size==3)
    Rating(fields(0).toInt,fields(1).toInt,fields(2).toFloat)
  }

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local").appName("logistic").getOrCreate()
    import spark.implicits._

    // 导入数据集
    val data = spark.sparkContext.textFile("data/sample_movielens_data.txt").map(parseRating).toDF()
    data.show()

    // 构建模型
    val Array(training,test) = data.randomSplit(Array(0.8, 0.2))
                      // 显性反馈
    val alsExplicit = new ALS().setMaxIter(5).setRegParam(0.01).setUserCol("userId").
                            setItemCol("movieId").setRatingCol("rating")
                      // 隐性反馈
    val alsIxplicit = new ALS().setMaxIter(5).setRegParam(0.01).setImplicitPrefs(true).
                            setUserCol("userId").setItemCol("movieId").setRatingCol("rating")

    print("------------------------------------\n模型训练\n")
    val modelExplicit = alsExplicit.fit(training)
    val modelIxplicit = alsIxplicit.fit(training)

    // 模型预测
    val predictionExplicit = modelExplicit.transform(test).na.drop()
    val predictionIxplicit = modelIxplicit.transform(test).na.drop()


    print("------------------------------------\n显性模型预测\n")
    predictionExplicit.show()
    print("------------------------------------\n隐性模型预测\n")
    predictionIxplicit.show()
  }

}

运行结果

源数据
+------+-------+------+
|userId|movieId|rating|
+------+-------+------+
|     0|      2|   3.0|
|     0|      3|   1.0|
|     0|      5|   2.0|
|     0|      9|   4.0|
|     0|     11|   1.0|
|     0|     12|   2.0|
|     0|     15|   1.0|
|     0|     17|   1.0|
|     0|     19|   1.0|
|     0|     21|   1.0|
|     0|     23|   1.0|
|     0|     26|   3.0|
|     0|     27|   1.0|
|     0|     28|   1.0|
|     0|     29|   1.0|
|     0|     30|   1.0|
|     0|     31|   1.0|
|     0|     34|   1.0|
|     0|     37|   1.0|
|     0|     41|   2.0|
+------+-------+------+
only showing top 20 rows


------------------------------------
模型训练
------------------------------------
显性模型预测
+------+-------+------+-----------+
|userId|movieId|rating| prediction|
+------+-------+------+-----------+
|    14|     31|   3.0|  2.1999722|
|    26|     85|   1.0|   4.345084|
|    16|     85|   5.0| -1.2715425|
|    20|     85|   2.0|  3.2713377|
|     8|     85|   5.0|  3.3143995|
|    23|     85|   1.0|-0.68929994|
|     7|     85|   4.0|  1.4216691|
|    12|     53|   1.0| -2.1721268|
|    28|     78|   1.0|-0.34255195|
|    17|     78|   1.0|  1.2883804|
|    11|     78|   1.0|  0.7823269|
|    28|     34|   1.0|  -1.012922|
|    16|     34|   1.0|  3.1402597|
|     4|     34|   1.0|  1.1908464|
|    26|     81|   3.0|  1.1169641|
|    27|     28|   1.0| 0.19116491|
|     6|     28|   1.0|   1.358405|
|    25|     76|   1.0| 0.98397815|
|    11|     76|   1.0|  3.4053497|
|     3|     26|   1.0|  0.5203902|
+------+-------+------+-----------+
only showing top 20 rows

------------------------------------
隐性模型预测
+------+-------+------+------------+
|userId|movieId|rating|  prediction|
+------+-------+------+------------+
|    14|     31|   3.0|  0.79802024|
|    26|     85|   1.0|  0.98835176|
|    16|     85|   5.0|   0.5506306|
|    20|     85|   2.0|  0.07750125|
|     8|     85|   5.0|  0.68542016|
|    23|     85|   1.0|  0.05137192|
|     7|     85|   4.0|    0.480247|
|    12|     53|   1.0|  0.16767296|
|    28|     78|   1.0|  0.17735796|
|    17|     78|   1.0|-0.016111419|
|    11|     78|   1.0|  0.29685006|
|    28|     34|   1.0|   0.0093874|
|    16|     34|   1.0|  0.52440804|
|     4|     34|   1.0|  0.14459659|
|    26|     81|   3.0|   0.4282986|
|    27|     28|   1.0|   0.3072154|
|     6|     28|   1.0|   0.2548714|
|    25|     76|   1.0|    1.111581|
|    11|     76|   1.0|  0.29482442|
|     3|     26|   1.0|   0.3968358|
+------+-------+------+------------+
only showing top 20 rows
慕青Voyager
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spark推荐算法实战MLlib推荐实例
03-07
本篇文章将深入探讨Spark推荐算法的实战应用，特别是使用MLlib库来构建推荐实例。 推荐系统是一种智能算法，它能够根据用户的个人喜好和历史行为，为用户推荐可能感兴趣的商品、服务或内容。在电子商务、社交媒体、...
spark mllib 常用的自学demo
09-21
自己本人线下记录的一些关于spark学习的例子，大家可以参考下，比如刚学习或者接触大数据的朋友可以看一下。
集群计算——Spark-Spark Core 、Spark Streaming、Spark SQL、MLlib、Spark集群管理器
weixin_46029055的博客
11-14 1865
Spark发源于美国美国加州伯克利分校AMPLab的大数据分析平台，它立足于于内存计算，从多迭代批量处理出发，兼顾数据仓库、流处理和图计算等多种计算范式，是大数据系统邻域的全栈计算平台。Spark当下成为Apache基金会的顶级开源项目。 Spark扩展了MapReduce计算模型，并且高效的支持更多的计算模式。由于速度很快，这意味着可以交互式的数据操作（否则每次操作就需要等待数分钟甚至数个小时）。Spark基于内存计算，提高了在大数据环境下处理的实时性，因而更能体现...
Spark学习之路——8.Spark MLlib
Nelson_hehe的博客
02-02 931
MLlib的官网文档： http://spark.apache.org/docs/latest/ml-guide.html 本节主要内容： 一、MLlib简述 二、基本数据类型 三、汇总统计 四、实例应用K-means算法 一、MLlib简述： 1.MLlib是什么？ MLlib是Spark的机器学习(ML)库。它的目标是让实用的机器学习变得可扩展和容易。在高层次上，它提供以下工...
mllib调参 spark_SparkMLlib学习之线性回归
weixin_33128703的博客
01-12 154
SparkMLlib学习之线性回归(一)回归的概念1，回归与分类的区别分类模型处理表示类别的离散变量，而回归模型则处理可以取任意实数的目标变量。但是二者基本的原则类似，都是通过确定一个模型，将输入特征映射到预测的输出。回归模型和分类模型都是监督学习的一种形式。2.回归分类线性回归模型：本质上和对应的线性分类模型一样，唯一的区别是线性回归使用的损失函数、相关连接函数和决策函数不同。MLlib提供了标...
sparkmllib 推荐系统实现（学习）
controller_Lw的博客
12-19 618
sparkmllib 推荐系统实现
基于大数据的餐饮推荐系统，整体采用Lambda架构，读取餐饮评分数据并通过Spark的MLlib中的ALS建立推荐模型后进行推荐
04-18
然后，这些数据流入批处理层，Spark集群通过MapReduce等操作对数据进行预处理和清洗；接着，在实时处理层，Spark Streaming实时接收新的评分数据，并更新模型；最后，服务层根据最新模型向用户推荐最有可能喜欢的菜...
计算机课程毕设：基于Spark MLlib ALS的音乐推荐系统.zip
12-25
《Spark MLlib ALS在音乐推荐系统中的应用》 在当今信息爆炸的时代，个性化推荐系统已成为互联网服务的重要组成部分，尤其在娱乐领域，如音乐推荐。本项目以“计算机课程毕设：基于Spark MLlib ALS的音乐推荐系统”...
sparkcore相关实例
04-08
Spark Core是Apache Spark的核心组件，它是Spark所有其他模块的基础，包括Spark SQL、Spark Streaming和MLlib等。这个压缩包文件“spark-core”很可能包含了与Spark Core相关的代码示例或者文档，帮助用户理解和学习...
java.sql.SQLException: Unknown system variable ‘query_cache_size‘【Pyspark】
weixin_51744807的博客
07-15 441
位置：E:\programfiles\anaconda\Lib\site-packages\pyspark\jars（这里根据各自的环境安排）根据该报错，发现网络上多数解决方都是基于java开发的解决方案，尝试过多种jar配置途径，都没办法解决该问题。首先产生该问题是没有配置合适的jar包，因此需要在本机的pyspark包中配置相关jar。后续发现时jar包有问题，通过参考其他文章思路，最终通过合适的jar包解决问题。的格式并提交到本地的mysql中，相关代码见文章末尾。的所以jar包一般用最新的即可。
从数据湖到湖仓一体：统一数据架构演进之路
最新发布
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
07-17 1284
本文详细探讨了从数据湖到湖仓一体的演进过程及其在现代数据管理中的重要性。湖仓一体由Databricks于2020年提出，旨在融合数据湖和数据仓库的优势，通过无缝集成，实现数据存储和管理的统一架构。 湖仓一体的出现主要是为了降低成本和解决数据孤岛问题。传统的数据湖和数据仓库各自独立建设，导致重复投资和数据管理上的困难，而湖仓一体通过简化基础架构、提升数据存储弹性和质量，有效减少了这些问题。
Spark SQL----CREATE TABLE
Gabriel Wang的博客
07-14 993
如果spark.sql.legacy.allowNonEmptyLocationInCTAS设置为true，spark将用输入查询的数据覆盖基础数据源，以确保创建的表包含与输入查询完全相同的数据。例如，你可以使用JDBC数据源在Spark中创建一个表“foo”，该表指向MySQL中的一个表”bar“。当你读/写表“foo”时，你实际上读/写了表“bar”。一般来说，CREATE TABLE是在创建一个“指针”，你需要确保它指向现有的东西。CREATE TABLE语句用于在现有数据库中定义一个表。
Apache Spark 的基本概念和在大数据分析中的应用
Pth_you的博客
07-15 545
Apache Spark是一个开源的大数据处理框架，由加州大学伯克利分校的AMPLab开发，并于2010年发布。它逐渐发展成为Apache软件基金会的顶级项目，并在大数据分析领域得到了广泛应用。以下是Apache Spark的基本概念和在大数据分析中的应用的详细解析。
从0开始学习pyspark--用户自定义函数（UDF）和 pandas UDF[第6节]
甜盐的博客
07-15 617
PySpark UDF（User Defined Function，用户自定义函数）允许用户在 Spark SQL 查询中使用自定义的 Python 函数，从而增强数据处理的灵活性和功能。UDF 使我们能够实现复杂的逻辑，处理 Spark SQL 内置函数无法覆盖的场景。pandas UDF（也称为 Vectorized UDF）是 PySpark 中的一种特殊类型的 UDF，利用了 Apache Arrow 来加速数据传输和处理。
Spark 和 Kafka 处理 API 请求与返回数据DEMO
Climbman的博客
07-15 374
以下是一个更详细的使用 Spark 和 Kafka 处理 API 请求与返回数据，并保障其正常性的示例代码。请注意，您需要根据实际的 API 接口和数据要求来进一步完善数据校验、错误处理和响应处理的逻辑。替换为实际的 API 端点，并根据 API 的要求设置正确的请求方法和数据格式。
尚硅谷大数据技术-数据湖Hudi视频教程-笔记03【Hudi集成Spark】
upward
07-15 1094
尚硅谷大数据技术-数据湖Hudi视频教程-笔记03【Hudi集成Spark】
Spark核心技术架构
在路上的专栏
07-15 967
Apache Spark是一个开源的分布式计算系统，它提供了一个快速、通用和易于使用的集群计算环境。Spark 支持多种编程语言，如 Scala、Java 和 Python，并针对大规模数据处理进行了优化。
【介绍下Spark MLlib机器学习】
cz88888888666的博客
06-24 344
🛸Spark MLlib是一个用于大规模数据处理的开源机器学习框架，它是Apache Spark项目的一部分，提供了一套用于构建机器学习模型的高级API和工具。🛸Spark MLlib支持常见的机器学习任务，包括分类、回归、聚类、推荐和降维等。它提供了丰富的特征提取、转换和选择功能，包括向量化、标准化、索引化和文本处理等。🛸在Spark MLlib中，机器学习算法被分为两种类型：转换器（Transformers）和估计器（Estimators）。转换器将一个DataFrame转换为另一个DataFra
Spark MLlib：用户画像构建与机器学习课件资源
Spark MLlib是Apache Spark中的一个核心模块，专注于机器学习（Machine Learning）和数据挖掘（Data Mining）功能。它是Spark生态系统中的一个重要组成部分，为大数据处理提供了强大的工具支持，尤其是在分布式环境...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值