Spark2 Linear Regression线性回归案例(参数调优)

最新推荐文章于 2024-08-27 21:15:17 发布
最新推荐文章于 2024-08-27 21:15:17 发布
阅读量5.4k 收藏 8
点赞数 1
分类专栏： ml
本文通过使用Apache Spark MLlib库中的ElasticNet回归方法，详细介绍了如何构建预测模型，并利用Train-Validation Split方法进行模型调优的过程。示例中以预测各州谋杀率为例，展示了特征组装、模型训练及评估的完整流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 回归正则化方法（Lasso，Ridge和ElasticNet）在高维和数据集变量之间多重共线性情况下运行良好。

 

数学上，ElasticNet被定义为L1和L2正则化项的凸组合：

通过适当设置α，ElasticNet包含L1和L2正则化作为特殊情况。例如，如果用参数α设置为1来训练线性回归模型，则其等价于Lasso模型。另一方面，如果α被设置为0，则训练的模型简化为ridge回归模型。 

RegParam:lambda>=0
ElasticNetParam:alpha in [0, 1]


导入包

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.Dataset
import org.apache.spark.sql.Row
import org.apache.spark.sql.DataFrame
import org.apache.spark.sql.Column
import org.apache.spark.sql.DataFrameReader
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.catalyst.encoders.ExpressionEncoder
import org.apache.spark.sql.Encoder
import org.apache.spark.sql.DataFrameStatFunctions
import org.apache.spark.sql.functions._
 
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.ml.feature.VectorAssembler
import org.apache.spark.ml.evaluation.RegressionEvaluator
import org.apache.spark.ml.regression.LinearRegression

导入样本数据

 

// Population人口,
// Income收入水平,
// Illiteracy文盲率,
// LifeExp,
// Murder谋杀率,
// HSGrad,
// Frost结霜天数(温度在冰点以下的平均天数) ,
// Area州面积
    val spark = SparkSession.builder().appName("Spark Linear Regression").config("spark.some.config.option", "some-value").getOrCreate()
 
    // For implicit conversions like converting RDDs to DataFrames
    import spark.implicits._
 
    val dataList: List[(Double, Double, Double, Double, Double, Double, Double, Double)] = List(
      (3615, 3624, 2.1, 69.05, 15.1, 41.3, 20, 50708),
      (365, 6315, 1.5, 69.31, 11.3, 66.7, 152, 566432),
      (2212, 4530, 1.8, 70.55, 7.8, 58.1, 15, 113417),
      (2110, 3378, 1.9, 70.66, 10.1, 39.9, 65, 51945),
      (21198, 5114, 1.1, 71.71, 10.3, 62.6, 20, 156361),
      (2541, 4884, 0.7, 72.06, 6.8, 63.9, 166, 103766),
      (3100, 5348, 1.1, 72.48, 3.1, 56, 139, 4862),
      (579, 4809, 0.9, 70.06, 6.2, 54.6, 103, 1982),
      (8277, 4815, 1.3, 70.66, 10.7, 52.6, 11, 54090),
      (4931, 4091, 2, 68.54, 13.9, 40.6, 60, 58073),
      (868, 4963, 1.9, 73.6, 6.2, 61.9, 0, 6425),
      (813, 4119, 0.6, 71.87, 5.3, 59.5, 126, 82677),
      (11197, 5107, 0.9, 70.14, 10.3, 52.6, 127, 55748),
      (5313, 4458, 0.7, 70.88, 7.1, 52.9, 122, 36097),
      (2861, 4628, 0.5, 72.56, 2.3, 59, 140, 55941),
      (2280, 4669, 0.6, 72.58, 4.5, 59.9, 114, 81787),
      (3387, 3712, 1.6, 70.1, 10.6, 38.5, 95, 39650),
      (3806, 3545, 2.8, 68.76, 13.2, 42.2, 12, 44930),
      (1058, 3694, 0.7, 70.39, 2.7, 54.7, 161, 30920),
      (4122, 5299, 0.9, 70.22, 8.5, 52.3, 101, 9891),
      (5814, 4755, 1.1, 71.83, 3.3, 58.5, 103, 7826),
      (9111, 4751, 0.9, 70.63, 11.1, 52.8, 125, 56817),
      (3921, 4675, 0.6, 72.96, 2.3, 57.6, 160, 79289),
      (2341, 3098, 2.4, 68.09, 12.5, 41, 50, 47296),
      (4767, 4254, 0.8, 70.69, 9.3, 48.8, 108, 68995),
      (746, 4347, 0.6, 70.56, 5, 59.2, 155, 145587),
      (1544, 4508, 0.6, 72.6, 2.9, 59.3, 139, 76483),
      (590, 5149, 0.5, 69.03, 11.5, 65.2, 188, 109889),
      (812, 4281, 0.7, 71.23, 3.3, 57.6, 174, 9027),
      (7333, 5237, 1.1, 70.93, 5.2, 52.5, 115, 7521),
      (1144, 3601, 2.2, 70.32, 9.7, 55.2, 120, 121412),
      (18076, 4903, 1.4, 70.55, 10.9, 52.7, 82, 47831),
      (5441, 3875, 1.8, 69.21, 11.1, 38.5, 80, 48798),
      (637, 5087, 0.8, 72.78, 1.4, 50.3, 186, 69273),
      (10735, 4561, 0.8, 70.82, 7.4, 53.2, 124, 40975),
      (2715, 3983, 1.1, 71.42, 6.4, 51.6, 82, 68782),
      (2284, 4660, 0.6, 72.13, 4.2, 60, 44, 96184),
      (11860, 4449, 1, 70.43, 6.1, 50.2, 126, 44966),
      (931, 4558, 1.3, 71.9, 2.4, 46.4, 127, 1049),
      (2816, 3635, 2.3, 67.96, 11.6, 37.8, 65, 30225),
      (681, 4167, 0.5, 72.08, 1.7, 53.3, 172, 75955),
      (4173, 3821, 1.7, 70.11, 11, 41.8, 70, 41328),
      (12237, 4188, 2.2, 70.9, 12.2, 47.4, 35, 262134),
      (1203, 4022, 0.6, 72.9, 4.5, 67.3, 137, 82096),
      (472, 3907, 0.6, 71.64, 5.5, 57.1, 168, 9267),
      (4981, 4701, 1.4, 70.08, 9.5, 47.8, 85, 39780),
      (3559, 4864, 0.6, 71.72, 4.3, 63.5, 32, 66570),
      (1799, 3617, 1.4, 69.48, 6.7, 41.6, 100, 24070),
      (4589, 4468, 0.7, 72.48, 3, 54.5, 149, 54464),
      (376, 4566, 0.6, 70.29, 6.9, 62.9, 173, 97203))
 
    val data = dataList.toDF("Population", "Income", "Illiteracy", "LifeExp", "Murder", "HSGrad", "Frost", "Area")

建立线性回归模型

 

val colArray = Array("Population", "Income", "Illiteracy", "LifeExp", "HSGrad", "Frost", "Area")
 
val assembler = new VectorAssembler().setInputCols(colArray).setOutputCol("features")
 
val vecDF: DataFrame = assembler.transform(data)
 
// 建立模型，预测谋杀率Murder
// 设置线性回归参数
val lr1 = new LinearRegression()
val lr2 = lr1.setFeaturesCol("features").setLabelCol("Murder").setFitIntercept(true)
// RegParam：正则化
val lr3 = lr2.setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8)
val lr = lr3
 
// Fit the model
val lrModel = lr.fit(vecDF)
 
// 输出模型全部参数
lrModel.extractParamMap()
// Print the coefficients and intercept for linear regression
println(s"Coefficients: ${lrModel.coefficients} Intercept: ${lrModel.intercept}")
 
val predictions = lrModel.transform(vecDF)
predictions.selectExpr("Murder", "round(prediction,1) as prediction").show
 
// Summarize the model over the training set and print out some metrics
val trainingSummary = lrModel.summary
println(s"numIterations: ${trainingSummary.totalIterations}")
println(s"objectiveHistory: ${trainingSummary.objectiveHistory.toList}")
trainingSummary.residuals.show()
println(s"RMSE: ${trainingSummary.rootMeanSquaredError}")
println(s"r2: ${trainingSummary.r2}")

代码执行结果

 

// 输出模型全部参数
lrModel.extractParamMap()
res15: org.apache.spark.ml.param.ParamMap =
{
    linReg_2ba28140e39a-elasticNetParam: 0.8,
    linReg_2ba28140e39a-featuresCol: features,
    linReg_2ba28140e39a-fitIntercept: true,
    linReg_2ba28140e39a-labelCol: Murder,
    linReg_2ba28140e39a-maxIter: 10,
    linReg_2ba28140e39a-predictionCol: prediction,
    linReg_2ba28140e39a-regParam: 0.3,
    linReg_2ba28140e39a-solver: auto,
    linReg_2ba28140e39a-standardization: true,
    linReg_2ba28140e39a-tol: 1.0E-6
}
 
// Print the coefficients and intercept for linear regression
println(s"Coefficients: ${lrModel.coefficients} Intercept: ${lrModel.intercept}")
Coefficients: [1.36662199778084E-4,0.0,1.1834384307116244,-1.4580829641757522,0.0,-0.010686434270049252,4.051355050528196E-6] Intercept: 109.589659881471
 
val predictions = lrModel.transform(vecDF)
predictions: org.apache.spark.sql.DataFrame = [Population: double, Income: double ... 8 more fields]
 
predictions.selectExpr("Murder", "round(prediction,1) as prediction").show
+------+----------+
|Murder|prediction|
+------+----------+
|  15.1|      11.9|
|  11.3|      11.0|
|   7.8|       9.5|
|  10.1|       8.6|
|  10.3|       9.6|
|   6.8|       4.3|
|   3.1|       4.2|
|   6.2|       7.5|
|  10.7|       9.3|
|  13.9|      12.3|
|   6.2|       4.7|
|   5.3|       4.6|
|  10.3|       8.8|
|   7.1|       6.6|
|   2.3|       3.5|
|   4.5|       3.9|
|  10.6|       8.9|
|  13.2|      13.2|
|   2.7|       6.3|
|   8.5|       7.8|
+------+----------+
only showing top 20 rows
 
// Summarize the model over the training set and print out some metrics
val trainingSummary = lrModel.summary
trainingSummary: org.apache.spark.ml.regression.LinearRegressionTrainingSummary = org.apache.spark.ml.regression.LinearRegressionTrainingSummary@68a83d76
 
println(s"numIterations: ${trainingSummary.totalIterations}")
numIterations: 11
 
println(s"objectiveHistory: ${trainingSummary.objectiveHistory.toList}")
objectiveHistory: List(0.49000000000000016, 0.3919242806809093, 0.19908078426904946, 0.1901453492751914, 0.17981874256031405, 0.17878173084286247, 0.1787617816935607, 0.17875431854661641, 0.1
7874702637141196, 0.17874512271568685, 0.1787449876896829)
trainingSummary.residuals.show()
+--------------------+
|           residuals|
+--------------------+
|  3.2200068116713023|
|  0.2745518816306607|
| -1.6535887417767414|
|   1.485762696757325|
|  0.6509766532389172|
|   2.457688146554534|
| -1.0675250558261182|
| -1.2879164685248439|
|  1.3672723619868314|
|  1.6125000289597242|
|   1.532060517905248|
|  0.6931301635074645|
|  1.5163001982000175|
| 0.46227066807431605|
| -1.2044058248740273|
|  0.6032541157521649|
|     1.7201545753635|
|-0.01942937427384...|
|  -3.632947522687547|
|  0.7077675962948007|
+--------------------+
only showing top 20 rows
 
println(s"RMSE: ${trainingSummary.rootMeanSquaredError}")
RMSE: 1.6663615527314546
 
println(s"r2: ${trainingSummary.r2}")
r2: 0.7920794990832152

模型调优，用Train-Validation Split

 

val colArray = Array("Population", "Income", "Illiteracy", "LifeExp", "HSGrad", "Frost", "Area")
 
val vecDF: DataFrame = new VectorAssembler().setInputCols(colArray).setOutputCol("features").transform(data)
 
val Array(trainingDF, testDF) = vecDF.randomSplit(Array(0.9, 0.1), seed = 12345)
 
// 建立模型，预测谋杀率Murder，设置线性回归参数
val lr = new LinearRegression().setFeaturesCol("features").setLabelCol("Murder").fit(trainingDF)
 
// 设置管道
val pipeline = new Pipeline().setStages(Array(lr))
 
// 建立参数网格
val paramGrid = new ParamGridBuilder().addGrid(lr.fitIntercept).addGrid(lr.elasticNetParam, Array(0.0, 0.5, 1.0)).addGrid(lr.maxIter, Array(10, 100)).build()
 
// 选择(prediction, true label)，计算测试误差。
// 注意RegEvaluator.isLargerBetter，评估的度量值是大的好，还是小的好，系统会自动识别
val RegEvaluator = new RegressionEvaluator().setLabelCol(lr.getLabelCol).setPredictionCol(lr.getPredictionCol).setMetricName("rmse")
 
val trainValidationSplit = new TrainValidationSplit().setEstimator(pipeline).setEvaluator(RegEvaluator).setEstimatorParamMaps(paramGrid).setTrainRatio(0.8) // 数据分割比例
 
// Run train validation split, and choose the best set of parameters.
val tvModel = trainValidationSplit.fit(trainingDF)
 
// 查看模型全部参数
tvModel.extractParamMap()
 
tvModel.getEstimatorParamMaps.length
tvModel.getEstimatorParamMaps.foreach { println } // 参数组合的集合
 
tvModel.getEvaluator.extractParamMap() // 评估的参数
 
tvModel.getEvaluator.isLargerBetter // 评估的度量值是大的好，还是小的好
 
tvModel.getTrainRatio
 
// 用最好的参数组合，做出预测
tvModel.transform(testDF).select("features", "Murder", "prediction").show()

调优代码执行结果

 

// 查看模型全部参数
tvModel.extractParamMap()
res45: org.apache.spark.ml.param.ParamMap =
{
    tvs_5de7d3dd1977-estimator: pipeline_062a1dffe557,
    tvs_5de7d3dd1977-estimatorParamMaps: [Lorg.apache.spark.ml.param.ParamMap;@60298de1,
    tvs_5de7d3dd1977-evaluator: regEval_05204824acb9,
    tvs_5de7d3dd1977-seed: -1772833110,
    tvs_5de7d3dd1977-trainRatio: 0.8
}
 
tvModel.getEstimatorParamMaps.length
res46: Int = 12
 
tvModel.getEstimatorParamMaps.foreach { println } // 参数组合的集合
{
    linReg_75628a5554b4-elasticNetParam: 0.0,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 0.0,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 100
}
{
    linReg_75628a5554b4-elasticNetParam: 0.0,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 0.0,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 100
}
{
    linReg_75628a5554b4-elasticNetParam: 0.5,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 0.5,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 100
}
{
    linReg_75628a5554b4-elasticNetParam: 0.5,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 0.5,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 100
}
{
    linReg_75628a5554b4-elasticNetParam: 1.0,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 1.0,
    linReg_75628a5554b4-fitIntercept: true,
    linReg_75628a5554b4-maxIter: 100
}
{
    linReg_75628a5554b4-elasticNetParam: 1.0,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 10
}
{
    linReg_75628a5554b4-elasticNetParam: 1.0,
    linReg_75628a5554b4-fitIntercept: false,
    linReg_75628a5554b4-maxIter: 100
}
 
tvModel.getEvaluator.extractParamMap() // 评估的参数
res48: org.apache.spark.ml.param.ParamMap =
{
    regEval_05204824acb9-labelCol: Murder,
    regEval_05204824acb9-metricName: rmse,
    regEval_05204824acb9-predictionCol: prediction
}
 
tvModel.getEvaluator.isLargerBetter // 评估的度量值是大的好，还是小的好
res49: Boolean = false
 
tvModel.getTrainRatio
res50: Double = 0.8
 
tvModel.transform(testDF).select("features", "Murder", "prediction").show()
+--------------------+------+------------------+
|            features|Murder|        prediction|
+--------------------+------+------------------+
|[1058.0,3694.0,0....|   2.7| 6.917232043935343|
|[2341.0,3098.0,2....|  12.5|14.760329005533478|
|[472.0,3907.0,0.6...|   5.5| 4.182074651181182|
|[812.0,4281.0,0.7...|   3.3| 4.915905572667441|
|[2816.0,3635.0,2....|  11.6|14.219231061596304|
|[4589.0,4468.0,0....|   3.0| 3.483554528704758|
+--------------------+------+------------------+

2021.1.21线性回归算法的原理及参数优化方案
超可爱慕之
01-21 2584
只需要知道用什么样的算法能够解决什么样的需求，不同的算法怎么去调参、调优 出去面试的时候可能会问一些公式的推导，经常问的都会去推导 复习： 核心：总结了机器学习的套路 1.随机产生w参数 2.把w参数与样本数据带入到误差函数中（最小二重法，损失函数，目标函数，误差函数都是这同一个公式）求解误差值 3.误差值与用户指定的误差阈值比较， 4.如果大于用户指定的误差阈值，继续调整w参数， （2，3，4） 5.如果误差小于用户指定的误差阈值，那么此时的w参数就是最佳的w参数 问题： 怎么调整w参数？ 比如现在w=1
线性回归（Lasso,Ridge,ElasticNet）调参
weixin_44414593的博客
08-07 2927
model_ridge = Ridge(normalize=True,) 然后使用for循环或者cv调试 alpha 即可。
Spark Mllib中LinearRegression参数含义
onway_goahead的博客
04-11 2058
1.相关参数设置： <1> setMaxIter()：设置最大迭代次数 <2> setRegParam()： 设置正则项的参数，控制损失函数与惩罚项的比例，防止整个训练过程过拟合 <3> setElasticNetParam()：使用L1范数还是L2范数 setElasticNetParam=0.0 为L2正则化； setElasticNetParam=1...
sklearn线性回归LinearRegression代码及调参
lyy的博客
09-19 1万+
代码： from sklearn import datasets from sklearn.linear_model import LinearRegression import matplotlib.pyplot as plt # 使用以后的数据集进行线性回归（这里是波士顿房价数据） ##1 数据的加载 from sklearn.model_selection import train_t...
mllib调参 spark_spark-MLlib之线性回归
weixin_31845113的博客
12-29 293
>>提君博客原创 http://www.cnblogs.com/tijun/ <<假定线性拟合方程：变量Xi是 i 个变量或者说属性参数ai是模型训练的目的就是计算出这些参数的值。线性回归分析的整个过程可以简单描述为如下三个步骤：寻找合适的预测函数，即上文中的h(x)h(x)，用来预测输入数据的判断结果。这个过程时非常关键的，需要对数据有一定的了解或分析，知道或...
Spark MLlib Linear Regression线性回归算法
Spark MLlib 机器学习
05-06 1万+
1、Spark MLlib Linear Regression线性回归算法 1.1 线性回归算法 1.1.1 基础理论 在统计学中，线性回归(Linear Regression)是利用称为线性回归方程的最小平方函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。这种函数是一个或多个称为回归系数的模型参数的线性组合。 回归分析中，只包括一个自变量和一个因变量，且二者的关系可用一条
Spark2 Linear Regression线性回归
kicilove的小屋
07-26 1331
https://www.cnblogs.com/wwxbi/p/6028261.html
Spark MLlib模型训练—回归算法 Linear regression
最新发布
2401_84052244的博客
08-27 4114
线性回归作为一种经典的回归方法，虽然简单但在实际应用中依旧表现出强大的效果。借助 Spark 的分布式计算框架，我们可以在大规模数据集上高效地进行线性回归建模。在本文中，我们详细介绍了线性回归的原理、参数、模型实现与调优，并结合 ScalaSpark 线性回归的优化策略特征标准化：在线性回归中，标准化特征有助于提升模型收敛速度，避免特征值差异过大引起的计算问题。特征选择：在高维数据集中，选择相关性高的特征可以提高模型的预测准确性。交叉验证。
Spark-ML 线性回归 LinearRegression （1）
qq_24734217的博客
07-20 1798
Spark-ML 线性回归 LinearRegression参数详述：
【Spark ML系列】Spark GeneralizedLinearRegression广义线性回归原理用法示例源码详解
wang2leee的博客
11-02 341
Spark GeneralizedLinearRegression广义线性回归原理用法示例源码权威详解
LinearRegression.rar
06-03
利用python代码手动实现线性和二次函数的反向传播，利用梯度下降算法实现参数更新
Spark mllib LinearRegression
易水寒
07-15 629
1. rdd 例子package com.immooc import org.apache.log4j.{Level, Logger} import org.apache.spark.mllib.linalg.Vectors import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.mllib.regres...
【机器学习小论文】sklearn线性回归LinearRegression代码及调参
xiaohutong1991的专栏
08-23 6906
一、前言 最近在写小论文，就是硕士毕业论文的部分成果，需要用到线性回归，所以就把相关代码贴上，便于日后写论文时总结，也顺便给后来者提供思路。小论文的思路主要是，先用线性回归，再用随机森林，最后再用xgboost，来预测房价，最后得出结论。所以，这个会陆续的贴出相关代码。至于数据清洗那一块，暂时不贴上了，主要原因就是数据清洗不容易，并且每个人的清洗方法也不一样，所以主要还是看思路。 二、算法简介 2.1 什么是回归分析 回归分析是一种预测性的建模技术，它研究的是因变量（目标）和自变量（预测器）之间的关
sklearn 线性回归LinearRegression()参数介绍
热门推荐
li980828298的博客
04-28 2万+
LinearRegression(fit_intercept=True,normalize=False,copy_X=True,n_jobs=1) fit_intercept:是否有截据，如果没有则直线过原点。 normalize:是否将数据归一化。 copy_X:默认为True，当为True时，X会被copied,否则X将会被覆写。（这一参数的具体作用没明白，求大神
机器学习15 线性回归（销售利润表.csv）调参实战代码 reshape（1，-1）
dd112474的博客
08-30 1027
结果的准确性score全是负数，一是检查模型能不能调整优化，而是看看数据清洗转化是否出错，如果都没有那就不要用这个模型了，score要越接近1才越好。结果报错了，报错代码是：1D表示1维，arry表示numpy中的数组。目前运行就可以建模了，红色部分表示有效代码，其余部分自己打草稿用。但是报错了，有两种报错形式，是同一个意思：数组的行列反了，应该。还是会报错，因为这里一维数组是Series类型，我们要把。原因是我们这里是一维数组，线性回归必须要二维数组。或者直接出来以后强制转换一次。，后面直接调参就可以。.
spark-MLlib之线性回归
weixin_30794491的博客
11-22 387
>>提君博客原创 http://www.cnblogs.com/tijun/ << 假定线性拟合方程： 提君博客原创 变量Xi是 i 个变量或者说属性 参数ai是模型训练的目的就是计算出这些参数的值。 线性回归分析的整个过程可以简单描述为如下三个步骤： 寻找合适的预测函数，即上文中的h(x)h(x)，用来预测输入数据的判断结果。这个...
机器学习经典算法具体解释及Python实现--线性回归（Linear Regression）算法
weixin_33817333的博客
07-31 320
（一）认识回归 回归是统计学中最有力的工具之中的一个。机器学习监督学习算法分为分类算法和回归算法两种，事实上就是依据类别标签分布类型为离散型、连续性而定义的。顾名思义。分类算法用于离散型分布预測，如前面讲过的KNN、决策树、朴素贝叶斯、adaboost、SVM、Logistic回归都是分类算法。回归算法用于连续型分布预測。针对的是数值型的样本，使用回归。能够在给定输入的时候预測出一个数值...
回归模型的评估及超参数调优
LKIDTI数据的博客
03-24 6276
一、回归模型 在机器学习中，其中算法最为重要一面就是回归算法，回归算法占我们理解机器学习一大块，这一块的学习可以帮助我们掌握超参数的调节。基本上只要一切基于特征预测连续型变量的需求，我们都使用回归技术。 最著名的就是我们的线性回归和逻辑回归，从他们衍生出了岭回归，Lasso，弹性网，除此之外，还有众多分类算法改进后的回归，比如回归树，随机森林的回归，支持向量回归，贝叶斯回归等等。在这里我们使用线性回归来了解回归模型评估和超参数调节。 首先，我们需要了解回归参数评价指标 二、回归类的模型评估指标 在回归模型中
sklearn.linear_model.LinearRegression
weixin_34336292的博客
01-02 117
官网：http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html class sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1) ...
pyspark mllib使用linearregression写线性回归代码
05-24
下面是使用 PySpark MLlib 中的 LinearRegression 模型进行线性回归的示例代码： ```python # 导入必要的库 from pyspark.ml.regression import LinearRegression from pyspark.ml.evaluation import RegressionEvaluator # 加载数据集 data = spark.read.format("libsvm").load("path/to/data") # 划分训练集和测试集 (trainingData, testData) = data.randomSplit([0.7, 0.3]) # 定义线性回归模型 lr = LinearRegression(maxIter=10, regParam=0.3, elasticNetParam=0.8) # 训练模型 model = lr.fit(trainingData) # 在测试集上进行预测 predictions = model.transform(testData) # 评估模型性能 evaluator = RegressionEvaluator(metricName="rmse") rmse = evaluator.evaluate(predictions) print("Root Mean Squared Error (RMSE) on test data = %g" % rmse) # 打印模型系数和截距 print("Coefficients: " + str(model.coefficients)) print("Intercept: " + str(model.intercept)) ``` 在这个示例中，我们首先使用 `spark.read.format("libsvm").load("path/to/data")` 加载一个 LIBSVM 格式的数据集。然后我们使用 `randomSplit` 方法将数据集划分成训练集和测试集。接下来，我们定义了一个 `LinearRegression` 模型，并通过 `fit` 方法对训练集进行拟合。最后，我们在测试集上进行预测，并使用 `RegressionEvaluator` 评估模型的性能。最后，我们打印出模型的系数和截距。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值