37.深度学习中的梯度下降法及其实现

在深度学习的优化过程中，梯度下降法及其变体是必不可少的工具。通过对梯度下降法的理论学习，我们能够更好地理解深度学习模型的训练过程。本篇文章将介绍梯度下降的基本原理，并通过代码实现展示其具体应用。我们会从二维平面的简单梯度下降开始，逐步过渡到三维，再对比多种优化器的效果。

一、梯度下降法简介

梯度下降法（Gradient Descent）是一种常用的优化算法，广泛应用于机器学习和深度学习中。其基本思想是通过迭代更新参数，使得损失函数逐步减小，最终找到最优解。常见的梯度下降法包括随机梯度下降（SGD）、动量法（Momentum）、自适应学习率方法（Adagrad、RMSprop、Adadelta）和Adam等。

二、梯度下降的二维实现

首先，我们来实现一个简单的二维平面内的梯度下降法。目标是找到函数 \(f(x) = x^2 + 4x + 1\) 的最小值。

import torch
import matplotlib.pyplot as plt# 定义目标函数
def f(x):return x**2 + 4*x + 1# 初始化参数
x = torch.tensor([2.0], requires_grad=True)
learning_rate = 0.7# 记录每次梯度下降的值
xs, ys = [], []# 梯度下降迭代
for i in range(100):y = f(x)y.backward()with torch.no_grad():x -= learning_rate * x.gradx.grad.zero_()xs.append(x.item())ys.append(y.item())# 打印最终结果
print(f"最终x值: {x.item()}")# 可视化
x_vals = torch.linspace(-4, 2, 100)
y_vals = f(x_vals)
plt.plot(x_vals.numpy(), y_vals.numpy(), label='f(x)=x^2 + 4x + 1')
plt.scatter(xs, ys, color='red', label='Gradient Descent')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.show()

通过以上代码，我们能够看到从初始点出发，梯度下降法逐步逼近最小值。

三、梯度下降的三维实现

增加一个维度，函数变为 \(f(x, y) = x^2 + y^2\)，我们希望通过梯度下降法找到该函数的最小值。

from mpl_toolkits.mplot3d import Axes3D# 定义目标函数
def f(x, y):return x**2 + y**2# 初始化参数
x = torch.tensor([2.0], requires_grad=True)
y = torch.tensor([2.0], requires_grad=True)
learning_rate = 0.1# 记录每次梯度下降的值
xs, ys, zs = [], [], []# 梯度下降迭代
for i in range(100):z = f(x, y)z.backward()with torch.no_grad():x -= learning_rate * x.grady -= learning_rate * y.gradx.grad.zero_()y.grad.zero_()xs.append(x.item())ys.append(y.item())zs.append(z.item())# 打印最终结果
print(f"最终x, y值: {x.item()}, {y.item()}")# 可视化
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot(xs, ys, zs, label='Gradient Descent Path', marker='o')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.legend()
plt.show()# 等高线图
plt.figure()
X, Y = torch.meshgrid(torch.linspace(-3, 3, 100), torch.linspace(-3, 3, 100))
Z = f(X, Y)
plt.contourf(X.numpy(), Y.numpy(), Z.numpy(), 50)
plt.plot(xs, ys, 'r-o', label='Gradient Descent Path')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.show()

通过以上代码，我们能够在三维空间中看到梯度下降的路径。

四、不同优化器的对比

接下来，我们生成一个数据集，使用不同的优化器进行对比，观察它们的收敛效果。

import torch.utils.data as data# 生成数据集
def generate_data(num_samples=1000):x = torch.rand(num_samples, 1)y = torch.rand(num_samples, 1)z = f(x, y) + torch.randn(num_samples, 1)return x, y, zx, y, z = generate_data()
dataset = data.TensorDataset(torch.cat([x, y], dim=1), z)
train_size = int(0.8 * len(dataset))
test_size = len(dataset) - train_size
train_dataset, test_dataset = data.random_split(dataset, [train_size, test_size])
train_loader = data.DataLoader(train_dataset, batch_size=32)
test_loader = data.DataLoader(test_dataset, batch_size=32)# 定义模型
class SimpleNN(torch.nn.Module):def __init__(self):super(SimpleNN, self).__init__()self.fc = torch.nn.Linear(2, 1)def forward(self, x):return self.fc(x)# 初始化模型和优化器
models = [SimpleNN() for _ in range(6)]
optimizers = [torch.optim.SGD(models[0].parameters(), lr=0.01),torch.optim.SGD(models[1].parameters(), lr=0.01, momentum=0.9),torch.optim.Adagrad(models[2].parameters(), lr=0.01),torch.optim.RMSprop(models[3].parameters(), lr=0.01),torch.optim.Adadelta(models[4].parameters()),torch.optim.Adam(models[5].parameters(), lr=0.01)
]
loss_fn = torch.nn.MSELoss()# 训练和测试函数
def train_epoch(model, optimizer, loader):model.train()total_loss = 0for x_batch, y_batch in loader:optimizer.zero_grad()y_pred = model(x_batch)loss = loss_fn(y_pred, y_batch)loss.backward()optimizer.step()total_loss += loss.item()return total_loss / len(loader)def test_epoch(model, loader):model.eval()total_loss = 0with torch.no_grad():for x_batch, y_batch in loader:y_pred = model(x_batch)loss = loss_fn(y_pred, y_batch)total_loss += loss.item()return total_loss / len(loader)# 记录误差
train_losses = [[] for _ in range(6)]
test_losses = [[] for _ in range(6)]# 训练和测试过程
num_epochs = 50
for epoch in range(num_epochs):for i in range(6):train_loss = train_epoch(models[i], optimizers[i], train_loader)test_loss = test_epoch(models[i], test_loader)train_losses[i].append(train_loss)test_losses[i].append(test_loss)# 可视化收敛曲线
plt.figure(figsize=(12, 6))
for i, name in enumerate(['SGD', 'Momentum', 'Adagrad', 'RMSprop', 'Adadelta', 'Adam']):plt.plot(train_losses[i], label=f'Train {name}')plt.plot(test_losses[i], '--', label=f'Test {name}')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

通过上述代码，我们能够对比不同优化器的收敛效果，从图中可以看到各个优化器的表现差异。