Spark ML（3）：回归算法实现（线性回归、逻辑回归）

最新推荐文章于 2025-07-09 17:43:31 发布
最新推荐文章于 2025-07-09 17:43:31 发布
阅读量1.8k 收藏 8
点赞数 3
CC 4.0 BY-SA版权
分类专栏： Spark ML 文章标签： Spark ML 回归算法 线性回归 逻辑回归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010886217/article/details/90312617
该博客主要介绍了Spark环境配置与回归算法代码实现。环境配置涉及spark2.1.0 - cdh5.7.0、cdh5.7.0等。环境准备包括搭建spark客户端调试环境、创建scala项目和添加pom依赖。代码实现部分给出测试数据样例，重点展示了线性回归和逻辑回归。

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

一、环境配置

1.spark2.1.0-cdh5.7.0（自编译）

2.cdh5.7.0

3.scala2.11.8

4.centos6.4

二、环境准备

1.spark客户端调试环境搭建

参考：https://blog.youkuaiyun.com/u010886217/article/details/83279157

2.创建scala项目

参考：https://blog.youkuaiyun.com/u010886217/article/details/84332961

3.添加pom依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>sparktest</groupId>
  <artifactId>sparktest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <inceptionYear>2008</inceptionYear>
  <properties>
    <scala.version>2.11.8</scala.version>
    <kafka.version>0.9.0.0</kafka.version>
    <hbase.version>1.2.0-cdh5.7.0</hbase.version>
    <spark.version>2.1.0</spark.version>
    <hadoop.version>2.6.0-cdh5.7.0</hadoop.version>
  </properties>

  <repositories>
<!--    <repository>-->
<!--      <id>scala-tools.org</id>-->
<!--      <name>Scala-Tools Maven2 Repository</name>-->
<!--      <url>http://scala-tools.org/repo-releases</url>-->
<!--    </repository>-->
    <repository>
      <id>cloudera</id>
      <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
  </repositories>

<!--  <pluginRepositories>-->
<!--    <pluginRepository>-->
<!--      <id>scala-tools.org</id>-->
<!--      <name>Scala-Tools Maven2 Repository</name>-->
<!--      <url>http://scala-tools.org/repo-releases</url>-->
<!--    </pluginRepository>-->
<!--  </pluginRepositories>-->

  <dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-mllib -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-mllib_2.11</artifactId>
      <version>2.1.0</version>
<!--      <scope>runtime</scope>-->
    </dependency>

    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.11</artifactId>
      <version>2.1.0</version>
    </dependency>

<!--    <dependency>-->
<!--      <groupId>org.apache.spark</groupId>-->
<!--      <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>-->
<!--      <version>2.1.0</version>-->
<!--    </dependency>-->
    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>${scala.version}</version>
    </dependency>

<!--    <dependency>-->
<!--      <groupId>org.apache.kafka</groupId>-->
<!--      <artifactId>kafka_2.11</artifactId>-->
<!--      <version>${kafka.version}</version>-->
<!--    </dependency>-->

<!--    <dependency>-->
<!--      <groupId>junit</groupId>-->
<!--      <artifactId>junit</artifactId>-->
<!--      <version>4.4</version>-->
<!--      <scope>test</scope>-->
<!--    </dependency>-->

<!--    &lt;!&ndash; https://mvnrepository.com/artifact/net.jpountz.lz4/lz4 &ndash;&gt;-->
<!--    <dependency>-->
<!--      <groupId>net.jpountz.lz4</groupId>-->
<!--      <artifactId>lz4</artifactId>-->
<!--      <version>1.3.0</version>-->
<!--    </dependency>-->

<!--    &lt;!&ndash; https://mvnrepository.com/artifact/org.apache.hbase/hbase-client &ndash;&gt;-->
<!--    <dependency>-->
<!--      <groupId>org.apache.hbase</groupId>-->
<!--      <artifactId>hbase-client</artifactId>-->
<!--      <version>${hbase.version}</version>-->
<!--    </dependency>-->
    <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-server -->
<!--    <dependency>-->
<!--      <groupId>org.apache.hbase</groupId>-->
<!--      <artifactId>hbase-server</artifactId>-->
<!--      <version>${hbase.version}</version>-->
<!--    </dependency>-->

<!--    <dependency>-->
<!--      <groupId>org.apache.zookeeper</groupId>-->
<!--      <artifactId>zookeeper</artifactId>-->
<!--      <version>3.4.5-cdh5.7.0</version>-->
<!--      <type>pom</type>-->
<!--    </dependency>-->

<!--    <dependency>-->
<!--      <groupId>mysql</groupId>-->
<!--      <artifactId>mysql-connector-java</artifactId>-->
<!--      <version>5.1.27</version>-->
<!--    </dependency>-->



<!--    <dependency>-->
<!--      <groupId>org.apache.hadoop</groupId>-->
<!--      <artifactId>hadoop-client</artifactId>-->
<!--      <version>${hadoop.version}</version>-->
<!--    </dependency>-->

    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>${spark.version}</version>
    </dependency>

    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>${spark.version}</version>
    </dependency>

  </dependencies>

  <build>
    <sourceDirectory>src/main/scala</sourceDirectory>
<!--    <testSourceDirectory>src/test/scala</testSourceDirectory>-->
    <plugins>
      <plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
              <goal>testCompile</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <scalaVersion>${scala.version}</scalaVersion>
          <args>
            <arg>-target:jvm-1.5</arg>
          </args>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-eclipse-plugin</artifactId>
        <configuration>
          <downloadSources>true</downloadSources>
          <buildcommands>
            <buildcommand>ch.epfl.lamp.sdt.core.scalabuilder</buildcommand>
          </buildcommands>
          <additionalProjectnatures>
            <projectnature>ch.epfl.lamp.sdt.core.scalanature</projectnature>
          </additionalProjectnatures>
          <classpathContainers>
            <classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>
            <classpathContainer>ch.epfl.lamp.sdt.launching.SCALA_CONTAINER</classpathContainer>
          </classpathContainers>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <reporting>
    <plugins>
      <plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <configuration>
          <scalaVersion>${scala.version}</scalaVersion>
        </configuration>
      </plugin>
    </plugins>
  </reporting>
</project>

三、代码实现

1.测试数据样例

position;square;price;direction;type;name;
0;190;20000;0;4室2厅2卫;中信城(别墅);
0;190;20000;0;4室2厅2卫;中信城(别墅);
5;400;15000;0;4室3厅3卫;融创上城;
0;500;15000;0;5室3厅2卫;中海莱茵东郡;
5;500;15000;0;5室3厅4卫;融创上城(别墅);
1;320;15000;1;1室1厅1卫;长江花园;
0;143;12000;0;3室2厅2卫;融创上城;
0;200;10000;0;4室3厅2卫;中海莱茵东郡(别墅);
0;207;9000;0;4室3厅4卫;中海莱茵东郡;
0;130;8500;0;3室2厅2卫;伟峰东第;
5;150;7000;0;3室2厅2卫;融创上城;
2;178;6000;0;4室2厅2卫;鸿城国际花园;
5;190;6000;0;3室2厅2卫;亚泰豪苑C栋;
1;150;6000;0;5室1厅2卫;通安新居A区;
2;165;6000;0;3室2厅2卫;万科惠斯勒小镇;
0;64;5500;0;1室1厅1卫;保利中央公园;
2;105;5500;0;2室2厅1卫;虹馆;
1;160;5300;0;3室2厅1卫;昊源高格蓝湾;
2;170;5100;0;4室2厅2卫;亚泰鼎盛国际;
...

2.线性回归

package sparktest
import org.apache.spark.ml.classification.LogisticRegression
import org.apache.spark.ml.feature.VectorAssembler
import org.apache.spark.ml.linalg
import org.apache.spark.ml.regression.LinearRegression
import org.apache.spark.sql.SparkSession
import org.apache.spark.{SparkConf, SparkContext}

import scala.util.Random

object Main {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("linear").setMaster("local")
    val sc = new SparkContext(conf)
    val spark = SparkSession.builder().config(conf).getOrCreate()

    val file = spark.read.format("csv").option("sep",";").option("header","true").load("house.csv")
    //val file: Nothing = spark.read.format("csv").option("sep", ";").option("header", "true").load("house.csv")
    import spark.implicits._
    //打乱顺序
    val rand = new Random()
    val data = file.select("square","price").map(
      row => (row.getAs[String](0).toDouble,row.getString(1).toDouble,rand.nextDouble()))
      .toDF("square","price","rand").sort("rand") //强制类型转换过程

    val ass = new VectorAssembler().setInputCols(Array("square")).setOutputCol("features")
    val dataset = ass.transform(data)//特征包装

    val Array(train,test) = dataset.randomSplit(Array(0.8,0.2))//拆分成训练数据集和测试数据集
    //train.show()
    //线性回归
    val lr = new LinearRegression().setStandardization(true).setMaxIter(10)
      .setFeaturesCol("features")
      .setLabelCol("price")
    //创建一个对象
    val model = lr.fit(train) //训练

    model.transform(test).show()


  }
}
结果：
|square|  price|                rand|features|        prediction|
+------+-------+--------------------+--------+------------------+
|  64.0| 1400.0|0.006545997025104056|  [64.0]| 1871.626837251842|
| 100.0| 2600.0|0.006070889056102979| [100.0]|1910.2354430535167|
|  10.0|  450.0|0.016279200291292373|  [10.0]|  1813.71392854933|
|  60.0| 1700.0| 0.01773595114007931|  [60.0]| 1867.336992162767|
| 150.0| 7000.0| 0.01799868562447937| [150.0]|1963.8585066669539|
| 320.0|15000.0|0.022266421888484267| [320.0]|  2146.17692295264|
|  42.0| 1200.0| 0.03158087604172155|  [42.0]|1848.0326892619296|
|  88.0| 1800.0|  0.0340325321865349|  [88.0]| 1897.365907786292|
|  60.0| 1600.0| 0.05842848976518067|  [60.0]| 1867.336992162767|
| 154.0| 3700.0| 0.08695690147815338| [154.0]| 1968.148351756029|
|  96.0| 2500.0| 0.08956069761188501|  [96.0]|1905.9455979644417|
|  63.0| 1400.0|  0.1058435529752908|  [63.0]|1870.5543759795733|
| 100.0| 2200.0| 0.12881102655257837| [100.0]|1910.2354430535167|
|  20.0|  500.0| 0.13298961275676147|  [20.0]|1824.4385412720173|
| 148.0| 2800.0|  0.1347286681517027| [148.0]|1961.7135841224165|
|  92.0| 2950.0|  0.1418523082181563|  [92.0]|1901.6557528753667|
|  96.0| 2300.0| 0.14272158486886666|  [96.0]|1905.9455979644417|
|  70.0| 1500.0| 0.14371869433210183|  [70.0]|1878.0616048854545|
|  18.0|  600.0|  0.1523863581129299|  [18.0]|  1822.29361872748|
|  20.0|  800.0| 0.17536250365755057|  [20.0]|1824.4385412720173|
+------+-------+--------------------+--------+------------------+
only showing top 20 rows

3.逻辑回归

package sparktest
import org.apache.spark.ml.classification.LogisticRegression
import org.apache.spark.ml.feature.VectorAssembler
import org.apache.spark.ml.linalg
import org.apache.spark.ml.regression.LinearRegression
//import org.apache.spark.m
import org.apache.spark.sql.SparkSession
import org.apache.spark.{SparkConf, SparkContext}

import scala.util.Random

object Main {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("linear").setMaster("local")
    val sc = new SparkContext(conf)
    val spark = SparkSession.builder().config(conf).getOrCreate()

    val file = spark.read.format("csv").option("sep",";").option("header","true").load("house.csv")
    //val file: Nothing = spark.read.format("csv").option("sep", ";").option("header", "true").load("house.csv")
    import spark.implicits._
    //打乱顺序
    val rand = new Random()
    val data = file.select("square","price").map(
      row => (row.getAs[String](0).toDouble,row.getString(1).toDouble,rand.nextDouble()))
      .toDF("square","price","rand").sort("rand") //强制类型转换过程

    val ass = new VectorAssembler().setInputCols(Array("square")).setOutputCol("features")
    val dataset = ass.transform(data)//特征包装

    val Array(train,test) = dataset.randomSplit(Array(0.8,0.2))//拆分成训练数据集和测试数据集


    //逻辑回归
    val lr = new LogisticRegression().setLabelCol("price").setFeaturesCol("features")
      .setRegParam(0.3).setElasticNetParam(0.8).setMaxIter(10)
    val model = lr.fit(train)
    model.transform(test).show()
    val s = model.summary.totalIterations
    println(s"iter: ${s}")
  }
}

结果：
|square| price|                rand|features|       rawPrediction|         probability|prediction|
+------+------+--------------------+--------+--------------------+--------------------+----------+
|  43.0|1600.0|0.001716305364737214|  [43.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  60.0|1600.0|0.010588427013326074|  [60.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  61.0|1300.0|0.043301012076277345|  [61.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  60.0|1600.0| 0.05231439852503761|  [60.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  20.0| 600.0| 0.05386280768045393|  [20.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  89.0|2800.0|  0.0650227911769532|  [89.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  60.0|1500.0| 0.06793901574354433|  [60.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  90.0|2500.0| 0.07541330585084804|  [90.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  65.0|1300.0| 0.07727780227514891|  [65.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  25.0|1300.0| 0.09515681816587895|  [25.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  50.0|1400.0| 0.08681645057310305|  [50.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  60.0|1600.0| 0.10042920576336689|  [60.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  41.0|1500.0| 0.11564005495013441|  [41.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  92.0|2950.0| 0.11751726539452112|  [92.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  71.0|1600.0| 0.12520507959550664|  [71.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
| 110.0|2700.0| 0.13631041935375054| [110.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  10.0| 450.0|  0.1429523132917182|  [10.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  65.0|1700.0| 0.15676743340088062|  [65.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  90.0|2100.0| 0.18187817541586593|  [90.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
|  62.0|1500.0| 0.19149303955455987|  [62.0]|[-0.0253687225534...|[6.85377863744923...|    1500.0|
+------+------+--------------------+--------+--------------------+--------------------+----------+
only showing top 20 rows

 

Spark MLlib模型训练—回归算法 Linear regression
2401_84052244的博客
08-27 4114
线性回归作为一种经典的回归方法，虽然简单但在实际应用中依旧表现出强大的效果。借助 Spark 的分布式计算框架，我们可以在大规模数据集上高效地进行线性回归建模。在本文中，我们详细介绍了线性回归的原理、参数、模型实现与调优，并结合 ScalaSpark 线性回归的优化策略特征标准化：在线性回归中，标准化特征有助于提升模型收敛速度，避免特征值差异过大引起的计算问题。特征选择：在高维数据集中，选择相关性高的特征可以提高模型的预测准确性。交叉验证。
Spark MLlib模型训练—回归算法 GLR( Generalized Linear Regression)
2401_84052244的博客
08-29 3979
广义线性回归作为线性回归的扩展，在处理不同分布类型的目标变量时具有极大的灵活性。Spark 提供了强大的分布式计算能力，使得广义线性回归可以在大规模数据集上高效训练和应用。本文从原理、代码实现、参数调优等多个角度，详细介绍了 Spark 中广义线性回归的使用方法，希望为读者提供实用的指导。通过合理的模型选择和调优，广义线性回归能够在各种复杂数据场景中提供准确的预测与分析。
Apache Spark源码走读之22 -- 浅谈mllib中线性回归的算法实现
weixin_34235371的博客
08-15 202
欢迎转载，转载请注明出处，徽沪一郎。 概要 本文简要描述线性回归算法在Spark MLLib中的具体实现，涉及线性回归算法本身及线性回归并行处理的理论基础，然后对代码实现部分进行走读。 线性回归模型 机器学习算法是的主要目的是找到最能够对数据做出合理解释的模型，这个模型是假设函数，一步步的推导基本遵循这样的思路 假设函数 为了找到最好的假设函数，需要找到合理的评估标准，一般来说...
基于 Spark MLlib 的推荐系统实现
最新发布
m0_73889530的博客
07-09 663
基于 Spark MLlib 的推荐系统实现 本文解析了使用Spark MLlib构建推荐系统的关键技术与优化方法。首先介绍了Spark MLlib的核心框架演进，重点对比了RDD和DataFrame两种API的特性及其在2025年的最新发展（如深度学习集成、AutoML支持）。其次深入剖析了协同过滤算法原理及前沿趋势（如神经网络协同过滤、图神经网络）。最后提供了优化的Java代码实现，通过分布式操作避免性能瓶颈。全文从框架、算法到实践三个维度，为构建高效推荐系统提供了全面指导。
mllib逻辑回归 spark_Spark MLlib线性回归算法
weixin_39540426的博客
12-31 163
首先也是最重要的，发放MLlib机器学习数据集，没有给数据的都是耍流氓~下载地址：github mllib 数据集 第一列是标签，也就y后面8列是x1、x2、x3...x8我们的目标是寻找 y =a1*x1 + a2*x2 + ... a8*x8 这样的一个线性方法这里面a1、a2、...a8是我们通过这一堆 【y和x1、x2、x3...x8 】训练得来的构建spark对象（这其实是一句废话）读...
spark-MLlib之线性回归
weixin_30794491的博客
11-22 387
>>提君博客原创 http://www.cnblogs.com/tijun/ << 假定线性拟合方程： 提君博客原创 变量Xi是 i 个变量或者说属性 参数ai是模型训练的目的就是计算出这些参数的值。 线性回归分析的整个过程可以简单描述为如下三个步骤： 寻找合适的预测函数，即上文中的h(x)h(x)，用来预测输入数据的判断结果。这个...
Spark MLlib回归算法LinearRegression
weixin_33796177的博客
04-29 261
    算法说明 　　线性回归是利用称为线性回归方程的函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析方法，只有一个自变量的情况称为简单回归，大于一个自变量情况的叫做多元回归，在实际情况中大多数都是多元回归。 　　线性回归（Linear Regression）问题属于监督学习（Supervised Learning）范畴，又称分类（Classification）或归纳学习（In...
Spark ML Pipeline：逻辑回归交叉验证实践
- **训练代码**：这部分代码展示了如何在Scala中使用Spark MLlib实现逻辑回归的Pipeline和交叉验证。它包括创建Pipeline、定义参数网格、构建交叉验证器、设定评估指标等步骤。具体步骤如下： 1. 导入必要的库和类...
【Spark ML系列】Spark GeneralizedLinearRegression广义线性回归原理用法示例源码详解
wang2leee的博客
11-02 341
Spark GeneralizedLinearRegression广义线性回归原理用法示例源码权威详解
ML 逻辑回归
05-30
综上所述，逻辑回归是一种简单而强大的分类算法，通过Sigmoid函数实现非线性映射，可用于处理二分类问题。通过优化损失函数，我们可以得到最佳的模型参数，从而实现对新数据的有效预测。在实际应用中，理解并掌握...
SparkMLlib学习之线性回归
weixin_33984032的博客
05-23 317
SparkMLlib学习之线性回归 （一）回归的概念 　　1，回归与分类的区别 　　　分类模型处理表示类别的离散变量，而回归模型则处理可以取任意实数的目标变量。但是二者基本的原则类似，都是通过确定一个模型，将输入特征映射到预测的输出。回归模型和分类模型都是监督学习的一种形式。 　　2.回归分类 　　　线性回归模型：本质上和对应的线性分类模型一样，唯一的区别是线性回归使用的损失函数、相关连...
Spark mllib 线性回归测试数据
05-27
Spark mllib 线性回归算法测试数据
使用 Spark MLlib 实现线性回归
Shockang的博客
12-26 5009
前言 本文隶属于专栏《1000个问题搞定大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！ 本专栏目录结构和参考文献请见1000个问题搞定大数据技术体系 目录 模型的创建与使用 第 1 步，数据准备。 在 MLlib 中， LinearRegressionWithSGD 需要一个 LabeledPoint 类型的 RDD 作为训练集。 训练集中 label 字段的值可以是任意实数。 第 2 步，训练模型。 LinearRegressionWithSGD 伴生对
Spark机器学习(1)：线性回归算法
weixin_34367257的博客
06-13 212
线性回归算法，是利用数理统计中回归分析，来确定两种或两种以上变量间相互依赖的定量关系的一种统计分析方法。 1. 梯度下降法 线性回归可以使用最小二乘法，但是速度比较慢，因此一般使用梯度下降法(Gradient Descent)，梯度下降法又分为批量梯度下降法(Batch Gradient Descent)和随机梯度下降法(Stochastic Gradient Descent)。批量梯度下...
Spark MLlib Linear Regression线性回归算法
热门推荐
Spark MLlib 机器学习
05-06 1万+
1、Spark MLlib Linear Regression线性回归算法 1.1 线性回归算法 1.1.1 基础理论 在统计学中，线性回归(Linear Regression)是利用称为线性回归方程的最小平方函数对一个或多个自变量和因变量之间关系进行建模的一种回归分析。这种函数是一个或多个称为回归系数的模型参数的线性组合。 回归分析中，只包括一个自变量和一个因变量，且二者的关系可用一条
Spark MLlib-线性回归
weixin_44240370的博客
04-15 1516
文章目录一、数学模型二、损失函数1、损失函数2、目标函数的概率解释<1>中心极限定理<2>高斯分布<3>极大似然估计与损失函数极小化等价三、最小二乘法四、梯度下降 一、数学模型 二、损失函数 1、损失函数 2、目标函数的概率解释 <1>中心极限定理 <2>高斯分布 <3>极大似然估计与损失函数极小化等价 三、最小二乘法 四、梯...
spark.mllib源码阅读-回归算法1-LinearRegression
Forever-守望
03-23 2695
Spark实现了三类线性回归方法：1、LinearRegression：普通线性回归模型2、LassoRegression：加L1正则化的线性回归3、RidgeRegression：加L1正则化的线性回归Spark采用了模型和训练分离定义的方式，模型和模型的迭代计算都很清晰：如LinearRegressionModel和LinearRegressionWithSGD，LassoModel和Lass
SparkMLlib线性回归算法案例
在记录自己编程工作与编程生活的同时，给那些困于无法入门编程世界的朋友提供一点帮助，在有限的生命中给有需要的人尽一点绵薄之力。
12-06 3476
SparkMLlib线性回归算法案例一、SparkMLlib线性回归模型二、案例实现 一、SparkMLlib线性回归模型 MLlib的线性回归模型采用随机梯度下降算法来优化目标函数。MLlib实现了分布式的随机梯度下降算法，其分布方法是：在每次迭代中，随机抽取一定比例的样本作为当前迭代的计算样本；对计算样本中的每一个样本分别计算梯度（分布式计算每个样本的梯度）；然后再通过聚合函数对样本的梯度进行累加，得到该样本的平均梯度及损失；最后根据最新的梯度及上次迭代的权重进行权重的更新。 MLlib线性回归
spark线性回归
m0_60196682的博客
05-31 594
因为最近开始了毕业设计，而我是数据清洗的，所以遇到了很多以前没见过的问题记录一下 数据： 2000-01-03 0.157039 2000-01-04 0.476351 0.157385 2000-01-05 0.474555 0.158185 2000-01-06 0.476826 0.158 2000-01-07 0.475459 0.158729 2000-01...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值