深入实践：PaddlePaddle模型训练

学习目标

本课程将带领学员深入了解如何使用PaddlePaddle框架进行模型训练，包括设置训练参数、监控训练过程以及调整超参数等关键步骤，以提高模型的性能。通过本课程的学习，学员将能够独立完成模型的训练与优化。

相关知识点

• PaddlePaddle模型训练

学习内容

1 PaddlePaddle模型训练

1.1 设置训练参数

在使用PaddlePaddle进行模型训练之前，正确设置训练参数是至关重要的一步。训练参数的选择直接影响到模型的训练效率和最终性能。本课程将详细介绍如何设置学习率、批次大小、迭代次数等关键参数。

1.1.1 学习率的设置

学习率是训练过程中最重要的参数之一，它决定了模型参数更新的速度。学习率过高可能导致模型训练不稳定，过低则会导致训练过程缓慢。在PaddlePaddle中，可以通过paddle.optimizer模块来设置学习率。例如，使用固定学习率：

%pip install paddlepaddle==3.0.0

import paddle
from paddle.optimizer import Adam

# 定义模型
model = paddle.nn.Sequential(
        paddle.nn.Flatten(),
        paddle.nn.Linear(784, 256),
        paddle.nn.ReLU(),
        paddle.nn.Linear(256, 10)
    )


# 设置学习率
learning_rate = 0.001
optimizer = Adam(learning_rate=learning_rate, parameters=model.parameters())

1.1.2 批次大小的设置

批次大小决定了每次训练时输入模型的数据量。较大的批次大小可以利用GPU的并行计算能力，提高训练速度，但也会增加内存消耗。较小的批次大小则可以减少内存消耗，但可能需要更多的迭代次数来达到相同的训练效果。在PaddlePaddle中，可以通过DataLoader来设置批次大小：

!wget https://model-community-picture.obs.cn-north-4.myhuaweicloud.com/ascend-zone/notebook_datasets/0da6ba332fc511f0a905c0d193714e3c/mnist.zip

!unzip mnist.zip

from paddle.vision.transforms import Compose, Normalize
from paddle.io import Dataset
import paddle
import numpy as np
import os
from PIL import Image

# 定义自定义 MNIST 数据集
class LocalMNIST(Dataset):
    def __init__(self, data_path, mode='train', transform=None):
        super(LocalMNIST, self).__init__()
        self.data_path = data_path
        self.mode = mode
        self.transform = transform
        self.images = []
        self.labels = []
        
        # 加载图像和标签
        self.load_data()

    def load_data(self):
        if self.mode == 'train':
            image_file = os.path.join(self.data_path, 'train-images-idx3-ubyte')
            label_file = os.path.join(self.data_path, 'train-labels-idx1-ubyte')
        else:
            image_file = os.path.join(self.data_path, 't10k-images-idx3-ubyte')
            label_file = os.path.join(self.data_path, 't10k-labels-idx1-ubyte')

        # 读取图像文件
        with open(image_file, 'rb') as f:
            images = np.frombuffer(f.read(), np.uint8, offset=16)
            images = images.reshape(-1, 28, 28)

        # 读取标签文件
        with open(label_file, 'rb') as f:
            labels = np.frombuffer(f.read(), np.uint8, offset=8)

        self.images = images
        self.labels = labels

    def __getitem__(self, idx):
        image = Image.fromarray(self.images[idx].astype('uint8'), 'L')
        label = np.array(self.labels[idx], dtype='int64')

        if self.transform is not None:
            image = self.transform(image)

        return image, label

    def __len__(self):
        return len(self.labels)

# 定义数据集路径
train_dataset_path = 'mnist/train'
test_dataset_path = 'mnist/test'

# 定义数据预处理
transform = Compose([Normalize(mean=[127.5], std=[127.5], data_format='CHW')])

# 创建自定义数据集
train_dataset = LocalMNIST(train_dataset_path, mode='train', transform=transform)
test_dataset = LocalMNIST(test_dataset_path, mode='test', transform=transform)

# 测试数据集
print(f"Train dataset size: {len(train_dataset)}")
print(f"Test dataset size: {len(test_dataset)}")

# 获取一个样本
image, label = train_dataset[0]
print(f"Image shape: {image.shape}, Label: {label}")

from paddle.io import DataLoader

# 假设train_dataset是已经准备好的训练数据集
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=True)

1.1.3 迭代次数的设置

迭代次数决定了模型在整个训练数据集上训练的次数。通常，迭代次数越多，模型的性能越好，但也会增加训练时间。在PaddlePaddle中，可以通过循环来控制迭代次数：

num_epochs = 10
for epoch in range(num_epochs):
    for batch_id, data in enumerate(train_loader):
        x_data, y_data = data
        logits = model(x_data)
        loss = paddle.nn.functional.cross_entropy(logits, y_data)
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()

1.2 监控训练过程

监控训练过程是确保模型训练顺利进行的重要手段。通过监控损失函数的变化、准确率的提升等指标，可以及时发现训练过程中的问题并进行调整。PaddlePaddle提供了多种工具和方法来帮助我们监控训练过程。

1.2.1 使用paddle.callbacks监控训练

PaddlePaddle的paddle.callbacks模块提供了多种回调函数，可以在训练过程中自动记录和显示训练指标。例如，使用VisualDL回调函数来可视化训练过程：

%pip install visualdl==2.5.3

import paddle
from paddle.optimizer import Adam

# 定义模型
model = paddle.Model(
    paddle.nn.Sequential(
        paddle.nn.Flatten(),
        paddle.nn.Linear(784, 256),
        paddle.nn.ReLU(),
        paddle.nn.Linear(256, 10)
    )
)


# 设置学习率
learning_rate = 0.001
optimizer = Adam(learning_rate=learning_rate, parameters=model.parameters())

# 编译模型
model.prepare(
    optimizer=paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    loss=paddle.nn.CrossEntropyLoss(),
    metrics=paddle.metric.Accuracy()
)

from paddle.callbacks import VisualDL

# 定义回调函数
visualdl_callback = VisualDL(log_dir='./log')

# 开始训练
model.fit(train_loader, epochs=num_epochs, callbacks=[visualdl_callback])

1.2.2 手动记录训练指标

除了使用回调函数，我们也可以手动记录训练过程中的指标。例如，记录每个epoch的损失值和准确率：

layer = model.network

import numpy as np

# 初始化记录列表
train_losses = []
train_accuracies = []

for epoch in range(num_epochs):
    epoch_loss = 0.0
    epoch_correct = 0
    total_samples = 0
    
    for batch_id, data in enumerate(train_loader):
        x_data, y_data = data
        logits = layer(x_data)
        loss = paddle.nn.functional.cross_entropy(logits, y_data)
        epoch_loss += loss.numpy().item()
        
        # 计算准确率
        pred = paddle.argmax(logits, axis=1)
        correct = (pred == y_data).sum().numpy().item()
        epoch_correct += correct
        total_samples += y_data.shape[0]
        
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()
    
    # 计算平均损失和准确率
    avg_loss = epoch_loss / (batch_id + 1)
    accuracy = epoch_correct / total_samples
    
    # 记录指标
    train_losses.append(avg_loss)
    train_accuracies.append(accuracy)
    
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}')

1.3 调整超参数

超参数的调整是提高模型性能的关键步骤。通过调整学习率、批次大小、迭代次数等超参数，可以显著提升模型的性能。本课程将介绍如何使用PaddlePaddle进行超参数调整。

1.3.1 使用网格搜索进行超参数调整

网格搜索是一种常用的超参数调整方法，通过遍历所有可能的超参数组合，找到最优的超参数设置。PaddlePaddle没有内置的网格搜索功能，但我们可以自己实现：
网络搜索时间较长，不建议运行！

import itertools

# 定义超参数范围
learning_rates = [0.001, 0.01]
batch_sizes = [32, 64]
num_epochs = [5, 10]

# 生成所有超参数组合
param_combinations = list(itertools.product(learning_rates, batch_sizes, num_epochs))

# 记录最佳超参数和性能
best_params = None
best_accuracy = 0.0

for lr, bs, ne in param_combinations:
    # 重新初始化模型和优化器
    model = paddle.nn.Sequential(
        paddle.nn.Flatten(),
        paddle.nn.Linear(784, 256),
        paddle.nn.ReLU(),
        paddle.nn.Linear(256, 10)
    )
    optimizer = Adam(learning_rate=lr, parameters=model.parameters())
    
    # 重新设置数据加载器
    train_loader = DataLoader(train_dataset, batch_size=bs, shuffle=True)
    
    # 训练模型
    for epoch in range(ne):
        for batch_id, data in enumerate(train_loader):
            x_data, y_data = data
            logits = model(x_data)
            loss = paddle.nn.functional.cross_entropy(logits, y_data)
            loss.backward()
            optimizer.step()
            optimizer.clear_grad()
    
    # 评估模型
    model.eval()
    correct = 0
    total = 0
    for batch_id, data in enumerate(test_loader):
        x_data, y_data = data
        logits = model(x_data)
        pred = paddle.argmax(logits, axis=1)
        correct += (pred == y_data).sum().numpy().item()
        total += y_data.shape[0]
    
    accuracy = correct / total
    print(f'Learning Rate: {lr}, Batch Size: {bs}, Epochs: {ne}, Accuracy: {accuracy:.4f}')
    
    # 更新最佳超参数
    if accuracy > best_accuracy:
        best_accuracy = accuracy
        best_params = {'learning_rate': lr, 'batch_size': bs, 'num_epochs': ne}

print(f'Best Parameters: {best_params}, Best Accuracy: {best_accuracy:.4f}')

Result:

Learning Rate: 0.001, Batch Size: 32, Epochs: 5, Accuracy: 0.9719
Learning Rate: 0.001, Batch Size: 32, Epochs: 10, Accuracy: 0.9672
Learning Rate: 0.001, Batch Size: 64, Epochs: 5, Accuracy: 0.9716
Learning Rate: 0.001, Batch Size: 64, Epochs: 10, Accuracy: 0.9707
Learning Rate: 0.01, Batch Size: 32, Epochs: 5, Accuracy: 0.9249
Learning Rate: 0.01, Batch Size: 32, Epochs: 10, Accuracy: 0.9263
Learning Rate: 0.01, Batch Size: 64, Epochs: 5, Accuracy: 0.9383
Learning Rate: 0.01, Batch Size: 64, Epochs: 10, Accuracy: 0.9443
Best Parameters: {‘learning_rate’: 0.001, ‘batch_size’: 32, ‘num_epochs’: 5}, Best Accuracy: 0.9719