程序员经验分享-hwhale

Spark-MLlib之分类和回归算法

2023-05-16

分类

逻辑回归

逻辑回归是预测分类响应的常用方法。广义线性模型的一个特例是预测结果的概率。在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

FamilyResponse TypeSupported Links
* Canonical Link
GaussianContinuousIdentity*, Log, Inverse
BinomialBinaryLogit*, Probit, CLogLog
PoissonCountLog*, Identity, Sqrt
GammaContinuousInverse*, Idenity, Log
TweedieZero-inflated continuousPower 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

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

spark

MLlib

之分类和回归算法

Spark-MLlib之分类和回归算法 的相关文章

  • 数据倾斜

    数据倾斜发生时的现象 1 绝大多数task执行得都非常快 但个别task执行的极慢 2 原本能正常执行的Spark作业 某天突然爆出OOM 内存溢出 异常 观察异常栈 是我们写的业务代码造成的 数据倾斜发生的原理 在进行shuffle的时候

  • Spark集群安装部署

    目录 一 环境准备 二 安装步骤 三 使用Standalone模式 四 使用Yarn模式 一 环境准备 由于Spark仅仅是一种计算机框架 不负责数据的存储和管理 因此 通常都会将Spark和Hadoop进行统一部署 由Hadoop中的HD

  • 11.Linux下Spark的安装配置以及spark-shell的启动和 Spark集群环境搭建

    本案例软件包 链接 https pan baidu com s 1zABhjj2umontXe2CYBW DQ 提取码 1123 若链接失效在下面评论 我会及时更新 目录 1 安装Spark 1 先用xftp将安装包传到home hadoo

  • 大数据--pyspark远程连接hive

    上一篇文章介绍了python连接hive的过程 通过地址 端口号访问到hive并对hive中的数据进行操作 这一篇文章介绍一下怎么通过windows本地pyspark 本地部署好的spark 远程虚拟机的hive 完成本地pyspark对h

  • Hudi 0.12.0 搭建——集成 Hive3.1 与 Spark3.2

    Hudi 搭建 https blog csdn net weixin 46389691 article details 128276527 环境准备 一 安装 Maven 1 解压 2 配置环境变量 3 修改 Maven 下载源 二 安装

  • pyspark 连接远程hive集群配置

    今天本地spark连接远程hive集群 直接把配置导入进去 本地直接应用远程环境 1 安装spark 设置spark环境变量 2 拿到远程集群配置文件 将配置文件放在spark conf 目录下 xml 一共五个文件 3 将mysql co

  • Spark中的基本概念

    Spark中的基本概念 1 基本概念 1 1 RDD 弹性分布式数据集 1 2 DAG 有向无环图 1 3 Partition 数据分区 1 4 NarrowDependency 窄依赖 1 5 ShuffleDependency 宽依赖

  • 学习大数据spark——心得体会

    总结与体会 1 项目总结 本次项目实现了Spark 单机模式Python版的安装 介绍了与Spark编程有关的一些基本概念 特别对RDD的创建 转换和行动操作做了比较详细的说明 对从RDD 到DataFrame的实现进 行了案例训练 包括

  • 【Spark系列2】reduceByKey和groupByKey区别与用法

    在spark中 我们知道一切的操作都是基于RDD的 在使用中 RDD有一种非常特殊也是非常实用的format pair RDD 即RDD的每一行是 key value 的格式 这种格式很像Python的字典类型 便于针对key进行一些处理

  • 大数据相关常用软件下载地址集锦

    文章目录 每日一句正能量 前言 一 软件下载地址如下 二 文档地址如下 结语 每日一句正能量 生命中有一些人与我们擦肩了 却来不及遇见 遇见了 却来不及相识 相识了 却来不及熟悉 熟悉了 却还是要说再见 前言 由于大数据开发中经常需要用到Z

  • 深入理解 SQL 中的 Grouping Sets 语句

    前言 SQL 中 Group By 语句大家都很熟悉 根据指定的规则对数据进行分组 常常和聚合函数一起使用 比如 考虑有表 dealer 表中数据如下 id Int city String car model String quantity

  • 浅谈Hadoop体系和MPP体系

    浅谈Hadoop体系和MPP体系 引言 如题 在大数据发展至今 为了应对日益繁多的数据分析处理 和解决客户各种奇思妙 怪 想需求 形形色色的大数据处理的框架和对应的数据存储手段层出不穷 有老当益壮的Hadoop体系 依靠Hadoop巨大的社

  • dolphinschedule使用shell任务结束状态研究

    背景 配置的dolphin任务 使用的是shell shell里包含了spark submit 如下截图 dolphin shell 介绍完毕 开始说明现象 有天有人调整了集群的cdp配置 executor cores max 1 我之前这

  • Spark SQL 之 Temporary View

    Spark SQL 之 Temporary View spark SQL的 temporary view 是支持原生SQL 的方式之一 spark SQL的 DataFrame 和 DataSet 均可以通过注册 temporary vie

  • 【Spark NLP】第 7 章：分类和回归

    大家好 我是Sonhhxg 柒 希望你看完之后 能对你有所帮助 不足请指正 共同学习交流 个人主页 Sonhhxg 柒的博客 CSDN博客 欢迎各位 点赞 收藏 留言 系列专栏 机器学习 ML 自然语言处理 NLP 深度学习 DL fore

  • 记一次Spark打包错误：object java.lang.Object in compiler mirror

    使用maven compile和package 一直报错scala reflect internal MissingRequirementError object scala runtime in compiler mirror not f

  • 大数据—— Flink 的优化

    目录 一 Flink内存优化 1 1 Flink 内存配置 二 配置进程参数 2 1 场景 2 2 操作步骤 三 解决数据倾斜 3 1 场景描述 3 2 解决方式 3 2 1 数据源的消费不均匀 调整并发度 3 2 2 数据分布不均匀 四

  • spark内存模型

    Spark 1 6 开始使用了统一内存管理模块 UnifiedMemoryManager 并引入了堆外内存 Off heap memory 1 6之前的内存管理就不进行介绍了 spark堆内和堆外内存模型的示意图 注意 堆外内存是依赖于wo

  • Spark 任务调度机制

    1 Spark任务提交流程 Spark YARN Cluster模式下的任务提交流程 如下图所示 图YARN Cluster任务提交流程 下面的时序图清晰地说明了一个Spark应用程序从提交到运行的完整流程 图Spark任务提交时序图 提交

  • 阿里技术官亲笔力作：Kafka限量笔记，一本书助你掌握Kafka的精髓

    前言 分布式 堪称程序员江湖中的一把利器 无论面试还是职场 皆是不可或缺的技能 而Kafka 这款分布式发布订阅消息队列的璀璨明珠 其魅力之强大 无与伦比 对于Kafka的奥秘 我们仍需继续探索 要论对Kafka的熟悉程度 恐怕阿里的大佬们

随机推荐

热门标签