深度学习从入门到精通 day_04

契合qht53_shine

已于 2025-04-21 19:56:28 修改

阅读量1k

点赞数 22

文章标签：深度学习人工智能

于 2025-04-21 19:55:46 首次发布

本文链接：https://blog.csdn.net/qq_59348412/article/details/147399747

版权

1. 参数初始化

神经网络的参数初始化是训练深度学习模型的关键步骤之一，初始化参数（通常是权重和偏置）会对模型的训练速度、收敛性以及最终的性能产生重要影响。下面是关于神经网络参数初始化的一些常见方法及其相关知识点。
官方文档参考：https://pytorch.org/docs/stable/nn.init.html

1.1 固定值初始化

固定值初始化是指在神经网络训练开始时，将所有权重或偏置初始化为一个特定的常数值。这种初始化方法虽然简单，但在实际深度学习应用中通常并不推荐。

1.1.1 全零初始化

        将神经网络中的所有权重参数初始化为0，方法：将所有权重初始化为零。
        缺点：导致对称性破坏，每个神经元在每一层中都会执行相同的计算，模型无法学习。
        应用场景：通常不用来初始化权重，但可以用来初始化偏置。
        对称性问题：

现象：同一层的所有神经元具有完全相同的初始权重和偏置。
后果：
- 在反向传播时，所有神经元会收到相同的梯度，导致权重更新完全一致。
- 无论训练多久，同一层的神经元本质上会保持相同的功能（相当于“一个神经元”的多个副本），极大降低模型的表达能力。

import torch
import torch.nn as nn

def test004():
    # 3. 全0参数初始化
    linear = nn.Linear(in_features=6, out_features=4)
    # 初始化权重参数
    nn.init.zeros_(linear.weight)
    # 打印权重参数
    print(linear.weight)


if __name__ == "__main__":
    test004()

1.1.2 全1初始化

全1初始化会导致网络中每个神经元接收到相同的输入信号，进而输出相同的值，这就无法进行学习和收敛。所以全1初始化只是一个理论上的初始化方法，但在实际神经网络的训练中并不适用。

import torch
import torch.nn as nn


def test003():
    # 3. 全1参数初始化
    linear = nn.Linear(in_features=6, out_features=4)
    # 初始化权重参数
    nn.init.ones_(linear.weight)
    # 打印权重参数
    print(linear.weight)


if __name__ == "__main__":
    test003()

1.1.3 任意常数初始化

将所有参数初始化为某个非零的常数（如 0.1，-1 等）。虽然不同于全0和全1，但这种方法依然不能避免对称性破坏的问题。

import torch
import torch.nn as nn


def test001():
    # 2. 固定值参数初始化
    linear = nn.Linear(in_features=6, out_features=4)
    # 初始化权重参数
    nn.init.constant_(linear.weight, 0.63)
    # 打印权重参数
    print(linear.weight)
    pass


def test002():
    net = nn.Linear(2, 2, bias=True)
    # 假设一个数值
    x = torch.tensor([[0.1, 0.95]])

    # 初始化权重参数
    net.weight.data = torch.tensor([
        [0.1, 0.2], 
        [0.3, 0.4]
    ])

    # 输出什么：权重参数会转置
    output = net(x)
    print(output, net.bias)
    pass


if __name__ == "__main__":
    test001()
    test002()

1.2 随机初始化

        方法：将权重初始化为随机的小值，通常从正态分布或均匀分布中采样。
        应用场景：这是最基本的初始化方法，通过随机初始化避免对称性破坏。
        代码演示：随机分布之均匀初始化。

import torch
import torch.nn as nn


def test001():
    # 1. 均匀分布随机初始化
    linear = nn.Linear(in_features=6, out_features=4)
    # 初始化权重参数
    nn.init.uniform_(linear.weight)
    # 打印权重参数
    print(linear.weight)


if __name__ == "__main__":
    test001()

代码演示：正态分布初始化

import torch
import torch.nn as nn


def test005():
    # 5. 正太分布初始化
    linear = nn.Linear(in_features=6, out_features=4)
    # 初始化权重参数
    nn.init.normal_(linear.weight, mean=0, std=1)
    # 打印权重参数
    print(linear.weight)


if __name__ == "__main__":
    test005()

1.3 Xavier 初始化

前置知识：
均匀分布：均匀分布的概率密度函数（PDF）：

算期望值（均值）：计

计算方差（二阶矩减去均值的平方）：

- 先计算 $E[X^2]$ ：

- 代入方差公式：

Xavier 初始化（由 Xavier Glorot 在 2010 年提出）是一种自适应权重初始化方法，专门为解决神经网络训练初期的梯度消失或爆炸问题而设计。Xavier 初始化也叫做Glorot初始化。Xavier 初始化的核心思想是根据输入和输出的维度来初始化权重，使得每一层的输出的方差保持一致。具体来说，权重的初始化范围取决于前一层的神经元数量（输入维度）和当前层的神经元数量（输出维度）。
方法：根据输入和输出神经元的数量来选择权重的初始值。

数学原理：

(1) 前向传播的方差一致性
假设输入 x 的均值为 0，方差为 σ_x^2，权重 W的均值为 0，方差为 σ_W^2，则输出 z=Wx的方差为：

为了使 Var(z)=Var(x)，需要：

        其中 $n_{in}$ 是输入维度（fan_in）。这里乘以 nin 的原因是，输出 z 是由 nin 个输入 x 的线性组合得到的，每个输入 x 都与一个权重 W 相乘。因此，输出 z 的方差是 nin 个独立的 Wx 项的方差之和。
        (2) 反向传播的梯度方差一致性
        在反向传播过程中，梯度 $\frac{\partial L}{\partial x}$ 是通过链式法则计算得到的，其中 L 是损失函数，x 是输入，z 是输出。梯度 $\frac{\partial L}{\partial x}$ 可以表示为：

假设 z=Wx，其中 W 是权重矩阵，那么 $\frac{\partial z}{\partial x}=W$ 。因此，梯度 $\frac{\partial L}{\partial x}$ 可以写为： $\frac{\partial L}{\partial x}=\frac{\partial L}{\partial z}W$
反向传播时梯度 $\frac{\partial L}{\partial x}$ 的方差应与 $\frac{\partial L}{\partial z}$ 相同，因此：

其中 $n_{out}$ 是输出维度（fan_out）。为了保持梯度的方差一致性，我们需要确保每个输入维度 nin 的梯度方差与输出维度 nout 的梯度方差相同。因此，我们需要将 W 的方差乘以 nout，以确保梯度的方差在反向传播过程中保持一致。

(3) 综合考虑
为了同时平衡前向传播和反向传播，Xavier 采用：

权重从以下分布中采样：
均匀分布：

在Xavier初始化中，我们选择 $a=-\sqrt{\frac{6}{n_{in}+n_{out}}}$ 和 $b=\sqrt{\frac{6}{n_{in}+n_{out}}}$ ，这样方差为：

正态分布：

        其中 $n_{\text{in}}$ 是当前层的输入神经元数量， $n_{\text{out}}$ 是输出神经元数量。在前向传播中，输出的方差受 $n_{in}$ 影响。在反向传播中，梯度的方差受 $n_{out}$ 影响。
        优点：平衡了输入和输出的方差，适合Sigmoid 和 Tanh 激活函数。
        应用场景：常用于浅层网络或使用Sigmoid 、Tanh 激活函数的网络。
示例：

import torch
import torch.nn as nn


def test007():
    # Xavier初始化：正态分布
    linear = nn.Linear(in_features=6, out_features=4)
    nn.init.xavier_normal_(linear.weight)
    print(linear.weight)

    # Xavier初始化：均匀分布
    linear = nn.Linear(in_features=6, out_features=4)
    nn.init.xavier_uniform_(linear.weight)
    print(linear.weight)


if __name__ == "__main__":
    test007()

1.4 He初始化

也叫kaiming 初始化。He 初始化的核心思想是调整权重的初始化范围，使得每一层的输出的方差保持一致。与 Xavier 初始化不同，He 初始化专门针对 ReLU 激活函数的特性进行了优化。

        数学推导
        (1) 前向传播的方差一致性
        对于 ReLU 激活函数，输出的方差为：

（因为 ReLU 使一半神经元输出为 0，方差减半）为使 Var(z)=Var(x)，需：

(2) 反向传播的梯度一致性
类似地，反向传播时梯度方差需满足：

因此：

        (3) 两种模式
                fan_in 模式（默认）：优先保证前向传播稳定，方差 $\frac{2}{n_{in}}$ 。
                fan_out 模式：优先保证反向传播稳定，方差 $\frac{2}{n_{out}}$ 。
                方法：专门为 ReLU 激活函数设计。权重从以下分布中采样：

均匀分布：

正态分布：

其中 $n_{\text{in}}$ 是当前层的输入神经元数量。

优点：适用于ReLU 和 Leaky ReLU 激活函数。
应用场景：深度网络，尤其是使用 ReLU 激活函数时。
示例：

import torch
import torch.nn as nn


def test006():
    # He初始化：正态分布
    linear = nn.Linear(in_features=6, out_features=4)
    nn.init.kaiming_normal_(linear.weight, nonlinearity="relu", mode='fan_in')
    print(linear.weight)

    # He初始化：均匀分布
    linear = nn.Linear(in_features=6, out_features=4)
    nn.init.kaiming_uniform_(linear.weight, nonlinearity="relu", mode='fan_out')
    print(linear.weight)


if __name__ == "__main__":
    test006()

1.5 总结

在使用Torch构建网络模型时，每个网络层的参数都有默认的初始化方法，同时还可以通过以上方法来对网络参数进行初始化。

2. 损失函数

2.1 线性回归损失函数

2.1.1 MAE损失

MAE（Mean Absolute Error，平均绝对误差）通常也被称为 L1-Loss，通过对预测值和真实值之间的绝对差取平均值来衡量他们之间的差异。
MAE的公式如下：

其中：

n 是样本的总数。
$y_i$ 是第 i 个样本的真实值。
$\hat{y}_i$ 是第 i 个样本的预测值。
$\left| y_i - \hat{y}_i \right|$ 是真实值和预测值之间的绝对误差。

特点：

鲁棒性：与均方误差（MSE）相比，MAE对异常值（outliers）更为鲁棒，因为它不会像MSE那样对较大误差平方敏感。
物理意义直观：MAE以与原始数据相同的单位度量误差，使其易于解释。

应用场景：MAE通常用于需要对误差进行线性度量的情况，尤其是当数据中可能存在异常值时，MAE可以避免对异常值的过度惩罚。
使用`torch.nn.L1Loss`即可计算MAE：

import torch
import torch.nn as nn

# 初始化MAE损失函数
mae_loss = nn.L1Loss()

# 假设 y_true 是真实值, y_pred 是预测值
y_true = torch.tensor([3.0, 5.0, 2.5])
y_pred = torch.tensor([2.5, 5.0, 3.0])

# 计算MAE
loss = mae_loss(y_pred, y_true)
print(f'MAE Loss: {loss.item()}')

2.1.2 MSE损失

均方差损失，也叫L2Loss，MSE（Mean Squared Error，均方误差）通过对预测值和真实值之间的误差平方取平均值，来衡量预测值与真实值之间的差异。
MSE的公式如下：

其中：

n 是样本的总数。
$y_i$ 是第 i 个样本的真实值。
$\hat{y}_i$ 是第 i 个样本的预测值。
$\left( y_i - \hat{y}_i \right)^2$ 是真实值和预测值之间的误差平方。

特点：

平方惩罚：因为误差平方，MSE 对较大误差施加更大惩罚，所以 MSE 对异常值更为敏感。
凸性：MSE 是一个凸函数(国际的叫法，国内叫凹函数)，这意味着它具有一个唯一的全局最小值，有助于优化问题的求解。

应用场景：MSE被广泛应用在神经网络中，使用 torch.nn.MSELoss 可以实现：

import torch
import torch.nn as nn

# 初始化MSE损失函数
mse_loss = nn.MSELoss()

# 假设 y_true 是真实值, y_pred 是预测值
y_true = torch.tensor([3.0, 5.0, 2.5])
y_pred = torch.tensor([2.5, 5.0, 3.0])

# 计算MSE
loss = mse_loss(y_pred, y_true)
print(f'MSE Loss: {loss.item()}')

2.2 CrossEntropyLoss

2.2.1 信息量

信息量用于衡量一个事件所包含的信息的多少。信息量的定义基于事件发生的概率：事件发生的概率越低，其信息量越大。其量化公式：
对于一个事件x，其发生的概率为 P(x)，信息量I(x) 定义为：

性质：1. 非负性：I(x)≥0；2. 单调性：P(x)越小，I(x)越大。

2.2.2 信息熵

信息熵是信息量的期望值。熵越高，表示随机变量的不确定性越大；熵越低，表示随机变量的不确定性越小。
公式由数学中的期望推导而来：

其中： $-logP(x_i)$ 是信息量， $P(x_i)$ 是信息量对应的概率

2.2.3 KL散度

KL散度用于衡量两个概率分布之间的差异。它描述的是用一个分布 Q来近似另一个分布 P时，所损失的信息量。KL散度越小，表示两个分布越接近。
对于两个离散概率分布 P和 Q，KL散度定义为：

其中：P 是真实分布，Q是近似分布。

2.2.4 交叉熵

对KL散度公式展开：

由上述公式可知，P是真实分布，H(P)是常数，所以KL散度可以用H(P,Q)来表示；H(P,Q)叫做交叉熵。
如果将P换成y，Q换成 $\hat{y}$ ，则交叉熵公式为：

其中：

C 是类别的总数。
y 是真实标签的one-hot编码向量，表示真实类别。
$\hat{y}$ 是模型的输出（经过 softmax 后的概率分布）。
$y_i$ 是真实类别的第 i 个元素（0 或 1）。
$\hat{y}_i$ 是预测的类别概率分布中对应类别 i 的概率。

函数曲线图：

特点：

概率输出：CrossEntropyLoss 通常与 softmax 函数一起使用，使得模型的输出表示为一个概率分布（即所有类别的概率和为 1）。PyTorch 的 nn.CrossEntropyLoss 已经内置了 Softmax 操作。如果我们在输出层显式地添加 Softmax，会导致重复应用 Softmax，从而影响模型的训练效果。
惩罚错误分类：该损失函数在真实类别的预测概率较低时，会施加较大的惩罚，这样模型在训练时更注重提升正确类别的预测概率。
多分类问题中的标准选择：在大多数多分类问题中，CrossEntropyLoss 是首选的损失函数。

应用场景：

CrossEntropyLoss 广泛应用于各种分类任务，包括图像分类、文本分类等，尤其是在神经网络模型中。
nn.CrossEntropyLoss基本原理：由交叉熵公式可知：

因为 $y_i$ 是one-hot编码，其值不是1便是0，又是乘法，所以只要知道1对应的index就可以了，展开后：

其中，m表示真实类别。
因为神经网络最后一层分类总是接softmax，所以可以把\hat{y}_m直接看为是softmax后的结果。

所以，CrossEntropyLoss 实质上是两步的组合：Cross Entropy = Log-Softmax + NLLLoss

Log-Softmax：对输入 logits 先计算对数 softmax：log(softmax(x))。
NLLLoss（Negative Log-Likelihood）：对 log-softmax 的结果计算负对数似然损失。简单理解就是求负数。原因是概率值通常在 0 到 1 之间，取对数后会变成负数。为了使损失值为正数，需要取负数。

对于 $softmax(x_i)$ ，在softmax介绍中了解到，需要减去最大值以确保数值稳定。

则：

所以：

总的交叉熵损失函数是所有样本的平均值：

示例：

import torch
import torch.nn as nn

# 假设有三个类别，模型输出是未经softmax的logits
logits = torch.tensor([[1.5, 2.0, 0.5], [0.5, 1.0, 1.5]])

# 真实的标签
labels = torch.tensor([1, 2])  # 第一个样本的真实类别为1，第二个样本的真实类别为2

# 初始化CrossEntropyLoss
# 参数：reduction：mean-平均值，sum-总和
criterion = nn.CrossEntropyLoss()

# 计算损失
loss = criterion(logits, labels)
print(f'Cross Entropy Loss: {loss.item()}')

在这个例子中，CrossEntropyLoss 直接作用于未经 softmax 处理的 logits 输出和真实标签，PyTorch 内部会自动应用 softmax 激活函数，并计算交叉熵损失。

        `CrossEntropyLoss` 的计算过程可以分为以下几个步骤：
        (1) LogSoftmax 操作
        首先，对每个样本的 logits 应用 `LogSoftmax` 函数，将 logits 转换为概率分布。`LogSoftmax` 函数的公式是：

对于第一个样本 `[1.5, 2.0, 0.5]`，减去最大值：

计算 $e^{x_i-\max(x)}$ ：

求和并取对数：

计算log_softmax：

对于第二个样本 `[0.5, 1.0, 1.5]`，减去最大值：

计算 $e^{x_i-\max(x)}$ ：

求和并取对数：

计算log_softmax：

(2) 计算每个样本的损失

接下来，根据真实标签 z_t 计算每个样本的交叉熵损失。交叉熵损失的公式是： $L_i=-log(softmax(x_i))$

对于第一个样本：真实类别是 1，对应的 softmax 值是 -0.6041。
对于第二个样本：真实类别是 2，对应的 softmax 值是 -0.6803。

(3) 计算平均损失

最后，计算所有样本的平均损失：

2.3 BCELoss

二分类交叉熵损失函数，使用在输出层使用sigmoid激活函数进行二分类时。
由交叉熵公式：

对于二分类问题，真实标签 y的值为（0 或 1），假设模型预测为正类的概率为 $\hat{y}$ ，则：

所以：

示例：

import torch
import torch.nn as nn

# y 是模型的输出，已经被sigmoid处理过，确保其值域在(0,1)
y = torch.tensor([[0.7], [0.2], [0.9], [0.7]])
# targets 是真实的标签，0或1
t = torch.tensor([[1], [0], [1], [0]], dtype=torch.float)

# 计算损失方式一:
bceLoss = nn.BCELoss()
loss1 = bceLoss(y, t)

#计算损失方式二: 两种方式结果相同
loss2 = nn.functional.binary_cross_entropy(y, t)

print(loss1, loss2)

逐样本计算：

样本	`y_i`	`t_i`	计算项 t_i * log(y_i) + (1-t_i) * log(1-y_i)
1	0.7	1	`1log(0.7) + 0log(0.3) ≈ -0.3567`
2	0.2	0	`0log(0.2) + 1log(0.8) ≈ -0.2231`
3	0.9	1	`1log(0.9) + 0log(0.1) ≈ -0.1054`
4	0.7	0	`0log(0.7) + 1log(0.3) ≈ -1.2040`

计算最终损失：

2.4 总结

当输出层使用softmax多分类时，使用交叉熵损失函数；

当输出层使用sigmoid二分类时，使用二分类交叉熵损失函数，比如在逻辑回归中使用；

当功能为线性回归时，使用均方差损失-L2 loss；

3. 反向传播算法

反向传播（Back Propagation，简称BP）算法是用于训练神经网络的核心算法之一，它通过计算损失函数（如均方误差或交叉熵）相对于每个权重参数的梯度，来优化神经网络的权重。

3.1 前向传播

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

3.1.1 数学表达

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

（1）输入层到隐藏层
给定输入 x 和权重矩阵 W_1 及偏置向量 b_1，隐藏层的输出（激活值）计算如下：

将 $z^{(1)}$ 通过激活函数 $\sigma$ 进行激活：

（2）隐藏层到输出层

隐藏层的输出 $a^{(1)}$ 通过输出层的权重矩阵 $W_2$ 和偏置 $b_2$ 生成最终的输出：

输出层的激活值 $a^{(2)}$ 是最终的预测结果：

3.1.2 作用

前向传播的主要作用是：

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

3.2 BP基础之梯度下降算法

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

3.2.1 数学描述

（1）数学公式

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

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

（2）过程阐述

初始化参数：随机初始化模型的参数 $\theta$ ，如权重 W和偏置 b。
计算梯度：损失函数 $L(\theta)$ 对参数 $\theta$ 的梯度 $\nabla_\theta L(\theta)$ ，表示损失函数在参数空间的变化率。
更新参数：按照梯度下降公式更新参数： $\theta := \theta - \alpha \nabla_\theta L(\theta)$ ，其中， $\alpha$ 是学习率，用于控制更新步长。
迭代更新：重复【计算梯度和更新参数】步骤，直到某个终止条件（如梯度接近0、不再收敛、完成迭代次数等）。

3.2.2 传统下降方式

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

（1）批量梯度下降

Batch Gradient Descent BGD

特点：
- 每次更新参数时，使用整个训练集来计算梯度。
优点：
- 收敛稳定，能准确地沿着损失函数的真实梯度方向下降。
- 适用于小型数据集。
缺点：
- 对于大型数据集，计算量巨大，更新速度慢。
- 需要大量内存来存储整个数据集。
公式：

其中，m 是训练集样本总数， $x^{(i)}, y^{(i)}$ 是第 i 个样本及其标签， $\hat{y}^{(i)}$ 是第 i 个样本预测值。

例如，在训练集中有100个样本，迭代50轮。那么在每一轮迭代中，都会一起使用这100个样本，计算整个训练集的梯度，并对模型更新。所以总共会更新50次梯度。因为每次迭代都会使用整个训练集计算梯度，所以这种方法可以得到准确的梯度方向。但如果数据集非常大，那么就导致每次迭代都很慢，计算成本就会很高。
示例：

x = torch.randn(1000, 10)
    y = torch.randn(1000, 1)

    dataset = TensorDataset(x, y)
    dataloader = DataLoader(dataset, batch_size=len(dataset))

    model = nn.Linear(10, 1)
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)

    epochs = 100

    for epoch in range(epochs):
        for b_x, b_y in dataloader:
            optimizer.zero_grad()
            output = model(b_x)
            loss = criterion(output, b_y)
            loss.backward()
            optimizer.step()

            print('Epoch %d, Loss: %f' % (epoch, loss.item()))

（2）随机梯度下降

Stochastic Gradient Descent, SGD

特点：
- 每次更新参数时，仅使用一个样本来计算梯度。
优点：
- 更新频率高，计算快，适合大规模数据集。
- 能够跳出局部最小值，有助于找到全局最优解。
缺点：
- 收敛不稳定，容易震荡，因为每个样本的梯度可能都不完全代表整体方向。
- 需要较小的学习率来缓解震荡。
公式：

其中，m 是训练集样本总数， $x^{(i)}, y^{(i)}$ 是第 i 个样本及其标签， $\hat{y}^{(i)}$ 是第 i 个样本预测值。

x = torch.randn(1000, 10)
    y = torch.randn(1000, 1)

    dataset = TensorDataset(x, y)
    dataloader = DataLoader(dataset, batch_size=len(dataset))

    model = nn.Linear(10, 1)
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)

    epochs = 100

    for epoch in range(epochs):
        for b_x, b_y in dataloader:
            optimizer.zero_grad()
            output = model(b_x)
            loss = criterion(output, b_y)
            loss.backward()
            optimizer.step()

            print('Epoch %d, Loss: %f' % (epoch, loss.item()))

（3）小批量梯度下降

Mini-batch Gradient Descent MGBD

特点：
- 每次更新参数时，使用一小部分训练集（小批量）来计算梯度。
优点：
- 在计算效率和收敛稳定性之间取得平衡。
- 能够利用向量化加速计算，适合现代硬件（如GPU）。
缺点：
- 选择适当的批量大小比较困难；批量太小则接近SGD，批量太大则接近批量梯度下降。
- 通常会根据硬件算力设置为32\64\128\256等2的次方。
公式：

其中，b 是小批量的样本数量，也就是 $batch\_size$ 。

例如，如果训练集中有100个样本，迭代50轮。如果设置小批量的数量是20，那么在每一轮迭代中，会有5次小批量迭代。换句话说，就是将100个样本分成5个小批量，每个小批量20个数据，每次迭代用一个小批量。因此，按照这样的方式，会对梯度，进行50轮*5个小批量=250次更新。
示例：

    x = torch.randn(1000, 10)
    y = torch.randn(1000, 1)

    dataset = TensorDataset(x, y)
	# 小批量梯度下降，每批次100个样本
    dataloader = DataLoader(dataset, batch_size=100, shuffle=True)

    model = nn.Linear(10, 1)
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)

    epochs = 100

    for epoch in range(epochs):
        for b_x, b_y in dataloader:
            optimizer.zero_grad()
            output = model(b_x)
            loss = criterion(output, b_y)
            loss.backward()
            optimizer.step()

            print('Epoch %d, Loss: %f' % (epoch, loss.item()))

3.2.3 存在的问题

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

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

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

3.2.4 优化下降方式

通过对标准的梯度下降进行改进，来提高收敛速度或稳定性。

（1）指数加权平均

        我们平时说的平均指的是将所有数加起来除以数的个数，很单纯的数学。再一个是移动平均数，指的是计算最近邻的N个数来获得平均数，感觉比纯粹的直接全部求均值高级一点。
        指数加权平均：Exponential Moving Average，简称EMA，是一种平滑时间序列数据的技术，它通过对过去的值赋予不同的权重来计算平均值。与简单移动平均不同，EMA赋予最近的数据更高的权重，较远的数据则权重较低，这样可以更敏感地反映最新的变化趋势。
        比如今天股市的走势，和昨天发生的国际事件关系很大，和6个月前发生的事件关系相对肯定小一些。
        给定时间序列 $\{x_t\}$ ，EMA在每个时刻 t 的值可以通过以下递推公式计算：

当 $t=1$ 时： $v_0 = x_0$ ；
当 $t>1$ 时： $v_t = \beta v_{t-1} + (1 - \beta) x_t$

其中：

$v_t$ 是第 t 时刻的EMA值；
$x_t$ 是第 t 时刻的观测值；
$\beta$ 是平滑系数，取值范围为 $0\leq \beta < 1$ 。 $\beta$ 越接近 1，表示对历史数据依赖性越高；越接近 0 则越依赖当前数据。

公式推导：

从上述公式可知：

当 β接近 1 时，β^k衰减较慢，因此历史数据的权重较高。
当 β接近 0 时，β^k衰减较快，因此历史数据的权重较低。

示例

假设我们有一组数据 x=[1,2,3,4,5]，我们选择

（1）β=0.1和β=0.9 来计算 EMA。初始化： $EMA_0=x_0=1$

计算后续值：

最终，EMA 的值为 [1,1.9,2.89,3.889,4.8889]。

（2）β=0.9，初始化： $EMA_0=x_0=1$

计算后续值：

最终，EMA 的值为 [1,1.1,1.29,1.561,1.9049]。

可以看到：

当 β=0.9 时，历史数据的权重较高，平滑效果较强。EMA值变化缓慢（新数据仅占10%权重），滞后明显。
当 β=0.1时，近期数据的权重较高，平滑效果较弱。EMA值快速逼近最新数据（每次新数据占90%权重）。

（2）Momentum

        动量（Momentum）是对梯度下降的优化方法，可以更好地应对梯度变化和梯度消失问题，从而提高训练模型的效率和稳定性。它通过引入指数加权平均来积累历史梯度信息，从而在更新参数时形成“动量”，帮助优化算法更快地越过局部最优或鞍点。
        梯度更新算法包括两个步骤：
        a. 更新动量项：首先计算当前的动量项 $v_t: v_{t} = \beta v_{t-1} + (1 - \beta) \nabla_\theta J(\theta_t)$

其中：

$v_{t-1}$ 是之前的动量项；
$\beta$ 是动量系数（通常为 0.9）；
$\nabla_\theta J(\theta_t)$ 是当前的梯度；

b. 更新参数：利用动量项更新参数：

特点：

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

在方向上的作用：

（1）梯度方向一致时

如果梯度在多个连续时刻方向一致（例如，一直指向某个方向），Momentum 会逐渐积累动量，使更新速度加快。
例如，假设梯度在多个时刻都是正向的，动量 v_t 会逐渐增大，从而加速参数更新。

（2）梯度方向不一致时

如果梯度方向在不同时刻不一致（例如，来回震荡），Momentum 会通过积累的历史梯度信息部分抵消这些震荡。
例如，假设梯度在一个时刻是正向的，下一个时刻是负向的，动量 v_t 会平滑这些变化，使更新路径更加稳定。

（3）局部最优或鞍点附近

在局部最优或鞍点附近，梯度可能会变得很小，导致标准梯度下降法停滞。
Momentum 通过积累历史梯度信息，可以帮助参数更新越过这些平坦区域。

动量方向与梯度方向一致

（1）梯度方向一致时

如果梯度在多个连续时刻方向一致（例如，一直指向某个方向），动量会逐渐积累，动量方向与梯度方向一致。
例如，假设梯度在多个时刻都是正向的，动量 v_t 会逐渐增大，从而加速参数更新。

（2）几何意义

在优化问题中，如果损失函数的几何形状是 平滑且单调 的（例如，一个狭长的山谷），梯度方向会保持一致。
在这种情况下，动量方向与梯度方向一致，Momentum 会加速参数更新，帮助算法更快地收敛。

动量方向与梯度方向不一致

（1）梯度方向不一致时

如果梯度方向在不同时刻不一致（例如，来回震荡），动量方向可能会与当前梯度方向不一致。
例如，假设梯度在一个时刻是正向的，下一个时刻是负向的，动量 v_t 会平滑这些变化，使更新路径更加稳定。

（2）几何意义

在优化问题中，如果损失函数的几何形状是 复杂且非凸 的（例如，存在多个局部最优或鞍点），梯度方向可能会在不同时刻发生剧烈变化。
在这种情况下，动量方向与梯度方向可能不一致，Momentum 会通过积累的历史梯度信息部分抵消这些震荡，使更新路径更加平滑。

总结：

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

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

示例：

# 定义模型和损失函数
model = nn.Linear(10, 1)
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # PyTorch 中 momentum 直接作为参数

# 模拟数据
X = torch.randn(100, 10)
y = torch.randn(100, 1)

# 训练循环
for epoch in range(100):
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
    print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

（3）AdaGrad

AdaGrad（Adaptive Gradient Algorithm）为每个参数引入独立的学习率，它根据历史梯度的平方和来调整这些学习率。具体来说，对于频繁更新的参数，其学习率会逐渐减小；而对于更新频率较低的参数，学习率会相对较大。AdaGrad避免了统一学习率的不足，更多用于处理稀疏数据和梯度变化较大的问题。
AdaGrad流程：

初始化：
- 初始化参数 \theta_0 和学习率 \eta 。
- 将梯度累积平方的向量 G_0 初始化为零向量。
梯度计算：
- 在每个时间步 t，计算损失函数 $J(\theta)$ 对参数 $\theta$ 的梯度 $g_t = \nabla_\theta J(\theta_t)$ 。
累积梯度的平方：
- 对每个参数 i 累积梯度的平方：

其中 $G_{t}$ 是累积的梯度平方和， $g_{t}$ 是第 i 个参数在时间步t 的梯度。

推导： $G_{t} = G_{t-1} + g_{t}^2=G_{t-2} + g_{t-1}^2 + g_{t}^2 = ... = g_{1}^2 + ... + g_{t-1}^2 + g_{t}^2$

4. 参数更新：

利用累积的梯度平方来更新参数：

$\theta_{t} = \theta_{t-1} - \frac{\eta}{\sqrt{G_{t} + \epsilon}} g_{t}$
其中：
- $\eta$ 是全局的初始学习率。
- $\epsilon$ 是一个非常小的常数，用于避免除零操作（通常取 10^{-8}）。
- $\frac{\eta}{\sqrt{G_{t} + \epsilon}}$ 是自适应调整后的学习率。

AdaGrad 为每个参数分配不同的学习率：

对于梯度较大的参数，Gt较大，学习率较小，从而避免更新过快。
对于梯度较小的参数，Gt较小，学习率较大，从而加快更新速度。

可以将 AdaGrad 类比为：

梯度较大的参数：类似于陡峭的山坡，需要较小的步长（学习率）以避免跨度过大。
梯度较小的参数：类似于平缓的山坡，可以采取较大的步长（学习率）以加快收敛。

优点：

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

缺点：

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

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

示例：

# 定义模型和损失函数
    model = torch.nn.Linear(10, 1)
    criterion = torch.nn.MSELoss()
    optimizer = torch.optim.Adagrad(model.parameters(), lr=0.01)

    # 模拟数据
    X = torch.randn(100, 10)
    y = torch.randn(100, 1)

    # 训练循环
    for epoch in range(100):
        optimizer.zero_grad()
        outputs = model(X)
        loss = criterion(outputs, y)
        loss.backward()
        optimizer.step()
        print(f'Epoch {epoch}, Loss: {loss.item()}')

（4）RMSProp

        虽然 AdaGrad 能够自适应地调整学习率，但随着训练进行，累积梯度平方 G_t会不断增大，导致学习率逐渐减小，最终可能变得过小，导致训练停滞。
        RMSProp（Root Mean Square Propagation）是一种自适应学习率的优化算法，在时间步中，不是简单地累积所有梯度平方和，而是使用指数加权平均来逐步衰减过时的梯度信息。旨在解决 AdaGrad 学习率单调递减的问题。它通过引入 指数加权平均 来累积历史梯度的平方，从而动态调整学习率。
        公式为：

其中：

s_t是当前时刻的指数加权平均梯度平方。
β是衰减因子，通常取 0.9。
η是初始学习率。
ϵ是一个小常数（通常取 10^{−8}），用于防止除零。
$g_t$ 是当前时刻的梯度。

优点：

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

缺点：

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

示例：

    # 定义模型和损失函数
    model = nn.Linear(10, 1)
    criterion = nn.MSELoss()
    optimizer = torch.optim.RMSprop(model.parameters(), lr=0.01, alpha=0.9, eps=1e-8)

    # 模拟数据
    X = torch.randn(100, 10)
    y = torch.randn(100, 1)

    # 训练循环
    for epoch in range(100):
        optimizer.zero_grad()
        outputs = model(X)
        loss = criterion(outputs, y)
        loss.backward()
        optimizer.step()
        print(f'Epoch {epoch}, Loss: {loss.item():.4f}')

（5）Adam

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

动量法：通过一阶动量（即梯度的指数加权平均）来加速收敛，尤其是在有噪声或梯度稀疏的情况下。
RMSProp：通过二阶动量（即梯度平方的指数加权平均）来调整学习率，使得每个参数的学习率适应其梯度的变化。

Adam过程

初始化：
- 初始化参数 $\theta_0$ 和学习率 $\eta$ 。
- 初始化一阶动量估计 m_0 = 0 和二阶动量估计 v_0 = 0。
- 设定动量项的衰减率 $\beta_1$ 和二阶动量项的衰减率 $\beta_2$ ，通常 $\beta_1 = 0.9$ ， $\beta_2 = 0.999$ 。
- 设定一个小常数 $\epsilon$ （通常取 10^{-8}），用于防止除零错误。
梯度计算：
- 在每个时间步 t，计算损失函数 $J(\theta)$ 对参数 $\theta$ 的梯度 $g_t = \nabla_\theta J(\theta_t)$ 。
一阶动量估计（梯度的指数加权平均）：
- 更新一阶动量估计：
  
  其中， m_t 是当前时间步 t 的一阶动量估计，表示梯度的指数加权平均。

4. 二阶动量估计（梯度平方的指数加权平均）：

更新二阶动量估计：

其中， $v_t$ 是当前时间步 t 的二阶动量估计，表示梯度平方的指数加权平均。

5. 偏差校正：

        由于一阶动量和二阶动量在初始阶段可能会有偏差，以二阶动量为例：
        在计算指数加权移动平均时，初始化 $v_{0}=0$ ，那么 $v_{1}=0.999\cdot v_{0}+0.001\cdot g_{1}^2$ ，得到 $v_{1}=0.001\cdot g_{1}^2$ ，显然得到的 $v_{1}$ 会小很多，导致估计的不准确，以此类推：
        根据： $v_{2}=0.999\cdot v_{1}+0.001\cdot g_{2}^2$ ，把 $v_{1}$ 带入后，得到： $v_{2}=0.999\cdot 0.001\cdot g_{1}^2+0.001\cdot g_{2}^2$ ，导致 $v_{2}$ 远小于 $g_{1}$ 和 $g_{2}$ ，所以 $v_{2}$ 并不能很好的估计出前两次训练的梯度。所以这个估计是有偏差的。
        使用以下公式进行偏差校正：

其中， $\hat{m}_t$ 和 $\hat{v}_t$ 是校正后的一阶和二阶动量估计。

推导：假设梯度 ${g_t}$ 是一个平稳的随机变量，其期望为：

根据指数加权平均的递推公式，我们可以递推计算 ${m_t}$ 的期望。
当 $t=1$ ：

假设 $m_0=0$ ，所以：

取期望：

当 $t=2$ ：

代入 $m_1=(1-\beta )*g_1$ ：

取期望：

$E(m_2)=\beta *(1-\beta )*E(g_1)+(1-\beta )*E(g_2)=\beta (1-\beta )*\mu +(1-\beta )*\mu =(1-\beta ^2)*\mu$

当 $t=3$ ：

代入 $m_2=\beta (1-\beta )*g_1+(1-\beta )*g_2$ ：

展开：

取期望： $E(m_3)=\beta ^2(1-\beta )*\mu +\beta (1-\beta )*\mu +(1-\beta )*\mu =(1-\beta ^3)*\mu$

        通过递推可以发现，对于任意时刻 t， $m_t$ 的期望为：
        通过上述公式我们发现 $m_t$ 的期望与梯度期望相差了( $1-\beta ^t$ )倍，我们想要找到一个修正后的 $\hat{m_t}$ ，使： $E(\hat{m_t})=\mu$
        所以：

进行缩放：

得出：

$v_t$ 推导同理。

6. 参数更新：使用校正后的动量估计更新参数：

优点：

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

缺点：

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

3.2.5 总结

梯度下降算法通过不断更新参数来最小化损失函数，是反向传播算法中计算权重调整的基础。在实际应用中，根据数据的规模和计算资源的情况，选择合适的梯度下降方式（批量、随机、小批量）及其变种（如动量法、Adam等）可以显著提高模型训练的效率和效果。
Adam是目前最为流行的优化算法之一，因其稳定性和高效性，广泛应用于各种深度学习模型的训练中。Adam结合了动量法和RMSProp的优点，能够在不同情况下自适应调整学习率，并提供快速且稳定的收敛表现。
示例：

    # 定义模型和损失函数
    model = nn.Linear(10, 1)
    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01, betas=(0.9, 0.999), eps=1e-8)

    # 模拟数据
    X = torch.randn(100, 10)
    y = torch.randn(100, 1)

    # 训练循环
    for epoch in range(100):
        optimizer.zero_grad()
        outputs = model(X)
        loss = criterion(outputs, y)
        loss.backward()
        optimizer.step()
        print(f'Epoch {epoch}, Loss: {loss.item():.4f}')