当前位置：首页 > article >正文

深度学习基础03_BP算法(下)过拟合和欠拟合

article 2024/12/2 3:30:33

一、BP算法(下)

0、反向传播代码回顾

写法一：

写法二(更常用)：

1、BP中的梯度下降

1.数学描述

2.传统下降方式

3.优化梯度下降方式

指数加权平均

Momentum

AdaGrad

RMSProp

Adam(常用)

总结

二、过拟合和欠拟合

1、概念

1.过拟合

2.欠拟合

3.判断

2、解决欠拟合

3、解决过拟合

1.L2正则化

2.L1正则化

3.Dropout

4.其他方法

一、BP算法(下)

0、反向传播代码回顾

作为深度学习里的核心部分，再来回顾一下完整的全连接神经网络的反向传播代码框架的两种写法：

写法一：

import torch
import torch.nn as nn
import torch.optim as optim

# 构建网络
Class MyNet(nn.module):
    def __init__(self,input_size,output_size):
        super(MyNet,self).__init__()
        # 定义网络结构
        self.linear1 = nn.Linear(input_size,2)
        self.linear2 = nn.Linear(2,2)
        self.linear3 = nn.Linear(2,output_size)
        # 激活函数 sigmoid
        self.activation = torch.sigmoid

        # 网络参数初始化 这里选择自动初始化
        """
        若要手动初始化：
        # 权重
        self.linear1.weight.data = torch.tensor([[0.10,0.20],[0.25,0.35]])
        # 偏置
        self.linear1.bias.data = torch.tensor([0.30,0.30])
        适合结构形式固定时的神经网络
        """

    def forward(self,x):
    # 定义前向传播过程
    x = self.linear1(x)
    x = self.activation(x)
    x = self.linear2(x)
    x = self.activation(x)
    x = self.linear3(x)
    x = self.activation(x)
    return x


# 训练模型
def train():
    # 创建数据集
    inputs = torch.tensor([[0.05, 0.10]])
    target = torch.tensor([[0.01, 0.99]])
    # 定义神经网络结构
    net = MyNet(2,2)
    # 定义优化器
    optimizer = optim.SGD(net.parameters(),lr=0.05)
    # 定义损失函数
    loss_fn = nn.MSELoss()
    # 训练
    epoch = 500
    for i in range(epoch):
        # 前向传播 获得网络输出值
        y_pred = net(inputs)
        # 计算误差
        loss = loss_fn(y_pred,target)
        # 梯度清零
        optimizer.zero_grad()
        # 反向传播
        loss.backward()
        # 更新梯度
        optimizer.step()
    # 打印更新后的所有网络参数
    print(net.state_dict())


if __name__ == "__main__":
    train()

写法二(更常用)：

import torch
import torch.nn as nn
import torch.optim as optim

class MyNet(nn.Module):

    def __init__(self,input_size,output_size):
        super(MyNet, self).__init__()
        # 定义网络结构 nn.Sequention 一种序列容器，可以将多个层按顺序堆叠在一起
        # 隐藏层
        hide1层 有input_size个特征，3个输出(3个神经元) '3行2列'
        self.hide1 = nn.Sequential(nn.Linear(input_size,3),nn.Sigmoid())
        self.hide2 = nn.Sequential(nn.Linear(3,2),nn.Sigmoid())
        self.hide2 = nn.Sequential(nn.Linear(2,4),nn.Sigmoid())
        # 输出层 输入进来每条数据有12个特征w 输出output_size个结果
        self.out = nn.Sequential(nn.Linear(4,output_size),nn.Sigmoid())

    def forward(self,input):
    # 前向传播过程
    x = self.hide1(input)
    x = self.hide2(x)
    x = self.hide3(x)
    y_pred = self.out(x)
    return  y_pred


def train():
    # 数据集
    inputs = torch.tensor([[0.05, 0.10],
                           [0.05,0.18],
                           [0.05,0.310]])
    target = torch.tensor([[1,2],[0,3],[2,4]],dtype=torch.float32)
    # 定义网络结构
    net = MyNet(2,2)
    # 优化器
    optimizer = optim.SGD(net.parameters(), lr=0.1)
    # 定义损失函数
    loss_fn = torch.nn.MSELoss()
    # 训练
    epoch = 500
    for i in range(epoch):
        # 前向传播
        # 获得网络输出值
        y_pred = net(inputs) # module父类已实现前向传播
        # 计算误差
        loss = loss_fn(y_pred, target)
        # 梯度清零
        optimizer.zero_grad()
        # 反向传播
        loss.backward()
        #更新梯度
        optimizer.step()
        
        # 打印更新后的网络参数
    print(net.state_dict())

if __name__ == "__main__":
    train()

1、BP中的梯度下降

1.数学描述

梯度下降公式： $w_{ij}^{new}= w_{ij}^{old} - \alpha \frac{\partial E}{\partial w_{ij}}$ ，其中 $\alpha$ 是学习率。

学习率太小，每次训练之后的效果太小，增加时间和算力成本。
学习率太大，大概率会跳过最优解，进入无限的训练和震荡中。
解决的方法就是，学习率也需要随着训练的进行而变化。

过程

初始化参数→计算梯度→更新参数→迭代更新→达到终止条件

2.传统下降方式

根据计算梯度时数据量不同，常见的方式有：批量梯度下降BGD、随机梯度下降SGD、小批量下降MGBD。

它们的特点以及优劣可参考：机器学习基础07_sklearn梯度下降&岭回归&拉索回归&逻辑回归_sklearn 梯度下降法-CSDN博客

但都存在问题：

收敛速度慢：BGD和MBGD使用固定学习率，太大会导致震荡，太小又收敛缓慢。
局部最小值和鞍点问题：SGD在遇到局部最小值或鞍点时容易停滞，导致模型难以达到全局最优。
训练不稳定：SGD中的噪声容易导致训练过程中不稳定，使得训练陷入震荡或不收敛。

3.优化梯度下降方式

传统的梯度下降优化算法中，可能会碰到以下情况:

碰到平缓区域，梯度值较小，参数优化变慢；碰到 “鞍点” ，梯度为 0，参数无法优化；碰到局部最小值等

对于这些问题, 出现了一些对梯度下降算法的优化方法,例如：Momentum、AdaGrad、RMSprop、Adam 等：

指数加权平均

指数移动加权平均(Exponential Moving Average简称EMA)则是参考各数值，并且各数值的权重都不同，距离越远的数字对平均数计算的贡献就越小（权重较小），距离越近则对平均数的计算贡献就越大（权重越大）。

计算公式

St 表示指数加权平均值(EMA)；
Yt 表示 t 时刻的值；
$\beta$ 是平滑系数，取值范围为 $0\leq \beta < 1$ ，其越接近 1，表示对历史数据依赖性越高；越接近 0 则越依赖当前数据。该值越大平均数越平缓。

import torch
import numpy as np
import matplotlib.pyplot as plt


"""
**指数移动加权平均**(Exponential Moving Average简称EMA)
参考各数值，并且各数值的权重都不同
距离越远的数字对平均数计算的贡献越小（权重较小）
距离越近则对平均数的计算贡献就越大（权重越大）
"""
def test01():
    # 模拟温度
    np.random.seed(666)
    y = np.random.randint(5,40,30)
    print(y)
    x = np.arange(30)
    plt.plot(x,y,c='b')
    plt.scatter(x,y,c='r')
    plt.show()

def test02(beta=0.9):
    # 模拟温度
    np.random.seed(666)
    y = np.random.randint(5,40,30)
    print(y)
    x = np.arange(30)
    y_ema = []
    for i in range(30):
        if i==0:
            y_ema.append(y[0])
        else:
            st = beta*y_ema[-1] + (1-beta)*y[i]
            y_ema.append(st)

    plt.plot(x,np.array(y_ema),c='b')
    plt.scatter(x,y,c='r')
    plt.show()


if __name__ == '__main__':
    # test01()
    test02()

Momentum

动量（Momentum）是对梯度下降的优化方法，可以更好地应对梯度变化和梯度消失问题，从而提高训练模型的效率和稳定性。

惯性效应： 该方法加入前面梯度的累积，这种惯性使得算法沿着当前的方向继续更新。如遇到鞍点，也不会因梯度逼近零而停滞。
减少震荡： 该方法平滑了梯度更新，减少在鞍点附近的震荡，帮助优化过程稳定向前推进。
加速收敛： 该方法在优化过程中持续沿着某个方向前进，能够更快地穿越鞍点区域，避免在鞍点附近长时间停留。

梯度计算公式：St = β * $S_{t-1}$ + (1- β) * Wt

$S_{t-1}$ 表示历史梯度移动加权平均值
Wt 表示当前时刻的梯度值
β 为权重系数

梯度下降公式中梯度的计算，就不再是当前时刻 t 的梯度值，而是历史梯度值的指数移动加权平均值：

$W_{t+1}=W_{t}-\alpha *D_t$

api

optimizer = optim.SGD(model.parameters(), lr=0.05, momentum=0.4) # 学习率和动量值可以根据实际情况调整,momentum 参数指定了动量系数,默认为0。动量系数通常设置为 0 到0.5 之间的一个值，但也可以根据具体的应用场景调整

def train():
    # 数据集
    inputs = torch.tensor([[0.05, 0.10],
                           [0.05,0.18],
                           [0.05,0.310]])
    target = torch.tensor([[1,2],[0,3],[2,4]],dtype=torch.float32)
    # 定义网络结构
    net = MyNet(2,2)
    # 优化器 加入动量值
    optimizer = optim.SGD(net.parameters(), lr=0.01,momentum=0.6)
    # 定义损失函数
    mes = torch.nn.MSELoss()
    # 训练
    epoch = 100
    for i in range(epoch):
        # 前向传播
        # 获得网络输出值
        y_pred = net(inputs) # module父类已实现前向传播
        # 计算误差
        loss = mes(y_pred, target)
        # 梯度清零
        optimizer.zero_grad()
        # 反向传播
        loss.backward()
        #更新梯度
        optimizer.step()

AdaGrad

AdaGrad（Adaptive Gradient Algorithm）为每个参数引入独立的学习率，它根据历史梯度的平方和来调整这些学习率，这样就使得参数具有较大的历史梯度的学习率减小，而参数具有较小的历史梯度的学习率保持较大，从而实现更有效的学习。

学习率计算公式：

其中s是累积平方梯度， s = s + g ⊙ g，⊙ 表示各个分量相乘；σ是小常数 σ = 1e-8( 用于防止除零操作）

参数更新公式：

优点：

自适应学习率：由于每个参数的学习率是基于其梯度的累积平方和来动态调整的，这意味着学习率会随着时间步的增加而减少，对梯度较大且变化频繁的方向非常有用，防止了梯度过大导致的震荡。
适合稀疏数据：AdaGrad 在处理稀疏数据时表现很好，因为它能够自适应地为那些较少更新的参数保持较大的学习率。

缺点：

学习率过度衰减：随着时间的推移，累积的时间步梯度平方值越来越大，导致学习率逐渐接近零，模型会停止学习。
不适合非稀疏数据：在非稀疏数据的情况下，学习率过快衰减可能导致优化过程早期停滞。

AdaGrad是一种有效的自适应学习率算法，然而由于学习率衰减问题，我们会使用改 RMSProp 或 Adam 来替代。

api

optimizer = optim.Adagrad(model.parameters(), lr=0.9) # 设置学习率

RMSProp

RMSProp（Root Mean Square Propagation）在时间步中，不是简单地累积所有梯度平方和，而是使用指数加权平均来逐步衰减过时的梯度信息。这种方法专门用于解决AdaGrad在训练过程中学习率过度衰减的问题。

使用指数移动平均累积历史梯度：

学习率和参数更新公式和AdaGrad没有变化。

优点

适应性强：RMSProp自适应调整每个参数的学习率，对于梯度变化较大的情况非常有效，使得优化过程更加平稳。
适合非稀疏数据：相比于AdaGrad，RMSProp更加适合处理非稀疏数据，因为它不会让学习率减小到几乎为零。
解决过度衰减问题：通过引入指数加权平均，RMSProp避免了AdaGrad中学习率过快衰减的问题，保持了学习率的稳定性

缺点

依赖于超参数的选择：RMSProp的效果对衰减率 $\beta$ 和学习率 $\alpha$ 的选择比较敏感，需要一些调参工作。

需要注意的是：AdaGrad 和 RMSProp 都是对于不同的参数分量使用不同的学习率，如果某个参数分量的梯度值较大，则对应的学习率就会较小，如果某个参数分量的梯度较小，则对应的学习率就会较大一些。

api

optimizer = optim.RMSprop(model.parameters(), lr=0.7, momentum=0.9) # 设置学习率和动量

Adam(常用)

Adam（Adaptive Moment Estimation）算法将动量法和RMSProp的优点结合在一起：

Momentum 使用指数加权平均计算当前的梯度值、AdaGrad、RMSProp 使用自适应的学习率，Adam 结合了 Momentum、RMSProp 的优点，使用：移动加权平均的梯度和移动加权平均的学习率。使得能够自适应学习率的同时，也能够使用 Momentum 的优点。

优点

高效稳健：Adam结合了动量法和RMSProp的优势，在处理非静态、稀疏梯度和噪声数据时表现出色，能够快速稳定地收敛。
自适应学习率：Adam通过一阶和二阶动量的估计，自适应调整每个参数的学习率，避免了全局学习率设定不合适的问题。
适用大多数问题：Adam几乎可以在不调整超参数的情况下应用于各种深度学习模型，表现良好。

缺点

超参数敏感：尽管Adam通常能很好地工作，但它对初始超参数（如 $\beta_1$ 、 $\beta_2$ 和 $\eta$ ）仍然较为敏感，有时需要仔细调参。
过拟合风险：由于Adam会在初始阶段快速收敛，可能导致模型陷入局部最优甚至过拟合。因此，有时会结合其他优化算法（如SGD）使用。

api

optimizer = optim.Adam(model.parameters(), lr=0.05) # 设置学习率

总结

在实际应用中，根据数据的规模和计算资源的情况，选择合适的梯度下降方式（批量、随机、小批量）及其变种（如动量法、Adam等）可以显著提高模型训练的效率和效果。

Adam是目前最为流行的优化算法之一，因其稳定性和高效性，广泛应用于各种深度学习模型的训练中。Adam结合了动量法和RMSProp的优点，能够在不同情况下自适应调整学习率，并提供快速且稳定的收敛表现。

二、过拟合和欠拟合

在训练深层神经网络时，由于模型参数较多，在数据量不足时很容易过拟合。而正则化技术主要就是用于防止过拟合，提升模型的泛化能力(对新数据表现良好)和鲁棒性（对异常数据表现良好）。

1、概念

1.过拟合

过拟合是指模型对训练数据拟合能力很强并表现很好，但在测试数据上表现较差。

过拟合常见原因有：

数据量不足：当训练数据较少时，模型可能会过度学习数据中的噪声和细节。
模型太复杂：如果模型很复杂，也会过度学习训练数据中的细节和噪声。
正则化强度不足：如果正则化强度不足，可能会导致模型过度学习训练数据中的细节和噪声。

2.欠拟合

欠拟合是由于模型学习能力不足，无法充分捕捉数据中的复杂关系。

3.判断

过拟合

训练误差低，但验证时误差高。模型在训练数据上表现很好，但在验证数据上表现不佳，说明模型可能过度拟合了训练数据中的噪声或特定模式。

欠拟合

训练误差和测试误差都高。模型在训练数据和测试数据上的表现都不好，说明模型可能太简单，无法捕捉到数据中的复杂模式。

2、解决欠拟合

增加模型复杂度：引入更多的参数、增加神经网络的层数或节点数量，使模型能够捕捉到数据中的复杂模式。
增加特征：通过特征工程添加更多有意义的特征，使模型能够更好地理解数据。
减少正则化强度：适当减小 L1、L2 正则化强度，允许模型有更多自由度来拟合数据。
训练更长时间：如果是因为训练不足导致的欠拟合，可以增加训练的轮数或时间.

3、解决过拟合

1.L2正则化

L2 正则化通过在损失函数中添加权重参数的平方和来实现，目标是惩罚过大的参数值：

$L_{\text{total}}(\theta) = L(\theta) + \lambda \cdot \frac{1}{2} \sum_{i} \theta_i^2$

其中 $\frac{1}{2} \sum_{i} \theta_i^2$ 是所有权重参数的平方和，称为 L2 正则化项； $\theta_i$ 是模型的第 i 个权重参数。

L2 正则化会惩罚权重参数过大的情况，通过参数平方值对损失函数进行约束。

梯度更新

$\theta_{t+1} = \theta_t - \eta \left( \nabla L(\theta_t) + \lambda \theta_t \right)$

参数越大惩罚力度就越大，从而让参数逐渐趋向于较小值，避免出现过大的参数。

作用

防止过拟合：当模型过于复杂、参数较多时，模型会倾向于记住训练数据中的噪声，导致过拟合。L2 正则化通过抑制参数的过大值，使得模型更加平滑，降低模型对训练数据噪声的敏感性。
限制模型复杂度：L2 正则化项强制权重参数尽量接近 0，避免模型中某些参数过大，从而限制模型的复杂度。通过引入平方和项，L2 正则化鼓励模型的权重均匀分布，避免单个权重的值过大。
提高模型的泛化能力：正则化项的存在使得模型在测试集上的表现更加稳健，避免在训练集上取得极高精度但在测试集上表现不佳。
平滑权重分布：L2 正则化不会将权重直接变为 0，而是将权重值缩小。这样模型就更加平滑的拟合数据，同时保留足够的表达能力。

import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001)  # L2 正则化,weight_decay就是L2正则化前面的参数λ

2.L1正则化

L1 正则化通过在损失函数中添加权重参数的绝对值之和来约束模型的复杂度：

$L_{\text{total}}(\theta) = L(\theta) + \lambda \sum_{i} |\theta_i|$

其中 $\sum_{i} |\theta_i|$ 是所有权重参数的绝对值之和，这个项即为 L1 正则化项。

梯度更新

$\theta_{t+1} = \theta_t - \eta \left( \nabla L(\theta_t) + \lambda \cdot \text{sign}(\theta_t) \right)$

其中sign()是符号函数， $\theta_t$ 为正时取1，为负时取值为-1，等于0时为0。

因为 L1 正则化依赖于参数的绝对值，其梯度更新时不是简单的线性缩小，而是通过符号函数来直接调整参数的方向。这就是为什么 L1 正则化能促使某些参数完全变为 0。

作用

稀疏性：L1 正则化的一个显著特性是它会促使许多权重参数变为零。这是因为 L1 正则化倾向于将权重绝对值缩小到零，使得模型只保留对结果最重要的特征，而将其他不相关的特征权重设为零，从而实现 特征选择 的功能。
防止过拟合：通过限制权重的绝对值，L1 正则化减少了模型的复杂度，使其不容易过拟合训练数据。相比于 L2 正则化，L1 正则化更倾向于将某些权重完全移除，而不是减小它们的值。
简化模型：由于 L1 正则化会将一些权重变为零，因此模型最终会变得更加简单，仅依赖于少数重要特征。这对于高维度数据特别有用，尤其是在特征数量远多于样本数量的情况下。
特征选择：因为 L1 正则化会将部分权重置零，因此它天然具有特征选择的能力，有助于自动筛选出对模型预测最重要的特征。

和L2的对比

L1 正则化 更适合用于产生稀疏模型，会让部分权重完全为零，适合做特征选择。
L2 正则化 更适合平滑模型的参数，避免过大参数，但不会使权重变为零，适合处理高维特征较为密集的场景。

对于 L1 正则化，PyTorch 的优化器并不直接支持，需要手动将 L1 惩罚项添加到损失函数中。

import torch
import torch.nn as nn
import torch.optim as optim


def train():
    """
    L1 正则化通过在损失函数中添加权重参数的绝对值之和来约束模型的复杂度。
    需手动添加
    """
    # 数据集
    inputs = torch.tensor([[0.5,1.0,1.5],
                           [0.5,3.1,1.8]])
    target = torch.tensor([[0.5],[1.5]])
    # 定义网络结构
    model = nn.Linear(3,1)
    # 优化器
    optimizer = optim.SGD(model.parameters(),lr=0.1)
    # 定义损失函数
    loss_fn = torch.nn.MSELoss()
    # 预测
    y_pred = model(inputs)
    # 计算损失：L1 正则化 加其加入到总损失中
    l1_lambda = 0.001
    l1_norm = sum(p.abs().sum() for p in model.parameters())
    loss = loss_fn(y_pred, target)+l1_lambda*l1_norm
    # 梯度清零
    if model.weight.grad is not None:
        model.weight.grad.zero_()
    # 反向传播
    loss.backward()
    # 参数更新
    optimizer.step()
    print(loss)

3.Dropout

Dropout 是一种在训练过程中随机丢弃部分神经元的技术。它通过减少神经元之间的依赖来防止模型过于复杂，从而避免过拟合。

Dropout过程：

按照指定的概率把部分神经元的值设置为0；
为了规避该操作带来的影响，需对非 0 的元素使用缩放因子1/(1-p)进行强化。

import torch
import torch.nn as nn


def test01():
    """
    Dropout 是一种在训练过程中随机丢弃部分神经元的技术,
    通过减少神经元之间的依赖来防止模型过于复杂，从而避免过拟合。
    """
    x = torch.tensor([[1,2,3,1,3,4,5,3,5,6]],dtype = torch.float32)
    # 按照指定的概率把部分神经元的值设置为0
    drop = nn.Dropout(0.6)
    print(x.shape)
    x = drop(x)
    print(x)
    print(x.shape)
    print(sum(sum(x!=0))/x.shape[1])


def test02():
    torch.manual_seed(666)
    x = torch.randint(0, 8, (3, 12)).float()
    w = torch.randn(12, 1, requires_grad=True)

    drop = nn.Dropout(0.5)
    # 随机抛点
    x = drop(x)

    output = x@w
    print(output)

    loss = output.sum()
    loss.backward()
    print(w.grad.flatten())



if __name__ == '__main__':
    # test01()
    test02()