11.28深度学习_bp算法

七、BP算法

多层神经网络的学习能力比单层网络强得多。想要训练多层网络，需要更强大的学习算法。误差反向传播算法（Back Propagation）是其中最杰出的代表，它是目前最成功的神经网络学习算法。现实任务使用神经网络时，大多是在使用 BP 算法进行训练，值得指出的是 BP 算法不仅可用于多层前馈神经网络，还可以用于其他类型的神经网络。通常说 BP 网络时，一般是指用 BP 算法训练的多层前馈神经网络。

误差反向传播算法(BP)的基本步骤:

1. 前向传播：正向计算得到预测值。
2. 计算损失：通过损失函数$$L(y_{\text{pred}},y_{\text{true}})$$ 计算预测值和真实值的差距。
3. 梯度计算：反向传播的核心是计算损失函数 $$L$$ 对每个权重和偏置的梯度。
4. 更新参数：一旦得到每层梯度，就可以使用梯度下降算法来更新每层的权重和偏置，使得损失逐渐减小。
5. 迭代训练：将前向传播、梯度计算、参数更新的步骤重复多次，直到损失函数收敛或达到预定的停止条件。

1. 前向传播

前向传播（Forward Propagation）把输入数据经过各层神经元的运算并逐层向前传输，一直到输出层为止。

下面是一个简单的三层神经网络（输入层、隐藏层、输出层）前向传播的基本步骤分析。

1.1输入层到隐藏层

给定输入 $$x$$ 和权重矩阵 $$W_1$$ 及偏置向量 $$b_1$$，隐藏层的输出（激活值）计算如下：
$$z^{(1)}=W_1\cdot x+b_1$$
将$$z^{(1)}$$ 通过激活函数 $$\sigma$$进行激活：
$$a^{(1)}=\sigma (z^{(1)})$$

1.2隐藏层到输出层

隐藏层的输出 $$a^{(1)}$$ 通过输出层的权重矩阵 $$W_2$$和偏置 $$b_2$$ 生成最终的输出：
$$z^{(2)}=W_2\cdot a^{(1)}+b_2$$
输出层的激活值 $$a^{(2)}$$ 是最终的预测结果：
$$y_{\text{pred}}=a^{(2)}=\sigma (z^{(2)})$$

前向传播的主要作用是：

1. 计算神经网络的输出结果，用于预测或计算损失。
2. 在反向传播中使用，通过计算损失函数相对于每个参数的梯度来优化网络。

2. 反向传播

反向传播（Back Propagation，简称BP）通过计算损失函数相对于每个参数的梯度来调整权重，使模型在训练数据上的表现逐渐优化。反向传播结合了链式求导法则和梯度下降算法，是神经网络模型训练过程中更新参数的关键步骤。

2.1 原理

利用链式求导法则对每一层进行求导,直到求出输入层x的导数,然后利用导数值进行梯度更新

2.2. 链式法则

链式求导法则（Chain Rule）是微积分中的一个重要法则，用于求复合函数的导数。在深度学习中，链式法则是反向传播算法的基础，这样就可以通过分层的计算求得损失函数相对于每个参数的梯度。以下面的复合函数为例：
$$\mathrm{f}(\mathrm{x})=\frac{1}{1+{\mathrm{e}}^{-(\mathrm{wx}+\mathrm{b})}}$$
其中 $$x$$ 是输入数据，$$w$$ 是权重，$$b$$ 是偏置。

2.2.1 函数分解

可以将该复合函数分解为：

2.2.2 链式求导

复合函数数学过程如下：
$$\begin{gathered} \frac{\partial f(x;w,b)}{\partial w}=\frac{\partial f(x;w,b)}{\partial h_6}\frac{\partial h_6}{\partial h_5}\frac{\partial h_5}{\partial h_4}\frac{\partial h_4}{\partial h_3}\frac{\partial h_3}{\partial h_2}\frac{\partial h_2}{\partial h_1}\frac{\partial h_1}{\partial w} \\ \frac{\partial f(x;w,b)}{\partial b}=\frac{\partial f(x;w,b)}{\partial h_6}\frac{\partial h_6}{\partial h_5}\frac{\partial h_5}{\partial h_4}\frac{\partial h_4}{\partial h_3}\frac{\partial h_3}{\partial h_2}\frac{\partial h_2}{\partial b} \end{gathered}$$
可以得到：
$$\begin{array}{rl}\frac{\partial f(x;w,b)}{\partial w}{|}_{x=1,w=0,b=0}& =\frac{\partial f(x;w,b)}{\partial h_6}\frac{\partial h_6}{\partial h_5}\frac{\partial h_5}{\partial h_4}\frac{\partial h_4}{\partial h_3}\frac{\partial h_3}{\partial h_2}\frac{\partial h_2}{\partial h_1}\frac{\partial h_1}{\partial w}\\ & =1\times -0.25\times 1\times 1\times -1\times 1\times 1\\ & =\mathrm{0.25.}\end{array}$$

2.2.3 代码实现

我们通过代码来实现以上过程：

import torch
import torch.nn as nn


def test006():
    x = torch.tensor(1.0)
    w = torch.tensor(0.0, requires_grad=True)
    b = torch.tensor(0.0, requires_grad=True)
    # 计算函数
    y = (torch.exp(-(w * x + b)) + 1) ** -1

    # 自动微分
    y.backward()
    # 梯度打印
    print(w.grad)


if __name__ == "__main__":
    test006()

打印结果：

tensor(0.2500)

2.4 重要性

反向传播算法极大地提高了多层神经网络训练的效率，使得训练深度模型成为可能。通过链式法则逐层计算梯度，反向传播可以有效地处理复杂的网络结构，确保每一层的参数都能得到合理的调整。

2.5 案例助解

这里我们通过一个实际的案例，去理解反向传播整个过程~

2.5.1 数据准备

整体网络结构及神经元数据和权重参数如下图所示：

数据解释如下：

• $$i_1=0.05，i_2=0.10$$ 代表输入层输入数据的2个特征；
• $$w_1=0.15，w_2=0.20$$代表的是输入数据映射到$$h_1$$的权重参数；
• $$w_3=0.25，w_4=0.30$$代表的是输入数据映射到$$h_2$$的权重参数；
• $$b1=0.35，b2=0.60$$分别代表输入层到隐藏层、隐藏层到输出层的偏执；
• $$w_5=0.40，w_6=0.45$$代表的是隐藏层的神经元映射到$$o_1$$的权重参数；
• $$w_7=0.50，w_8=0.55$$代表的是隐藏层的神经元映射到$$o_2$$的权重参数；
• $$o_1$$下面标注的$$0.01$$表示target为$$0.01$$，$$o_2$$下面标注的$$0.99$$表示target为$$0.99$$；

2.5.2 神经元计算

所以，我们可以得到如下数据：

计算h1的相关数据：
$$\begin{gathered} {\mathrm{h}}_1={\mathrm{w}}_1\ast {\mathrm{i}}_1+{\mathrm{w}}_2\ast {\mathrm{i}}_2+{\mathrm{b}}_1=0.15\ast 0.05+0.20\ast 0.10+0.35=0.3775 \\ {k}_1=sigmoid(h1)=sigmoid(0.3775)=0.5933 \end{gathered}$$
计算h2的相关数据：
$$\begin{gathered} {\mathrm{h}}_2={\mathrm{w}}_3\ast {\mathrm{i}}_1+{\mathrm{w}}_4\ast {\mathrm{i}}_2+{\mathrm{b}}_1=0.25\ast 0.05+0.30\ast 0.10+0.35=0.3925 \\ {k}_2=sigmoid(h2)=sigmoid(0.3925)=0.5969 \end{gathered}$$
计算o1的相关数据：
$$\begin{gathered} {\mathrm{o}}_1={\mathrm{w}}_5\ast {\mathrm{k}}_1+{\mathrm{w}}_6\ast {\mathrm{k}}_2+{\mathrm{b}}_2=0.40\ast 0.5933+0.45\ast 0.5969+0.60=1.1059 \\ {m}_1=sigmoid(o1)=sigmoid(1.1059)=0.7514 \end{gathered}$$
计算o2的相关数据：
$$\begin{gathered} {\mathrm{o}}_2={\mathrm{w}}_7\ast {\mathrm{k}}_1+{\mathrm{w}}_8\ast {\mathrm{k}}_2+{\mathrm{b}}_2=0.50\ast 0.5933+0.55\ast 0.5969+0.60=1.2249 \\ {m}_2=sigmoid(o2)=sigmoid(1.2249)=0.7729 \end{gathered}$$
所以，最终的预测结果分别为: 0.7514、0.7729

2.5.3 损失计算

预测值和真实值(target)进行比较计算损失：
$$\begin{gathered} MSELoss=\frac{1}{2}(({\mathrm{m}}_1{-\mathrm{target}}_1{)}^2+(({\mathrm{m}}_2{-\mathrm{target}}_2{)}^2) \\ =\frac{1}{2}((0.7514-0.01{)}^2+((0.7729-0.99{)}^2)=0.2984 \end{gathered}$$
得到损失是：0.2984

2.5.4 梯度计算

接下来，我们进行梯度计算和参数更新

计算 w5 权重的梯度
$$\begin{array}{rl}\frac{\partial \mathrm{L}}{\partial {\mathrm{w}}_5}& =\frac{\partial \mathrm{L}}{\partial {o1}_1}\ast \frac{\partial {\mathrm{m}}_1}{\partial {\mathrm{o}}_1}\ast \frac{\partial {\mathrm{o}}_1}{\partial {\mathrm{w}}_5}\\ & =({\mathrm{m}}_1-{\mathrm{target}}_1)\ast \mathrm{sigmoid}({\mathrm{o}}_1)\ast \left(1-\mathrm{sigmoid}({\mathrm{o}}_1)\right)\ast {\mathrm{k}}_1\\ & =(0.7514-0.01)\ast sigmoid(1.1059)\ast \left(1-sigmoid(1.1059)\right)\ast 0.5933\\ & =0.0822\end{array}$$
计算 w7 权重的梯度
$$\begin{array}{rl}\frac{\partial \mathrm{L}}{\partial {\mathrm{w}}_7}& =\frac{\partial \mathrm{L}}{\partial {\mathrm{m}}_2}\ast \frac{\partial {\mathrm{m}}_2}{\partial {\mathrm{o}}_2}\ast \frac{\partial {\mathrm{o}}_2}{\partial {\mathrm{w}}_7}\\ & =({\mathrm{m}}_2-{\mathrm{target}}_2)\ast \mathrm{sigmoid}({\mathrm{o}}_2)\ast \left(1-\mathrm{sigmoid}({\mathrm{o}}_2)\right)\ast {\mathrm{k}}_1\\ & =(0.7729-0.99)\ast sigmoid(1.2249)\ast \left(1-sigmoid(1.2249)\right)\ast 0.5933\\ & =-0.0226\end{array}$$
计算 w1 权重的梯度

2.5.5 参数更新

现在就可以进行权重更新了：假设学习率是0.5
$$\begin{gathered} w_5=0.40-0.5\ast 0.0822=0.3589 \\ {w}_7=0.50+0.5\ast 0.0226=0.5113 \\ {w}_1=0.15-0.5\ast 0.0004=0.1498 \end{gathered}$$

2.5.6 代码实现

参考代码如下：

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


class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.linear1 = nn.Linear(2, 2)
        self.linear2 = nn.Linear(2, 2)

        # 网络参数初始化
        self.linear1.weight.data = torch.tensor([[0.15, 0.20], [0.25, 0.30]])
        self.linear2.weight.data = torch.tensor([[0.40, 0.45], [0.50, 0.55]])
        self.linear1.bias.data = torch.tensor([0.35, 0.35])
        self.linear2.bias.data = torch.tensor([0.60, 0.60])

    def forward(self, x):

        x = self.linear1(x)
        x = torch.sigmoid(x)
        x = self.linear2(x)
        x = torch.sigmoid(x)

        return x


if __name__ == "__main__":

    inputs = torch.tensor([[0.05, 0.10]])
    target = torch.tensor([[0.01, 0.99]])

    # 获得网络输出值
    net = Net()
    output = net(inputs)

    # 计算误差
    loss = torch.sum((output - target) ** 2) / 2

    # 优化方法
    optimizer = optim.SGD(net.parameters(), lr=0.5)

    # 梯度清零
    optimizer.zero_grad()

    # 反向传播
    loss.backward()

    # 打印(w1-w8)观察w5、w7、w1 的梯度值是否与手动计算一致
    print(net.linear1.weight.grad.data)
    print(net.linear2.weight.grad.data)

    #更新梯度
    optimizer.step()
   
    # 打印更新后的网络参数
    print(net.state_dict())

打印结果：

tensor([[0.0004, 0.0009],
        [0.0005, 0.0010]])
tensor([[ 0.0822,  0.0827],
        [-0.0226, -0.0227]])
OrderedDict([('linear1.weight', tensor([[0.1498, 0.1996],
        [0.2498, 0.2995]])), ('linear1.bias', tensor([0.3456, 0.3450])), ('linear2.weight', tensor([[0.3589, 0.4087],
        [0.5113, 0.5614]])), ('linear2.bias', tensor([0.5308, 0.6190]))])

另一种写法(常用)

import torch
import torch.nn as nn
import torch.optim as optim
import os
class MyModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(MyModel, self).__init__()
        # 定义网络结构
        # 输入层到隐藏层
        self.hidden=nn.Sequential(nn.Linear(input_size, 2),nn.Sigmoid())
        # 初始化隐藏层权重和偏置(默认自动,这里手动是为了测试案例中运算的数字)
        self.hidden[0].weight.data = torch.tensor([[0.15, 0.20], [0.25, 0.30]])
        self.hidden[0].bias.data = torch.tensor([0.35, 0.35])
        # 隐藏层到输出层
        self.out = nn.Sequential(nn.Linear(2, output_size),nn.Sigmoid())
        self.out[0].weight.data = torch.tensor([[0.40, 0.45], [0.50, 0.55]])
        self.out[0].bias.data = torch.tensor([0.60, 0.60])
    def forward(self, x):
        x = self.hidden(x)
        output = self.out(x)
        return output
def train(epochs=10):
    # 模型
    model = MyModel(input_size=2, output_size=2)
    # 优化器
    optimizer = optim.SGD(model.parameters(), lr=0.5)
    #损失函数
    criterion = nn.MSELoss()

    # 输入数据
    input = torch.tensor([[0.05, 0.10]])
    target = torch.tensor([[0.01, 0.99]])

    #前向传播
    output = model(input)

    #计算损失
    loss = criterion(output, target)

    # 梯度清零
    optimizer.zero_grad()

    # 反向传播
    loss.backward()

    # 更新权重参数：让损失尽可能小
    optimizer.step()

    #更新后的模型参数
    state_dict=model.state_dict()
    print("更新后的模型参数：",state_dict)

    #保存模型参数
    filepath = os.path.relpath(os.path.join(os.path.dirname(__file__),"weights/model.pth"))
    
    
def detect():
    # 加载模型参数
    filepath = os.path.relpath(os.path.join(os.path.dirname(__file__),"weights/model.pth"))
    model = MyModel(input_size=2, output_size=2)
    model.load_state_dict(torch.load(filepath))
    input = torch.tensor([[0.05, 0.10]])
    output = model(input)
    print("预测推理",output)
    
    
if __name__=="__main__":
    train()
    detect()

3. BP之梯度下降

梯度下降算法的目标是找到使损失函数 $$L(\theta )$$ 最小的参数 $$\theta$$，其核心是沿着损失函数梯度的负方向更新参数，以逐步逼近局部或全局最优解，从而使模型更好地拟合训练数据。

3.1 数学描述

简单回顾下数学知识。

3.1.1 数学公式

$$w_{ij}^{new}=w_{ij}^{old}-\alpha \frac{\partial E}{\partial w_{ij}}$$

其中，$$\alpha$$是学习率：

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

3.1.2 过程阐述

1. 初始化参数：随机初始化模型的参数 $$\theta$$，如权重 $$W$$和偏置 $$b$$。

2. 计算梯度：损失函数 $$L(\theta )$$对参数 $$\theta$$ 的梯度 $${\nabla }_{\theta }L(\theta )$$，表示损失函数在参数空间的变化率。

3. 更新参数：按照梯度下降公式更新参数：$$\theta :=\theta -\alpha {\nabla }_{\theta }L(\theta )$$，其中，$$\alpha$$ 是学习率，用于控制更新步长。

4. 迭代更新：重复【计算梯度和更新参数】步骤，直到某个终止条件（如梯度接近0、不再收敛、完成迭代次数等）。

3.2 传统下降方式

根据计算梯度时数据量不同，常见的方式有：

3. 2.1 批量梯度下降

Batch Gradient Descent BGD

• 特点：

  • 每次更新参数时，使用整个训练集来计算梯度。

• 优点：

  • 收敛稳定，能准确地沿着损失函数的真实梯度方向下降。
  • 适用于小型数据集。

• 缺点：

  • 对于大型数据集，计算量巨大，更新速度慢。
  • 需要大量内存来存储整个数据集。

• 公式：
  $$\theta :=\theta -\alpha \frac{1}{m}\sum _{i=1}^m{\nabla }_{\theta }L(\theta ;x^{(i)},y^{(i)})$$
  其中，$$m$$ 是训练集样本总数，$$x^{(i)},y^{(i)}$$是第 $$i$$ 个样本及其标签。

3.2.2 随机梯度下降

Stochastic Gradient Descent, SGD

• 特点：

  • 每次更新参数时，仅使用一个样本来计算梯度。

• 优点：

  • 更新频率高，计算快，适合大规模数据集。
  • 能够跳出局部最小值，有助于找到全局最优解。

• 缺点：

  • 收敛不稳定，容易震荡，因为每个样本的梯度可能都不完全代表整体方向。
  • 需要较小的学习率来缓解震荡。

• 公式：
  $$\theta :=\theta -\alpha {\nabla }_{\theta }L(\theta ;x^{(i)},y^{(i)})$$

  其中，$$x^{(i)},y^{(i)}$$ 是当前随机抽取的样本及其标签。

  ​

3.2.3 小批量梯度下降

Mini-batch Gradient Descent MGBD

• 特点：

  • 每次更新参数时，使用一小部分训练集（小批量）来计算梯度。

• 优点：

  • 在计算效率和收敛稳定性之间取得平衡。
  • 能够利用向量化加速计算，适合现代硬件（如GPU）。

• 缺点：

  • 选择适当的批量大小比较困难；批量太小则接近SGD，批量太大则接近批量梯度下降。
  • 通常会根据硬件算力设置为32\64\128\256等2的次方。

• 公式：
  $$\theta :=\theta -\alpha \frac{1}{b}\sum _{i=1}^b{\nabla }_{\theta }L(\theta ;x^{(i)},y^{(i)})$$
  其中，$$b$$ 是小批量的样本数量，也就是 $$batch\_size$$。

3.3 存在的问题

• 收敛速度慢：BGD和MBGD使用固定学习率，太大会导致震荡，太小又收敛缓慢。

• 局部最小值和鞍点问题：SGD在遇到局部最小值或鞍点时容易停滞，导致模型难以达到全局最优。

• 训练不稳定：SGD中的噪声容易导致训练过程中不稳定，使得训练陷入震荡或不收敛。

3.4 优化梯度下降方式

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

碰到平缓区域，梯度值较小，参数优化变慢 碰到 “鞍点” ，梯度为 0，参数无法优化 碰到局部最小值 对于这些问题, 出现了一些对梯度下

降算法的优化方法,例如：Momentum、AdaGrad、RMSprop、Adam 等.

3.4.1 指数加权平均

我们最常见的算数平均指的是将所有数加起来除以数的个数，每个数的权重是相同的。

加权平均指的是给每个数赋予不同的权重求得平均数。

移动平均数，指的是计算最近邻的 N 个数来获得平均数。

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

比如：明天气温怎么样，和昨天气温有很大关系，而和一个月前的气温关系就小一些。

计算公式可以用下面的式子来表示：

​

其中：

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

代码演示：

import torch
import matplotlib.pyplot as plt


ELEMENT_NUMBER = 30


# 1. 实际平均温度
def test01():

    # 固定随机数种子
    torch.manual_seed(0)

    # 产生30天的随机温度
    temperature = torch.randn(size=[ELEMENT_NUMBER,]) * 10
    print(temperature)

    # 绘制平均温度
    days = torch.arange(1, ELEMENT_NUMBER + 1, 1)
    plt.plot(days, temperature, color='r')
    plt.scatter(days, temperature)
    plt.show()


# 2. 指数加权平均温度
def test02(beta=0.9):

    # 固定随机数种子
    torch.manual_seed(0)

    # 产生30天的随机温度
    temperature = torch.randn(size=[ELEMENT_NUMBER,]) * 10
    print(temperature)

    exp_weight_avg = []
    for idx, temp in enumerate(temperature):

        # 第一个元素的的 EWA 值等于自身
        if idx == 0:
            exp_weight_avg.append(temp)
            continue

        # 第二个元素的 EWA 值等于上一个 EWA 乘以 β + 当前气温乘以 (1-β)
        new_temp = exp_weight_avg[-1] * beta + (1 - beta) * temp
        exp_weight_avg.append(new_temp)


    days = torch.arange(1, ELEMENT_NUMBER + 1, 1)
    plt.plot(days, exp_weight_avg, color='r')
    plt.scatter(days, temperature)
    plt.show()


if __name__ == '__main__':

    test01()
    test02(0.5)
    test02(0.9)

执行效果：

3.4.2 Momentum

a.特点

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

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

b.梯度计算公式

梯度计算公式：Dt = β * St-1 + (1- β) * Dt

1. St-1 表示历史梯度移动加权平均值
2. wt 表示当前时刻的梯度值
3. β 为权重系数

举个例子，假设：权重 β 为 0.9，例如：

第一次梯度值：s1 = d1 = w1 

第二次梯度值：s2 = 0.9 + s1 + d2 * 0.1 

第三次梯度值：s3 = 0.9 * s2 + d3 * 0.1 

第四次梯度值：s4 = 0.9 * s3 + d4 * 0.1

- w 表示初始梯度
- d 表示当前轮数计算出的梯度值
- s 表示历史梯度值

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

公式修改为：$$W_{t+1}=W_t-\alpha \ast D_t$$

c.原理

那么，Monmentum 优化方法是如何一定程度上克服 “平缓”、”鞍点”、”峡谷” 的问题呢？

当处于鞍点位置时，由于当前的梯度为 0，参数无法更新。但是 Momentum 动量梯度下降算法已经在先前积累了一些梯度值，很有可能使得跨过鞍点。

由于 mini-batch 普通的梯度下降算法，每次选取少数的样本梯度确定前进方向，可能会出现震荡，使得训练时间变长。Momentum 使用移动加权平均，平滑了梯度的变化，使得前进方向更加平缓，有利于加快训练过程。一定程度上有利于降低 “峡谷” 问题的影响。

峡谷问题：就是会使得参数更新出现剧烈震荡.

Momentum 算法可以理解为是对梯度值的一种调整，我们知道梯度下降算法中还有一个很重要的学习率，Momentum 并没有学习率进行优化。

d.API

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

e.总结：

• 动量项更新：利用当前梯度和历史动量来计算新的动量项。
• 权重参数更新：利用更新后的动量项来调整权重参数。
• 梯度计算：在每个时间步计算当前的梯度，用于更新动量项和权重参数。

Momentum 算法是对梯度值的平滑调整，但是并没有对梯度下降中的学习率进行优化。

3.4.3 AdaGrad

​ AdaGrad（Adaptive Gradient Algorithm）为每个参数引入独立的学习率，它根据历史梯度的平方和来调整这些学习率，这样就使得参数具有较大的历史梯度的学习率减小，而参数具有较小的历史梯度的学习率保持较大，从而实现更有效的学习。AdaGrad避免了统一学习率的不足，更多用于处理稀疏数据和梯度变化较大的问题。

AdaGrad流程：

1. 初始化学习率 α、初始化参数 θ、小常数 σ = 1e-6

2. 初始化梯度累积变量 s = 0

3. 从训练集中采样 m 个样本的小批量，计算梯度 g

4. 累积平方梯度 s = s + g ⊙ g，⊙ 表示各个分量相乘

5. 学习率 α 的计算公式如下：

   

6. 参数更新公式如下：

   

• 其中：

  • $$\alpha$$ 是全局的初始学习率。

  • $$\sigma$$ 是一个非常小的常数，用于避免除零操作（通常取$$10^{-8}$$）。

  • $$\frac{\alpha }{\sqrt{s}+\sigma }$$ 是自适应调整后的学习率。

优点：

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

缺点：

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

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

API

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

3.4.4 RMSProp

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

RMSProp过程

1. 初始化学习率 α、初始化参数 θ、小常数 σ = 1e-8( 用于防止除零操作（通常取 $$10^{-8}$$）)。

2. 初始化参数 θ

3. 初始化梯度累计变量 s=0

4. 从训练集中采样 m 个样本的小批量，计算梯度 g

5. 使用指数移动平均累积历史梯度，公式如下：

   

6. 学习率 α 的计算公式如下：

   

7. 参数更新公式如下：

   

优点

• 适应性强：RMSProp自适应调整每个参数的学习率，对于梯度变化较大的情况非常有效，使得优化过程更加平稳。

• 适合非稀疏数据：相比于AdaGrad，RMSProp更加适合处理非稀疏数据，因为它不会让学习率减小到几乎为零。

• 解决过度衰减问题：通过引入指数加权平均，RMSProp避免了AdaGrad中学习率过快衰减的问题，保持了学习率的稳定性

缺点

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

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

API

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

3.4.5 Adam

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

• 动量法：通过一阶动量（即梯度的指数加权平均）来加速收敛，尤其是在有噪声或梯度稀疏的情况下。
• RMSProp：通过二阶动量（即梯度平方的指数加权平均）来调整学习率，使得每个参数的学习率适应其梯度的变化。
• Momentum 使用指数加权平均计算当前的梯度值、AdaGrad、RMSProp 使用自适应的学习率，Adam 结合了 Momentum、RMSProp 的优点，使用：移动加权平均的梯度和移动加权平均的学习率。使得能够自适应学习率的同时，也能够使用 Momentum 的优点。

优点

1. 高效稳健：Adam结合了动量法和RMSProp的优势，在处理非静态、稀疏梯度和噪声数据时表现出色，能够快速稳定地收敛。

2. 自适应学习率：Adam通过一阶和二阶动量的估计，自适应调整每个参数的学习率，避免了全局学习率设定不合适的问题。

3. 适用大多数问题：Adam几乎可以在不调整超参数的情况下应用于各种深度学习模型，表现良好。

缺点

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

API

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

3.5 总结

​ 梯度下降算法通过不断更新参数来最小化损失函数，是反向传播算法中计算权重调整的基础。在实际应用中，根据数据的规模和计算资源的情况，选择合适的梯度下降方式（批量、随机、小批量）及其变种（如动量法、Adam等）可以显著提高模型训练的效率和效果。

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