文章目录
- @[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 可视化训练曲线**
文章目录
- @[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.3 怎么设计训练流程？
一个典型的监督学习训练流程包括以下步骤：
- 准备数据（加载、预处理）。
- 初始化模型。
- 定义损失函数和优化器。
- 执行多个 epoch 的训练（包括前向传播、损失计算、反向传播、参数更新）。
- 评估模型性能。
代码示例：监督学习的典型流程
以下是一个简单的监督学习流程，用于分类任务（例如使用 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 为什么要设置超参数？
合理的超参数设置可以：
- 提升训练效率 ：加速收敛，减少训练时间。
- 提高模型性能 ：避免欠拟合或过拟合。
- 改善稳定性 ：避免训练过程中的数值不稳定或发散。
超参数通常需要通过经验或网格搜索、随机搜索等方法来确定最佳值。
2.3 怎么设置超参数？
以下是常见的超参数设置和推荐值：
- 学习率 ：较小值（如 0.001~0.01）通常较稳定，但训练慢；较大值（如 0.1）可能加速训练，但易导致不收敛。
- 批量大小 ：32、64 或 128 是常用的值，GPU 通常能更好地处理较大的 batch。
- 训练轮数 ：视数据集大小和模型复杂度而定，通常设置为 5~100。
- 优化器 ：推荐从 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 为什么要预处理？
- 提高模型训练效果 ：例如，归一化可以加快收敛速度。
- 减少数据噪声 ：例如，去掉异常值。
- 统一数据格式 ：确保数据符合模型输入要求。
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 为什么需要数据集加载器？
- 批量化处理 ：分批加载可以减少内存占用，加速训练。
- 随机性 ：支持数据打乱（shuffle），有助于减少模型对数据顺序的依赖。
- 并行化 ：支持多线程加载数据，提高数据读取效率。
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 为什么需要后处理？
- 增加数据多样性 ：数据增强通过对原始数据的变换提高模型的泛化能力。
- 简化训练流程 ：通过动态调整避免为每种场景重新处理数据。
- 满足特定需求 ：根据不同模型需求生成合适的输入。
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 为什么要初始化模型？
- 定义网络结构 ：为任务设计合适的模型结构。
- 参数初始化 ：参数初始化对训练过程至关重要，好的初始化方式可以加速收敛并减少梯度消失或爆炸问题。
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）？
- 充分学习数据 ：单次遍历数据（一个 epoch）通常不足以学到有效的参数。
- 渐进式优化 ：每次迭代（mini-batch）更新参数，多个 epoch 能够进一步减少损失。
7.3 训练流程
每个 epoch 的训练包括：
- 前向传播 ：计算模型输出和损失。
- 反向传播 ：通过梯度计算更新参数。
- 评估中间结果 ：打印损失、准确率等指标。
代码示例：多个 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 为什么打印中间结果？
在训练过程中打印中间结果（例如损失和准确率）有以下重要意义：
- 监控训练过程 ：可以观察模型是否正常收敛，避免梯度爆炸或梯度消失。
- 调试和排错 ：如果损失不减小或表现异常，可能是模型结构或超参数设置的问题。
- 评估性能趋势 ：通过观察准确率的变化，判断模型是否欠拟合或过拟合。
8.2 什么是常见的中间结果？
- 训练损失（Training Loss） ：表示模型在训练数据上的误差。
- 验证损失（Validation Loss） ：表示模型在验证数据上的误差，用于监控模型的泛化能力。
- 训练准确率（Training Accuracy） ：模型在训练数据上的分类正确率。
- 验证准确率（Validation Accuracy） ：模型在验证数据上的分类正确率。
8.3 怎么计算和打印中间结果？
- 损失计算 ：通过定义的损失函数
criterion直接计算。 - 准确率计算 ：通过比较模型输出的预测值与真实标签，统计预测正确的数量。
- 打印格式优化 ：可以采用
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()
- 中间结果打印是训练中的重要环节，可以帮助实时了解模型的训练和验证性能。
- 可以通过
print或绘制曲线，直观展示损失和准确率的变化趋势。 - 验证集的使用能有效监控模型的泛化性能，避免过拟合。
