【漫话机器学习系列】087.常见的神经网络最优化算法（Common Optimizers Of Neural Nets）

常见的神经网络优化算法

1. 引言

在深度学习中，优化算法（Optimizers）用于更新神经网络的权重，以最小化损失函数（Loss Function）。一个高效的优化算法可以加速训练过程，并提高模型的性能和稳定性。本文介绍几种常见的神经网络优化算法，包括随机梯度下降（SGD）、带动量的随机梯度下降（Momentum SGD）、均方根传播算法（RMSProp）以及自适应矩估计（Adam），并提供相应的代码示例。

2. 常见的优化算法

2.1 随机梯度下降（Stochastic Gradient Descent, SGD）

随机梯度下降（SGD）是最基本的优化算法，其更新规则如下：

其中：

w 代表网络参数（权重）；
α 是学习率（Learning Rate），控制更新步长；
∇L(w) 是损失函数相对于权重的梯度。

代码示例（使用 PyTorch 实现 SGD）

python 复制代码

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

# 定义简单的线性模型
model = nn.Linear(1, 1)  # 1 个输入特征，1 个输出特征
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降

# 训练步骤
for epoch in range(100):
    optimizer.zero_grad()  # 清空梯度
    inputs = torch.tensor([[1.0]], requires_grad=True)
    targets = torch.tensor([[2.0]])

    outputs = model(inputs)
    loss = criterion(outputs, targets)  # 计算损失
    loss.backward()  # 反向传播
    optimizer.step()  # 更新参数

    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/100], Loss: {loss.item():.4f}')

运行结果

Matlab 复制代码

Epoch [0/100], Loss: 4.9142
Epoch [10/100], Loss: 2.1721
Epoch [20/100], Loss: 0.9601
Epoch [30/100], Loss: 0.4244
Epoch [40/100], Loss: 0.1876
Epoch [50/100], Loss: 0.0829
Epoch [60/100], Loss: 0.0366
Epoch [70/100], Loss: 0.0162
Epoch [80/100], Loss: 0.0072
Epoch [90/100], Loss: 0.0032

2.2 带动量的随机梯度下降（Momentum SGD）

带动量的 SGD 在 SGD 的基础上加入动量（Momentum），用于加速收敛并减少震荡：

其中：

是累积的梯度，类似于物理中的动量；
β 是动量系数（通常取 0.9）。

代码示例（Momentum SGD）

Matlab 复制代码

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

model = nn.Linear(1, 1)  # 1 个输入特征，1 个输出特征
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

for epoch in range(100):
    optimizer.zero_grad()
    inputs = torch.tensor([[1.0]], requires_grad=True)
    targets = torch.tensor([[2.0]])
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/100], Loss: {loss.item():.4f}')

运行结果

Matlab 复制代码

Epoch [0/100], Loss: 3.0073
Epoch [10/100], Loss: 1.3292
Epoch [20/100], Loss: 0.5875
Epoch [30/100], Loss: 0.2597
Epoch [40/100], Loss: 0.1148
Epoch [50/100], Loss: 0.0507
Epoch [60/100], Loss: 0.0224
Epoch [70/100], Loss: 0.0099
Epoch [80/100], Loss: 0.0044
Epoch [90/100], Loss: 0.0019

优点：

缓解了 SGD 震荡问题，提高收敛速度；
在非凸优化问题中表现更好。

2.3 均方根传播算法（RMSProp）

RMSProp 通过自适应调整学习率来加速训练，并缓解震荡问题：

其中：

是梯度平方的滑动平均；
β 是衰减系数（一般取 0.9）；
ϵ 是一个很小的数，防止除零错误。

代码示例（RMSProp）

python 复制代码

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

# 定义简单的线性模型
model = nn.Linear(1, 1)  # 1 个输入特征，1 个输出特征
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.9)

for epoch in range(100):
    optimizer.zero_grad()
    inputs = torch.tensor([[1.0]], requires_grad=True)
    targets = torch.tensor([[2.0]])
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/100], Loss: {loss.item():.4f}')

运行结果

Matlab 复制代码

Epoch [0/100], Loss: 1.1952
Epoch [10/100], Loss: 0.5887
Epoch [20/100], Loss: 0.3333
Epoch [30/100], Loss: 0.1731
Epoch [40/100], Loss: 0.0752
Epoch [50/100], Loss: 0.0239
Epoch [60/100], Loss: 0.0043
Epoch [70/100], Loss: 0.0003
Epoch [80/100], Loss: 0.0000
Epoch [90/100], Loss: 0.0000

优点：

适用于非平稳目标函数；
能有效处理不同特征尺度的问题；
在 RNN（循环神经网络）等任务上表现较好。

2.4 自适应矩估计（Adam, Adaptive Moment Estimation）

Adam 结合了动量法（Momentum）和 RMSProp，同时考虑梯度的一阶矩（平均值）和二阶矩（方差）：

其中：

是梯度的一阶矩估计；
是梯度的二阶矩估计；
分别控制一阶矩和二阶矩的指数衰减率（通常取 0.9 和 0.999）。

代码示例（Adam）

python 复制代码

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

# 定义简单的线性模型
model = nn.Linear(1, 1)  # 1 个输入特征，1 个输出特征
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.Adam(model.parameters(), lr=0.01)

for epoch in range(100):
    optimizer.zero_grad()
    inputs = torch.tensor([[1.0]], requires_grad=True)
    targets = torch.tensor([[2.0]])
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/100], Loss: {loss.item():.4f}')

输出结果

Matlab 复制代码

Epoch [0/100], Loss: 3.6065
Epoch [10/100], Loss: 2.8894
Epoch [20/100], Loss: 2.2642
Epoch [30/100], Loss: 1.7359
Epoch [40/100], Loss: 1.3021
Epoch [50/100], Loss: 0.9555
Epoch [60/100], Loss: 0.6855
Epoch [70/100], Loss: 0.4805
Epoch [80/100], Loss: 0.3287
Epoch [90/100], Loss: 0.2192

优点：

结合 Momentum 和 RMSProp 的优势；
适用于大规模数据集和高维参数优化；
具有自适应学习率，适用于不同类型的问题。

3. 选择合适的优化算法

优化算法	特点	适用场景
SGD	计算简单，但容易震荡	适用于大规模数据，适合凸优化问题
Momentum SGD	增加动量，减少震荡，加速收敛	适用于复杂深度神经网络
RMSProp	自适应调整学习率，适用于非平稳问题	适用于 RNN、强化学习等
Adam	结合 Momentum 和 RMSProp，自适应学习率	适用于大多数深度学习任务

4. 结论

在神经网络训练过程中，优化算法的选择对最终的模型性能有重要影响。SGD 是最基础的优化方法，而带动量的 SGD 在收敛速度和稳定性上有所提升。RMSProp 适用于非平稳目标函数，而 Adam 结合了 Momentum 和 RMSProp 的优势，成为当前最流行的优化算法之一。

不同任务可能需要不同的优化算法，通常的建议是：

对于简单的凸优化问题，可以使用 SGD。
对于深度神经网络，可以使用 Momentum SGD 或 Adam。
对于 RNN 和强化学习问题，RMSProp 是一个不错的选择。

合理选择优化算法可以显著提升模型训练的效率和效果！