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-逻辑回归