pytorch经典训练流程

文章目录

• • @[toc]
  • • 1. **经典训练流程和任务：监督学习**
    • • **1.1 什么是监督学习？**
      • **1.2 为什么要设计训练流程？**
      • **1.3 怎么设计训练流程？**
      • **代码示例：监督学习的典型流程**
    • 2. **超参数设置**
    • • **2.1 什么是超参数？**
      • **2.2 为什么要设置超参数？**
      • **2.3 怎么设置超参数？**
      • **代码示例：设置超参数**
    • 3. **数据集预处理（Pre-transform）**
    • • **3.1 什么是数据集预处理？**
      • **3.2 为什么要预处理？**
      • **3.3 怎么做预处理？**
      • **代码示例：数据预处理**
    • 4. **数据集加载**
    • • **4.1 什么是数据集加载？**
      • **4.2 为什么需要数据集加载器？**
      • **4.3 怎么加载数据集？**
      • **代码示例：数据加载**
    • 5. **数据集后处理（Transform）**
    • • **5.1 什么是数据集后处理？**
      • **5.2 为什么需要后处理？**
      • **5.3 常见的后处理操作**
      • **代码示例：数据集后处理**
      • **可视化增强后的数据**
    • 6. **模型初始化、优化器初始化**
    • • **6.1 什么是模型初始化？**
      • **6.2 为什么要初始化模型？**
      • **6.3 怎么初始化模型？**
      • **代码示例：模型初始化**
      • **优化器初始化**
    • 7. **多个 Epoch 的训练：梯度下降**
    • • **7.1 什么是梯度下降？**
      • **7.2 为什么要多次训练（多个 Epoch）？**
      • **7.3 训练流程**
      • **代码示例：多个 Epoch 的训练**
    • 8. **中间结果打印 (Loss, Accuracy 等)**
    • • **8.1 为什么打印中间结果？**
      • **8.2 什么是常见的中间结果？**
      • **8.3 怎么计算和打印中间结果？**
      • **代码示例：中间结果打印**
      • **8.4 增加验证过程**
      • **8.5 可视化训练曲线**

1. 经典训练流程和任务：监督学习

1.1 什么是监督学习？

监督学习是一种机器学习方法，模型通过已标注的数据（输入与输出）进行训练，从而学习从输入预测输出的映射关系。其目标是让模型能够在未标注的新数据上作出准确预测。

典型任务：

• 分类任务：预测输入属于哪个类别（例如图像分类、垃圾邮件检测）。
• 回归任务：预测连续的数值（例如房价预测、股票预测）。

1.2 为什么要设计训练流程？

监督学习的目标是最小化模型预测输出和真实输出之间的误差（称为损失）。一个标准的训练流程可以帮助我们：

1. 有效利用数据 ：通过批量化处理大数据集，逐步优化模型参数。
2. 动态调整模型 ：通过多轮迭代学习更好的参数。
3. 评估模型性能 ：通过指标（例如准确率、损失值）判断模型效果。

1.3 怎么设计训练流程？

一个典型的监督学习训练流程包括以下步骤：

1. 准备数据（加载、预处理）。
2. 初始化模型。
3. 定义损失函数和优化器。
4. 执行多个 epoch 的训练（包括前向传播、损失计算、反向传播、参数更新）。
5. 评估模型性能。

代码示例：监督学习的典型流程

以下是一个简单的监督学习流程，用于分类任务（例如使用 MNIST 手写数字数据集）：

# 1. 加载必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 2. 数据准备
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量
    transforms.Normalize((0.5,), (0.5,))  # 标准化
])

# 加载MNIST数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# 3. 模型初始化
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc = nn.Sequential(
            nn.Flatten(),  # 展平输入
            nn.Linear(28 * 28, 128),  # 全连接层
            nn.ReLU(),  # 激活函数
            nn.Linear(128, 10)  # 输出层（10类别）
        )

    def forward(self, x):
        return self.fc(x)

model = SimpleNN()

# 4. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器

# 5. 训练流程
epochs = 5
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for batch_idx, (inputs, labels) in enumerate(train_loader):
        # 清除之前的梯度
        optimizer.zero_grad()
    
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)
    
        # 反向传播和参数更新
        loss.backward()
        optimizer.step()
    
        running_loss += loss.item()
  
    print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss/len(train_loader):.4f}")

# 6. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)  # 获取最大值对应的类别
        correct += (predicted == labels).sum().item()
        total += labels.size(0)

print(f"Accuracy: {100 * correct / total:.2f}%")

2. 超参数设置

2.1 什么是超参数？

超参数是那些在训练模型之前手动设置的参数，而不是通过训练自动学习的参数。超参数对模型性能和训练过程有重要影响。常见的超参数包括：

• 学习率（learning rate）：决定每次参数更新的步长大小。
• 批量大小（batch size）：决定一次训练中使用的样本数。
• 训练轮数（epochs）：模型在整个数据集上训练的完整次数。
• 隐藏层的层数和单元数（网络结构相关）。
• 优化器类型（如 SGD, Adam）。

2.2 为什么要设置超参数？

合理的超参数设置可以：

1. 提升训练效率 ：加速收敛，减少训练时间。
2. 提高模型性能 ：避免欠拟合或过拟合。
3. 改善稳定性 ：避免训练过程中的数值不稳定或发散。

超参数通常需要通过经验或网格搜索、随机搜索等方法来确定最佳值。

2.3 怎么设置超参数？

以下是常见的超参数设置和推荐值：

1. 学习率 ：较小值（如 0.001~0.01）通常较稳定，但训练慢；较大值（如 0.1）可能加速训练，但易导致不收敛。
2. 批量大小 ：32、64 或 128 是常用的值，GPU 通常能更好地处理较大的 batch。
3. 训练轮数 ：视数据集大小和模型复杂度而定，通常设置为 5~100。
4. 优化器 ：推荐从 Adam 开始，默认参数 lr=0.001。

代码示例：设置超参数

以下是一个简单的超参数设置示例，包含了常见的超参数配置：

# 超参数定义
learning_rate = 0.01  # 学习率
batch_size = 64       # 批量大小
epochs = 10           # 训练轮数

# 数据加载
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 模型、损失函数和优化器初始化
model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 输出超参数设定
print(f"Hyperparameters:\n Learning Rate: {learning_rate}\n Batch Size: {batch_size}\n Epochs: {epochs}")

3. 数据集预处理（Pre-transform）

3.1 什么是数据集预处理？

数据集预处理是指在模型训练前对原始数据进行转换，使其适合输入到模型中。典型的预处理包括：

• 图像归一化、缩放。
• 缺失值填充。
• 特征工程（如词嵌入、独热编码）。

在深度学习中，pre-transform 通常是一次性操作，处理后的数据保存到磁盘，后续训练直接加载以节省时间。

3.2 为什么要预处理？

1. 提高模型训练效果 ：例如，归一化可以加快收敛速度。
2. 减少数据噪声 ：例如，去掉异常值。
3. 统一数据格式 ：确保数据符合模型输入要求。

3.3 怎么做预处理？

以下以 MNIST 数据集为例说明预处理：

• 归一化：将像素值从 [0, 255] 映射到 [0, 1]。
• 标准化：使数据均值为 0，标准差为 1。

代码示例：数据预处理

# 定义预处理操作
transform = transforms.Compose([
    transforms.ToTensor(),  # 转为 PyTorch 张量
    transforms.Normalize((0.5,), (0.5,))  # 标准化：均值为0，方差为1
])

# 加载并预处理数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)

# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

4. 数据集加载

4.1 什么是数据集加载？

数据集加载是指将数据从存储介质中读取到内存中，并按需提供给模型训练的过程。PyTorch 提供了 DataLoader 方便进行批量化加载数据。

4.2 为什么需要数据集加载器？

1. 批量化处理 ：分批加载可以减少内存占用，加速训练。
2. 随机性 ：支持数据打乱（shuffle），有助于减少模型对数据顺序的依赖。
3. 并行化 ：支持多线程加载数据，提高数据读取效率。

4.3 怎么加载数据集？

• DataLoader 是核心工具，可以控制批量大小、是否打乱、加载线程数等。

代码示例：数据加载

from torch.utils.data import DataLoader

# 批量加载数据
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)

# 查看一个 batch 的数据
data_iter = iter(train_loader)
images, labels = next(data_iter)

print(f"Batch size: {images.size()}")  # 打印形状 (batch_size, 1, 28, 28)
print(f"Labels: {labels}")             # 打印标签

下一步，将详细讲解 数据集后处理（Transform） 和其他剩余内容。

5. 数据集后处理（Transform）

5.1 什么是数据集后处理？

数据集后处理是指在每次运行训练或推理时，对加载后的数据进行动态转换操作。这些操作和预处理（Pre-transform）不同，它们会在每次访问数据时应用，而不是一次性保存到磁盘。典型操作包括：

• 数据增强（如随机裁剪、旋转）。
• 数据格式转换（如将图片转换为张量）。
• 特定模型需求的格式调整。

5.2 为什么需要后处理？

1. 增加数据多样性 ：数据增强通过对原始数据的变换提高模型的泛化能力。
2. 简化训练流程 ：通过动态调整避免为每种场景重新处理数据。
3. 满足特定需求 ：根据不同模型需求生成合适的输入。

5.3 常见的后处理操作

以下列举了图像任务中常见的后处理操作：

• 随机裁剪（RandomCrop）。
• 随机旋转（RandomRotation）。
• 随机翻转（RandomHorizontalFlip）。
• 图像缩放（Resize）。

代码示例：数据集后处理

以下代码实现了动态的数据增强和标准化操作：

from torchvision import transforms

# 定义数据增强和标准化操作
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),  # 50%概率水平翻转
    transforms.RandomRotation(degrees=10),  # 随机旋转 -10 到 10 度
    transforms.ToTensor(),                  # 转为张量
    transforms.Normalize((0.5,), (0.5,))    # 标准化
])

# 加载训练数据集（应用transform）
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)

# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 查看一个经过后处理的数据样本
data_iter = iter(train_loader)
images, labels = next(data_iter)

print(f"Image batch shape: {images.size()}")  # 打印形状
print(f"Label batch: {labels}")

可视化增强后的数据

你还可以可视化数据增强后的图像，直观观察后处理效果：

import matplotlib.pyplot as plt

# 可视化前几个图像
for i in range(6):
    plt.subplot(2, 3, i+1)
    plt.imshow(images[i].squeeze().numpy(), cmap='gray')
    plt.title(f"Label: {labels[i].item()}")
plt.tight_layout()
plt.show()

6. 模型初始化、优化器初始化

6.1 什么是模型初始化？

模型初始化是定义模型结构，并为模型的参数赋初值的过程。在 PyTorch 中，模型通过继承 torch.nn.Module 来构建。模型的参数在定义时会默认随机初始化。

6.2 为什么要初始化模型？

1. 定义网络结构 ：为任务设计合适的模型结构。
2. 参数初始化 ：参数初始化对训练过程至关重要，好的初始化方式可以加速收敛并减少梯度消失或爆炸问题。

6.3 怎么初始化模型？

• PyTorch 提供了多种参数初始化方式（如 Xavier 初始化、He 初始化）。
• 模型结构在 __init__ 方法中定义，前向计算逻辑在 forward 方法中定义。

代码示例：模型初始化

以下示例构建了一个简单的卷积神经网络（CNN）：

import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 定义网络层
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)  # 输入通道1，输出通道16
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(32 * 7 * 7, 128)  # 全连接层
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # 定义前向传播
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)  # 最大池化
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(x.size(0), -1)  # 展平
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 初始化模型
model = SimpleCNN()
print(model)

优化器初始化

优化器是用于更新模型参数的工具。在初始化时，需要指定优化器类型和学习率。

# 定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 打印模型的可训练参数
for name, param in model.named_parameters():
    print(name, param.shape, param.requires_grad)

7. 多个 Epoch 的训练：梯度下降

7.1 什么是梯度下降？

梯度下降是深度学习中优化模型参数的核心算法。它通过计算损失函数相对于模型参数的梯度，逐步更新参数以最小化损失。

7.2 为什么要多次训练（多个 Epoch）？

1. 充分学习数据 ：单次遍历数据（一个 epoch）通常不足以学到有效的参数。
2. 渐进式优化 ：每次迭代（mini-batch）更新参数，多个 epoch 能够进一步减少损失。

7.3 训练流程

每个 epoch 的训练包括：

1. 前向传播 ：计算模型输出和损失。
2. 反向传播 ：通过梯度计算更新参数。
3. 评估中间结果 ：打印损失、准确率等指标。

代码示例：多个 Epoch 的训练

epochs = 5
for epoch in range(epochs):
    model.train()
    total_loss = 0.0
  
    for inputs, labels in train_loader:
        optimizer.zero_grad()  # 清除梯度
        outputs = model(inputs)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 参数更新
    
        total_loss += loss.item()
  
    print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(train_loader):.4f}")

8. 中间结果打印 (Loss, Accuracy 等)

8.1 为什么打印中间结果？

在训练过程中打印中间结果（例如损失和准确率）有以下重要意义：

1. 监控训练过程 ：可以观察模型是否正常收敛，避免梯度爆炸或梯度消失。
2. 调试和排错 ：如果损失不减小或表现异常，可能是模型结构或超参数设置的问题。
3. 评估性能趋势 ：通过观察准确率的变化，判断模型是否欠拟合或过拟合。

8.2 什么是常见的中间结果？

1. 训练损失（Training Loss） ：表示模型在训练数据上的误差。
2. 验证损失（Validation Loss） ：表示模型在验证数据上的误差，用于监控模型的泛化能力。
3. 训练准确率（Training Accuracy） ：模型在训练数据上的分类正确率。
4. 验证准确率（Validation Accuracy） ：模型在验证数据上的分类正确率。

8.3 怎么计算和打印中间结果？

1. 损失计算 ：通过定义的损失函数 criterion 直接计算。
2. 准确率计算 ：通过比较模型输出的预测值与真实标签，统计预测正确的数量。
3. 打印格式优化 ：可以采用 print 或日志工具（如 logging）打印结果。

代码示例：中间结果打印

以下是训练过程中打印损失和准确率的完整代码示例：

# 定义一个函数计算准确率
def compute_accuracy(outputs, labels):
    _, predicted = torch.max(outputs, 1)  # 获取预测值的类别
    correct = (predicted == labels).sum().item()  # 统计正确数量
    accuracy = correct / labels.size(0)  # 计算准确率
    return accuracy

# 训练过程
epochs = 5
for epoch in range(epochs):
    model.train()
    total_loss = 0.0
    total_accuracy = 0.0
  
    for inputs, labels in train_loader:
        optimizer.zero_grad()  # 清除梯度
        outputs = model(inputs)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 参数更新
    
        total_loss += loss.item()  # 累积损失
        total_accuracy += compute_accuracy(outputs, labels)  # 累积准确率
  
    avg_loss = total_loss / len(train_loader)  # 平均损失
    avg_accuracy = total_accuracy / len(train_loader)  # 平均准确率
    print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}, Accuracy: {avg_accuracy:.4f}")

8.4 增加验证过程

通常，在每个 epoch 的末尾会用验证集进行评估，以监控模型的泛化性能。

# 验证过程
def validate_model(model, val_loader, criterion):
    model.eval()  # 设置为评估模式
    total_loss = 0.0
    total_accuracy = 0.0
  
    with torch.no_grad():  # 禁用梯度计算
        for inputs, labels in val_loader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            total_loss += loss.item()
            total_accuracy += compute_accuracy(outputs, labels)
  
    avg_loss = total_loss / len(val_loader)
    avg_accuracy = total_accuracy / len(val_loader)
    return avg_loss, avg_accuracy

# 在训练中加入验证
for epoch in range(epochs):
    # 训练
    model.train()
    train_loss = 0.0
    train_accuracy = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        train_accuracy += compute_accuracy(outputs, labels)
  
    # 验证
    val_loss, val_accuracy = validate_model(model, test_loader, criterion)
  
    # 打印训练和验证结果
    print(f"Epoch {epoch+1}/{epochs}")
    print(f"  Training  - Loss: {train_loss/len(train_loader):.4f}, Accuracy: {train_accuracy/len(train_loader):.4f}")
    print(f"  Validation - Loss: {val_loss:.4f}, Accuracy: {val_accuracy:.4f}")

8.5 可视化训练曲线

为了更清楚地观察训练过程中的趋势，可以通过可视化工具绘制损失和准确率曲线：

import matplotlib.pyplot as plt

# 记录损失和准确率
train_losses, val_losses = [], []
train_accuracies, val_accuracies = [], []

for epoch in range(epochs):
    # 训练
    model.train()
    train_loss = 0.0
    train_accuracy = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        train_accuracy += compute_accuracy(outputs, labels)
  
    # 验证
    val_loss, val_accuracy = validate_model(model, test_loader, criterion)
  
    # 保存结果
    train_losses.append(train_loss / len(train_loader))
    val_losses.append(val_loss)
    train_accuracies.append(train_accuracy / len(train_loader))
    val_accuracies.append(val_accuracy)

# 绘制曲线
plt.figure(figsize=(12, 5))

# 损失曲线
plt.subplot(1, 2, 1)
plt.plot(range(epochs), train_losses, label='Train Loss')
plt.plot(range(epochs), val_losses, label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.title('Loss Curve')

# 准确率曲线
plt.subplot(1, 2, 2)
plt.plot(range(epochs), train_accuracies, label='Train Accuracy')
plt.plot(range(epochs), val_accuracies, label='Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Accuracy Curve')

plt.tight_layout()
plt.show()

1. 中间结果打印是训练中的重要环节，可以帮助实时了解模型的训练和验证性能。
2. 可以通过 print 或绘制曲线，直观展示损失和准确率的变化趋势。
3. 验证集的使用能有效监控模型的泛化性能，避免过拟合。