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

DAY 41 简单CNN-2025.10.5

news 2025/10/6 7:06:28

简单CNN

知识回顾

数据增强
卷积神经网络定义的写法
batch归一化：调整一个批次的分布，常用与图像数据
特征图：只有卷积操作输出的才叫特征图
调度器：直接修改基础学习率

卷积操作常见流程如下：

输入 → 卷积层 → Batch归一化层（可选） → 池化层 → 激活函数 → 下一层
Flatten -> Dense (with Dropout，可选) -> Dense (Output)

作业：尝试手动修改下不同的调度器和CNN的结构，观察训练的差异。

笔记：

1. 数据增强

核心：通过对原始数据进行随机变换（如旋转、翻转、缩放、加噪等），增加数据多样性，从而提升模型的泛化能力，减少过拟合。是训练深度学习模型（尤其是图像任务）的常用技巧。

2. 卷积神经网络定义的写法

核心：CNN 的定义依赖于具体框架（如 PyTorch、TensorFlow），但核心结构一致 —— **通常包含输入层、卷积层（提取局部特征）、池化层（降维）、激活层（引入非线性）、全连接层（输出结果）**等。关键是根据任务需求合理堆叠层结构，而非固定 “写法”。

3. batch 归一化

核心：对每个批次的输入数据进行标准化（调整为均值≈0、方差≈1 的分布），目的是缓解 “内部协变量偏移”，稳定训练、加速收敛。虽常用于图像数据，但不限于图像（文本、语音等任务也可使用）。

4. 特征图

核心：特征图是神经网络中各层输出的、承载输入数据特征信息的张量。不仅卷积层的输出是特征图，池化层、激活层（如 ReLU）甚至部分中间全连接层的输出，只要包含特征信息，都可称为特征图。卷积层输出是最典型的特征图，但并非唯一。

5. 调度器

核心：学习率调度器的作用是**根据训练进度（如轮次、迭代次数）动态调整 “当前学习率”，而非修改 “基础学习率”（初始设定的学习率）。例如，按固定步长衰减、余弦退火等，都是基于基础学习率调整当前值，基础学习率本身不变。

作业

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 npplt.rcParams['font.family'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = Falsedevice = 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)

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（如果可用）

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指标没有改善，才降低LRfactor=0.5        # 降低LR的比例（新LR = 旧LR × 0.5）
)

# 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.0correct = 0total = 0for batch_idx, (data, target) in enumerate(train_loader):data, target = data.to(device), target.to(device)  # 移至GPUoptimizer.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 / totaltrain_acc_history.append(epoch_train_acc)train_loss_history.append(epoch_train_loss)# 测试阶段model.eval()  # 设置为评估模式test_loss = 0correct_test = 0total_test = 0with 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_testtest_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")