简单CNN
知识回顾
- 数据增强
- 卷积神经网络定义的写法
- batch归一化：调整一个批次的分布，常用与图像数据
- 特征图：只有卷积操作输出的才叫特征图
- 调度器：直接修改基础学习率
卷积操作常见流程如下：
- 输入 → 卷积层 → Batch归一化层（可选） → 池化层 → 激活函数 → 下一层
- Flatten -> Dense (with Dropout，可选) -> Dense (Output)
作业：尝试手动修改下不同的调度器和CNN的结构，观察训练的差异。
笔记：
1. 数据增强
核心：通过对原始数据进行随机变换（如旋转、翻转、缩放、加噪等），增加数据多样性，从而提升模型的泛化能力，减少过拟合。是训练深度学习模型（尤其是图像任务）的常用技巧。
2. 卷积神经网络定义的写法
核心：CNN 的定义依赖于具体框架（如 PyTorch、TensorFlow），但核心结构一致 ------ **通常包含输入层、卷积层（提取局部特征）、池化层（降维）、激活层（引入非线性）、全连接层（输出结果）**等。关键是根据任务需求合理堆叠层结构，而非固定 "写法"。
3. batch 归一化
核心 ：对每个批次的输入数据进行标准化（调整为均值≈0、方差≈1 的分布） ，目的是缓解 "内部协变量偏移"，稳定训练、加速收敛。虽常用于图像数据，但不限于图像（文本、语音等任务也可使用）。
4. 特征图
核心：特征图是神经网络中各层输出的、承载输入数据特征信息的张量。不仅卷积层的输出是特征图，池化层、激活层（如 ReLU）甚至部分中间全连接层的输出，只要包含特征信息，都可称为特征图。卷积层输出是最典型的特征图，但并非唯一。
5. 调度器
核心：学习率调度器的作用是**根据训练进度（如轮次、迭代次数）动态调整 "当前学习率"，而非修改 "基础学习率"（初始设定的学习率）。例如，按固定步长衰减、余弦退火等，都是基于基础学习率调整当前值，基础学习率本身不变。
作业
python
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets,transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['font.family'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
device = torch.device('cuda'if torch.cuda.is_available() else 'cpu')
print(f'使用设备：{device}')
train_transform = transforms.Compose([
transforms.RandomCrop(32,padding=4),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2,contrast=0.2,saturation=0.2,hue=0.1),
transforms.RandomRotation(15),
transforms.ToTensor(),
transforms.Normalize((0.4914,0.4822,0.4465),(0.2023,0.1994,0.2010))
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914,0.4822,0.4465),(0.2023,0.1994,0.2010))
])
train_dataset = datasets.CIFAR10(
root='./data',
train=True,
download=True,
transform=train_transform
)
test_dataset = datasets.CIFAR10(
root='./data',
train=False,
transform=test_transform
)
batch_size=64
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=batch_size,shuffle=False)
python
class CNN(nn.Module):
def __init__(self):
super(CNN,self).__init__()
self.conv1 = nn.Conv2d(
in_channels=3,
out_channels=32,
kernel_size=3,
padding=1
)
self.bn1 = nn.BatchNorm2d(num_features=32)
self.relu1 = nn.ReLU()
self.pool1=nn.MaxPool2d(kernel_size=2,stride=2)
self.conv2 = nn.Conv2d(
in_channels=32,
out_channels=64,
kernel_size=3,
padding=1
)
self.bn2=nn.BatchNorm2d(num_features=64)
self.relu2=nn.ReLU()
self.pool2=nn.MaxPool2d(kernel_size=2)
self.conv3 = nn.Conv2d(
in_channels=64,
out_channels=128,
kernel_size=3,
padding=1
)
self.bn3 = nn.BatchNorm2d(num_features=128)
self.relu3 = nn.ReLU()
self.pool3 = nn.MaxPool2d(kernel_size=2)
self.fc1 = nn.Linear(
in_features=128*4*4,
out_features=512
)
self.dropout = nn.Dropout(p=0.5)
self.fc2 = nn.Linear(in_features=512,out_features=10)
def forward(self,x):
x=self.conv1(x)
x=self.bn1(x)
x= self.relu1(x)
x=self.pool1(x)
x=self.conv2(x)
x=self.bn2(x)
x=self.relu2(x)
x=self.pool2(x)
x = self.conv3(x) # 卷积后尺寸：[batch_size, 128, 8, 8]（padding=1保持尺寸）
x = self.bn3(x)
x = self.relu3(x)
x = self.pool3(x)
x = x.view(-1, 128 * 4 * 4) # -1自动计算批量维度，保持批量大小不变
x = self.fc1(x) # 全连接层：2048→512，尺寸变为[batch_size, 512]
x = self.relu3(x) # 激活函数（复用relu3，与卷积块3共用）
x = self.dropout(x) # Dropout随机丢弃神经元，不改变尺寸
x = self.fc2(x) # 全连接层：512→10，尺寸变为[batch_size, 10]（未激活，直接输出logits）
return x # 输出未经过Softmax的logits，适用于交叉熵损失函
# 初始化模型
model = CNN()
model = model.to(device) # 将模型移至GPU（如果可用）
python
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam优化器
# 引入学习率调度器，在训练过程中动态调整学习率--训练初期使用较大的 LR 快速降低损失，训练后期使用较小的 LR 更精细地逼近全局最优解。
# 在每个 epoch 结束后，需要手动调用调度器来更新学习率，可以在训练过程中调用 scheduler.step()
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
optimizer, # 指定要控制的优化器（这里是Adam）
mode='min', # 监测的指标是"最小化"（如损失函数）
patience=3, # 如果连续3个epoch指标没有改善，才降低LR
factor=0.5 # 降低LR的比例（新LR = 旧LR × 0.5）
)
python
# 5. 训练模型（记录每个 iteration 的损失）
def train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs):
model.train() # 设置为训练模式
# 记录每个 iteration 的损失
all_iter_losses = [] # 存储所有 batch 的损失
iter_indices = [] # 存储 iteration 序号
# 记录每个 epoch 的准确率和损失
train_acc_history = []
test_acc_history = []
train_loss_history = []
test_loss_history = []
for epoch in range(epochs):
running_loss = 0.0
correct = 0
total = 0
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device) # 移至GPU
optimizer.zero_grad() # 梯度清零
output = model(data) # 前向传播
loss = criterion(output, target) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新参数
# 记录当前 iteration 的损失
iter_loss = loss.item()
all_iter_losses.append(iter_loss)
iter_indices.append(epoch * len(train_loader) + batch_idx + 1)
# 统计准确率和损失
running_loss += iter_loss
_, predicted = output.max(1)
total += target.size(0)
correct += predicted.eq(target).sum().item()
# 每100个批次打印一次训练信息
if (batch_idx + 1) % 100 == 0:
print(f'Epoch: {epoch+1}/{epochs} | Batch: {batch_idx+1}/{len(train_loader)} '
f'| 单Batch损失: {iter_loss:.4f} | 累计平均损失: {running_loss/(batch_idx+1):.4f}')
# 计算当前epoch的平均训练损失和准确率
epoch_train_loss = running_loss / len(train_loader)
epoch_train_acc = 100. * correct / total
train_acc_history.append(epoch_train_acc)
train_loss_history.append(epoch_train_loss)
# 测试阶段
model.eval() # 设置为评估模式
test_loss = 0
correct_test = 0
total_test = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += criterion(output, target).item()
_, predicted = output.max(1)
total_test += target.size(0)
correct_test += predicted.eq(target).sum().item()
epoch_test_loss = test_loss / len(test_loader)
epoch_test_acc = 100. * correct_test / total_test
test_acc_history.append(epoch_test_acc)
test_loss_history.append(epoch_test_loss)
# 更新学习率调度器
scheduler.step(epoch_test_loss)
print(f'Epoch {epoch+1}/{epochs} 完成 | 训练准确率: {epoch_train_acc:.2f}% | 测试准确率: {epoch_test_acc:.2f}%')
# 绘制所有 iteration 的损失曲线
plot_iter_losses(all_iter_losses, iter_indices)
# 绘制每个 epoch 的准确率和损失曲线
plot_epoch_metrics(train_acc_history, test_acc_history, train_loss_history, test_loss_history)
return epoch_test_acc # 返回最终测试准确率
# 6. 绘制每个 iteration 的损失曲线
def plot_iter_losses(losses, indices):
plt.figure(figsize=(10, 4))
plt.plot(indices, losses, 'b-', alpha=0.7, label='Iteration Loss')
plt.xlabel('Iteration（Batch序号）')
plt.ylabel('损失值')
plt.title('每个 Iteration 的训练损失')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
# 7. 绘制每个 epoch 的准确率和损失曲线
def plot_epoch_metrics(train_acc, test_acc, train_loss, test_loss):
epochs = range(1, len(train_acc) + 1)
plt.figure(figsize=(12, 4))
# 绘制准确率曲线
plt.subplot(1, 2, 1)
plt.plot(epochs, train_acc, 'b-', label='训练准确率')
plt.plot(epochs, test_acc, 'r-', label='测试准确率')
plt.xlabel('Epoch')
plt.ylabel('准确率 (%)')
plt.title('训练和测试准确率')
plt.legend()
plt.grid(True)
# 绘制损失曲线
plt.subplot(1, 2, 2)
plt.plot(epochs, train_loss, 'b-', label='训练损失')
plt.plot(epochs, test_loss, 'r-', label='测试损失')
plt.xlabel('Epoch')
plt.ylabel('损失值')
plt.title('训练和测试损失')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
# 8. 执行训练和测试
epochs = 20 # 增加训练轮次以获得更好效果
print("开始使用CNN训练模型...")
final_accuracy = train(model, train_loader, test_loader, criterion, optimizer, scheduler, device, epochs)
print(f"训练完成！最终测试准确率: {final_accuracy:.2f}%")
# # 保存模型
# torch.save(model.state_dict(), 'cifar10_cnn_model.pth')
# print("模型已保存为: cifar10_cnn_model.pth")开始使用CNN训练模型...
Epoch: 1/20 | Batch: 100/782 | 单Batch损失: 1.8709 | 累计平均损失: 2.0590
Epoch: 1/20 | Batch: 200/782 | 单Batch损失: 1.6807 | 累计平均损失: 1.9324
Epoch: 1/20 | Batch: 300/782 | 单Batch损失: 1.6498 | 累计平均损失: 1.8578
Epoch: 1/20 | Batch: 400/782 | 单Batch损失: 1.4804 | 累计平均损失: 1.8070
Epoch: 1/20 | Batch: 500/782 | 单Batch损失: 1.6850 | 累计平均损失: 1.7689
Epoch: 1/20 | Batch: 600/782 | 单Batch损失: 1.5303 | 累计平均损失: 1.7388
Epoch: 1/20 | Batch: 700/782 | 单Batch损失: 1.5416 | 累计平均损失: 1.7088
Epoch 1/20 完成 | 训练准确率: 38.06% | 测试准确率: 53.42%
Epoch: 2/20 | Batch: 100/782 | 单Batch损失: 1.3082 | 累计平均损失: 1.4381
Epoch: 2/20 | Batch: 200/782 | 单Batch损失: 1.2268 | 累计平均损失: 1.3850
Epoch: 2/20 | Batch: 300/782 | 单Batch损失: 1.0096 | 累计平均损失: 1.3600
Epoch: 2/20 | Batch: 400/782 | 单Batch损失: 1.2103 | 累计平均损失: 1.3390
Epoch: 2/20 | Batch: 500/782 | 单Batch损失: 1.3138 | 累计平均损失: 1.3202
Epoch: 2/20 | Batch: 600/782 | 单Batch损失: 1.2625 | 累计平均损失: 1.3034
Epoch: 2/20 | Batch: 700/782 | 单Batch损失: 1.2830 | 累计平均损失: 1.2835
Epoch 2/20 完成 | 训练准确率: 54.25% | 测试准确率: 64.37%
Epoch: 3/20 | Batch: 100/782 | 单Batch损失: 1.1114 | 累计平均损失: 1.1357
Epoch: 3/20 | Batch: 200/782 | 单Batch损失: 1.1303 | 累计平均损失: 1.1332
Epoch: 3/20 | Batch: 300/782 | 单Batch损失: 1.2957 | 累计平均损失: 1.1235
Epoch: 3/20 | Batch: 400/782 | 单Batch损失: 1.0679 | 累计平均损失: 1.1129
Epoch: 3/20 | Batch: 500/782 | 单Batch损失: 0.6953 | 累计平均损失: 1.1115
Epoch: 3/20 | Batch: 600/782 | 单Batch损失: 1.1491 | 累计平均损失: 1.0991
Epoch: 3/20 | Batch: 700/782 | 单Batch损失: 1.1106 | 累计平均损失: 1.0903
Epoch 3/20 完成 | 训练准确率: 60.93% | 测试准确率: 70.62%
...
Epoch: 20/20 | Batch: 500/782 | 单Batch损失: 0.5230 | 累计平均损失: 0.6353
Epoch: 20/20 | Batch: 600/782 | 单Batch损失: 0.7573 | 累计平均损失: 0.6336
Epoch: 20/20 | Batch: 700/782 | 单Batch损失: 0.6212 | 累计平均损失: 0.6346
Epoch 20/20 完成 | 训练准确率: 77.75% | 测试准确率: 80.30%
