Day41 Python打卡训练营

知识回顾

1.  数据增强

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

3.  batch归一化：调整一个批次的分布，常用与图像数据

4.  特征图：只有卷积操作输出的才叫特征图

5.  调度器：直接修改基础学习率

卷积操作常见流程如下：

1. 输入 → 卷积层 → Batch归一化层（可选） → 池化层 → 激活函数 → 下一层

2.  Flatten -> Dense (with Dropout，可选) -> Dense (Output)

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  # 解决负号显示问题# 检查GPU是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")# 1. 数据预处理
# 训练集：使用多种数据增强方法提高模型泛化能力
train_transform = transforms.Compose([# 随机裁剪图像，从原图中随机截取32x32大小的区域transforms.RandomCrop(32, padding=4),# 随机水平翻转图像（概率0.5）transforms.RandomHorizontalFlip(),# 随机颜色抖动：亮度、对比度、饱和度和色调随机变化transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),# 随机旋转图像（最大角度15度）transforms.RandomRotation(15),# 将PIL图像或numpy数组转换为张量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))
])# 2. 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(root='./data',train=True,download=True,transform=train_transform  # 使用增强后的预处理
)test_dataset = datasets.CIFAR10(root='./data',train=False,transform=test_transform  # 测试集不使用增强
)# 3. 创建数据加载器
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)
# 4. 定义CNN模型的定义（替代原MLP）
class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()  # 继承父类初始化# ---------------------- 第一个卷积块 ----------------------# 卷积层1：输入3通道（RGB），输出32个特征图，卷积核3x3，边缘填充1像素self.conv1 = nn.Conv2d(in_channels=3,       # 输入通道数（图像的RGB通道）out_channels=32,     # 输出通道数（生成32个新特征图）kernel_size=3,       # 卷积核尺寸（3x3像素）padding=1            # 边缘填充1像素，保持输出尺寸与输入相同)# 批量归一化层：对32个输出通道进行归一化，加速训练self.bn1 = nn.BatchNorm2d(num_features=32)# ReLU激活函数：引入非线性，公式：max(0, x)self.relu1 = nn.ReLU()# 最大池化层：窗口2x2，步长2，特征图尺寸减半（32x32→16x16）self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # stride默认等于kernel_size# ---------------------- 第二个卷积块 ----------------------# 卷积层2：输入32通道（来自conv1的输出），输出64通道self.conv2 = nn.Conv2d(in_channels=32,      # 输入通道数（前一层的输出通道数）out_channels=64,     # 输出通道数（特征图数量翻倍）kernel_size=3,       # 卷积核尺寸不变padding=1            # 保持尺寸：16x16→16x16（卷积后）→8x8（池化后）)self.bn2 = nn.BatchNorm2d(num_features=64)self.relu2 = nn.ReLU()self.pool2 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半：16x16→8x8# ---------------------- 第三个卷积块 ----------------------# 卷积层3：输入64通道，输出128通道self.conv3 = nn.Conv2d(in_channels=64,      # 输入通道数（前一层的输出通道数）out_channels=128,    # 输出通道数（特征图数量再次翻倍）kernel_size=3,padding=1            # 保持尺寸：8x8→8x8（卷积后）→4x4（池化后）)self.bn3 = nn.BatchNorm2d(num_features=128)self.relu3 = nn.ReLU()  # 复用激活函数对象（节省内存）self.pool3 = nn.MaxPool2d(kernel_size=2)  # 尺寸减半：8x8→4x4# ---------------------- 全连接层（分类器） ----------------------# 计算展平后的特征维度：128通道 × 4x4尺寸 = 128×16=2048维self.fc1 = nn.Linear(in_features=128 * 4 * 4,  # 输入维度（卷积层输出的特征数）out_features=512          # 输出维度（隐藏层神经元数）)# Dropout层：训练时随机丢弃50%神经元，防止过拟合self.dropout = nn.Dropout(p=0.5)# 输出层：将512维特征映射到10个类别（CIFAR-10的类别数）self.fc2 = nn.Linear(in_features=512, out_features=10)def forward(self, x):# 输入尺寸：[batch_size, 3, 32, 32]（batch_size=批量大小，3=通道数，32x32=图像尺寸）# ---------- 卷积块1处理 ----------x = self.conv1(x)       # 卷积后尺寸：[batch_size, 32, 32, 32]（padding=1保持尺寸）x = self.bn1(x)         # 批量归一化，不改变尺寸x = self.relu1(x)       # 激活函数，不改变尺寸x = self.pool1(x)       # 池化后尺寸：[batch_size, 32, 16, 16]（32→16是因为池化窗口2x2）# ---------- 卷积块2处理 ----------x = self.conv2(x)       # 卷积后尺寸：[batch_size, 64, 16, 16]（padding=1保持尺寸）x = self.bn2(x)x = self.relu2(x)x = self.pool2(x)       # 池化后尺寸：[batch_size, 64, 8, 8]# ---------- 卷积块3处理 ----------x = self.conv3(x)       # 卷积后尺寸：[batch_size, 128, 8, 8]（padding=1保持尺寸）x = self.bn3(x)x = self.relu3(x)x = self.pool3(x)       # 池化后尺寸：[batch_size, 128, 4, 4]# ---------- 展平与全连接层 ----------# 将多维特征图展平为一维向量：[batch_size, 128*4*4] = [batch_size, 2048]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（如果可用）
# 5. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数，适用于多分类任务
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器，学习率0.001
# 引入学习率调度器，在训练过程中动态调整学习率--训练初期使用较大的 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）
)
# scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)  
# # 每5个epoch，LR = LR × 0.1  # scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.5)  
# # 当epoch=10、20、30时，LR = LR × 0.5  # scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=0.0001)  
# # LR在[0.0001, LR_initial]之间按余弦曲线变化，周期为2×T_max  
# 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")

在传统机器学习中,特征工程是一个手动的过程,涉及从原始数据中提取和构造有助于模型学习的特征。
而在深度学习中，特别是CNN，这些层的作用正是从原始输入数据(如图像)中逐层自动学习和提取有用的特征表示。卷积神经网络(CNN)中的卷积、池化层、激活层可以视为自动化的特征工程过程，这些层在神经网络模型中承担了特征工程的角色，代替了人工手动设计特征，实现了自动化的特征学习和提取。

卷积层(convolution)
卷积层的核心是卷积核,他在图片上滑动相乘得到新的输出,这个卷积操作可以取图像特征(轮廓 边缘 深层信息)
想要了解卷积操作，我们需要知道几点
1.卷积核是什么
2.卷积核是如何计算的?

卷积核滑动这个操作叫做卷积，卷积本无意义，卷积核才有意义，设计卷积核是一门艺术这个卷积和概率论中的卷积公式毫无关系。比如手机上的锐化 平滑 饱和度,其实都是特定的卷积核来运算实现,同时我们进行这些操作的时候也有参数可选-----其实这些参数就是不同的卷积核和卷积核滑动过程中涉及到的不同参数。卷积核的参数是在训练中学习到的，训练开始的时候卷积核是随机数初始化的。

语音、图像、文本 最后都会变成矩阵，都可以应用卷积核来卷积提取特征除了对于图像二维卷积，文本可以做一维卷积卷积核的参数包含每个单元上的权重，还有一个偏置。卷积层矩阵乘完也要加上偏置你会发现
卷积如何计算的?
卷积核又叫滤波器，他的尺寸大小叫做感受野,滤波的意思是筛选和过滤，滤波器目的是过滤不需要的信息、加强需要强调的部分。
输入是原始图片，过程是卷积操作，输出是包含了新的特征的图片每个通道上都有自己的卷积，这些通道上卷积操作完还要相加
卷积层的计算过程
每个通道都有一个卷积核，所以3通道的图像会需要一个三通道的卷积核假设有一个 3x3x3 的卷积核(3 个通道,每个通道大小为 3x3)作用于一个 5x5x3 的 RGB 图像块(高 5、宽 5、3 个通道)。卷积核的每个 3x3 通道分别与图像的对应通道进行卷积运算，计算包含几个核心的参数:卷积核尺寸、步长、填充。然后将这3个矩阵对应位置的元素相加(可能再加上偏置值)，就得到一个 3x3的特征图，此特征图即为该卷积核生成的一个输出通道卷积核的通道需要和图像的通道的一致
1个卷积核
1111122 步长越大 下采样的效果越好
首推一个公式

每一层输出的结果就是特征图。特征图可以看作是对输入数据中不同特征的一种表示，它包含了输入数据在不同层次、不同尺度下的特征信息。这个特征图其实也可以展现出来，需要通过归一化到[0,1]或[0,255]后显示为图像。实际上可以能提取图像信息的不止卷积可以提取，VIT(视觉 transformer)、RNN 都可以，这是提取的效果好坏有所区别。
如果有多个这样的卷积核，就会生成多个特征图，这些特征图共同构成了卷积层的输出，输出的通道数等于卷积核的数量。

其中填充的意思是在图像2侧填充为 0的像素，零填充的主要作用是在不改变步长和卷积核大小的情况下，控制输出特征图的尺寸，避免因卷积操作导致图像边缘信息过度丢失。当然还有其他的填充操作，比如复制边缘像素值填充等

所以卷积就是对图像做线性变换,但是是一块一块的做,并非像 MLP 一次做完全部输入的线性变换。那为啥我不给图像直接展平，然后经过全连接，不是更好么?所以这就是卷积设计的巧妙之处，他其实就是个一块一块的全连接，以局部区域为单位进行操作MLP 对整个输入进行全局的线性变换，无法捕捉局部模式。在处理图像时，图像中的重要信息(如边缘、角点)往往是局部的，卷积的局部性使得它能更有效地提取这些局部特征，而 MLP 可能会忽略这些局部信息，因为它将所有像素同等对待，没有考虑空间上的局部相关性。所以这个卷积核越小，考虑到的同部越精细;卷积核越大，考虑到越是全局信息.

@浙大疏锦行