Spark-MLlib之分类和回归算法

最新推荐文章于 2022-05-27 18:09:18 发布
最新推荐文章于 2022-05-27 18:09:18 发布
阅读量2.7k 收藏 7
点赞数
分类专栏： 机器学习 算法 文章标签： 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，因此仅适用于驱动程序。

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

wyc_595998412
关注
专栏目录
Spark MLlib 特征工程系列—特征转换QuantileDiscretizer
08-24 63
是 Spark 提供的一个特征转换器，用于将连续数值型特征离散化为多个区间。与Bucketizer不同，基于分位数（Quantiles）来划分数据，使得每个区间内的数据点数大致相等。这种方法在对数据进行分箱（Binning）时非常有效，特别是当数据的分布不均匀时。是一种基于分位数的离散化工具，特别适合数据分布不均衡的场景。通过设置区间数量，可以灵活调整离散化后的特征，使得每个区间内的数据点数接近一致。在实际应用中，常用于信用评分、市场分析等需要特征离散化的领域。掌握。
spark官方文档MLlib学习---分类与回归
leemusk的博客
11-21 846
分类与回归 官方文档 一、分类 1. 逻辑分类 Logistic回归是一种用于预测分类响应的流行方法。 这是广义线性模型的一种特殊情况，可以预测结果的可能性。 在spark.ml中，逻辑回归可以通过使用二项式逻辑回归来预测二进制结果，或者可以通过使用多项逻辑回归来预测多类结果。 使用family参数在这两种算法之间进行选择，或者不设置它，Spark会推断出正确的变体。 通过将family参数设置为...
【Spark】分类和回归算法-分类
buracag_mc的博客
09-03 1235
同步于Buracag的博客 本节主要讲Spark ML中关于分类算法的实现。示例的算法Demo包含：LR、DT、RF、GBTs、多层感知器、线性支持向量机、One-vs-Rest分类器以及NB等。 文章目录1. Logistic regression1.1 二分类LR1.2 多分类LR2. 决策树分类器3. 随机森林分类器4. 梯度提升树分类器5. 多层感知器分类器6. 线性支持向量机7. One...
Spark MLlib中分类和回归算法
weixin_30364325的博客
01-16 211
Spark MLlib中分类和回归算法： -分类算法： pyspark.mllib.classification -朴素贝叶斯 NaiveBayes -支持向量机（优化：随机梯度下降）SVMWithSGD -逻辑回归...
Spark MLlib 机器学习算法（一）
sunqingok的博客
12-25 459
一 协同过滤算法 协同过滤（Collaborative filtering）算法是一种基于群体用户或者物品的典型推荐算法，主要有两种：一种是通过考察具有相同爱好的用户对相同物品的评分标准进行计算。一种是考察具有相同特质的物品从而推荐给选择了某件物品的用户。 协同过滤算法关键是计算相似度，主要有以下几种方法： 1、 基于欧几里得距离计算 公式： 主要从不同目标的绝对差异性考虑 2、 基于余弦角度计算 公式： 主要从方向趋势上考虑 3、 交替最小二乘法（ALS） Val ratings = data.map
spark mllib 决策树算法
chuwanfei的博客
06-28 515
该样例取自spark高级数据分析第四章的内容，数据集来自http://t.cn/ R2wmIsI,包含一个 CSV 格式的压缩数据文件 covtype.data.gz,附带一个描述数据文件的 信息文件 covtype.info spark mllib将特征向量抽象为LabeledPoint,它由一个包含多个特征值的Spark MLlib Vector 和一个称为标号(label)的目标值组成。该目
基于spark-ml,spark-mllib,spark-streaming的推荐算法实现.zip
最新发布
03-14
Spark MLlib 是 Spark 的机器学习（ML）库，它提供了多种常用的机器学习算法，如分类、回归、聚类、协同过滤等，并且包含了模型选择、特征提取和转换等工具。在这个项目中，我们将关注于推荐算法的实现，特别是 ...
spark-mllib_2.10-1.0.0.zip
10-11
回归算法如线性回归和岭回归则用于预测连续数值。聚类算法如K-Means和Gaussian混合模型用于无监督学习，帮助发现数据中的自然分组。协同过滤是推荐系统的核心，用于预测用户对物品的喜好。 【spray-extensions】...
spark-mllib-examples
04-29
Spark MLlib是Apache Spark的核心机器学习库，它提供了丰富的数据挖掘和机器学习算法，包括分类、回归、聚类、协同过滤、特征提取等。在"Spark MLlib示例"项目中，我们可以深入理解如何在Scala编程环境中使用Spark ...
Spark-MLlib实例——逻辑回归
Ganymede的Hadoop世界
04-17 5020
Spark-MLlib实例——逻辑回归，应用于二元分类的情况，这里以垃圾邮件分类为例，即是否为垃圾邮件两种情况。
spark-mllib
05-03
标记点在监督学习算法中使用，我们使用双精度浮点数来存储标签，因此可以在回归和分类中使用标记点。在二元分类中，标签应该是 0（负向）或 1（正向）。在多类别分类中，标签应该是从 0 开始的类别索引，例如 0, 1, ...
Spark ML（3）：回归算法实现（线性回归、逻辑回归）
小蚯蚓的博客
05-18 1834
一、环境配置 1.spark2.1.0-cdh5.7.0（自编译） 2.cdh5.7.0 3.scala2.11.8 4.centos6.4 二、环境准备 1.spark客户端调试环境搭建 参考：https://blog.csdn.net/u010886217/article/details/83279157 2.创建scala项目 参考：https://blog.csdn.ne...
二 Spark机器学习MLlib： LogisticRegression
数学民工
09-19 892
一 MLlib简单介绍MLllib目前分为两个代码包： spark.mllib 包含基于RDD的原始算法API。 spark.ml 则提供了基于DataFrames 高层次的API，可以用来构建机器学习管道。 本文用基于DataFrame的API，DataFrame结构与MySQL表基本一致，处理数据比较方便。 基于DataFrame的API,包名为：org.apache.spark.
使用Spark MLlib的逻辑回归(LogisticRegression)进行用户分类预测识别
陆云子安的专栏
05-18 7660
import org.apache.spark.SparkContext import org.apache.spark.SparkConf import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD} import org.apache.spark.mlli
mllib逻辑回归 spark_Spark MLlib学习——分类和回归
weixin_33997566的博客
01-13 573
本章节介绍了分类和回归的算法。它还包括讨论特定类别的算法部分，如：线性方法，树和集成。下面是整个API Doc中的内容框架，这里不会每个都详细介绍，主要会把用到的介绍出来，后续用到的再陆续添加。(下面的链接都是指向官网文档而不是本笔记中的对应内容所在位置，而且有些内容没有出现在本笔记中)逻辑回归逻辑回归是预测分类问题的流行算法。它是 广义线性模型的一个特例来预测结果的可能性。 在spark.ml逻...
spark 2.x 源码分析 之 Logistic Regression 逻辑回归
u013855234的博客
11-22 1136
Logistic Regression 逻辑回归 注：第一次写博客，希望互相交流改进。如果公式显示不完整，请看github原文 一、二元逻辑回归 简介 回归是解决变量之间的映射关系（x->y），而逻辑回归则通过sigmoid函数将映射值限定在(0,1)。sigmoid图像如下： 假设特征是x，线性函数可以表示为： 而逻辑回归则是在其基础上...
机器学习实验之肿瘤分类与预测（SVM）
热门推荐
Gettler的博客
05-27 1万+
肿瘤分类与预测（SVM） 【实验内容】 采用SVM方法，对美国威斯康星州的乳腺癌诊断数据集进行分类，实现针对乳腺癌检测的分类器，以判断一个患者的肿瘤是良性还是恶性。 【实验要求】 参考实现步骤：（具体实现可以不同） 1.加载data文件夹里的数据集：威斯康星乳腺肿瘤数据集（数据集路径：data/data74924/data.csv）。 2.查看样本特征和特征值，查看样本特征值的描述信息。 3.进行数据清洗（如删除无用列，将诊断结果的字符标识B、M替换为数值0、1等）。 4.进行特征选取（方便后续的模
Spark ML离线训练模型用于在线预测
abc50319的专栏
11-01 5868
最近公司有需求需要将离线训练好的算法模型应用到线上去实时预测，在线预测不考虑feature加工的情况下，经调研，发现jpmml-sparkml+jpmml-evaluator的方式可以满足条件。不过使用时需要注意该框架是AGPL-3.0协议。 方案：spark ml + jpmml-sparkml + jpmml-evaluator Spark离线训练Random Forest模型并保存为pm...
分类与回归算法介绍
lihe的博客
12-30 4071
分类算法 分类(Classification)是机器学习的主要任务之一，分类算法是一种典型的监督学习算法，是根据样本的特征将样本划分到合适的类别中。具体来说就是利用训练样本来进行训练，从而得到样本特征到样本标签的映射，再利用该映射来得到新样本的标签，最终达到将样本划分到不同类别的目的。简而言之，分类就是通过一组代表物体、事件等的相关属性来判断其类别。 分类问题通常有两种，一种是二元分类问题，另一种是多元分类。对于二元分类问题，通过已有的特征属性来判断事物或者事件的类别，其产生+的结果只有“0”和“1”，即要
spark(57) -- sparkmllib -- sparkmllib的算法的分类和应用场景
03-16
spark(57)是指Apache Spark的版本号为2.4.7。而sparkmllib是Spark中的机器学习库，提供了多种算法用于分类、回归、聚类、协同过滤等任务。 sparkmllib的算法分类包括：监督学习、无监督学习、半监督学习和推荐系统。其中监督学习包括分类和回归，无监督学习包括聚类和降维，半监督学习是介于监督学习和无监督学习之间的一种学习方式，推荐系统则是一种特殊的协同过滤算法。 sparkmllib的应用场景非常广泛，可以用于金融、医疗、电商、社交网络等领域。例如，可以使用分类算法对信用卡欺诈进行检测，使用聚类算法对客户进行分群，使用推荐系统算法对用户进行个性化推荐等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值