Spark-MLlib之分类和回归算法

分类

逻辑回归

逻辑回归是预测分类响应的常用方法。广义线性模型的一个特例是预测结果的概率。在spark.ml逻辑回归中，可以使用二项Logistic回归来预测二元结果，或者可以使用多项Logistic回归来预测多类结果。使用该family 参数在这两种算法之间进行选择，或者保持不设置，Spark将推断出正确的变量。

通过将family参数设置为“多项式”，可以将多项逻辑回归用于二进制分类。它将产生两组系数和两个截距。

当在不具有常量非零列的数据集上截断LogisticRegressionModel时，Spark MLlib为常量非零列输出零系数。此行为与R glmnet相同，但与LIBSVM不同。

二项Logistic回归

欲了解更多的背景和有关二项logistic回归的实现的详细信息，请参阅的文件中回归spark.mllib。

例子

以下示例显示如何使用弹性网络正则化训练二项分类的二项式和多项Logistic回归模型。elasticNetParam对应$ \ alpha $并对应$ \ lambda $。αα和。regParamλλ

有关参数的更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.classification.LogisticRegression

//加载训练数据
val  training  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

val  lr  =  new  LogisticRegression （）
  。setMaxIter （10 ）
  。setRegParam （0.3 ）
  。setElasticNetParam （0.8 ）

//适合模型
val  lrModel  =  lr 。适合（训练）

//打印的回归系数和截距
的println （的“系数：$ { lrModel 。系数} 截取：$ { lrModel 。拦截} ” ）

//我们也可以使用多项式族进行二元分类
val  mlr  =  new  LogisticRegression （）
  。setMaxIter （10 ）
  。setRegParam （0.3 ）
  。setElasticNetParam （0.8 ）
  。setFamily （“multinomial” ）

val  mlrModel  =  mlr 。适合（训练）

//打印的系数和截距与多项家庭回归
的println （的“多项式系数：$ { mlrModel 。coefficientMatrix } ” ）
的println （的“多项拦截：$ { mlrModel 。interceptVector } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / LogisticRegressionWithElasticNetExample.scala”中找到完整的示例代码。

spark.ml逻辑回归的实现还支持在训练集上提取模型的摘要。请注意，这是存储为预测和指标DataFrame在LogisticRegressionSummary被注释@transient，因此仅适用于驱动程序。

• Scala
• Java
• Python

LogisticRegressionTrainingSummary 提供了摘要 LogisticRegressionModel。在二进制分类的情况下，可以使用某些附加度量，例如ROC曲线。可以通过该binarySummary方法访问二进制摘要 。见BinaryLogisticRegressionTrainingSummary。

继续前面的例子：

import  org.apache.spark.ml.classification.LogisticRegression

//从早期
//示例
val  trainingSummary  =  lrModel中训练的返回LogisticRegressionModel实例中提取摘要。binarySummary

//获得每次迭代的目标。
val  objectiveHistory  =  trainingSummary 。objectiveHistory 
println （“objectiveHistory：” ）
objectiveHistory 。foreach （损失 =>  println （亏损））

//获取接收器操作特性作为数据帧和areaUnderROC。
val  roc  =  trainingSummary 。中华民国
ROC 。显示（）
的println （的“areaUnderROC：$ { trainingSummary 。areaUnderROC } ” ）

//设置模型阈值以最大化F-Measure 
val  fMeasure  =  trainingSummary 。fMeasureByThreshold 
val  maxFMeasure  =  fMeasure 。选择（max （“F-Measure” ））。头（）。getDouble （0 ）
val  bestThreshold  =  fMeasure 。where （$ “F-Measure”  ===  maxFMeasure ）
  。选择（“阈值” ）。头（）。getDouble （0）
lrModel 。setThreshold （bestThreshold ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / LogisticRegressionSummaryExample.scala”中找到完整的示例代码。

多项逻辑回归

通过多项logistic（softmax）回归支持多类分类。在多项逻辑回归中，算法产生$ K $系数的集合，或者维度$ K \次J $的矩阵，其中$ K $是结果类的数量，$ J $是特征的数量。如果算法符合截距项，则可获得长度$ K $截距矢量。KK组系数，或维数的矩阵，其中是结果类的数量，是特征的数量。如果算法与截距项拟合，则可获得截距的长度向量。K×JK×JKKJJKK

多项系数可用coefficientMatrix，截距可用interceptVector。

coefficientsintercept不支持使用多项式训练的逻辑回归模型和方法。使用coefficientMatrix和interceptVector替代。

结果类$ k \ in {1,2，...，K} $的条件概率使用softmax函数建模。k∈1,2,…,Kk∈1,2,…,K使用softmax函数中的进行建模。

 

P(Y=k|X,βk,β0k)=eβk⋅X+β0k∑K−1k′=0eβk′⋅X+β0k′P(Y=k|X,βk,β0k)=eβk⋅X+β0k∑k′=0K−1eβk′⋅X+β0k′

 

我们使用多项式响应模型最小化加权负对数似然，使用弹性网惩罚来控制过度拟合。

 

minβ,β0−[∑i=1Lwi⋅logP(Y=yi|xi)]+λ[12(1−α)||β||22+α||β||1]minβ,β0−[∑i=1Lwi⋅log⁡P(Y=yi|xi)]+λ[12(1−α)||β||22+α||β||1]

 

有关详细的推导，请参阅此处。

例子

以下示例显示如何使用弹性网络正则化训练多类逻辑回归模型，以及提取用于评估模型的多类训练摘要。import org.apache.spark.ml.classification.LogisticRegression //加载训练数据 val training = spark 。读 。格式（“libsvm” ） 。load （“data / mllib / sample_multiclass_classification_data.txt” ） val lr = new LogisticRegression （） 。setMaxIter （10 ） 。setRegParam （0.3 ） 。setElasticNetParam （0.8 ） //适合模型 val lrModel = lr 。适合（训练） //对于打印多项Logistic回归系数和截距 的println （的“系数：\ n $ { lrModel 。coefficientMatrix } ” ） 的println （的“拦截：\ n $ { lrModel 。interceptVector } ” ） val trainingSummary = lrModel 。概要 //获得每次迭代的目标 val objectiveHistory = trainingSummary 。objectiveHistory println （“objectiveHistory：” ） objectiveHistory 。foreach （println ） //对于多类，我们可以在每个标签的基础上检查指标 println （“标签的误报率：” ） trainingSummary 。falsePositiveRateByLabel 。zipWithIndex 。foreach { case （rate ， label ） => println （s“label $ label ：$ rate ” ） } println （“标签真正的正面率：” ） trainingSummary 。truePositiveRateByLabel 。zipWithIndex 。foreach { case （rate ， label ） => println （s“label $ label ：$ rate ” ） } println （“标签精度：” ） trainingSummary 。precisionByLabel 。zipWithIndex 。foreach { case （prec ， label ） => println （s“label $ label ：$ prec ” ） } println （“召回标签：” ） trainingSummary 。回忆贝拉贝尔。zipWithIndex 。foreach { case （rec ， label ） => println （s“label $ label ：$ rec ” ） } println （“F-measure by label：” ） trainingSummary 。fMeasureByLabel 。zipWithIndex 。foreach { case （f ， label ） => println （s“label $ label ：$ f ” ） } val accuracy = trainingSummary 。准确度 val falsePositiveRate = trainingSummary 。weightedFalsePositiveRate val truePositiveRate = trainingSummary 。weightedTruePositiveRate val fMeasure = trainingSummary 。weightedFMeasure val precision = trainingSummary 。weightedPrecision val recall = trainingSummary 。weightedRecall println （s“准确度：$ accuracy \ nFPR：$ falsePositiveRate \ nTPR：$ truePositiveRate \ n“ + s”F-measure：$ fMeasure \ nPrecision：$ precision \ nRecall：$ recall “ ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / MulticlassLogisticRegressionWithElasticNetExample.scala”中找到完整的示例代码。

决策树分类器

决策树是一种流行的分类和回归方法。有关spark.ml实施的更多信息可以在决策树部分中找到。

例子

以下示例以LibSVM格式加载数据集，将其拆分为训练和测试集，在第一个数据集上训练，然后在保留的测试集上进行评估。我们使用两个特征变换器来准备数据; 这些帮助标签和分类功能的索引类别，添加DataFrame决策树算法可识别的元数据。

​有关参数的更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.classification.DecisionTreeClassificationModel 
import  org.apache.spark.ml.classification.DecisionTreeClassifier 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator 
import  org.apache .spark.ml.feature。{ IndexToString ， StringIndexer ， VectorIndexer }

//将以LIBSVM格式存储的数据加载为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//索引标签，将元数据添加到标签列。
//适合整个数据集以包含索引中的所有标签。
val  labelIndexer  =  new  StringIndexer （）
  。setInputCol （“label” ）
  。setOutputCol （“indexedLabel” ）
  。fit （data ）
//自动识别分类特征并对其进行索引。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“features” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ） //具有> 4个不同值的要素被视为连续。
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练DecisionTree模型。
val  dt  =  new  DecisionTreeClassifier （）
  。setLabelCol （“indexedLabel” ）
  。setFeaturesCol （“indexedFeatures” ）

//将索引标签转换回原始标签。
val  labelConverter  =  new  IndexToString （）
  。setInputCol （“预测” ）
  。setOutputCol （“predictLabel” ）
  。setLabels （labelIndexer 。标签）

//管道中的链索引器和树。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （labelIndexer ， featureIndexer ， dt ， labelConverter ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。select （“predictLabel” ， “label” ， “features” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  MulticlassClassificationEvaluator （）
  。setLabelCol （“indexedLabel” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“精度” ）
VAL  精度 =  求值。评估（预测）
println （s“测试错误= $ { （1.0  -  准确度）} ” ）

val  treeModel  =  model 。阶段（2 ）。asInstanceOf [ DecisionTreeClassificationModel ] 
的println （的“学习的分类树模型：\ n $ { 的TreeModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / DecisionTreeClassificationExample.scala”中找到完整的示例代码。

随机分类器

随机是一种流行的分类和回归方法。有关spark.ml实施的更多信息可以在随机部分中找到。

例子

以下示例以LibSVM格式加载数据集，将其拆分为训练和测试集，在第一个数据集上训练，然后在保留的测试集上进行评估。我们使用两个特征变换器来准备数据; 这些有助于标签和分类功能的索引类别，将DataFrame基于树的算法可识别的元数据添加到其中。

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.classification。{ RandomForestClassificationModel ， RandomForestClassifier } 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator 
import  org.apache.spark.ml.feature。{ IndexToString ， StringIndexer ， VectorIndexer }

//加载并解析数据文件，将其转换为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//索引标签，将元数据添加到标签列。
//适合整个数据集以包含索引中的所有标签。
val  labelIndexer  =  new  StringIndexer （）
  。setInputCol （“label” ）
  。setOutputCol （“indexedLabel” ）
  。fit （data ）
//自动识别分类特征并对其进行索引。
//设置maxCategories，使> 4个不同值的特征被视为连续。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“功能” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ）
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练一个RandomForest模型。
val  rf  =  new  RandomForestClassifier （）
  。setLabelCol （“indexedLabel” ）
  。setFeaturesCol （“indexedFeatures” ）
  。setNumTrees （10 ）

//将索引标签转换回原始标签。
val  labelConverter  =  new  IndexToString （）
  。setInputCol （“预测” ）
  。setOutputCol （“predictLabel” ）
  。setLabels （labelIndexer 。标签）

//管道中的链索引器和林。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （labelIndexer ， featureIndexer ， rf ， labelConverter ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。select （“predictLabel” ， “label” ， “features” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  MulticlassClassificationEvaluator （）
  。setLabelCol （“indexedLabel” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“精度” ）
VAL  精度 =  求值。评估（预测）
println （s“测试错误= $ { （1.0  -  准确度）} ” ）

val  rfModel  =  model 。阶段（2 ）。asInstanceOf [ RandomForestClassificationModel ] 
的println （的“学习的分类林模型：\ n $ { rfModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / RandomForestClassifierExample.scala”中找到完整的示例代码。

Gradient-boosted树分类器

Gradient-boosted树（GBT）是使用决策树集合的流行分类和回归方法。有关spark.ml实施的更多信息可以在GBT部分中找到。

例子

以下示例以LibSVM格式加载数据集，将其拆分为训练和测试集，在第一个数据集上训练，然后在保留的测试集上进行评估。我们使用两个特征变换器来准备数据; 这些有助于标签和分类功能的索引类别，将DataFrame基于树的算法可识别的元数据添加到其中。​​​​​​​有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.classification。{ GBTClassificationModel ， GBTClassifier } 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator 
import  org.apache.spark.ml.feature。{ IndexToString ， StringIndexer ， VectorIndexer }

//加载并解析数据文件，将其转换为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//索引标签，将元数据添加到标签列。
//适合整个数据集以包含索引中的所有标签。
val  labelIndexer  =  new  StringIndexer （）
  。setInputCol （“label” ）
  。setOutputCol （“indexedLabel” ）
  。fit （data ）
//自动识别分类特征并对其进行索引。
//设置maxCategories，使> 4个不同值的特征被视为连续。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“功能” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ）
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练GBT模型。
val  gbt  =  new  GBTClassifier （）
  。setLabelCol （“indexedLabel” ）
  。setFeaturesCol （“indexedFeatures” ）
  。setMaxIter （10 ）
  。setFeatureSubsetStrategy （“auto” ）

//将索引标签转换回原始标签。
val  labelConverter  =  new  IndexToString （）
  。setInputCol （“预测” ）
  。setOutputCol （“predictLabel” ）
  。setLabels （labelIndexer 。标签）

//链路索引器和管道中的GBT。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （labelIndexer ， featureIndexer ， gbt ， labelConverter ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。select （“predictLabel” ， “label” ， “features” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  MulticlassClassificationEvaluator （）
  。setLabelCol （“indexedLabel” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“精度” ）
VAL  精度 =  求值。评估（预测）
println （s“测试错误= $ { 1.0  -  准确度} ” ）

val  gbtModel  =  model 。阶段（2 ）。asInstanceOf [ GBTClassificationModel ] 
的println （的“学习的分类模型GBT：\ n $ { gbtModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / GradientBoostedTreeClassifierExample.scala”中找到完整的示例代码。

多层感知器分类器

多层感知器分类器（MLPC）是基于前馈人工神经网络的分类器。MLPC由多层节点组成。每层完全连接到网络中的下一层。输入层中的节点表示输入数据。所有其他节点通过输入与节点的权重和偏差的线性组合将输入映射到输出，并应用激活函数。这可以用MLPC的矩阵形式写入，层数如下： 中间层中的节点使用sigmoid（逻辑）函数： 输出层中的节点使用softmax函数： 输出层中的节点数对应于类的数量。wwbbK+1K+1

y(x)=fK(...f2(wT2f1(wT1x+b1)+b2)...+bK)y(x)=fK(...f2(w2Tf1(w1Tx+b1)+b2)...+bK)

f(zi)=11+e−zif(zi)=11+e−zi

f(zi)=ezi∑Nk=1ezkf(zi)=ezi∑k=1Nezk

NN

 

MLPC采用反向传播来学习模型。我们使用逻辑损失函数进行优化，使用L-BFGS作为优化例程。

例子

​​​​​​​有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.classification.MultilayerPerceptronClassifier 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator

//将以LIBSVM格式存储的数据加载为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）
  。load （“data / mllib / sample_multiclass_classification_data.txt” ）

//将数据拆分为train并测试
val  splits  =  data 。randomSplit （阵列（0.6 ， 0.4 ）， 种子 =  1234L ）
VAL  列车 =  分裂（0 ）
VAL  测试 =  拆分（1 ）

//指定的神经网络层：
//尺寸的输入层4（特征），两个中间尺寸5和4 
//和大小3的输出（类）
VAL  层 =  阵列[ 诠释]（4 ， 5 ， 4 ， 3 ）

//创建训练器并设置其参数
val  trainer  =  new  MultilayerPerceptronClassifier （）
  。setLayers （图层）
  。setBlockSize （128 ）
  。setSeed （1234L ）
  。setMaxIter （100 ）

//训练模型
val  模型 =  训练师。适合（火车）

//计算集上的计算精度
val  结果 =  模型。transform （test ）
val  predictionAndLabels  =  result 。select （“prediction” ， “label” ）
val  evaluateator  =  new  MulticlassClassificationEvaluator （）
  。setMetricName （“准确度” ）

println （s“测试集准确度= $ { 评估者。评估（predictionAndLabels ）} ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / MultilayerPerceptronClassifierExample.scala”中找到完整的示例代码。

线性支持向量机

甲支持向量机构建一个超平面或在高或无限维空间，该空间可用于分类，回归或其他任务中设定的超平面的。直观地，通过与任何类的最近训练数据点具有最大距离的超平面（所谓的功能边界）实现良好的分离，因为通常边缘越大，分类器的泛化误差越低。Spark ML中的LinearSVC支持使用线性SVM进行二进制分类。在内部，它 使用OWLQN优化器优化铰链损耗。

例子

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.classification.LinearSVC

//加载训练数据
val  training  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

val  lsvc  =  new  LinearSVC （）
  。setMaxIter （10 ）
  。setRegParam （0.1 ）

//使模型
val  lsvcModel  =  lsvc 。适合（训练）

//打印线性SVC的系数和截距
的println （的“系数：$ { lsvcModel 。系数} 截取：$ { lsvcModel 。截距} ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / LinearSVCExample.scala”中找到完整的示例代码。

One-vs-Rest分类器（又名One-vs-All）

OneVsRest是用于执行多类分类的机器学习减少的示例，给定可以有效地执行二进制分类的基础分类器。它也被称为“一对一”。

OneVsRest实现为Estimator。对于基本分类器，它接受实例Classifier并为每个k类创建二进制分类问题。训练i类的分类器来预测标签是否为i，将类i与所有其他类区分开来。

通过评估每个二元分类器来完成预测，并且将最有信心的分类器的索引输出为标签。

例子

下面的示例演示了如何加载 Iris数据集，将其解析为DataFrame并使用执行多类分类OneVsRest。计算测试误差以测量算法精度。

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.classification。{ LogisticRegression ， OneVsRest } 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator

//加载数据文件。
val  inputData  =  spark 。读。格式（“libsvm” ）
  。load （“data / mllib / sample_multiclass_classification_data.txt” ）

//生成列车/测试拆分。
val  Array （train ， test ） =  inputData 。randomSplit （阵列（0.8 ， 0.2 ））

//实例化基类分类器
val  classifier  =  new  LogisticRegression （）
  。setMaxIter （10 ）
  。setTol （1 E - 6 ）
  。setFitIntercept （true ）

//实例化One Vs Rest分类器。
VAL  OVR  =  新 OneVsRest （）。setClassifier （分类器）

//训练多类模型。
VAL  ovrModel  =  OVR 。适合（火车）

//在测试数据上评分模型。
val  predictions  =  ovrModel 。变换（测试）

//获得评估者。
val  evaluator  =  new  MulticlassClassificationEvaluator （）
  。setMetricName （“准确度” ）

//计算测试数据的分类错误。
val  准确度 =  评估者。评估（预测）
println （s“测试错误= $ { 1  -  准确度} ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / OneVsRestExample.scala”中找到完整的示例代码。

朴素贝叶斯

朴素贝叶斯分类器是一类简单的概率分类器，它基于贝叶斯定理应用特征之间的强（天真）独立假设。该spark.ml实现目前支持多项式朴素贝叶斯 和伯努利朴素贝叶斯。更多信息可以在MLlib的Naive Bayes部分找到。

例子

 

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.classification.NaiveBayes 
import  org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator

//将以LIBSVM格式存储的数据加载为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//将数据拆分为训练和测试集（30％用于测试）
val  Array （trainingData ， testData ） =  data 。randomSplit （阵列（0.7 ， 0.3 ）， 种子 =  1234L ）

//训练NaiveBayes模型。
val  model  =  new  NaiveBayes （）
  。适合（训练数据）

//选择要显示的示例行。
val  预测 =  模型。transform （testData ）
预测。show （）

//选择（预测，真实标签）并计算测试错误
val  evaluateator  =  new  MulticlassClassificationEvaluator （）
  。setLabelCol （“label” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“精度” ）
VAL  精度 =  求值。评估（预测）
println （s“测试集精度= $准确度” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / NaiveBayesExample.scala”中找到完整的示例代码。

回归

线性回归

使用线性回归模型和模型摘要的界面类似于逻辑回归案例。

当通过“l-bfgs”求解器在不具有常量非零列的数据集上插入LinearRegressionModel时，Spark MLlib为常量非零列输出零系数。此行为与R glmnet相同，但与LIBSVM不同。

例子

以下示例演示了训练弹性网正则化线性回归模型和提取模型汇总统计量。

 

有关参数的更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.regression.LinearRegression

//加载训练数据
val  training  =  spark 。读。格式（“libsvm” ）
  。load （“data / mllib / sample_linear_regression_data.txt” ）

val  lr  =  new  LinearRegression （）
  。setMaxIter （10 ）
  。setRegParam （0.3 ）
  。setElasticNetParam （0.8 ）

//适合模型
val  lrModel  =  lr 。适合（训练）

//打印线性回归系数和截距
的println （的“系数：$ { lrModel 。系数} 截取：$ { lrModel 。截距} ” ）

//在训练集上总结模型并打印出一些指标
val  trainingSummary  =  lrModel 。摘要
的println （的“numIterations：$ { trainingSummary 。totalIterations } ” ）
的println （的“objectiveHistory：[ $ { trainingSummary 。objectiveHistory 。mkString （”， “ ）} ]” ）
trainingSummary 。残差。show （）
println （s“RMSE：$ {
       trainingSummary 。rootMeanSquaredError } “ ）
的println （的” R2：$ { trainingSummary 。R2 } “ ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / LinearRegressionWithElasticNetExample.scala”中找到完整的示例代码。

广义线性回归

与假设输出遵循高斯分布的线性回归相比，广义线性模型（GLM）是线性模型的规范，其中响应变量遵循指数分布族的一些分布。Spark的界面允许灵活地指定GLM，可用于各种类型的预测问题，包括线性回归，泊松回归，逻辑回归等。目前，只支持指数族分布的一个子集，它们列 在下面。ÿ一世ÿ一世GeneralizedLinearRegressionspark.ml

注意：Spark目前仅通过其GeneralizedLinearRegression 接口支持多达4096个功能，如果超出此约束，则会抛出异常。有关详细信息，请参阅高级部分。尽管如此，对于线性和逻辑回归，可以使用LinearRegression和LogisticRegression估计器训练具有更多特征的模型。

GLM需要指数族分布，这些分布可以用“规范”或“自然”形式写成，也就是 自然指数族分布。自然指数族分布的形式如下：

Fÿ（ÿ| θ，τ）= h （y，τ）exp（θ ＆CenterDot;＆ÿ- A （θ ）d（τ））Fÿ（ÿ|θ，τ）=H（ÿ，τ）EXP⁡（θ⋅ÿ- 一个（θ）d（τ））

其中是感兴趣的参数，是一个色散参数。在GLM中，假设响应变量是从自然指数族分布中提取的：τÿ我θθττÿ一世ÿ一世

ÿ一世~ f（⋅ | θ一世，τ）ÿ一世〜F（⋅|θ一世，τ）

其中感兴趣的参数涉及响应变量的期望值由μ我θ一世θ一世μ一世μ一世

μ一世= A.“（θ一世）μ一世=一个“（θ一世）

这里，由所选分布的形式定义。GLM还允许指定链接函数，该函数定义响应变量 与所谓的线性预测器：一个“（θ一世）一个“（θ一世）μ一世μ一世 η一世η一世

G（μ一世）= η一世= x一世→Ť＆CenterDot;＆β⃗ G（μ一世）=η一世=X一世→Ť⋅β→

通常，选择链接函数使得，其产生感兴趣的参数与线性预测之间的简化关系。在这种情况下，链接函数被称为“规范”链接函数。一个“= g- 1一个“=G- 1θθηηG（μ ）G（μ）

θ一世= A.' - 1（μ一世）= g(g−1(ηi))=ηiθi=A′−1(μi)=g(g−1(ηi))=ηi

GLM找到最大化似然函数的回归系数。β⃗ β→

maxβ⃗ L(θ⃗ |y⃗ ,X)=∏i=1Nh(yi,τ)exp(yiθi−A(θi)d(τ))maxβ→L(θ→|y→,X)=∏i=1Nh(yi,τ)exp⁡(yiθi−A(θi)d(τ))

其中感兴趣的参数有关回归系数 通过θiθiβ⃗ β→

θi=A′−1(g−1(xi→⋅β⃗ ))θi=A′−1(g−1(xi→⋅β→))

Spark的广义线性回归界面还提供了用于诊断GLM模型拟合的汇总统计数据，包括残差，p值，偏差，Akaike信息标准等。

有关 GLM及其应用的更全面的评论，请参见此处。

可用的families

Family	Response Type	Supported Links
* Canonical Link
Gaussian	Continuous	Identity*, Log, Inverse
Binomial	Binary	Logit*, Probit, CLogLog
Poisson	Count	Log*, Identity, Sqrt
Gamma	Continuous	Inverse*, Idenity, Log
Tweedie	Zero-inflated continuous	Power link function

例子

以下示例演示了如何使用高斯响应和身份链接功能训练GLM并提取模型摘要统计信息。

 

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.regression.GeneralizedLinearRegression

//加载训练数据
val  dataset  =  spark 。读。格式（“libsvm” ）
  。load （“data / mllib / sample_linear_regression_data.txt” ）

val  glr  =  new  GeneralizedLinearRegression （）
  。setFamily （“高斯” ）
  。setLink （“身份” ）
  。setMaxIter （10 ）
  。setRegParam （0.3 ）

//适合模型
val  model  =  glr 。适合（数据集）

//打印广义线性回归模型的系数和截距
的println （的“系数：$ { 模型。系数} ” ）
的println （的“截取：{$ 模型。截距} ” ）

//在训练集上总结模型并打印出一些指标
val  summary  =  model 。总结
的println （的“系数的标准误差：$ { 总结。coefficientStandardErrors 。mkString （” “ ）} ” ）
的println （的“牛逼值：$ { 总结。tValues 。mkString （”” ）} “ ）
的println （的” P值：$ { 总结。p值。mkString （“” ）} “ ）
的println （的”分散性：$ { 总结。分散} “ ）
的println （的”空越轨：$ { 总结。nullDeviance } “ ）
的println （的”剩余自由度空：$ { 摘要。residualDegreeOfFreedomNull } “ ）
的println （的”越轨：$ { 总结。越轨} “ ）
的println （的“剩余自由度：$ { 总结。residualDegreeOfFreedom } ” ）
的println （的“AIC：$ { 总结。AIC } ” ）
的println （“越轨残差：” ）
总结。残差（）。show （）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / GeneralizedLinearRegressionExample.scala”中找到完整的示例代码。

决策树回归

决策树是一种流行的分类和回归方法。有关spark.ml实施的更多信息可以在决策树部分中找到。

例子

以下示例以LibSVM格式加载数据集，将其拆分为训练和测试集，在第一个数据集上训练，然后在保留的测试集上进行评估。我们使用特征变换器来对分类特征进行索引，将DataFrame决策树算法可识别的元数据添加到其中。

 

有关参数的更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.evaluation.RegressionEvaluator 
import  org.apache.spark.ml.feature.VectorIndexer 
import  org.apache.spark.ml.regression.DecisionTreeRegressionModel 
import  org.apache .spark.ml.regression.DecisionTreeRegressor

//将以LIBSVM格式存储的数据加载为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//自动识别分类要素并对其进行索引。
//在这里，我们将具有> 4个不同值的特征视为连续的。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“features” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ）
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练DecisionTree模型。
val  dt  =  new  DecisionTreeRegressor （）
  。setLabelCol （“label” ）
  。setFeaturesCol （“indexedFeatures” ）

//管道中的链索引器和树。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （featureIndexer ， dt ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。选择（“预测” ， “标签” ， “功能” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  RegressionEvaluator （）
  。setLabelCol （“label” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“RMSE” ）
VAL  RMSE  =  求值。评估（预测）
println （s“测试数据的均方根误差（RMSE）= $ rmse ” ）

val  treeModel  =  model 。阶段（1 ）。asInstanceOf [ DecisionTreeRegressionModel ] 
的println （的“习得回归树模型：\ n $ { 的TreeModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / DecisionTreeRegressionExample.scala”中找到完整的示例代码。

随机森林回归

随机森林是一种流行的分类和回归方法。有关spark.ml实施的更多信息可以在随机森林部分中找到。

例子

以下示例以LibSVM格式加载数据集，将其拆分为训练和测试集，在第一个数据集上训练，然后在保留的测试集上进行评估。我们使用特征变换器来索引分类特征，将DataFrame基于树的算法可识别的元数据添加到其中。

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.evaluation.RegressionEvaluator 
import  org.apache.spark.ml.feature.VectorIndexer 
import  org.apache.spark.ml.regression。{ RandomForestRegressionModel ， RandomForestRegressor }

//加载并解析数据文件，将其转换为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//自动识别分类要素并对其进行索引。
//设置maxCategories，使> 4个不同值的特征被视为连续。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“features” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ）
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练一个RandomForest模型。
val  rf  =  new  RandomForestRegressor （）
  。setLabelCol （“label” ）
  。setFeaturesCol （“indexedFeatures” ）

//管道中的链索引器和林。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （featureIndexer ， rf ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。选择（“预测” ， “标签” ， “功能” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  RegressionEvaluator （）
  。setLabelCol （“label” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“RMSE” ）
VAL  RMSE  =  求值。评估（预测）
println （s“测试数据的均方根误差（RMSE）= $ rmse ” ）

val  rfModel  =  model 。阶段（1 ）。asInstanceOf [ RandomForestRegressionModel ] 
的println （的“习得回归林模型：\ n $ { rfModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / RandomForestRegressorExample.scala”中找到完整的示例代码。

梯度提升树回归

梯度提升树（GBT）是使用决策树集合的流行回归方法。有关spark.ml实施的更多信息可以在GBT部分中找到。

例子

注意：对于此示例数据集，GBTRegressor实际上只需要1次迭代，但通常情况下不会这样。

 

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.Pipeline 
import  org.apache.spark.ml.evaluation.RegressionEvaluator 
import  org.apache.spark.ml.feature.VectorIndexer 
import  org.apache.spark.ml.regression。{ GBTRegressionModel ， GBTRegressor }

//加载并解析数据文件，将其转换为DataFrame。
val  data  =  spark 。读。格式（“libsvm” ）。load （“data / mllib / sample_libsvm_data.txt” ）

//自动识别分类要素并对其进行索引。
//设置maxCategories，使> 4个不同值的特征被视为连续。
val  featureIndexer  =  new  VectorIndexer （）
  。setInputCol （“features” ）
  。setOutputCol （“indexedFeatures” ）
  。setMaxCategories （4 ）
  。适合（数据）

//将数据拆分为训练和测试集（30％用于测试）。
val  Array （trainingData ， testData ） =  数据。randomSplit （阵列（0.7 ， 0.3 ））

//训练GBT模型。
val  gbt  =  new  GBTRegressor （）
  。setLabelCol （“label” ）
  。setFeaturesCol （“indexedFeatures” ）
  。setMaxIter （10 ）

//链路索引器和管道中的GBT。
val  pipeline  =  new  Pipeline （）
  。setStages （Array （featureIndexer ， gbt ））

//训练模型。这也运行索引器。
val  model  =  管道。适合（训练数据）

// 作出预测。
val  预测 =  模型。变换（testData ）

//选择要显示的示例行。
预测。选择（“预测” ， “标签” ， “功能” ）。节目（5 ）

//选择（预测，真实标签）并计算测试错误。
val  evaluator  =  new  RegressionEvaluator （）
  。setLabelCol （“label” ）
  。setPredictionCol （“预测” ）
  。setMetricName （“RMSE” ）
VAL  RMSE  =  求值。评估（预测）
println （s“测试数据的均方根误差（RMSE）= $ rmse ” ）

val  gbtModel  =  model 。阶段（1 ）。asInstanceOf [ GBTRegressionModel ] 
的println （的“习得回归模型GBT：\ n $ { gbtModel 。toDebugString } ” ）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / GradientBoostedTreeRegressorExample.scala”中找到完整的示例代码。

生存回归

在spark.ml我们中，我们实现了加速失效时间（AFT） 模型，该模型是用于删失数据的参数生存回归模型。它描述了生存时间对数的模型，因此它通常被称为生存分析的对数线性模型。与为相同目的设计的比例风险模型不同 ，AFT模型更容易并行化，因为每个实例都独立地为目标函数做出贡献。

x‘x‘titi

L(β,σ)=∏i=1n[1σf0(logti−x′βσ)]δiS0(logti−x′βσ)1−δiL(β,σ)=∏i=1n[1σf0(log⁡ti−x′βσ)]δiS0(log⁡ti−x′βσ)1−δi

δiδiϵi=logti−x‘βσϵi=log⁡ti−x‘βσ

ι(β,σ)=∑i=1n[−δilogσ+δilogf0(ϵi)+(1−δi)logS0(ϵi)]ι(β,σ)=∑i=1n[−δilog⁡σ+δilog⁡f0(ϵi)+(1−δi)log⁡S0(ϵi)]

S0(ϵi)S0(ϵi)f0(ϵi)f0(ϵi)

 

S0(ϵ)S0(ϵ)

S0(ϵi)=exp(−eϵi)S0(ϵi)=exp⁡(−eϵi)

f0(ϵi)f0(ϵi)

f0(ϵi)=eϵiexp(−eϵi)f0(ϵi)=eϵiexp⁡(−eϵi)

ι(β,σ)=−∑i=1n[δilogσ−δiϵi+eϵi]ι(β,σ)=−∑i=1n[δilog⁡σ−δiϵi+eϵi]

−ι(β,σ)−ι(β,σ)ββlogσlog⁡σ

∂(−ι)∂β=∑1=1n[δi−eϵi]xiσ∂(−ι)∂β=∑1=1n[δi−eϵi]xiσ

∂(−ι)∂(logσ)=∑i=1n[δi+(δi−eϵi)ϵi]∂(−ι)∂(log⁡σ)=∑i=1n[δi+(δi−eϵi)ϵi]

 

−ι(β,σ)−ι(β,σ)ββlogσlog⁡σ

当拟合AFTSurvivalRegressionModel而不截断具有常量非零列的数据集时，Spark MLlib为常量非零列输出零系数。此行为与R survival :: survreg不同。

例子

有关更多详细信息，请参阅Scala API文档。

import  org.apache.spark.ml.linalg.Vectors 
import  org.apache.spark.ml.regression.AFTSurvivalRegression

val  训练 =  火花。createDataFrame （SEQ （
  （1.218 ， 1.0 ， 载体。密（1.560 ， - 0.605 ））， 
  （2.949 ， 0.0 ， 载体。密（0.346 ， 2.158 ））， 
  （3.627 ， 0.0 ， 载体。密（1.380 ， 0.231 ）），
  （0.273 ， 1.0， 矢量。密（0.520 ， 1.151 ））， 
  （4.199 ， 0.0 ， 载体。密（0.795 ， - 0.226 ）） 
））。toDF （“标签” ， “检查员” ， “特征” ）
VAL  quantileProbabilities  =  阵列（0.3 ， 0.6 ）
VAL  船尾 =  新 AFTSurvivalRegression （） 
  。setQuantileProbabilities （quantileProbabilities ）
  。setQuantilesCol （“分位数” ）

val  model  =  aft 。适合（训练）

//打印AFT生存回归
println 的系数，截距和比例参数（s“系数：$ { 模型。系数} ” ）
println （s“拦截： $ { 模型。拦截} ” ）
的println （的“规模：$ { 模型。规模} “ ）
模型。变换（训练）。显示（假）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / AFTSurvivalRegressionExample.scala”中找到完整的示例代码。

等渗回归

等渗回归 属于回归算法族。正式等张回归是一个问题，其中给定一组有限的实数表示观察到的响应，并且拟合的未知响应值找到最小化的函数Y=y1,y2,...,ynY=y1,y2,...,ynX=x1,x2,...,xnX=x1,x2,...,xn

 

f(x)=∑i=1nwi(yi−xi)2(1)(1)f(x)=∑i=1nwi(yi−xi)2

 

关于完整订单，取决于 哪里是正权重。由此产生的函数称为等渗回归，它是独一无二的。它可以被视为订单限制下的最小二乘问题。基本上等渗回归是 最适合原始数据点的 单调函数。x1≤x2≤...≤xnx1≤x2≤...≤xnwiwi

isotonicisotonic

训练返回IsotonicRegressionModel，可用于预测已知和未知特征的标签。等张回归的结果被视为分段线性函数。因此预测规则是：

• 如果预测输入与训练特征完全匹配，则返回相关联的预测。如果有多个具有相同特征的预测，则返回其中一个。哪一个是未定义的（与java.util.Arrays.binarySearch相同）。
• 如果预测输入低于或高于所有训练特征，则分别返回具有最低或最高特征的预测。如果存在具有相同特征的多个预测，则分别返回最低或最高。
• 如果预测输入落在两个训练特征之间，则将预测视为分段线性函数，并且根据两个最接近特征的预测来计算内插值。如果存在具有相同特征的多个值，则使用与先前点相同的规则。

例子

 

有关API的详细信息，请参阅IsotonicRegressionScala文档。

import  org.apache.spark.ml.regression.IsotonicRegression

//加载数据 
val  dataset  =  spark 。读。格式（“libsvm” ）
  。load （“data / mllib / sample_isotonic_regression_libsvm_data.txt” ）

//训练等张回归模型。
val  ir  =  new  IsotonicRegression （）
val  model  =  ir 。适合（数据集）

println （s“按升序排列的边界：$ { model 。边界} \ n” ）
的println （s “用边界相关的预测：$ { 模型。预测} \ n” ）

//做出预测。
模特。变换（数据集）。show （）

在Spark repo中的“examples / src / main / scala / org / apache / spark / examples / ml / IsotonicRegressionExample.scala”中找到完整的示例代码。

线性方法

L1L1L2L2

L1L1L2L2L1L1L2L2

α(λ∥w∥1)+(1−α)(λ2∥w∥22),α∈[0,1],λ≥0α(λ‖w‖1)+(1−α)(λ2‖w‖22),α∈[0,1],λ≥0

ααL1L1L2L2αα11αα00

 

决策树

决策树 及其集合是分类和回归的机器学习任务的流行方法。决策树被广泛使用，因为它们易于解释，处理分类特征，扩展到多类分类设置，不需要特征缩放，并且能够捕获非线性和特征交互。诸如随机森林和增强的树集合算法是分类和回归任务的最佳表现者。

该spark.ml实现支持使用连续和分类特征进行二元和多类分类以及回归的决策树。该实现按行分区数据，允许分布式培训数百万甚至数十亿实例。

用户可以在MLlib决策树指南中找到有关决策树算法的更多信息。此API与原始MLlib Decision Tree API之间的主要区别是：

• 支持ML管道
• 决策树的分离用于分类与回归
• 使用DataFrame元数据来区分连续和分类功能

决策树的Pipelines API提供了比原始API更多的功能。
特别是，对于分类，用户可以获得每个类的预测概率（也称为类条件概率）; 对于回归，用户可以获得有偏差的预测样本方差。

树木集合（随机森林和梯度树木）在树集合部分中描述。

输入和输出

我们在此列出输入和输出（预测）列类型。所有输出列都是可选的; 要排除输出列，请将其对应的Param设置为空字符串。

输入列

帕拉姆的名字	类型	默认	描述
labelCol	双	“标签”	标签来预测
featuresCol	向量	“特征”	特征向量

输出列

帕拉姆的名字	类型	默认	描述	笔记
predictionCol	双	“预测”	预测标签
rawPredictionCol	向量	“rawPrediction”	长度＃类的向量，具有进行预测的树节点处的训练实例标签的计数	仅限分类
probabilityCol	向量	“可能性”	长度＃等级的向量等于rawPrediction归一化为多项分布	仅限分类
varianceCol	双		预测的偏差样本方差	仅回归

树集合

DataFrame API支持两种主要的树集合算法：随机森林和梯度提升树（GBT）。两者都使用spark.ml决策树作为基础模型。

用户可以在MLlib Ensemble指南中找到有关集合算法的更多信息。
在本节中，我们将演示用于集合的DataFrame API。

此API与原始MLlib合奏API之间的主要区别是：

• 支持DataFrames和ML Pipelines
• 分类与回归的分离
• 使用DataFrame元数据来区分连续和分类功能
• 随机森林的更多功能：特征重要性的估计，以及用于分类的每个类（也称为类条件概率）的预测概率。

随机森林

随机森林 是决策树的集合。随机森林结合了许多决策树，以降低过度拟合的风险。该spark.ml实现支持使用连续和分类特征的随机森林进行二进制和多类分类以及回归。

有关算法本身的更多信息，请参阅spark.mllib随机森林的文档。

输入和输出

我们在此列出输入和输出（预测）列类型。所有输出列都是可选的; 要排除输出列，请将其对应的Param设置为空字符串。

输入列

帕拉姆的名字	类型	默认	描述
labelCol	双	“标签”	标签来预测
featuresCol	向量	“特征”	特征向量

输出列（预测）

帕拉姆的名字	类型	默认	描述	笔记
predictionCol	双	“预测”	预测标签
rawPredictionCol	向量	“rawPrediction”	长度＃类的向量，具有进行预测的树节点处的训练实例标签的计数	仅限分类
probabilityCol	向量	“可能性”	长度＃等级的向量等于rawPrediction归一化为多项分布	仅限分类

梯度树（GBT）

渐变树（GBT） 是决策树的集合。GBT迭代地训练决策树以最小化损失函数。该spark.ml实现支持使用连续和分类特征的二进制分类和回归的GBT。

有关算法本身的更多信息，请参阅spark.mllib有关GBT的文档。

输入和输出

我们在此列出输入和输出（预测）列类型。所有输出列都是可选的; 要排除输出列，请将其对应的Param设置为空字符串。

输入列

帕拉姆的名字	类型	默认	描述
labelCol	双	“标签”	标签来预测
featuresCol	向量	“特征”	特征向量

请注意，GBTClassifier目前仅支持二进制标签。

输出列（预测）

帕拉姆的名字	类型	默认	描述	笔记
predictionCol	双	“预测”	预测标签

将来，GBTClassifier还会输出rawPrediction和的列probability，就像那样RandomForestClassifier。

参考网站:https://mp.csdn.net/postedit