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: " + lr.explainParams() + " ")

// 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对象。上述的程序来自：srcmainscalaorgapachesparkexamplesml 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；