Spark MLlib框架详解

1. 概述

1.1 功能

　　MLlib是Spark的机器学习（machine learing）库，其目标是使得机器学习的使用更加方便和简单，其具备以下功能：

• ML算法：经常使用的学习算法，包括分类、回归、聚类和过滤；
• 特征：特征萃取、转换、降维和选取；
• Pipelines：其是一个工具，目标是用于构建、测量和调节；
• 使用工具：包括线性代数、统计学习和数据操做等等。

1.2 API架包

MLlib有两个API架包：

　　1) Spark.mllib：基于RDD的API包，在spark 2.0时已经进入维护模型。

　　2) Spark.ml：基于DataFrame的API包，目前Spark官方首推使用该包。

2. Pipelines Components

MLlib标准化机器学习算法的API，使得更容易将多个算法组合成到单个管道（工做流）。其设计思想是受到Scikit-learn项目的启发。

• DataFrame：MLlib的数据使用Spark SQL中的DataFrame结构来存储，即用户的数据集和模型的输出标签都是以此结构存储，包括Pipeline内部数据的传输都是以此结构存储；
• Transformer：MLlib将算法模型用Transformer结构来表示，其以一个DataFrame数据做为输入，经过模型计算后转换为一个DataFrame数据；
• Estimator：Estimator结构也表示一种算法，但其以一个DataFrame数据做为输入，经过模型计算后转换为一个Transformer对象，而不是DataFrame数据；
• Pipeline：MLlib使用Pipeline来组织多个ML模型，即其内部有多个Transformer和Estimator对象，从而组成一个算法工做流；
• Parameter：MLlib使用Parameter结构来存储参数，用户经过这些参数来配置和调节模型。即在一个Pipeline对象内的全部Transformer和Estimator对象都共享一个Parameter对象。

2.1 DataFrame

　　机器学习中数据集是由一个个样本组成，而每一个样本实际上是一条有多个特征组成的记录，从而数据集实际上是一个矩阵结构。而Spark SQL中的DataFrame结构也拥有相似的结构，DataFrame内部有一行行的数据Row组成，每一个Row对象内部也能够由多个属性组成。从而MLlib使用DataFrame来描述机器学习中的数据集正好不过了。

　　Spark SQL的DataFrame其实一种Dataset类型，只是存储的是Row元素，以下Spark源码所示：

Package object sql{ …… type DataFrame = Dataset[Row] }

 

2.2 Pipeline

　　MLlib使用Pipeline来组织多个ML模型，其内部有多个Transformer和Estimator对象，从而组成一个算法工做流。在Spark ML中与Pipeline相关联的类如图 1所示。从图中可明显看出Transformer和Estimator都是PipelineStage抽象类的子类；而且Pipeline类内部有一个stages数组来存储PipelineStage对象，即存放Transformer和Estimator对象；当用户调用Pipeline的fit()方法时，将产生一个PipelineModel对象；PipelineModel类有一个transform()方法能返回一个DataFrame对象。

 

图 1  

3. 工做机制

　　Pipeline是由一系列stage组成，这些stage有两种类型：Transformer和Estimator。Stage在Pipeline的运行是有序的，并且输入的DataFrame会在stage中被转换和传递。若stage是Transformer类型，则对条用Transformer对象的transform()方法将输入的DataFrame转换为另外一种DataFrame；若stage是Estimator类型，则会调用Estimator对象的fit()方法产生Transformer对象，调用该Transformer对象的transform()方法同样会产生一个DataFrame。

能够将上述这一段，详细解释为两个过程：模型训练和模型预测，以下所示：

3.1 模型训练

　　Pipeline对象内部有一个stages容器，存放多个Transformer对象和一个Estimator对象。当用户调用Pipeline对象的fit()方法时，会接收输入的DataFrame，而后在这些stage中被转换和传递。当传递到最后一个stage(Estimator对象)时，将生成一个PipelineModel对象（Transformer子类），如图 2所示。

 

图 2

　　用户调用上图中Pipeline的fit()时，会将stages容器存放的全部Transformer对象和Estimator对象生成的Transformer对象都添加到PipelineModel对象中，该对象有一个stages容器(Array[Transformer]类型)，其可以存放Transformer对象。

    经过Spark源码，能够查看Pipeline类中的fit()内容以下所示：

override def fit(dataset: Dataset[_]): PipelineModel = { transformSchema(dataset.schema, logging = true) val theStages = $(stages) … var curDataset = dataset val transformers = ListBuffer.empty[Transformer] theStages.view.zipWithIndex.foreach { case (stage, index) => if (index <= indexOfLastEstimator) { val transformer = stage match { case estimator: Estimator[_] =>//如果Estimator对象，则调用fit()方法生成一个Transformer estimator.fit(curDataset) case t: Transformer =>//如果Transformer对象，则直接返回 t case _ => throw new IllegalArgumentException( s"Does not support stage $stage of type ${stage.getClass}") } if (index < indexOfLastEstimator) { curDataset = transformer.transform(curDataset)//若是不是最后的对象，则调用transformer对象的transform方法，生成一个DataFrame } transformers += transformer //将生成的全部Transformer对象都添加到一个list中 } else { transformers += stage.asInstanceOf[Transformer] } }  new PipelineModel(uid, transformers.toArray).setParent(this) //最后建立PipelineModel对象，并传递上述的Transformer列表。 }

3.2 模型预测

　　在模型训练阶段会经过向Pipeline的fit()方法传递DataFrame数据来训练模型，从而生成一个PipelineModel对象(Transformer子类)，该对象内部有一个stages容器，存放了全部Transformer对象。

　　当进行模型预测时，即经过向PipelineModel对象的transform传递一个DataFrame数据来预测时，会依序调用其stages容器中的Transformer对象，每一个Transformer对象都有一个DataFrame输入和一个DataFrame的输出，最后生成一个DataFrame做为用户的输出，如图 3所示。

 

图 3

相似，能够查看PipelineModel对象的transform()方法，以下所示：

override def transform(dataset: Dataset[_]): DataFrame = { transformSchema(dataset.schema, logging = true) stages.foldLeft(dataset.toDF)((cur, transformer) => transformer.transform(cur)) }

　　stages.foldLeft(dataset.toDF)((cur, transformer) => transformer.transform(cur))语句正是图 3的实现，即第一次输入数据是dataset.toDF，而后每次调用transformer.transform(cur))方法，产生的DataFrame输出做为下一次的输入。

3.3 关系总结

　　经过上述Pipeline工做机制的分析，如今从机器学习的角度总结一下Pipeline、Transformer和Estimator三者之间的关系，如图 4所示。

 

图 4

1. Transformer：是对数据进行预处理，如特征向量萃取、向量转换或降维；
2. Estimator：机器学习的某种算法，如线性回归、贝叶斯或支持向量机；
3. Pipeline：是一种算法组织者，将Transformer和Estimator组织成有序的执行过程。

4. Examples

4.1 Estimator、Transformer和Param

　　本节以Estimator类为例，没有使用Pipeline结构来组织Estimator和Transformer对象。Estimator类能够单独使用，不须要Pipeline结构也能工做，此时Estimator相似Scikit-learn框架。首先，用户直接调用Estimator对象的fit()方法来训练数据；而后，根据fit()方法返回的Transformer对象，用户接着调用Transformer的transform()方法来预测或测试；

以下所示的完整程序：

// scalastyle:off println package org.apache.spark.examples.ml   // $example on$ import org.apache.spark.ml.classification.LogisticRegression import org.apache.spark.ml.linalg.{Vector, Vectors} import org.apache.spark.ml.param.ParamMap import org.apache.spark.sql.Row // $example off$ import org.apache.spark.sql.SparkSession   object EstimatorTransformerParamExample {   def main(args: Array[String]): Unit = { val spark = SparkSession .builder .appName("EstimatorTransformerParamExample") .getOrCreate()   // $example on$ // Prepare training data from a list of (label, features) tuples. val training = spark.createDataFrame(Seq( (1.0, Vectors.dense(0.0, 1.1, 0.1)), (0.0, Vectors.dense(2.0, 1.0, -1.0)), (0.0, Vectors.dense(2.0, 1.3, 1.0)), (1.0, Vectors.dense(0.0, 1.2, -0.5)) )).toDF("label", "features")   // Create a LogisticRegression instance. This instance is an Estimator. val lr = new LogisticRegression() // Print out the parameters, documentation, and any default values. println("LogisticRegression parameters:\n" + lr.explainParams() + "\n")   // We may set parameters using setter methods. lr.setMaxIter(10) .setRegParam(0.01)   // Learn a LogisticRegression model. This uses the parameters stored in lr. val model1 = lr.fit(training) // Since model1 is a Model (i.e., a Transformer produced by an Estimator), // we can view the parameters it used during fit(). // This prints the parameter (name: value) pairs, where names are unique IDs for this // LogisticRegression instance. println("Model 1 was fit using parameters: " + model1.parent.extractParamMap)   // We may alternatively specify parameters using a ParamMap, // which supports several methods for specifying parameters. val paramMap = ParamMap(lr.maxIter -> 20) .put(lr.maxIter, 30) // Specify 1 Param. This overwrites the original maxIter. .put(lr.regParam -> 0.1, lr.threshold -> 0.55) // Specify multiple Params.   // One can also combine ParamMaps. val paramMap2 = ParamMap(lr.probabilityCol -> "myProbability") // Change output column name. val paramMapCombined = paramMap ++ paramMap2   // Now learn a new model using the paramMapCombined parameters. // paramMapCombined overrides all parameters set earlier via lr.set* methods. val model2 = lr.fit(training, paramMapCombined) println("Model 2 was fit using parameters: " + model2.parent.extractParamMap)   // Prepare test data. val test = spark.createDataFrame(Seq( (1.0, Vectors.dense(-1.0, 1.5, 1.3)), (0.0, Vectors.dense(3.0, 2.0, -0.1)), (1.0, Vectors.dense(0.0, 2.2, -1.5)) )).toDF("label", "features")   // Make predictions on test data using the Transformer.transform() method. // LogisticRegression.transform will only use the 'features' column. // Note that model2.transform() outputs a 'myProbability' column instead of the usual // 'probability' column since we renamed the lr.probabilityCol parameter previously. model2.transform(test) .select("features", "label", "myProbability", "prediction") .collect() .foreach { case Row(features: Vector, label: Double, prob: Vector, prediction: Double) => println(s"($features, $label) -> prob=$prob, prediction=$prediction") } // $example off$   spark.stop() } }

　　其实Estimator类的单独使用，也能够理解为Pipeline对象只有一个Estimator对象。上述的程序来自：\src\main\scala\org\apache\spark\examples\ml\ ElementwiseProductExample.scala

4.2 Pipeline

　　输入的Dataframe通过PipelineStage对象处理后悔输出新的DataFrame，此时输出的DataFrame会增长一些列，即增长了一些特征，而具体增长什么列，须要看具体是什么PipelineStage对象。

以下所示，输入DataFrame只有三列"id"、"text"、"label"，但输出DataFrame不只保存了输入列，同时增长了一些列。

package org.apache.spark.examples.ml   // $example on$ import org.apache.spark.ml.{Pipeline, PipelineModel} import org.apache.spark.ml.classification.LogisticRegression import org.apache.spark.ml.feature.{HashingTF, Tokenizer} import org.apache.spark.ml.linalg.Vector import org.apache.spark.sql.Row // $example off$ import org.apache.spark.sql.SparkSession   object PipelineExample {   def main(args: Array[String]): Unit = { val spark = SparkSession .builder .appName("PipelineExample") .getOrCreate()   // $example on$ // Prepare training documents from a list of (id, text, label) tuples. val training = spark.createDataFrame(Seq( (0L, "a b c d e spark", 1.0), (1L, "b d", 0.0), (2L, "spark f g h", 1.0), (3L, "hadoop mapreduce", 0.0) )).toDF("id", "text", "label")   // Configure an ML pipeline, which consists of three stages: tokenizer, hashingTF, and lr. //Tokenizer功能是对输入的DataFrame某一列进行分割，分割后将数据添加到DataFrame的新列种 val tokenizer = new Tokenizer() .setInputCol("text") //设置输入DataFrame中要处理的列名字 .setOutputCol("words") //设置输出的DataFrame中增长列的名字 val hashingTF = new HashingTF() .setNumFeatures(1000) .setInputCol(tokenizer.getOutputCol) .setOutputCol("features") val lr = new LogisticRegression() .setMaxIter(10) .setRegParam(0.001) val pipeline = new Pipeline() .setStages(Array(tokenizer, hashingTF, lr))   // Fit the pipeline to training documents. val model = pipeline.fit(training)   // Now we can optionally save the fitted pipeline to disk model.write.overwrite().save("/tmp/spark-logistic-regression-model")   // We can also save this unfit pipeline to disk pipeline.write.overwrite().save("/tmp/unfit-lr-model")   // And load it back in during production val sameModel = PipelineModel.load("/tmp/spark-logistic-regression-model")   // Prepare test documents, which are unlabeled (id, text) tuples. val test = spark.createDataFrame(Seq( (4L, "spark i j k"), (5L, "l m n"), (6L, "spark hadoop spark"), (7L, "apache hadoop") )).toDF("id", "text")   // Make predictions on test documents. model.transform(test) .select("id", "text", "probability", "prediction") .collect() .foreach { case Row(id: Long, text: String, prob: Vector, prediction: Double) => println(s"($id, $text) --> prob=$prob, prediction=$prediction") } // $example off$   spark.stop() } }

5. 参考文献

[1]. Spark MLlib ；