当前位置：首页 > news >正文

AI学习指南深度学习篇-带动量的随机梯度下降法Python实践

news 来源：原创 2024/9/22 9:30:15

AI学习指南深度学习篇-带动量的随机梯度下降法Python实践

深度学习已经成为现代人工智能领域的重要基石。随机梯度下降法（SGD）是训练深度学习模型的常用优化算法，而带动量的随机梯度下降（Momentum SGD）在此基础上进一步加速了收敛过程，改善了模型的训练效果。本篇博客将深入探讨带动量的SGD及其在Python中的实现，涵盖代码示例、参数调优以及最佳实践。

1. 什么是带动量的随机梯度下降法？

在了解带动量的SGD之前，我们需要先了解普通的SGD。

1.1 随机梯度下降法（SGD）

随机梯度下降法是一种迭代优化算法，主要用于训练机器学习模型。其基本思想是通过不断更新模型参数，以最小化目标函数（通常是损失函数）。在SGD中，每次迭代只使用一小批数据（mini-batch）来计算梯度。

$\theta_{t+1} = \theta_t - \eta \nabla_{\theta} J(\theta_t; x^{(i)}, y^{(i)})$

其中：

$\theta$ 是模型的参数
$\eta$ 是学习率
$J$ 是损失函数
$x^{(i)}, y^{(i)})$ 是当前的训练样本

1.2 带动量的SGD

带动量的SGD引入了“动量”的概念，通过累积过去梯度的指数平均来加速SGD的更新。动量在一定程度上帮助模型跳出局部最优解，提高收敛速度。

其更新公式为：

$v_t = \beta v_{t-1} + (1 - \beta) \nabla_{\theta} J(\theta_t; x^{(i)}, y^{(i)})$

$\theta_{t+1} = \theta_t - \eta v_t$

在这里：

$v_t$ 是当前动量的值
$\beta$ 是动量衰减因子（通常取0.9）

2. 环境配置

在开始深度学习实现之前，请确保你已经安装了Python以及常用的深度学习库，如TensorFlow或PyTorch。

2.1 安装TensorFlow

如果你选择使用TensorFlow，可以使用以下命令安装：

pip install tensorflow

2.2 安装PyTorch

如果你选择使用PyTorch，可以使用以下命令安装：

pip install torch torchvision

3. 使用TensorFlow实现带动量的SGD

3.1 数据集准备

我们将使用著名的MNIST手写数字数据集来演示如何使用带动量的SGD优化模型。首先，加载数据集并进行预处理。

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import numpy as np# 加载数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0# 将数据形状调整为 (批次，长度，高度，颜色通道)
x_train = np.expand_dims(x_train, axis=-1)
x_test = np.expand_dims(x_test, axis=-1)

3.2 构建模型

接下来，我们创建一个简单的卷积神经网络（CNN）模型。

def create_model():model = models.Sequential()model.add(layers.Conv2D(32, (3, 3), activation="relu", input_shape=(28, 28, 1)))model.add(layers.MaxPooling2D((2, 2)))model.add(layers.Conv2D(64, (3, 3), activation="relu"))model.add(layers.MaxPooling2D((2, 2)))model.add(layers.Flatten())model.add(layers.Dense(64, activation="relu"))model.add(layers.Dense(10, activation="softmax"))return modelmodel = create_model()

3.3 编译模型

使用带动量的SGD作为优化器：

# 设置动量
momentum = 0.9
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=momentum)# 编译模型
model.compile(optimizer=optimizer,loss="sparse_categorical_crossentropy",metrics=["accuracy"])

3.4 训练模型

训练模型，并观察训练过程中的损失和准确率。

# 训练模型
epochs = 10
history = model.fit(x_train, y_train, epochs=epochs, validation_split=0.2)# 可视化训练过程
import matplotlib.pyplot as pltplt.plot(history.history["loss"], label="train_loss")
plt.plot(history.history["val_loss"], label="val_loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.show()

3.5 评估模型

最后，我们评估模型在测试集上的表现。

test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc}")

4. 使用PyTorch实现带动量的SGD

接下来，我们将使用PyTorch实现同样的功能。

4.1 数据集准备

import torch
from torchvision import datasets, transforms
from torch import nn, optim# 数据预处理
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
trainset = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testset = datasets.MNIST(root="./data", train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

4.2 构建模型

class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 32, kernel_size=3)self.pool = nn.MaxPool2d(kernel_size=2)self.conv2 = nn.Conv2d(32, 64, kernel_size=3)self.fc1 = nn.Linear(64 * 5 * 5, 128)self.fc2 = nn.Linear(128, 10)def forward(self, x):x = self.pool(F.relu(self.conv1(x)))x = self.pool(F.relu(self.conv2(x)))x = x.view(-1, 64 * 5 * 5)x = F.relu(self.fc1(x))x = self.fc2(x)return xmodel = Net()

4.3 优化器设置

# 设置动量
momentum = 0.9
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=momentum)criterion = nn.CrossEntropyLoss()

4.4 训练模型

# 训练模型
epochs = 10
for epoch in range(epochs):running_loss = 0.0for images, labels in trainloader:optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()running_loss += loss.item()print(f"Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}")# 可视化训练过程...

4.5 评估模型

# 评估模型
correct = 0
total = 0
with torch.no_grad():for images, labels in testloader:outputs = model(images)_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print(f"Test accuracy: {100 * correct / total}%")