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逻辑回归的实现还支持在训练集上提取模型的摘要。请注意,这是存储为预测和指标DataFrameLogisticRegressionSummary被注释@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不支持使用多项式训练的逻辑回归模型和方法。使用coefficientMatrixinterceptVector替代。

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

 

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

 

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

 

minβ,β0[i=1LwilogP(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+ezif(zi)=11+e−zi

f(zi)=eziNk=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个功能,如果超出此约束,则会抛出异常。有关详细信息,请参阅高级部分。尽管如此,对于线性和逻辑回归,可以使用LinearRegressionLogisticRegression估计器训练具有更多特征的模型。

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

Fÿÿθτyτexpθ ·&ÿθ dτFÿ(ÿ|θ,τ)=H(ÿ,τ)EXP⁡(θ⋅ÿ- 一个(θ)d(τ))

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

ÿ一世f⋅ θ一世τÿ一世〜F(⋅|θ一世,τ)

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

μ一世A.θ一世μ一世=一个“(θ一世)

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

Gμ一世η一世x一世Ť·&β⃗ G(μ一世)=η一世=X一世→Ť⋅β→

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

θ一世A.1μ一世g(g1(ηi))=ηiθi=A′−1(μi)=g(g−1(ηi))=ηi

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

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

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

θi=A1(g1(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模型更容易并行化,因为每个实例都独立地为目标函数做出贡献。

xx‘titi

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

δiδiϵi=logtixβσϵ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[δieϵi]xiσ∂(−ι)∂β=∑1=1n[δi−eϵi]xiσ

(ι)(logσ)=i=1n[δi+(δieϵ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(yixi)2(1)(1)f(x)=∑i=1nwi(yi−xi)2

 

关于完整订单,取决于 哪里是正权重。由此产生的函数称为等渗回归,它是独一无二的。它可以被视为订单限制下的最小二乘问题。基本上等渗回归是 最适合原始数据点的 单调函数x1x2...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

α(λw1)+(1α)(λ2w22),α[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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值