深度学习的优化⽅法

tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.0, nesterov=False, name=
)

# 导⼊相应的⼯具包
import tensorflow as tf
# 实例化优化⽅法：SGD 
opt = tf.keras.optimizers.SGD(learning_rate=0.1)
# 定义要调整的参数
var = tf.Variable(1.0)
# 定义损失函数：⽆参但有返回值
loss = lambda: (var ** 2)/2.0 
# 计算梯度，并对参数进⾏更新，步⻓为 `- learning_rate * grad`
opt.minimize(loss, [var]).numpy()
# 展示参数更新结果
var.numpy()

# 1-0.1*1=0.9
0.9

• 每个 Epoch 要训练的图⽚数量：50000
• 训练集具有的 Batch 个数：50000/256+1=196
• 每个 Epoch 具有的 Iteration 个数：196
• 10个 Epoch 具有的 Iteration 个数：1960

• 计算损失函数，并进⾏反向传播：

• 计算梯度值：

• 参数更新：

import torch
import matplotlib.pyplot as plt
ELEMENT_NUMBER = 30
#1. 实际平均温度
def test01():# 固定随机数种子torch.manual_seed(0)# 产生30天的随机温度temperature = torch.randn(size=[ELEMENT_NUMBER,]) * 10print(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,]) * 10print(temperature)exp_weight_avg = []# idx从1开始for idx, temp in enumerate(temperature, 1):# 第一个元素的 EWA 值等于自身if idx == 1:exp_weight_avg.append(temp)continue# 第二个元素的 EWA 值等于上一个 EWA 乘以 β + 当前气温乘以 (1-β)# idx-2：2-2=0，exp_weight_avg列表中第一个值的下标值new_temp = exp_weight_avg[idx - 2] * beta + (1 - beta) * tempexp_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()

• s_t是当前时刻指数加权平均梯度值
• s_t-1是历史指数加权平均梯度值
• g_t是当前时刻的梯度值
• β 是调节权重系数，通常取 0.9 或 0.99
• η是学习率
• w_t是当前时刻模型权重参数

1. w 表示初始梯度
2. g 表示当前轮数计算出的梯度值
3. s 表示历史梯度移动加权平均值

• Wt：当前时刻模型权重参数
• St：当前时刻指数加权平均梯度值
• η：学习率

def test01():    # 1 初始化权重参数   w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)    loss = ((w ** 2) / 2.0).sum()    # 2 实例化优化方法：SGD 指定参数beta=0.9    （momentum指定加权的权数）# 创建优化器，将 w 放在一个列表中optimizer = torch.optim.SGD([w], lr=0.01, momentum=0.9)    # 3 第1次更新 计算梯度，并对参数进行更新    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第1次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))   # 4 第2次更新 计算梯度，并对参数进行更新    # 使用更新后的参数机选输出结果   loss = ((w ** 2) / 2.0).sum()    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第2次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))

1. 初始化学习率 η、初始化参数w、小常数 σ = 1e-10
2. 初始化梯度累计变量 s = 0
3. 从训练集中采样 m 个样本的小批量，计算梯度gt
4. 累积平方梯度: st = s(t-1) + gt ⊙ gt，⊙ 表示各个分量相乘
5. 学习率 η 的计算公式如下：

1. 权重参数更新公式如下：

1. 重复 3-7 步骤

• 优点
  • 自适应学习率，适合稀疏数据。
  • 不需要手动调整学习率。
• 缺点
  • 学是可能会使得学习率过早、过量的降低，导致模型训练后期学习率太小，较难找到最优解。
  • 需要存储历史梯度的平方，可能增加内存消耗

import torch
import torch.nn as nn# 定义一个简单的模型
model = nn.Linear(10, 1)
# 初始化 Adagrad 优化器
optimizer = torch.optim.Adagrad(model.parameters(), lr=0.01, weight_decay=0.01)# 模拟训练过程
input_data = torch.randn(10, 10)
target = torch.randn(10, 1)
criterion = nn.MSELoss()for epoch in range(10):optimizer.zero_grad()output = model(input_data)loss = criterion(output, target)loss.backward()optimizer.step()print(f"Epoch {epoch+1}, Loss: {loss.item()}")

def test02():    # 1 初始化权重参数    w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)    loss = ((w ** 2) / 2.0).sum() # 2 实例化优化方法：adagrad优化方法    optimizer = torch.optim.Adagrad ([w], lr=0.01)   # 3 第1次更新 计算梯度，并对参数进行更新    optimizer.zero_grad()    loss.backward()    optimizer.step()   print('第1次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))    # 4 第2次更新 计算梯度，并对参数进行更新    # 使用更新后的参数机选输出结果    loss = ((w ** 2) / 2.0).sum()    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第2次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))

1. 初始化学习率 η、初始化权重参数w、小常数 σ = 1e-10
2. 初始化梯度累计变量 s = 0
3. 从训练集中采样 m 个样本的小批量，计算梯度 g_t
4. 使用指数加权平均累计历史梯度，⊙ 表示各个分量相乘，公式如下：

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

6.权重参数更新公式如下：

7.重复 3-7 步骤

• 优点
  • 自适应学习率，适合处理稀疏数据。
  • 避免了 Adagrad 中学习率过早衰减的问题。
• 适用场景
  • 适合非凸优化问题。
  • 常用于深度学习中的图像识别、自然语言处理等任务

• 如果模型在训练集上表现良好，但在验证集上表现较差（过拟合），可以尝试增加 weight_decay 的值。
• 如果模型在训练集上表现不佳，可能是由于 weight_decay 设置过高导致的欠拟合，此时应适当降低其值。

def test03():    # 1 初始化权重参数    w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)    loss = ((w ** 2) / 2.0).sum()    # 2 实例化优化方法：RMSprop算法，其中alpha对应这beta    optimizer = torch.optim.RMSprop([w], lr=0.01, alpha=0.9)   # 3 第1次更新 计算梯度，并对参数进行更新    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第1次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))    # 4 第2次更新 计算梯度，并对参数进行更新    # 使用更新后的参数机选输出结果    loss = ((w ** 2) / 2.0).sum()    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第2次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))

• 修正梯度: 使⽤梯度的指数加权平均
• 修正学习率: 使⽤梯度平⽅的指数加权平均

def test04():    # 1 初始化权重参数    w = torch.tensor([1.0], requires_grad=True)    loss = ((w ** 2) / 2.0).sum()    # 2 实例化优化方法：Adam算法，其中betas是指数加权的系数    optimizer = torch.optim.Adam([w], lr=0.01,betas=[0.9,0.99])    # 3 第1次更新 计算梯度，并对参数进行更新    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第1次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))    # 4 第2次更新 计算梯度，并对参数进行更新    # 使用更新后的参数机选输出结果    loss = ((w ** 2) / 2.0).sum()    optimizer.zero_grad()    loss.backward()    optimizer.step()    print('第2次: 梯度w.grad: %f, 更新后的权重:%f' % (w.grad.numpy(), w.detach().numpy()))

import torch
import matplotlib.pyplot as plt
import numpy as npplt.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体为黑体
plt.rcParams['axes.unicode_minus'] = False
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"# 定义函数 y = 4x^2
def func(x_t):return torch.pow(2 * x_t, 2)# 测试梯度下降过程
def aaaa():lr_list = [0.01, 0.1, 0.125, 0.2, 0.3]  # 学习率列表max_iteration = 4  # 最大迭代次数for lr in lr_list:x = torch.tensor([2.], requires_grad=True)  # 每次循环重新初始化 xiter_rec, loss_rec, x_rec = list(), list(), list()  # 每次循环清空记录列表for i in range(max_iteration):y = func(x)  # 计算损失值y.backward()  # 计算梯度print(f"LR:{lr}, Iter:{i}, X:{x.item():.4f}, X.grad:{x.grad.item():.4f}, Loss:{y.item():.4f}")x_rec.append(x.item())  # 记录权重值loss_rec.append(y.item())  # 记录损失值iter_rec.append(i)  # 记录迭代次数# 更新参数x.data.sub_(lr * x.grad)  # x = x - lr * x.gradx.grad.zero_()  # 清空梯度# 创建一个新的图形窗口plt.figure(figsize=(12, 5))# 绘制损失值ax1 = plt.subplot(121)ax1.plot(iter_rec, loss_rec, '-ro')ax1.grid()ax1.set_xlabel("Iteration")ax1.set_ylabel("Loss value")ax1.set_title(f"Loss vs Iteration (lr={lr})")# 绘制函数曲线和梯度下降路径ax2 = plt.subplot(122)x_t = torch.linspace(-3, 3, 100)y_t = func(x_t)ax2.plot(x_t.numpy(), y_t.numpy(), label="y = 4x^2", color='black')ax2.plot(x_rec, [func(torch.tensor(x)).item() for x in x_rec], '-ro', label=f"Gradient Descent Path (lr={lr})")ax2.grid()ax2.legend()ax2.set_title(f"Function Curve and Descent Path (lr={lr})")# 显示当前学习率的图像plt.tight_layout()plt.show()# 运行测试
aaaa()

import torch
import torch.optim as optim
import torch.nn as nn# 定义一个简单的模型
model = nn.Linear(10, 1)
optimizer = optim.Adam(model.parameters(), lr=0.01)# 定义学习率调度器
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)# 训练过程
for epoch in range(100):# 训练模型optimizer.zero_grad()output = model(torch.randn(1, 10))loss = nn.MSELoss()(output, torch.randn(1, 1))loss.backward()optimizer.step()# 更新学习率scheduler.step()# 打印当前学习率if epoch % 10 == 0:print(f"Epoch {epoch}, Current LR: {scheduler.get_last_lr()[0]:.6f}")

import torch
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optimdef aa_StepLR():# 0. 参数初始化LR = 0.1  # 设置学习率初始值为 0.1iteration = 10max_epoch = 200# 1. 初始化参数y_true = torch.tensor([0.0], requires_grad=False)x = torch.tensor([1.0], requires_grad=False)w = torch.tensor([1.0], requires_grad=True)# 2. 定义优化器optimizer = optim.SGD([w], lr=LR, momentum=0.9)# 3. 设置学习率下降策略scheduler_lr = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)# StepLR是一种简单但常用的学习率调度器，适用于训练过程中需要逐步降低学习率的场景。# 参数    step_size    表示每隔多少个    epoch    调整一次学习率。# 参数    gamma    是学习率的衰减因子，表示每次调整时学习率乘以的系数。# 4. 获取学习率的值和当前的 epochlr_list, epoch_list = list(), list()for epoch in range(max_epoch):lr_list.append(optimizer.param_groups[0]['lr'])  # 获取当前学习率epoch_list.append(epoch)  # 记录当前的 epochfor i in range(iteration):  # 遍历每一个 batch 数据loss = ((w * x - y_true) ** 2) / 2.0  # 目标函数optimizer.zero_grad()  # 清空梯度loss.backward()  # 反向传播optimizer.step()  # 更新参数# 更新下一个 epoch 的学习率scheduler_lr.step()# 5. 绘制学习率变化的曲线plt.plot(epoch_list, lr_list, label="Step LR Scheduler")plt.xlabel("Epoch")plt.ylabel("Learning rate")plt.legend()plt.title("Learning Rate Schedule")plt.show()# 调用函数
aa_StepLR()

import torch
import torch.optim as optim
import matplotlib.pyplot as plt# 定义一个简单的模型
model = torch.nn.Linear(2, 1)
optimizer = optim.SGD(model.parameters(), lr=0.1)# 创建 ExponentialLR 调度器
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.95)# 模拟训练过程
learning_rates = []
num_epochs = 100
for epoch in range(num_epochs):optimizer.step()scheduler.step()current_lr = optimizer.param_groups[0]['lr']learning_rates.append(current_lr)print(f"Epoch {epoch + 1}, Learning Rate: {current_lr:.6f}")# 绘制学习率变化曲线
plt.plot(range(1, num_epochs + 1), learning_rates, label="Exponential Decay")
plt.xlabel("Epoch")
plt.ylabel("Learning Rate")
plt.title("ExponentialLR Scheduler")
plt.legend()
plt.grid(True)
plt.show()

import torch
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optimdef aa_ExponentialLR():# 0. 参数初始化LR = 0.1  # 设置学习率初始值为 0.1iteration = 10max_epoch = 200# 1. 初始化参数y_true = torch.tensor([0.0], requires_grad=False)x = torch.tensor([1.0], requires_grad=False)w = torch.tensor([1.0], requires_grad=True)# 2. 定义优化器optimizer = optim.SGD([w], lr=LR, momentum=0.9)# 3.设置学习率下降策略gamma = 0.95scheduler_lr = optim.lr_scheduler.ExponentialLR(optimizer, gamma=gamma)# 4. 获取学习率的值和当前的 epochlr_list, epoch_list = list(), list()for epoch in range(max_epoch):lr_list.append(optimizer.param_groups[0]['lr'])  # 获取当前学习率epoch_list.append(epoch)  # 记录当前的 epochfor i in range(iteration):  # 遍历每一个 batch 数据loss = ((w * x - y_true) ** 2) / 2.0  # 目标函数optimizer.zero_grad()  # 清空梯度loss.backward()  # 反向传播optimizer.step()  # 更新参数# 更新下一个 epoch 的学习率scheduler_lr.step()# 5. 绘制学习率变化的曲线plt.plot(epoch_list, lr_list, label="Step LR Scheduler")plt.xlabel("Epoch")plt.ylabel("Learning rate")plt.legend()plt.title("Learning Rate Schedule")plt.show()# 调用函数
aa_ExponentialLR()

• 简单任务和较小的模型：SGD 或 Momentum
• 复杂任务或有大量数据：Adam 是最常用的选择，因其在大部分任务上都表现优秀
• 需要处理稀疏数据或文本数据：Adagrad 或 RMSProp

• 知道梯度下降算法

• 理解神经⽹络的链式法则

• 掌握反向传播算法（BP算法）

• 知道梯度下降算法的优化⽅法

• 了解学习率退⽕