阅读 479

Spark实现逻辑回归算法和实例代码解析

spark mllib 机器学习

1. 逻辑回归概述

1.1 概述

逻辑回归与线性回归类似,但它不属于回归分析家族(主要为二分类),而属于分类家族,差异主要在于变量不同,因此其解法与生成曲线也不尽相同。 逻辑回归是无监督学习的一个重要算法,对某些数据与事物的归属(分到哪个类别)及可能性(分到某一类别的概率)进行评估。

1.2 使用场景

  • 在医学界,广泛应用于流行病学中,比如探索某个疾病的危险因素,根据危险因素预测疾病是否发生,与发生的概率。比如探讨胃癌,可以选择两组人群,一组是胃癌患者,一组是非胃癌患者。因变量是“是否胃癌”,这里“是”与“否”就是要研究的两个分类类别。自变量是两组人群的年龄,性别,饮食习惯,等等许多(可以根据经验假设),自变量可以是连续的,也可以是分类的。
  • 在金融界,较为常见的是使用逻辑回归去预测贷款是否会违约,或放贷之前去估计贷款者未来是否会违约或违约的概率。
  • 在消费行业中,也可以被用于预测某个消费者是否会购买某个商品,是否会购买会员卡,从而针对性得对购买概率大的用户发放广告,或代金券等等,进行精准营销。

2.逻辑回归算法原理

公式推导部分转自知乎机器学习专栏 zhuanlan.zhihu.com/p/28775274

2.1Sigmoid函数

逻辑回归本质是线性回归,只是在特征到结果的过程上加上了一层映射。即首先需要把特征进行求和,然后将求和后的结果应用于一个g(z)函数,g(z)可以将值映射到0或者是1上面,这个函数就是Sigmoid函数,公式如下:

2.2原理图

默认分类的值是0.5,超过0.5则类别为1,小于0.5类别为0

在线性回归的基础上,套用了Sigmoid函数。下面左图是一个线性的决策边界,右图是非线性的决策边界。

对于线性边界的情况,边界形式可以归纳为如下公式(1):

因此我们可以构造预测函数为公式(2):

该预测函数表示分类结果为1时的概率。因此对于输入点x,分类结果为类别1和类别0的概率分别为公式(3):

对于训练数据集,特征数据x={x1, x2, … , xm}和对应的分类数据y={y1, y2, … , ym}。构建逻辑回归模型f,最典型的构建方法便是应用极大似然估计。对公式(3)取极大似然函数,可以得到如下的公式(4):

再对公式(4)取对数,可得到公式(5):

最大似然估计就是求使l取最大值时的theta。Spark MLlib 中提供了两种方法来求这个参数,分别是梯度下降法SGD和L-BFGS。

2.3spark mllib

逻辑回归和多重线性回归有很多的相似之处。最大的区别是他们的因变量不同。这两个回归也可以统一归为广义线性模型。在 spark mllib 实现的过程中也是先定义好父类广义线性模型,然后让线性回归和逻辑回归去继承这个类,重新覆盖里面的一些参数,比如 Updater,GradientDescent等。

逻辑回归主要包含以下类:

  1. 首先是伴生对象类,LogisticRegressionWithSGD.(包含有静态train方法)
  2. 然后是逻辑回归的主类,class LogisticRegressionWithSGD,这个类继承了GeneralizedLinearAlgorithm类。同时执行了父类的run方法。不过里面的部分参数,比如说梯度下降方法,权重更新方法在LogisticRegressionWithSGD有新的定义。父类包含有optimizer.optimize方法。用于执行梯度下降。权重的优化计算调用的是runMiniBatchWithSGD。梯度的计算调用的是Gradient.compute 方法。
  3. 最后有一个逻辑回归模型,LogisticRegressionModel类。其里面也包含有predict方法来进行预测。

逻辑回归相关的spark mllib源码解析可以参考这篇文章:blog.csdn.net/stevekangpe…

2.4逻辑回归优缺点

  • 优点:计算代价低,速度快,容易理解和实现。
  • 缺点:容易欠拟合,分类和回归的精度不高

3.Spark实现逻辑回归代码解析

3.1简单例子

下面的例子展示了如何使用逻辑回归训练模型,预测结果,保存和调用模型。

import org.apache.spark.SparkContext
import org.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionModel}
import org.apache.spark.mllib.evaluation.MulticlassMetrics
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.util.MLUtils
// 加载训练数据
val data = MLUtils.loadLibSVMFile(sc, "data/mllib/sample_libsvm_data.txt")
// 切分数据,training (60%) and test (40%).
val splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
val training = splits(0).cache()
val test = splits(1)
// 训练模型
val model = new LogisticRegressionWithLBFGS()
  .setNumClasses(10)
  .run(training)
// Compute raw scores on the test set.
val predictionAndLabels = test.map { case LabeledPoint(label, features) =>
  val prediction = model.predict(features)
  (prediction, label)
}
// Get evaluation metrics.
val metrics = new MulticlassMetrics(predictionAndLabels)
val precision = metrics.precision
println("Precision = " + precision)
// 保存和加载模型
model.save(sc, "myModelPath")
val sameModel = LogisticRegressionModel.load(sc, "myModelPath")
复制代码

3.2实例调参分析

package Classification
/**
  * LogisticRegression Algorithm
  * Created by wy on 2019/03/25
  */

//spark初始化
import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}
//分类数据格式处理
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.rdd.RDD
//逻辑回归-随机梯度下降SGD
import org.apache.spark.mllib.classification.LogisticRegressionWithSGD
//计算Accuracy、PR、ROC和AUC
import org.apache.spark.mllib.evaluation.BinaryClassificationMetrics
//数据标准化
import org.apache.spark.mllib.linalg.distributed.RowMatrix
import org.apache.spark.mllib.feature.StandardScaler
//参数调优
import org.apache.spark.mllib.optimization.{Updater,SimpleUpdater,L1Updater,SquaredL2Updater}
import org.apache.spark.mllib.classification.ClassificationModel

object LogisticRegression {

  //屏蔽不必要的日志显示在终端上
  //Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
  Logger.getLogger("org.apache.spark").setLevel(Level.ERROR) //warn类信息不会显示,只显示error级别的
  Logger.getLogger("org.apache.eclipse.jetty.server").setLevel(Level.OFF)

  def main(args: Array[String]): Unit = {
    //初始化
    val conf = new SparkConf().setMaster("local").setAppName("LogisticRegression")
    val sc = new SparkContext(conf)
    /**
      * 数据:lr_test.txt
      * 该数据集包含了46个feature,1个label
      * */
    //input
    val sourceRDD = sc.textFile("E:\\Spark\\scala-data\\LRdata\\lr_test.txt")
    val data = sourceRDD.map{
      line =>{
        val arr = line.split("#")
        val label = arr(1).toDouble
        val features = arr(0).split(",").map(_.toDouble)
        LabeledPoint(label,Vectors.dense(features))  //创建一个稠密向量
      }
    }
    /**
      * 创建一个稀疏向量(第一种方式)
      * val sv1: Vector = Vector.sparse(3, Array(0,2), Array(1.0,3.0));
      * 创建一个稀疏向量(第二种方式)
      * val sv2 : Vector = Vector.sparse(3, Seq((0,1.0),(2,3.0)))
      *
      * 对于稠密向量:很直观,你要创建什么,就加入什么,其函数声明为Vector.dense(values : Array[Double])
      * 对于稀疏向量,当采用第一种方式时,3表示此向量的长度,第一个Array(0,2)表示的索引,第二个Array(1.0, 3.0)
      * 与前面的Array(0,2)是相互对应的,表示第0个位置的值为1.0,第2个位置的值为3
      *
      * 对于稀疏向量,当采用第二种方式时,3表示此向量的长度,后面的比较直观,Seq里面每一对都是(索引,值)的形式。
      * */
    data.cache()  //缓存
    val Array(trainData, testData) = data.randomSplit(Array(0.8,0.2),seed = 11L)
    trainData.cache()
    testData.cache()
    val numData = data.count
    val numTrainData = trainData.count
    val numTestData = testData.count
    println("原始数据量:",numData)       //40530
    println("训练数据量:",numTrainData)  //32503
    println("测试数据量:",numTestData)   //8027

    val stepSize = 0.1           //迭代步长,默认为1.0
    val numIterations = 50       //迭代次数,默认为100
    val miniBatchFraction = 1.0  //每次迭代参与计算的样本比例,默认为1.0

    /** 训练逻辑回归模型 */
    val lrModel = LogisticRegressionWithSGD.train(data, numIterations, stepSize, miniBatchFraction)
    //打印模型权重值
    val res = lrModel.weights.toArray
    println("权重值列表如下:")
    res.foreach(println)
    println("----------------------拟合预测结果--------------------")

    //预测值与真实值比较
    //val testPoint = testData.first
    //val testPredict = lrModel.predict(testPoint.features)
    //testPredict: Double = 0.0
    //val testTrueLabel = testPoint.label
    //testTrueLabel: Double = 0.0

    /** 预测的正确率计算 */
    val lrTestCorrect = data.map { x =>
      if (lrModel.predict(x.features)== x.label) 1 else 0
    }.sum
    //预测正确率
    val lrAccuracy = lrTestCorrect / numData
    println(f"Accuracy:${lrAccuracy * 100}%2.3f%%")
    // Accuracy: 97.839%

    /** 计算 准确率-召回律(PR曲线) ROC曲线的面积(AUC)
      * 1.准确率通常用于评价结果的质量,定义为真阳性的数目除以真阳性和假阳性的总数,其中真阳性值被预测的类别为1的样本,
      *   假阳性是错误预测为1的样本。
      * 2.召回率用来评价结果的完整性,定义为真阳性的数目除以真阳性和假阳性的和,其中假阳性是类别为1却被预测为0的样本。
      *   通常高准确率对应着低召回率
      * 3.ROC曲线与PR曲线类似,是对分类器的真阳性率-假阳性率的图形化解释。
      * */
    val metrics = Seq(lrModel).map{ model =>
      val scoreAndLabels = data.map{ x =>
        (model.predict(x.features), x.label)
      }
      val metrics = new BinaryClassificationMetrics(scoreAndLabels)
      (model.getClass.getSimpleName, metrics.areaUnderPR(), metrics.areaUnderROC())
    }

    //val allMetrics = metrics ++ nbMetrics ++ dtMetrics
    metrics.foreach{ case (model, pr, roc) =>
      println(f"model:$model\n" +
        f"Area under PR: ${pr * 100.0}%2.3f%%\n" +
        f"Area under ROC: ${roc * 100.0}%2.3f%%")
    }
    //Accuracy:97.839%
    //model:LogisticRegressionModel
    //Area under PR: 51.081%
    //Area under ROC: 50.000%
    
    /** 改进模型性能以及参数调优 */
    //特征标准化
    //将特征变量用(RowMatrix类)表示成MLlib中的(分布矩阵)
    val vectors = data.map(x => x.features)
    val matrix = new RowMatrix(vectors)
    val matrixSummary = matrix.computeColumnSummaryStatistics() //计算矩阵每列的统计特性
    println("----------------------特征标准化----------------------")
    println("mean:       ",matrixSummary.mean)        //输出每列均值
    println("max:        ",matrixSummary.max)         //每列最大值
    println("variance:   ",matrixSummary.variance)    //矩阵每列方差
    println("numNonzeros:",matrixSummary.numNonzeros) //每列非0项的数目
    println("normL2:     ",matrixSummary.normL2)      //L2范数:向量各元素的平方和然后求平方根

    /**为使得数据更符合模型的假设,对每个特征进行标准化,使得每个特征是(0均值)和(单位标准差)*/
    //做法:对(每个特征值)减去(列的均值),然后(除以)列的(标准差)以进行缩放
    val scaler = new StandardScaler(withMean = true, withStd = true).fit(vectors) //将向量传到转换函数
    val scaledData = data.map(x => LabeledPoint(x.label, scaler.transform(x.features)))

    //println(data.first.features)
    println("标准化后的特征第一行结果:")
    println(scaledData.first.features)
    //[0.0016544159298287912,0.0273303020874253,0.008141541536538578,0.07992614623509364,...
    //为验证第一个特征已经应用标准差公式被转换了,用 第一个特征(减去)其均值,然后(除以)标准差--方差的平方根
    println("验证第一个特征是否正确")
    println((data.first.features(0) - matrixSummary.mean(0)) / math.sqrt(matrixSummary.variance(0)))
    //0.0016544159298287912 验证正确

    /** 现在使用标准化的数据重新训练模型逻辑回归-(决策树和朴素贝叶斯不受特征标准化的影响)*/
    //val Array(scaledTrainData, scaledTestData) = scaledData.randomSplit(Array(0.8,0.2),seed = 11L)

    val scaledLrModel = LogisticRegressionWithSGD.train(scaledData,numIterations,stepSize,miniBatchFraction)

    val scaledLrCorrect = scaledData.map{ x =>
      if (scaledLrModel.predict(x.features) == x.label) 1 else 0
    }.sum
    val scaledLrTestAccuracy = scaledLrCorrect / numData

    val lrPredictionsVsTrue = scaledData.map{ x =>
      (scaledLrModel.predict(x.features), x.label)
    }
    val lrMetricsScaled = new BinaryClassificationMetrics(lrPredictionsVsTrue)
    val lrPr = lrMetricsScaled.areaUnderPR()   //lrPr: Double = 0.27532
    val lrPoc = lrMetricsScaled.areaUnderROC() //lrPoc: Double = 0.58451

    println("------------标准化后数据训练、拟合和结果----------------")
    println(f"Model:${scaledLrModel.getClass.getSimpleName}\n" +
      f"Accuracy:      ${scaledLrTestAccuracy * 100}%2.3f%%\n" +
      f"Area under PR: ${lrPr * 100}%2.3f%%\n" +
      f"Area under ROC:${lrPoc * 100}%2.3f%%")
    //Model:LogisticRegressionModel
    //Accuracy:      64.974%
    //Area under PR: 35.237%
    //Area under ROC:65.355%

    /** 模型参数调优MLlib线性模型优化技术:SGD和L-BFGS(只在逻辑回归中使用LogisticRegressionWithLBFGS)*/
    //线性模型
    //定义训练调参辅助函数,根据给定输入训练模型 (输入, 则正则化参数, 迭代次数, 正则化形式, 步长)
    def trainWithParams(input: RDD[LabeledPoint], regParam: Double, numIterations: Int,
                        updater: Updater, stepSize: Double) = {
      val lr =new LogisticRegressionWithSGD  //逻辑回归也可以用LogisticRegressionWithLBFGS
      lr.optimizer
        .setNumIterations(numIterations)  //迭代次数
        .setStepSize(stepSize)            //步长
        .setRegParam(regParam)            //则正则化参数
        .setUpdater(updater)              //正则化形式
      lr.run(input)                       //输入训练数据RDD
    }

    //定义第二个辅助函数,label为需要调试的参数,data:输入预测的数据,model训练的模型
    def createMetrics(label: Double, data: RDD[LabeledPoint], model: ClassificationModel) = {
      val scoreAndLabels = data.map { point =>
        (model.predict(point.features),point.label)  //(predicts,label)
      }
      val metrics = new BinaryClassificationMetrics(scoreAndLabels)
      (label, metrics.areaUnderROC())  //计算AUC
    }

    //加快多次模型训练速度, 缓存标准化后的数据
    scaledData.cache()
    println("------------------标准化后数据调参---------------------")
    //1迭代次数
    val iterateResults = Seq(1, 5, 10, 50, 100).map { param =>
      //训练
      val model = trainWithParams(scaledData, 0.0, param, new SimpleUpdater, 1.0)
      //拟合,计算AUC
      createMetrics(param, scaledData, model)
    }
    println("1迭代次数numIterations:Seq(1, 5, 10, 50, 100)")
    iterateResults.foreach { case (param, auc) => println(f"$param iterations, AUC = ${auc * 100}%2.2f%%")}
    //1 iterations, AUC = 64.50%
    //5 iterations, AUC = 67.07%
    //10 iterations, AUC = 67.10%
    //50 iterations, AUC = 67.56%
    //100 iterations, AUC = 67.56%
    var maxIterateAuc = 0.0
    var bestIterateParam = 0
    for(x <- iterateResults){
      //println(x)
      if(x._2 > maxIterateAuc){
        maxIterateAuc = x._2
        bestIterateParam = x._1.toInt
      }
    }
    println("max auc: " + maxIterateAuc + " best numIterations param: " + bestIterateParam)


    //2步长 大步长收敛快,太大可能导致收敛到局部最优解
    val stepResults = Seq(0.001, 0.01, 0.1, 1.0, 10.0).map { param =>
      val model = trainWithParams(scaledData, 0.0, bestIterateParam, new SimpleUpdater, param)
      createMetrics(param, scaledData, model)
    }
    println("\n2步长stepSize:Seq(0.001, 0.01, 0.1, 1.0, 10.0)")
    stepResults.foreach { case (param, auc) => println(f"$param stepSize, AUC = ${auc * 100}%2.2f%%")}
    //0.001 step size, AUC = 64.50%
    //0.01 step size, AUC = 64.50%
    //0.1 step size, AUC = 65.36%
    //1.0 step size, AUC = 67.56%
    //10.0 step size, AUC = 50.20%
    var maxStepAuc = 0.0
    var bestStepParam = 0.0
    for(x <- stepResults){
      //println(x)
      if(x._2 > maxStepAuc){
        maxStepAuc = x._2
        bestStepParam = x._1
      }
    }
    println("max auc: " + maxStepAuc + " best stepSize param: " + bestStepParam)

    //3.1正则化参数,默认值为0.0,L1正则new L1Updater
    val regL1Results = Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0).map{ param =>
      val model = trainWithParams(scaledData, param, bestIterateParam, new L1Updater, bestStepParam)
      createMetrics(param, scaledData, model)
    }
    println("\n3.1 L1正则化参数regParam:Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0)")
    regL1Results.foreach{ case (param,auc) => println(f"$param regParam L1, AUC = ${auc * 100}%2.2f%%")}
    //regParam L1 = 0.0, AUC = 67.56%
    //regParam L1 = 0.001, AUC = 66.43%
    //regParam L1 = 0.01, AUC = 65.74%
    //regParam L1 = 0.1, AUC = 50.00%
    //regParam L1 = 1.0, AUC = 50.00%
    //regParam L1 = 10.0, AUC = 50.00%
    var maxRegL1Auc = 0.0
    var bestRegL1Param = 0.0
    for(x <- regL1Results){
      //println(x)
      if(x._2 > maxRegL1Auc){
        maxRegL1Auc = x._2
        bestRegL1Param = x._1
      }
    }
    println("max auc: " + maxRegL1Auc + " best L1regParam: " + bestRegL1Param)

    //3.2正则化参数:默认值为0.0,L2正则new SquaredL2Updater
    val regL2Results = Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0).map{ param =>
      val model = trainWithParams(scaledData, param, bestIterateParam, new SquaredL2Updater, bestStepParam)
      createMetrics(param, scaledData, model)
    }
    println("\n3.2 L2正则化参数regParam:Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0)")
    regL2Results.foreach{ case (param,auc) => println(f"$param regParam L2, AUC = ${auc * 100}%2.2f%%")}
    //regParam L2 = 0.0 , AUC = 67.56%
    //regParam L2 = 0.001 , AUC = 67.56%
    //regParam L2 = 0.01 , AUC = 67.43%
    //regParam L2 = 0.1 , AUC = 67.14%
    //regParam L2 = 1.0 , AUC = 66.60%
    //regParam L2 = 10.0 , AUC = 36.76%
    var maxRegL2Auc = 0.0
    var bestRegL2Param = 0.0
    for(x <- regL2Results){
      //println(x)
      if(x._2 > maxRegL2Auc){
        maxRegL2Auc = x._2
        bestRegL2Param = x._1
      }
    }
    println("max auc: " + maxRegL2Auc + " best L2regParam: " + bestRegL2Param)
    //4正则化形式:默认为new SimpleUpdater 正则化系数无效,前两个参数调参后最优AUC为maxStepAuc
    //则,3.1和3.2的最优AUC与maxStepAuc比较,较大的则为最优正则化形式
    var bestRegParam = 0.0
    var bestUpdaterID = 0
    if(maxStepAuc >= maxRegL1Auc ){
      if(maxStepAuc >= maxRegL2Auc){
        bestUpdaterID = 0
        bestRegParam = 0.0
      }
      else {
        bestUpdaterID = 2
        bestRegParam = bestRegL2Param
      }
    }
    else {
      if(maxRegL2Auc >= maxRegL1Auc){
        bestUpdaterID = 2
        bestRegParam = bestRegL2Param
      }
      else {
        bestUpdaterID = 1
        bestRegParam = bestRegL1Param
      }
    }
    val Updaters = Seq(new SimpleUpdater, new L1Updater, new SquaredL2Updater)
    val bestUpdater = Updaters(bestUpdaterID)

    //最优参数:
    println("------------------更新模型训练参数---------------------")
    println(f"best numIterations param: $bestIterateParam\n" +
      f"best stepSize param: $bestStepParam\n" +
      f"best regParam: $bestRegParam\n" +
      f"best regUpdater: $bestUpdater\n"
    )
    // numIterations:50
    // stepSize:1.0
    // regParam:0.0
    // updater:new SimpleUpdater
    /** 数据标准化、参数调优后,再次训练逻辑回归模型,可以用28分训练测试 */
    val upDateLrModel = trainWithParams(scaledData, bestRegParam, bestIterateParam, bestUpdater, bestStepParam)

    //保存和加载模型
    upDateLrModel.save(sc, "E:\\Spark\\scala-data\\Model")
    val newModel = LogisticRegressionModel.load(sc, "E:\\Spark\\scala-data\\Model")

    //打印模型权重值
    val newRes = newModel.weights.toArray
    println("参数调优后特征权重值列表如下:")
    newRes.foreach(println)
    
  }
}
复制代码

3.3本地运行结果

------------标准化后数据训练、拟合和结果----------------
Model:LogisticRegressionModel
Accuracy:      64.974%
Area under PR: 35.237%
Area under ROC:65.355%
------------------标准化后数据调参---------------------
1迭代次数numIterations:Seq(1, 5, 10, 50, 100)
1.0 iterations, AUC = 64.50%
5.0 iterations, AUC = 67.07%
10.0 iterations, AUC = 67.10%
50.0 iterations, AUC = 67.56%
100.0 iterations, AUC = 67.56%
max auc: 0.6756122825453876 best numIterations param: 50

2步长stepSize:Seq(0.001, 0.01, 0.1, 1.0, 10.0)
0.001 stepSize, AUC = 64.50%
0.01 stepSize, AUC = 64.50%
0.1 stepSize, AUC = 65.36%
1.0 stepSize, AUC = 67.56%
10.0 stepSize, AUC = 50.20%
max auc: 0.6756122825453876 best stepSize param: 1.0

3.1 L1正则化参数regParam:Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0)
0.0 regParam L1, AUC = 67.56%
0.001 regParam L1, AUC = 66.43%
0.01 regParam L1, AUC = 65.74%
0.1 regParam L1, AUC = 50.00%
1.0 regParam L1, AUC = 50.00%
10.0 regParam L1, AUC = 50.00%
max auc: 0.6756122825453876 best L1regParam: 0.0

3.2 L2正则化参数regParam:Seq(0.0, 0.001, 0.01, 0.1, 1.0, 10.0)
0.0 regParam L2, AUC = 67.56%
0.001 regParam L2, AUC = 67.56%
0.01 regParam L2, AUC = 67.43%
0.1 regParam L2, AUC = 67.14%
1.0 regParam L2, AUC = 66.60%
10.0 regParam L2, AUC = 36.76%
max auc: 0.6756122825453876 best L2regParam: 0.0
------------------更新模型训练参数---------------------
best numIterations param: 50
best stepSize param: 1.0
best regParam: 0.0
best regUpdater: org.apache.spark.mllib.optimization.SimpleUpdater@4b6fc615
---------------调用模型输出特征权重值------------------
-0.014912705104766975
-0.010300917189488083
0.0037483953352201067
-1.0105291799106376E-4
0.08089240228856116
···
复制代码

参考文献:

Spark MLlib 源代码解析之逻辑回归LogisticRegression

知乎专栏-深入机器学习系列3-逻辑回归

关注下面的标签,发现更多相似文章
评论