目录

• 1、线性回归简介
• • 1.1 线性回归应用场景
  • 1.2 什么是线性回归
  • • 1.2.1 定义与公式
    • 1.2.2 线性回归的特征与目标的关系分析
• 2、线性回归api初步使用
• • 2.1 线性回归API
  • 2.2 举例
  • • 2.2.1 步骤分析
    • 2.2.2 代码过程
• 3、线性回归的损失和优化
• • 3.1 损失函数
  • 3.2 优化算法
  • • 3.2.1 正规方程
    • • （1）什么是正规方程
      • （2）正规方程求解举例
    • 3.2.2 正规方程的推导
  • **推导方式一**：
  • **推导方式二**：
  • • 3.2.2 梯度下降(Gradient Descent)
    • • （1）什么是梯度下降
      • （2）梯度的概念
      • （3）梯度下降举例
      • （4）梯度下降（Gradient Descent）公式
  • 3.3 梯度下降和正规方程的对比
  • • 3.3.1 算法选择依据：
• 4、梯度下降法介绍
• • 4.1 全梯度下降算法（FGD）
  • 4.2 随机梯度下降算法（SGD）
  • 4.3 小批量梯度下降算法（mini-batch）
  • 4.4 随机平均梯度下降算法（SAG）
  • 4.5 梯度下降法算法比较和进一步优化
  • • 4.5.1 算法比较
    • 4.5.2 梯度下降优化算法
• 5、线性回归api(sklearn包实现)
• • 总结：
• 6、案例：波士顿房价预测
• • 6.1 案例背景介绍
  • 6.2 案例分析
  • 6.3 回归性能评估
  • 6.4 代码实现
  • • （1）正规方程
    • （2）梯度下降法
• 7、欠拟合和过拟合
• • 7.1 定义
  • 7.2 原因以及解决办法
  • （1）欠拟合原因以及解决办法
  • （2）过拟合原因以及解决办法
  • 7.3 正则化
  • • 7.3.1 什么是正则化
    • 7.3.2 正则化类别
    • • （1）==L2正则化==
      • （2）==L1正则化==
  • 7.4 维灾难
  • • 7.4.1 什么是维灾难
    • 7.4.2 维数灾难与过拟合
• 8、正则化线性模型
• • 8.1 Ridge Regression (岭回归，又名 Tikhonov regularization)
  • 8.2 Lasso Regression(Lasso 回归)
  • 8.3 Elastic Net (弹性网络)
  • 8.4 Early Stopping
  • 总结：
• 9、线性回归的改进-岭回归
• • 9.1 API
  • 9.2 观察正则化程度的变化，对结果的影响？
  • 9.3 波士顿房价预测
• 10、模型的保存和加载
• • 10.1 sklearn模型的保存和加载API
  • 10.2 线性回归的模型保存加载案例
  • 总结：

1、线性回归简介

1.1 线性回归应用场景

• 房价预测

• 销售额度预测

• 贷款额度预测

举例：

1.2 什么是线性回归

1.2.1 定义与公式

线性回归(Linear regression)是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式。

• 特点：只有一个自变量的情况称为单变量回归，多于一个自变量情况的叫做多元回归

• 线性回归用矩阵表示举例：
  

那么怎么理解呢？我们来看几个例子：

• 期末成绩：0.7×考试成绩+0.3×平时成绩
• 房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

上面两个例子，我们看到特征值与目标值之间建立了一个关系，这个关系可以理解为线性模型。

1.2.2 线性回归的特征与目标的关系分析

线性回归当中主要有两种模型，一种是线性关系，另一种是非线性关系。在这里我们只能画一个平面更好去理解，所以都用单个特征或两个特征举例子。

（1）线性关系

• 单变量线性关系：
  
• 多变量线性关系
  

注释：单特征与目标值的关系呈直线关系，或者两个特征与目标值呈现平面的关系,
更高维度的我们不用自己去想，记住这种关系即可

（2）非线性关系

注释：为什么会这样的关系呢？原因是什么？
如果是非线性关系，那么回归方程可以理解为：
w1x1+w2x22+w3x32w_1x_1+w_2x_2^2+w_3x_3^2w1​x1​+w2​x22​+w3​x32​

2、线性回归api初步使用

2.1 线性回归API

• sklearn.linear_model.LinearRegression()
  参数：
  • LinearRegression.coef_：回归系数

2.2 举例

2.2.1 步骤分析

• 1.获取数据集
• 2.数据基本处理（该案例中省略）
• 3.特征工程（该案例中省略）
• 4.机器学习
• 5.模型评估（该案例中省略）

2.2.2 代码过程

• （1）导入模块

from sklearn.linear_model import LinearRegression

• （2）构造数据集

# 比如x为不同的时间段两门课的期中成绩，y为期末成绩
x = [[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]]
y = [84.2, 80.6, 80.1, 90, 83.2, 87.6, 79.4, 93.4]

• （3）机器学习-- 模型训练

# 实例化API
estimator = LinearRegression()
# 使用fit方法进行训练
estimator.fit(x,y)# 打印对应的系数：
print("线性回归的系数是：\n", estimator.coef_)
# 打印预测结果是：
print("输出预测结果：\n", estimator.predict([[100, 80]])) # 100和80为特征值，也就是期中成绩

结果：

3、线性回归的损失和优化

假设房子例子，真实的数据之间存在这样的关系：

真实关系：真实房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

那么现在呢，我们随意指定一个关系（猜测）

随机指定关系：预测房子价格 = 0.25×中心区域的距离 + 0.14×城市一氧化氮浓度 + 0.42×自住房平均房价 + 0.34×城镇犯罪率

请问这样的话，会发生什么？真实结果与我们预测的结果之间是不是存在一定的误差呢？类似下面这样子：

既然存在这个误差，那我们就将这个误差给衡量出来：

3.1 损失函数

总损失定义为：

• yiy_iyi​为第iii个训练样本的真实值
• h(xi)h(xi)h(xi)为第iii个训练样本特征值组合预测函数
• 又称最小二乘法

如何去减少这个损失，使我们预测的更加准确些？既然存在了这个损失，我们一直说机器学习有自动学习的功能，在线性回归这里更是能够体现。这里可以通过一些优化方法去优化（其实是数学当中的求导功能）回归的总损失！！！

3.2 优化算法

如何去求模型当中的WWW，使得损失最小？（目的是找到最小损失对应的W值）

• 线性回归经常使用的两种优化算法：
  • 正规方程
  • 梯度下降法

3.2.1 正规方程

（1）什么是正规方程

理解：X为特征值矩阵，y为目标值矩阵。直接求到最好的结果
缺点：当特征过多过复杂时，求解速度太慢并且得不到结果

（2）正规方程求解举例

以下表示数据为例：

即：

运用正规方程方法求解参数：

上面的式子并不好求解，原因在于求矩阵逆的过程是非常繁琐的。
另外，关于正规方程公式的推到过程也是个重点，下面来看：

3.2.2 正规方程的推导

• 推导方式一：

总损失定义为：

其中：

• yi为第i个训练样本的真实值
• h(xi)为第i个训练样本特征值组合预测函数
• 又称最小二乘法

把损失函数转换成矩阵写法：

其中y是真实值矩阵，X是特征值矩阵，w是权重矩阵

对其求解关于w的最小值，起止y,X 均已知二次函数直接求导，导数为零的位置，即为最小值。

求导：

注：式(1)到式(2)推导过程中, X是一个m行n列的矩阵，并不能保证其有逆矩阵，但是右乘XT把其变成一个方阵，保证其有逆矩阵。

式（5）到式（6）推导过程中，和上类似。

• 推导方式二：

总损失定义为：

其中：

• yi为第i个训练样本的真实值
• h(xi)为第i个训练样本特征值组合预测函数
• 又称最小二乘法

把损失函数分开书写：

对展开上式进行求导：

需要求得求导函数的极小值，即上式求导结果为0，经过化解，得结果为：

经过化解为：

补充：需要用到的矩阵求导公式：

3.2.2 梯度下降(Gradient Descent)

（1）什么是梯度下降

梯度下降法的基本思想可以类比为一个下山的过程。

假设这样一个场景：

一个人被困在山上，需要从山上下来(i.e. 找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低。

因此，下山的路径就无法确定，他必须利用自己周围的信息去找到下山的路径。这个时候，他就可以利用梯度下降算法来帮助自己下山。

具体来说就是，以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着山的高度下降的地方走，（同理，如果我们的目标是上山，也就是爬到山顶，那么此时应该是朝着最陡峭的方向往上走）。然后每走一段距离，都反复采用同一个方法，最后就能成功的抵达山谷。

梯度下降的基本过程就和下山的场景很类似。

首先，我们有一个可微分的函数。这个函数就代表着一座山。

我们的目标就是找到这个函数的最小值，也就是山底。

根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数值变化最快的方向。 所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。

（2）梯度的概念

梯度是微积分中一个很重要的概念

​ 在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率；

​ 在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向；

这也就说明了为什么我们需要千方百计的求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的反方向一直走，就能走到局部的最低点！

（3）梯度下降举例

• 1、单变量函数的梯度下降：
  我们假设有一个单变量的函数 :J(θ)=θ2J(θ) = θ^2J(θ)=θ2
  函数的微分:J′(θ)=2θJ'(θ) = 2θJ′(θ)=2θ
  初始化，起点为：θ0=1θ^0 = 1θ0=1
  学习率：α=0.4α = 0.4α=0.4

我们开始进行梯度下降的迭代计算过程:

如图，经过四次的运算，也就是走了四步，基本就抵达了函数的最低点，也就是山底：

• 2、多变量函数的梯度下降：
  我们假设有一个目标函数 ：J(θ)=θ12+θ22J(θ) = θ_1^2 + θ_2^2J(θ)=θ12​+θ22​
  现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0，0)点。但是接下 来，我们会从梯度下降算法开始一步步计算到这个最小值! 我们假设初始的起点为: θ0=(1,3)θ^0 = (1, 3)θ0=(1,3)
  初始的学习率为:α=0.1α = 0.1α=0.1
  函数的梯度为:▽:J(θ)=<2θ1,2θ2>J(θ) =< 2θ_1 ,2θ_2>J(θ)=<2θ1​,2θ2​>

进行多次迭代：

我们发现，已经基本靠近函数的最小值点：

（4）梯度下降（Gradient Descent）公式

• 1、 α是什么含义？
  α在梯度下降算法中被称作为学习率或者步长，意味着我们可以通过α来控制每一步走的距离，以保证不要步子跨的太大扯着蛋，哈哈，其实就是不要走太快，错过了最低点。同时也要保证不要走的太慢，导致太阳下山了，还没有走到山下。所以α的选择在梯度下降法中往往是很重要的！α不能太大也不能太小，太小的话，可能导致迟迟走不到最低点，太大的话，会导致错过最低点！

• 2、为什么梯度要乘以一个负号？
  梯度前加一个负号，就意味着朝着梯度相反的方向前进！我们在前文提到，梯度的方向实际就是函数在此点上升最快的方向！而我们需要朝着下降最快的方向走，自然就是负的梯度的方向，所以此处需要加上负号

我们通过两个图更好理解梯度下降的过程

所以有了梯度下降这样一个优化算法，回归就有了"自动学习"的能力

• 3、优化动态图演示:

3.3 梯度下降和正规方程的对比

梯度下降	正规方程
需要选择学习率	不需要
需要迭代求解	一次运算得出
特征数量较大可以使用	需要计算方程，时间复杂度高O(n3)

3.3.1 算法选择依据：

• 小规模数据：
  • 正规方程：LinearRegression(不能解决拟合问题)
  • 岭回归
• 大规模数据：
  • 梯度下降法：SGDRegressor

4、梯度下降法介绍

前面介绍了最基本的梯度下降法实现流程，常见的梯度下降算法有：

• 全梯度下降算法(Full gradient descent）,
• 随机梯度下降算法（Stochastic gradient descent）,
• 小批量梯度下降算法（Mini-batch gradient descent）,
• 随机平均梯度下降算法（Stochastic average gradient descent）

它们都是为了正确地调节权重向量，通过为每个权重计算一个梯度，从而更新权值，使目标函数尽可能最小化。其差别在于样本的使用方式不同。

4.1 全梯度下降算法（FGD）

计算训练集所有样本误差，对其求和再取平均值作为目标函数。

权重向量沿其梯度相反的方向移动，从而使当前目标函数减少得最多。

因为在执行每次更新时，我们需要在整个数据集上计算所有的梯度，所以全梯度下降法的速度会很慢，同时，全梯度下降法无法处理超出内存容量限制的数据集。

全梯度下降法同样也不能在线更新模型，即在运行的过程中，不能增加新的样本。

其是在整个训练数据集上计算损失函数关于参数θ的梯度：

4.2 随机梯度下降算法（SGD）

由于FGD每迭代更新一次权重都需要计算所有样本误差，而实际问题中经常有上亿的训练样本，故效率偏低，且容易陷入局部最优解，因此提出了随机梯度下降算法。

其每轮计算的目标函数不再是全体样本误差，而仅是单个样本误差，即每次只代入计算一个样本目标函数的梯度来更新权重，再取下一个样本重复此过程，直到损失函数值停止下降或损失函数值小于某个可以容忍的阈值。

此过程简单，高效，通常可以较好地避免更新迭代收敛到局部最优解。其迭代形式为：

其中，x(i)表示一条训练样本的特征值，y(i)表示一条训练样本的标签值

但是由于，SGD每次只使用一个样本迭代，若遇上噪声则容易陷入局部最优解。

4.3 小批量梯度下降算法（mini-batch）

小批量梯度下降算法是FGD和SGD的折中方案,在一定程度上兼顾了以上两种方法的优点。

每次从训练样本集上随机抽取一个小样本集，在抽出来的小样本集上采用FGD迭代更新权重。

被抽出的小样本集所含样本点的个数称为batch_size，通常设置为2的幂次方，更有利于GPU加速处理。

特别的，若batch_size=1，则变成了SGD；若batch_size=n，则变成了FGD.其迭代形式为:

4.4 随机平均梯度下降算法（SAG）

在SGD方法中，虽然避开了运算成本大的问题，但对于大数据训练而言，SGD效果常不尽如人意，因为每一轮梯度更新都完全与上一轮的数据和梯度无关。

随机平均梯度算法克服了这个问题，在内存中为每一个样本都维护一个旧的梯度，随机选择第i个样本来更新此样本的梯度，其他样本的梯度保持不变，然后求得所有梯度的平均值，进而更新了参数。

如此，每一轮更新仅需计算一个样本的梯度，计算成本等同于SGD，但收敛速度快得多。

4.5 梯度下降法算法比较和进一步优化

常见的梯度下降算法有：

• 全梯度下降算法(Full gradient descent）,
• 随机梯度下降算法（Stochastic gradient descent）,
• 小批量梯度下降算法（Mini-batch gradient descent）,
• 随机平均梯度下降算法（Stochastic average gradient descent）

它们都是为了正确地调节权重向量，通过为每个权重计算一个梯度，从而更新权值，使目标函数尽可能最小化。其差别在于样本的使用方式不同。

通过一个数据集案例进行对比，查看他们的区别

4.5.1 算法比较

为了比对四种基本梯度下降算法的性能，我们通过一个逻辑二分类实验来说明。本文所用的Adult数据集来自UCI公共数据库（http://archive.ics.uci.edu/ml/datasets/Adult）。 数据集共有15081条记录，包括“性别”“年龄”“受教育情况”“每周工作时常”等14个特征，数据标记列显示“年薪是否大于50000美元”。我们将数据集的80%作为训练集，剩下的20%作为测试集，使用逻辑回归建立预测模型，根据数据点的14个特征预测其数据标记（收入情况）。

以下6幅图反映了模型优化过程中四种梯度算法的性能差异。

在图1和图2中，横坐标代表有效迭代次数，纵坐标代表平均损失函数值。图1反映了前25次有效迭代过程中平均损失函数值的变化情况，为了便于观察，图2放大了第10次到25次的迭代情况。

从图1中可以看到，四种梯度算法下，平均损失函数值随迭代次数的增加而减少。FG的迭代效率始终领先，能在较少的迭代次数下取得较低的平均损失函数值。FG与SAG的图像较平滑，这是因为这两种算法在进行梯度更新时都结合了之前的梯度；SG与mini-batch的图像曲折明显，这是因为这两种算法在每轮更新梯度时都随机抽取一个或若干样本进行计算，并没有考虑到之前的梯度。

从图2中可以看到虽然四条折现的纵坐标虽然都趋近于0，但SG和FG较早，mini-batch最晚。这说明如果想使用mini-batch获得最优参数，必须对其进行较其他三种梯度算法更多频次的迭代。

在图3，4，5，6中，横坐标表示时间，纵坐标表示平均损失函数值。

从图3中可以看出使用四种算法将平均损失函数值从0.7降到0.1最多只需要2.5s，由于本文程序在初始化梯度时将梯度设为了零，故前期的优化效果格外明显。其中SG在前期的表现最好，仅1.75s便将损失函值降到了0.1，虽然SG无法像FG那样达到线性收敛，但在处理大规模机器学习问题时，为了节约时间成本和存储成本，可在训练的一开始先使用SG，后期考虑到收敛性和精度可改用其他算法。

从图4，5，6可以看出，随着平均损失函数值的不断减小，SG的性能逐渐反超FG，FG的优化效率最慢，即达到相同平均损失函数值时FG所需要的时间最久。

综合分析六幅图我们得出以下结论：

• （1）FG方法由于它每轮更新都要使用全体数据集，故花费的时间成本最多，内存存储最大。

• （2）SAG在训练初期表现不佳，优化速度较慢。这是因为我们常将初始梯度设为0，而SAG每轮梯度更新都结合了上一轮梯度值。

• （3）综合考虑迭代次数和运行时间，SG表现性能都很好，能在训练初期快速摆脱初始梯度值，快速将平均损失函数降到很低。但要注意，在使用SG方法时要慎重选择步长，否则容易错过最优解。

• （4）mini-batch结合了SG的“胆大”和FG的“心细”，从6幅图像来看，它的表现也正好居于SG和FG二者之间。在目前的机器学习领域，mini-batch是使用最多的梯度下降算法，正是因为它避开了FG运算效率低成本大和SG收敛效果不稳定的缺点。

4.5.2 梯度下降优化算法

以下这些算法主要用于深度学习优化

• 动量法
  • 其实动量法(SGD with monentum)就是SAG的姐妹版
  • SAG是对过去K次的梯度求平均值
  • SGD with monentum 是对过去所有的梯度求加权平均
• Nesterov加速梯度下降法
  • 类似于一个智能球，在重新遇到斜率上升时候，能够知道减速
• Adagrad
  • 让学习率使用参数
  • 对于出现次数较少的特征，我们对其采用更大的学习率，对于出现次数较多的特征，我们对其采用较小的学习率。
• Adadelta
  • Adadelta是Adagrad的一种扩展算法，以处理Adagrad学习速率单调递减的问题。
• RMSProp
  • 其结合了梯度平方的指数移动平均数来调节学习率的变化。
  • 能够在不稳定（Non-Stationary）的目标函数情况下进行很好地收敛。
• Adam
  • 结合AdaGrad和RMSProp两种优化算法的优点。
  • 是一种自适应的学习率算法

参考链接：https://blog.csdn.net/google19890102/article/details/69942970

5、线性回归api(sklearn包实现)

• sklearn.linear_model.LinearRegression(fit_intercept=True)

  • 通过正规方程优化
  • 参数
    • fit_intercept：是否计算偏置
  • 属性
    • LinearRegression.coef_：回归系数
    • LinearRegression.intercept_：偏置

• sklearn.linear_model.SGDRegressor(loss="squared_loss", fit_intercept=True, learning_rate ='invscaling', eta0=0.01)

  • SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型。
  • 参数：
  • loss:损失类型
    • loss=”squared_loss”: 普通最小二乘法
  • fit_intercept：是否计算偏置
  • learning_rate : string, optional
    • 学习率填充
    • ‘constant’: eta = eta0
    • ‘optimal’: eta = 1.0 / (alpha * (t + t0)) [default]
    • ‘invscaling’: eta = eta0 / pow(t, power_t)
      • power_t=0.25:存在父类当中
    • 对于一个常数值的学习率来说，可以使用learning_rate=’constant’ ，并使用eta0来指定学习率。
  • 属性：
    • SGDRegressor.coef_：回归系数
    • SGDRegressor.intercept_：偏置

sklearn提供给我们两种实现的API， 可以根据选择使用

总结：

• 正规方程
  • sklearn.linear_model.LinearRegression()
• 梯度下降法
  • sklearn.linear_model.SGDRegressor(）

看完API，肯定还是很懵逼，下面来看一个例子：

6、案例：波士顿房价预测

6.1 案例背景介绍

• 数据介绍：
  
  

给定的这些特征，是专家们得出的影响房价的结果属性。我们此阶段不需要自己去探究特征是否有用，只需要使用这些特征。到后面量化很多特征需要我们自己去寻找

6.2 案例分析

回归当中的数据大小不一致，是否会导致结果影响较大。所以需要做标准化处理。

• 数据分割与标准化处理
• 回归预测
• 线性回归的算法效果评估

6.3 回归性能评估

均方误差(Mean Squared Error)MSE)评价机制：

注：yiy^iyi为预测值，y‾\overline{y}y​为真实值。

思考：MSE和最小二乘法的区别是？答：MSE取平均了，最小二乘法没有。
下面是MSE的API：

sklearn.metrics.mean_squared_error(y_true, y_pred)

• 功能：均方误差回归损失
• y_true:真实值
• y_pred:预测值
• return:浮点数结果

6.4 代码实现

（1）正规方程

"""
# 1.获取数据
# 2.数据基本处理
# 2.1 分割数据
# 3.特征工程-标准化
# 4.机器学习-线性回归
# 5.模型评估
"""from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.metrics import mean_absolute_errordef linear_model1():"""线性回归：正规方程:return:"""# 1.获取数据boston = load_boston()# print(boston)# 2.数据基本处理# 2.1 分割数据x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)# 3.特征工程-标准化trasfer = StandardScaler()x_train = trasfer.fit_transform(x_train)x_test = trasfer.fit_transform(x_test)# 4.机器学习-线性回归estimator = LinearRegression()estimator.fit(x_train, y_train)print("这个模型的偏置是：\n", estimator.intercept_)print("这个模型的系数是：\n", estimator.coef_)# 5.模型评估# 5.1 预测值y_pre = estimator.predict(x_test)print("预测值是：\n", y_pre)# 5.2 均方误差ret = mean_absolute_error(y_test, y_pre)print("均方误差：\n", ret)if __name__ == "__main__":linear_model1() # 正规方程

（2）梯度下降法

def linear_model2():"""线性回归：梯度下降法:return:"""# 1.获取数据boston = load_boston()print(boston)# 2.数据基本处理# 2.1 分割数据x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)# 3.特征工程-标准化trasfer = StandardScaler()x_train = trasfer.fit_transform(x_train)x_test = trasfer.fit_transform(x_test)# 4.机器学习-线性回归# estimator = SGDRegressor(max_iter=1000, learning_rate="constant", eta0= 0.1)estimator = SGDRegressor(max_iter=1000) # max_iter就是使用梯度下降法时最大的迭代次数，其实就是多少个epochestimator.fit(x_train, y_train)print("这个模型的偏置是：\n", estimator.intercept_)print("这个模型的系数是：\n", estimator.coef_)# 5.模型评估# 5.1 预测值y_pre = estimator.predict(x_test)print("预测值是：\n", y_pre)# 5.2 均方误差ret = mean_absolute_error(y_test, y_pre)print("均方误差：\n", ret)if __name__ == "__main__":linear_model2() # 梯度下降法

我们也可以尝试去修改学习率：

estimator = SGDRegressor(max_iter=1000,learning_rate="constant",eta0=0.1)

此时我们可以通过调参数，找到学习率效果更好的值。

7、欠拟合和过拟合

7.1 定义

• 过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
• 欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

那么是什么原因导致模型复杂？线性回归进行训练学习的时候变成模型会变得复杂，这里就对应前面再说的线性回归的两种关系，非线性关系的数据，也就是存在很多无用的特征或者现实中的事物特征跟目标值的关系并不是简单的线性关系。

7.2 原因以及解决办法

• （1）欠拟合原因以及解决办法

  • 原因：学习到数据的特征过少
  • 解决办法：
    • 1）添加其他特征项，有时候我们模型出现欠拟合的时候是因为特征项不够导致的，可以添加其他特征项来很好地解决。例如，“组合”、“泛化”、“相关性”三类特征是特征添加的重要手段，无论在什么场景，都可以照葫芦画瓢，总会得到意想不到的效果。除上面的特征之外，“上下文特征”、“平台特征”等等，都可以作为特征添加的首选项。
    • 2）添加多项式特征，这个在机器学习算法里面用的很普遍，例如将线性模型通过添加二次项或者三次项使模型泛化能力更强。

---

• （2）过拟合原因以及解决办法

  • 原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点
  • 解决办法：
    • 1）重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致的，如果出现了过拟合就需要我们重新清洗数据。
    • 2）增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小。
    • 3）正则化
    • 4）减少特征维度，防止维灾难

提到的正则化和维灾难又是什么呢？下面来解释：

7.3 正则化

7.3.1 什么是正则化

在解决回归过拟合中，我们选择正则化。但是对于其他机器学习算法如分类算法来说也会出现这样的问题，除了一些算法本身作用之外（决策树、神经网络），我们更多的也是去自己做特征选择，包括之前说的删除、合并一些特征

如何解决？

在学习的时候，数据提供的特征有些影响模型复杂度或者这个特征的数据点异常较多，所以算法在学习的时候尽量减少这个特征的影响（甚至删除某个特征的影响），这就是正则化。更确切的来说：

正则化(Regularization) 是机器学习中对原始损失函数引入额外信息，以便防止过拟合和提高模型泛化性能的一类方法的统称。

注：调整时候，算法并不知道某个特征影响，而是去调整参数得出优化的结果

7.3.2 正则化类别

（1）L2正则化

• 作用：可以使得其中一些W的都很小，都接近于0，削弱某个特征的影响
• 优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
• 使用L2正则化的线性回归模型叫：Ridge回归（岭回归）。

（2）L1正则化

• 作用：可以使得其中一些W的值直接为0，删除这个特征的影响
• 使用L1正则化的线性回归模型叫：LASSO回归

注意：
若λ\lambdaλ 过大，则会导致除 θ0{\theta _0}θ0​ 之外的其他参数惩罚过大，也就是会≈0\approx 0≈0，那这个怎么理解：
这是因为我们最终的目的是 使得损失函数 LLL 减小，因此只能通过减小 θ\thetaθ 来实现。

7.4 维灾难

7.4.1 什么是维灾难

随着维度的增加，分类器性能逐步上升，到达某点之后，其性能便逐渐下降

有一系列的图片，每张图片的内容可能是猫也可能是狗；我们需要构造一个分类器能够对猫、狗自动的分类。首先，要寻找到一些能够描述猫和狗的特征，这样我们的分类算法就可以利用这些特征去识别物体。猫和狗的皮毛颜色可能是一个很好的特征，考虑到红绿蓝构成图像的三基色，因此用图片三基色各自的平均值称得上方便直观。这样就有了一个简单的Fisher分类器：

if  0.5*red + 0.3*green + 0.2*blue > 0.6 : return cat;
else return dog;

使用颜色特征可能无法得到一个足够准确的分类器，如果是这样的话，我们不妨加入一些诸如图像纹理(图像灰度值在其X、Y方向的导数dx、dy)，就有5个特征(Red、Blue、Green、dx、dy)来设计我们的分类器：

也许分类器准确率依然无法达到要求，加入更多的特征，比如颜色、纹理的统计信息等等，如此下去，可能会得到上百个特征。那是不是我们的分类器性能会随着特征数量的增加而逐步提高呢？答案也许有些让人沮丧，事实上，当特征数量达到一定规模后，分类器的性能是在下降的。

随着维度(特征数量)的增加，分类器的性能却下降了

7.4.2 维数灾难与过拟合

我们假设猫和狗图片的数量是有限的(样本数量总是有限的)，假设有10张图片，接下来我们就用这仅有的10张图片来训练我们的分类器。

增加一个特征，比如绿色，这样特征维数扩展到了2维：

增加一个特征后，我们依然无法找到一条简单的直线将它们有效分类

再增加一个特征，比如蓝色，扩展到3维特征空间：

在3维特征空间中，我们很容易找到一个分类平面，能够在训练集上有效的将猫和狗进行分类：

在高维空间中，我们似乎能得到更优的分类器性能。

从1维到3维，给我们的感觉是：维数越高，分类性能越优。然而，维数过高将导致一定的问题：在一维特征空间下，我们假设一个维度的宽度为5个单位，这样样本密度为10/5=2;在2维特征空间下，10个样本所分布的空间大小25，这样样本密度为10/25=0.4;在3维特征空间下，10个样本分布的空间大小为125，样本密度就为10/125=0.08.

如果继续增加特征数量，随着维度的增加，样本将变得越来越稀疏，在这种情况下，也更容易找到一个超平面将目标分开。然而，如果我们将高维空间向低维空间投影，高维空间隐藏的问题将会显现出来：

过多的特征导致的过拟合现象：训练集上表现良好，但是对新数据缺乏泛化能力。

高维空间训练形成的线性分类器，相当于在低维空间的一个复杂的非线性分类器，这种分类器过多的强调了训练集的准确率甚至于对一些错误/异常的数据也进行了学习，而正确的数据却无法覆盖整个特征空间。为此，这样得到的分类器在对新数据进行预测时将会出现错误。这种现象称之为过拟合，同时也是维灾难的直接体现。

简单的线性分类器在训练数据上的表现不如非线性分类器，但由于线性分类器的学习过程中对噪声没有对非线性分类器敏感，因此对新数据具备更优的泛化能力。换句话说，通过使用更少的特征，避免了维数灾难的发生(也即避免了高维情况下的过拟合)

由于高维而带来的数据稀疏性问题：假设有一个特征，它的取值范围D在0到1之间均匀分布，并且对狗和猫来说其值都是唯一的，我们现在利用这个特征来设计分类器。如果我们的训练数据覆盖了取值范围的20%(e.g 0到0.2)，那么所使用的训练数据就占总样本量的20%。上升到二维情况下，覆盖二维特征空间20%的面积，则需要在每个维度上取得45%的取值范围。在三维情况下，要覆盖特征空间20%的体积，则需要在每个维度上取得58%的取值范围…在维度接近一定程度时，要取得同样的训练样本数量，则几乎要在每个维度上取得接近100%的取值范围，或者增加总样本数量，但样本数量也总是有限的。

如果一直增加特征维数，由于样本分布越来越稀疏，如果要避免过拟合的出现，就不得不持续增加样本数量。

数据在高维空间的中心比在边缘区域具备更大的稀疏性，数据更倾向于分布在空间的边缘区域：

不属于单位圆的训练样本比搜索空间的中心更接近搜索空间的角点。这些样本很难分类，因为它们的特征值差别很大（例如，单位正方形的对角的样本）。

一个有趣的问题是，当我们增加特征空间的维度时，圆（超球面）的体积如何相对于正方形（超立方体）的体积发生变化。尺寸d的单位超立方体的体积总是1 ^ d = 1.尺寸d和半径0.5的内切超球体的体积可以计算为：

在高维空间中，大多数训练数据驻留在定义特征空间的超立方体的角落中。如前所述，特征空间角落中的实例比围绕超球体质心的实例难以分类：

an 8D hypercube which has 2^8 = 256 corners

事实证明，许多事物在高维空间中表现得非常不同。 例如，如果你选择一个单位平方（1×1平方）的随机点，它将只有大约0.4％的机会位于小于0.001的边界（换句话说，随机点将沿任何维度“极端”这是非常不可能的）。 但是在一个10000维单位超立方体（1×1×1立方体，有1万个1）中，这个概率大于99.999999％。 高维超立方体中的大部分点都非常靠近边界。更难区分的是：如果你在一个单位正方形中随机抽取两个点，这两个点之间的距离平均约为0.52。如果在单位三维立方体中选取两个随机点，则平均距离将大致为0.66。但是在一个100万维的超立方体中随机抽取两点呢？那么平均距离将是大约408.25（大约1,000,000 / 6）！

非常违反直觉：当两个点位于相同的单位超立方体内时，两点如何分离？这个事实意味着高维数据集有可能非常稀疏：大多数训练实例可能彼此远离。当然，这也意味着一个新实例可能离任何训练实例都很远，这使得预测的可信度表现得比在低维度数据中要来的差。训练集的维度越多，过度拟合的风险就越大。

理论上讲，维度灾难的一个解决方案可能是增加训练集的大小以达到足够密度的训练实例。 不幸的是，在实践中，达到给定密度所需的训练实例的数量随着维度的数量呈指数增长。 如果只有100个特征（比MNIST问题少得多），那么为了使训练实例的平均值在0.1以内，需要比可观察宇宙中的原子更多的训练实例，假设它们在所有维度上均匀分布。

对于8维超立方体，大约98％的数据集中在其256个角上。结果，当特征空间的维度达到无穷大时，从采样点到质心的最小和最大欧几里得距离的差与最小距离本身只比趋于零：

距离测量开始失去其在高维空间中测量的有效性,由于分类器取决于这些距离测量,因此在较低维空间中分类通常更容易，其中较少特征用于描述感兴趣对象。

如果理论无限数量的训练样本可用，则维度的诅咒不适用，我们可以简单地使用无数个特征来获得完美的分类。训练数据的大小越小，应使用的功能就越少。如果N个训练样本足以覆盖单位区间大小的1D特征空间，则需要N ^ 2个样本来覆盖具有相同密度的2D特征空间，并且在3D特征空间中需要N ^ 3个样本。换句话说，所需的训练实例数量随着使用的维度数量呈指数增长。

8、正则化线性模型

介绍下面四个正则化的线性模型：

• Ridge Regression 岭回归
• Lasso 回归
• Elastic Net 弹性网络
• Early stopping

8.1 Ridge Regression (岭回归，又名 Tikhonov regularization)

岭回归是线性回归的正则化版本，即在原来的线性回归的 cost function 中添加正则项（regularization term）:

以达到在拟合数据的同时，使模型权重尽可能小的目的,岭回归代价函数:

• α=0：岭回归退化为线性回归

8.2 Lasso Regression(Lasso 回归)

Lasso 回归是线性回归的另一种正则化版本，正则项为权值向量的1范数。

Lasso回归的代价函数 ：

【注意 】

• Lasso Regression 的代价函数在 θi=0θ_i=0θi​=0处是不可导的.
• 解决方法：在θi=0θ_i=0θi​=0处用一个次梯度向量(subgradient vector)代替梯度，如下式
• Lasso Regression 的次梯度向量

Lasso Regression 有一个很重要的性质是：倾向于完全消除不重要的权重。

例如：当α 取值相对较大时，高阶多项式退化为二次甚至是线性：高阶多项式特征的权重被置为0。

也就是说，Lasso Regression 能够自动进行特征选择，并输出一个稀疏模型（只有少数特征的权重是非零的）。

8.3 Elastic Net (弹性网络)

弹性网络在岭回归和Lasso回归中进行了折中，通过 混合比(mix ratio) r 进行控制：

• r=0：弹性网络变为岭回归
• r=1：弹性网络便为Lasso回归

弹性网络的代价函数 ：

一般来说，我们应避免使用朴素线性回归（就是最原始的线性回归），而应对模型进行一定的正则化处理，那如何选择正则化方法呢？

答：

• 常用：岭回归

• 假设只有少部分特征是有用的：

  • 弹性网络
  • Lasso
  • 一般来说，弹性网络的使用更为广泛。因为在特征维度高于训练样本数，或者特征是强相关的情况下，Lasso回归的表现不太稳定。

• api:

from sklearn.linear_model import Ridge, ElasticNet, Lasso

8.4 Early Stopping

Early Stopping 也是正则化迭代学习的方法之一。

其做法为：在验证错误率达到最小值的时候停止训练。

总结：

• Ridge Regression 岭回归
  • 就是把系数添加平方项
  • 然后限制系数值的大小
  • α值越小，系数值越大，α越大，系数值越小
• Lasso 回归
  • 对系数值进行绝对值处理
  • 由于绝对值在顶点处不可导，所以进行计算的过程中产生很多0，最后得到结果为：稀疏矩阵
• Elastic Net 弹性网络
  • 是前两个内容的综合
  • 设置了一个r,如果r=0–岭回归；r=1–Lasso回归
• Early stopping
  • 通过限制错误率的阈值，进行停止

9、线性回归的改进-岭回归

9.1 API

（1）：

• sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True,solver="auto", normalize=False)
  • 具有l2正则化的线性回归
  • alpha:正则化力度，也叫 λ
    • λ取值：0~1 1~10
  • solver:会根据数据自动选择优化方法
  • sag:如果数据集、特征都比较大，选择该随机梯度下降优化
  • normalize:数据是否进行标准化
    • normalize=False:可以在fit之前调用preprocessing.StandardScaler标准化数据
  • Ridge.coef_:回归权重
  • Ridge.intercept_:回归偏置

Ridge方法相当于SGDRegressor(penalty=‘l2’, loss=“squared_loss”),只不过SGDRegressor实现了一个普通的随机梯度下降学习，推荐使用Ridge(实现了SAG)

（2）：下面这个API具有交叉验证

• sklearn.linear_model.RidgeCV(_BaseRidgeCV, RegressorMixin)
  • 具有l2正则化的线性回归，可以进行交叉验证
  • coef_:回归系数

class _BaseRidgeCV(LinearModel):def __init__(self, alphas=(0.1, 1.0, 10.0),fit_intercept=True, normalize=False,scoring=None,cv=None, gcv_mode=None,store_cv_values=False):

9.2 观察正则化程度的变化，对结果的影响？

• 正则化力度越大，权重系数会越小
• 正则化力度越小，权重系数会越大

9.3 波士顿房价预测

"""
# 1.获取数据
# 2.数据基本处理
# 2.1 分割数据
# 3.特征工程-标准化
# 4.机器学习-线性回归
# 5.模型评估
"""from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor, RidgeCV, Ridge
from sklearn.metrics import mean_absolute_errordef linear_model():"""线性回归：岭回归:return:"""# 1.获取数据boston = load_boston()print(boston)# 2.数据基本处理# 2.1 分割数据x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)# 3.特征工程-标准化trasfer = StandardScaler()x_train = trasfer.fit_transform(x_train)x_test = trasfer.fit_transform(x_test)# 4.机器学习-线性回归# estimator = Ridge(alpha=1.0)estimator = RidgeCV(alphas=(0.001, 0.01, 0.1, 1, 10, 100)) # 交叉验证estimator.fit(x_train, y_train)print("这个模型的偏置是：\n", estimator.intercept_)print("这个模型的系数是：\n", estimator.coef_)# 5.模型评估# 5.1 预测值y_pre = estimator.predict(x_test)print("预测值是：\n", y_pre)# 5.2 均方误差ret = mean_absolute_error(y_test, y_pre)print("均方误差：\n", ret)if __name__ == "__main__":linear_model() # 岭回归

10、模型的保存和加载

10.1 sklearn模型的保存和加载API

• import joblib
  • 保存：joblib.dump(estimator, 'test.pkl')
  • 加载：estimator = joblib.load('test.pkl')

10.2 线性回归的模型保存加载案例

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, SGDRegressor, RidgeCV, Ridge
from sklearn.metrics import mean_absolute_error
import joblibdef dump_load():"""模型保存和加载:return:"""# 1.获取数据boston = load_boston()print(boston)# 2.数据基本处理# 2.1 分割数据x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, test_size=0.2)# 3.特征工程-标准化trasfer = StandardScaler()x_train = trasfer.fit_transform(x_train)x_test = trasfer.fit_transform(x_test)# # 4.机器学习-线性回归# # 4.1 模型训练# # estimator = Ridge(alpha=1.0)# estimator = RidgeCV(alphas=(0.001, 0.01, 0.1, 1, 10, 100)) # 交叉验证# estimator.fit(x_train, y_train)## # 4.2 模型保存# joblib.dump(estimator, 'test.pkl')# 4.3 模型加载estimator = joblib.load("test.pkl")print("这个模型的偏置是：\n", estimator.intercept_)print("这个模型的系数是：\n", estimator.coef_)# 5.模型评估# 5.1 预测值y_pre = estimator.predict(x_test)print("预测值是：\n", y_pre)# 5.2 均方误差ret = mean_absolute_error(y_test, y_pre)print("均方误差：\n", ret)if __name__ == "__main__":dump_load() # 岭回归

总结：

• import joblib
  • 保存：joblib.dump(estimator, 'test.pkl')
  • 加载：estimator = joblib.load('test.pkl')
  • 注意：
    • 1.保存文件，后缀名是**.pkl
    • 2.加载模型是需要通过一个变量进行承接

机器学习算法——线性回归的详细介绍 及 利用sklearn包实现线性回归模型相关推荐

1. 机器学习算法原理：详细介绍各种机器学习算法的原理、优缺点和适用场景

   目录 引言 二.线性回归 三.逻辑回归 四.支持向量机 五.决策树 六.随机森林 七.K-均值聚类 八.主成分分析(PCA) 九.K近邻算法 十.朴素贝叶斯分类器 十一.神经网络 十二.AdaBoos ...

2. 机器学习算法——决策树算法详细介绍，并使用sklearn实现案例预测，可视化决策树

   目录 一.决策树算法简介 二.决策树分类原理 1.熵 1.1 概念 1.2 案例 2.决策树的划分依据一:信息增益 2.1 概念 2.2 案例: 3.决策树的划分依据二:信息增益率 3.1 概念 3. ...

3. 垃圾收集概述和垃圾收集算法（超详细介绍）

   文章目录 垃圾收集概述和垃圾收集算法(超详细介绍) 为什么我们还要去了解垃圾收集和内存分配 哪些内存需要回收 不需要回收的 需要回收的 方法区的回收 回收废弃常量 回收"不再被使用的类&qu ...

4. 基于实时计算Flink的机器学习算法平台及场景介绍

   作者:高旸(吾与),阿里巴巴高级技术专家 1. 前言 随着互联网"人口红利"的"消耗殆尽",基于"T+1"或者离线计算的机器学习平台及推荐系 ...

5. KNN（K最近邻算法）的详细介绍

   KNN(最近邻算法)的最详细介绍 一.KNN算法的基本介绍 二.KNN算法的基本思想 三.基于sklearn实现KNN(基于iris数据) 四.非基于sklearn实现KNN(基于iris数据) 五. ...

6. 机器学习算法--逻辑回归原理介绍

   一.逻辑回归基本概念 1. 什么是逻辑回归 逻辑回归就是这样的一个过程:面对一个回归或者分类问题,建立代价函数,然后通过优化方法迭代求解出最优的模型参数,然后测试验证我们这个求解的模型的好坏. Log ...

7. 机器学习算法 09-02 TensorFlow核心概念 TensorFlow基础代码、TensorFlow线性回归解析解和BGD求法

   目录 1 核心概念 2 代码流程 3 基础代码: 3.1 tf的版本 定义常量 理解tensor 了解session 3. 2   指定设备.  Variable 初始化 .  with块创建sess ...

8. 太极软件qn的代码_超详细介绍如何利用太极+QN框架制作一个属于自己的QQxml卡片...

   己整理测试分享给大家.转载请注明出处. 首先准备工作三点(缺一不可) 1.下载太极2.下载QNotfied框架(文末提供下载地址)3在太极中创建QQ并卸载本身QQ xml代码会在文末分享 在太极模块管 ...

9. 【机器学习】混淆矩阵详细介绍（代码+含义+解释）

   文章目录一瞥 图形介绍 重要概念 混淆矩阵延伸出的各个评价指标 关键术语 图形介绍 同样的道理,这里我们采用recall来计算模型的好坏,也就是说那些异常的样本我们的检测到了多少,这也是咱们最初的目的 ...

最新文章

1. 我所经历的大文件数据导出（后台执行,自动生成）
2. Adaboost(自适应提升树)算法原理
3. C语言中atoi()函数的用法
4. linux程序设计---序
5. 解决undefined reference to symbol ‘sem_close@@GLIBC_2.2.5‘问题
6. smith标准型_线性系统理论（八）多项式矩阵Smith-McMillan标准型计算方法
7. CNN中卷积的学习笔记
8. 对于已有的【寄存】代码，【式样】变更，【参照】其他代码修正时的注意事项！
9. python装饰器详解-学习笔记-Python装饰器详解
10. vs2008的永久破解安装
11. Quartz定时任务手动触发
12. 贸易相关术语[C-E]
13. php语法变化大,浅析PHP7新功能及语法变化总结
14. 软件开发的流程是怎样的？
15. zhang 快速并行细化方法_Zhang快速并行细化算法.docx
16. kubernetes中Pod容器错误 init:ImagePullBackOff 解决方法
17. 计算机毕设（附源码）JAVA-SSM化妆品销售网站
18. （五）不只是 huohuo 的 JS 面试题
19. 用Python分析了5万条相亲网站数据，看相亲男女画像
20. RK3399平台开发系列讲解（其他篇）1.18、瑞芯微 RK3288 芯片介绍

热门文章

1. Photoshop如何使用绘画和图像修饰之实例演示？
2. TVS管的定义及使用注意事项
3. 怎样看懂电路板？电路板短路检查方法是什么？
4. 解决Windows 11网络连接问题：教你轻松排查网络故障
5. Java实现 LeetCode 738 单调递增的数字（暴力）
6. PyQt5中的lambda表达式的使用
7. 大数据毕设选题 - 疫情实时数据分析可视化（Flask python）
8. 计算机专业十六字口号,励志口号大全16字
9. 产品项目分析之竞品分析
10. 如何写IT项目解决方案