Pytorch入门P4周学习打卡：猴痘病识别
- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊
前言
本篇是我训练营的第四次学习，主要目标是使用 PyTorch 完成一个本地图片二分类任务——猴痘图片识别。P1 周跑通了 MNIST 手写数字识别、P2 周理解了 CIFAR10 彩色图片和 CNN 的 shape 变化、P3 周掌握了本地自定义数据集的加载和 BatchNorm，本周的任务则在上一周的基础上进一步增加了：保存训练过程中效果最好的模型参数，并且加载模型去预测本地指定图片。同时要求调整网络结构使测试集 accuracy 达到 88%。
本周的猴痘病图片识别任务一共有 2 个类别：Monkeypox 猴痘、Others 其他
从本周开始，学习重心逐渐从“跑通流程”转向“优化模型性能”，模型的搭建和调整是深度学习中的重点。
感谢K同学啊老师的教学，以及 ChatGPT 和 Kimi。
P1-P4 周整体对比
| 对比项目 | P1 周：MNIST 手写数字识别 | P2 周：CIFAR10 彩色图片识别 | P3 周：天气识别 | P4 周：猴痘二分类识别 |
|---|---|---|---|---|
| 数据来源 | torchvision 内置数据集 | torchvision 内置数据集 | 本地文件夹数据集 | 本地文件夹数据集 |
| 图像类型 | 灰度图 | RGB 彩色图 | RGB 彩色图 | RGB 彩色图 |
| 输入 shape | [32, 1, 28, 28] |
[32, 3, 32, 32] |
[32, 3, 224, 224] |
[32, 3, 224, 224] |
| 类别数 | 10 类 | 10 类 | 4 类 | 2 类 |
| 数据加载方式 | datasets.MNIST |
datasets.CIFAR10 |
datasets.ImageFolder |
datasets.ImageFolder |
| 是否手动划分训练集/测试集 | 否 | 否 | 是 | 是 |
一、准备工作
1. 设置运行设备：GPU 或 CPU
和前面一样，首先判断当前设备是否支持 GPU，如果支持就使用 CUDA 加速，否则使用 CPU。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
device(type='cpu')
这一步完全相同，程序会自动判断当前电脑能不能使用 CUDA。如果可以使用，就把模型和数据放到 GPU 上运行；如果不可以，就放到 CPU 上运行。我自己安装的是 CPU 版本 PyTorch，所以只有CPU。
2. 关于猴痘病图片识别数据集
本周使用的是猴痘病图片数据集，它需要自己下载并放在本地 data 文件夹下，文件夹结构如下：
data/
├── Monkeypox/ # 猴痘病图片
└── Others/ # 其他（非猴痘）图片
数据集共包含 2 个类别：
| 类别 | 标签含义 | 说明 |
|---|---|---|
Monkeypox |
猴痘相关图片 | 模型需要识别的目标类别 |
Others |
其他皮肤图片 | 非猴痘类别，用来与 Monkeypox 区分 |
P3 周和 P4 周的数据加载方式基本一致，都是使用 pathlib.Path + datasets.ImageFolder 来读取本地图片。
P3 周天气识别是 4 分类； P4 周猴痘识别是 2 分类；
3. 导入本地数据集
首先使用 pathlib.Path 读取本地数据文件夹，并提取类别名称。
import os,PIL,random,pathlib
data_dir = './data/'
data_dir = pathlib.Path(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
classeNames
['Monkeypox', 'Others']
这一段的意思是：
pathlib.Path(data_dir)：把字符串路径./data/转换成 Path 对象；- 使用
glob('*')获取data_dir路径下的所有子文件夹路径； - 通过
split("\\")对每条路径进行分割，提取出文件夹名称（即类别名称），存入classeNames列表中。 - 每一个子文件夹名称就是一个类别；
- 最终得到
classeNames = ['Monkeypox', 'Others']。
4. 数据预处理：transforms.Compose()
本周的图片来自本地文件夹，不同图片的原始尺寸可能不同。CNN 网络要求输入图片大小一致，所以要先用 transforms 对图片进行统一处理。
total_datadir = './data/'
# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
transforms.Resize([224, 224]), # 将输入图片resize成统一尺寸
transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
transforms.Normalize( # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]) # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)
total_data
运行结果：
Dataset ImageFolder
Number of datapoints: 2142
Root location: ./data/
StandardTransform
Transform: Compose(
Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=True)
ToTensor()
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
)
这说明数据集一共有 2142 张图片，根目录是 ./data/。transforms.Resize([224, 224]) 将不同大小的原始图片统一 resize 成 224 × 224 像素。神经网络一次训练时需要把多张图片拼成一个 batch，如果每张图片大小不同，就无法组成同一个 Tensor，本地图片，尺寸可能不一致，所以需要手动 resize。transforms.ToTensor() 将 PIL Image 或 numpy.ndarray 格式的图片转换为 PyTorch 的 Tensor 格式，同时把像素值从 0-255 缩放到 0-1 之间。转换后的图片 shape 是 [3, 224, 224] ，其中：3 → RGB 三个通道；224 → 图片高度；224 → 图片宽度；transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) 对 RGB 三个通道进行标准化处理。
🌟 mean 与 std 数值是怎么来的？
这些均值和标准差不是从猴痘数据集计算出来的，而是通过计算 ImageNet 数据集 中所有训练图像的 RGB 通道均值和标准差得出的，具体计算过程如下：
- 获取 ImageNet 数据集：ImageNet 包含约 120 万张训练图像，每张图像有 RGB 三个通道。
- 计算均值（Mean）：
- Red 通道均值 ≈ 0.485
- Green 通道均值 ≈ 0.456
- Blue 通道均值 ≈ 0.406
- 计算标准差（Standard Deviation）：
- Red 通道标准差 ≈ 0.229
- Green 通道标准差 ≈ 0.224
- Blue 通道标准差 ≈ 0.225
这组均值和标准差通常来自 ImageNet 数据集的 RGB 通道统计值。它们经常用于自然图片分类任务，尤其是在输入尺寸为 224 × 224 的图像任务中比较常见。
5. 使用 ImageFolder 自动生成标签
total_data.class_to_idx
运行结果：
{'Monkeypox': 0, 'Others': 1}
ImageFolder 会根据文件夹名称自动分配标签，total_data.class_to_idx 是一个存储了数据集类别和对应索引的字典。Monkeypox 对应索引 0，Others 对应索引 1。
6. 划分训练集和测试集
因为本周数据集没有提前分好训练集和测试集，所以需要使用 random_split 手动划分。
train_size = int(0.8 * len(total_data))
test_size = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset
(<torch.utils.data.dataset.Subset at 0x1e289ad0e30>,
<torch.utils.data.dataset.Subset at 0x1e289ad3020>)
这一段的意思是：
train_size = int(0.8 * len(total_data))：训练集大小为总数据量的 80%。总数据量是 2142，所以训练集大小为int(0.8 × 2142) = 1713。test_size = len(total_data) - train_size：测试集大小为剩余的 20%，即2142 - 1713 = 429。torch.utils.data.random_split(total_data, [train_size, test_size])：将数据集随机打乱后，按照[1713, 429]的比例划分为训练集和测试集。因为是随机划分，所以每次运行得到的训练集和测试集可能不完全一样。如果想让结果更稳定，可以设置随机种子。
查看训练集和测试集大小：
train_size, test_size
运行结果：
(1713, 429)
7. 创建 DataLoader 数据加载器
划分好数据集后，用 DataLoader 包装成可以批量加载的数据迭代器。
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=1)
这一段和前几周非常相似。DataLoader 的作用就是把数据按 batch 送入模型。这里设置 batch_size = 32，表示每次送入 32 张图片。shuffle=True 表示每个 epoch 开始前打乱数据顺序，这样可以减少模型记住固定顺序的可能。num_workers=1 用 1 个子进程辅助加载数据 。
8. 查看一个 batch 的数据格式
for X, y in test_dl:
print("Shape of X [N, C, H, W]: ", X.shape)
print("Shape of y: ", y.shape, y.dtype)
break
运行结果：
Shape of X [N, C, H, W]: torch.Size([32, 3, 224, 224])
Shape of y: torch.Size([32]) torch.int64
这个 shape 可以拆开理解：
torch.Size([32, 3, 224, 224])
↑ ↑ ↑ ↑
N C H W
│ │ │ └── 宽度：224 像素
│ │ └─────── 高度：224 像素
│ └──────────── 通道数：3，RGB 彩色图
└──────────────── batch_size，一批 32 张图片
四周数据集 shape 对比：
MNIST: [32, 1, 28, 28]
CIFAR10: [32, 3, 32, 32]
天气图像: [32, 3, 224, 224]
猴痘图像: [32, 3, 224, 224] ← 本周
| 项目 | P1 周 MNIST | P2 周 CIFAR10 | P3 周天气识别 | P4 周猴痘识别 |
|---|---|---|---|---|
| shape | [32, 1, 28, 28] |
[32, 3, 32, 32] |
[32, 3, 224, 224] |
[32, 3, 224, 224] |
| 通道数 C | 1（灰度） | 3（RGB） | 3（RGB） | 3（RGB） |
| 高 H | 28 | 32 | 224 | 224 |
| 宽 W | 28 | 32 | 224 | 224 |
| 单张图像素数 | 784 | 3072 | 150528 | 150528 |
可以看出，P4 周和 P3 周在输入图片尺寸上完全一样，都是 224 × 224 的 RGB 彩色图。但 本周的类别数从 4 类变成了 2 类，是二分类问题。
二、构建简单的 CNN 网络
本周使用的是一个带有 BatchNorm 的 CNN 网络。整体结构可以分为两部分：
- 特征提取网络：用卷积层、池化层提取图片特征；
- 分类网络：用全连接层根据提取到的特征进行分类。
本周的猴痘病图片分类任务有 2 个类别，所以最后一层输出维度是：len(classeNames)，也就是 2。本周网络相比 P3 周引入了 BatchNorm（批归一化层）。
1. torch.nn.Conv2d() 卷积层
卷积层用于提取图片的局部特征，比如猴痘病症的皮肤纹理、颜色变化等。
函数原型：
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0,
dilation=1, groups=1, bias=True, padding_mode='zeros',
device=None, dtype=None)
常用参数解释：
| 参数 | 含义 | 本周代码中的体现 |
|---|---|---|
in_channels |
输入图片通道数 | 第一层是 3，因为猴痘图片是 RGB 彩色图 |
out_channels |
输出特征图数量 | 第一层输出 12 个特征图 |
kernel_size |
卷积核大小 | 本周使用 5 × 5 |
stride |
卷积步长 | 本周为 1 |
padding |
是否填充边缘 | 本周为 0，不填充 |
例如：
self.conv1 = nn.Conv2d(
in_channels=3,
out_channels=12,
kernel_size=5,
stride=1,
padding=0
)
这一句表示：输入是 RGB 三通道图片，经过第一层卷积后，输出 12 个特征图。
2. torch.nn.BatchNorm2d() 批归一化层
函数原型：
torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True,
track_running_stats=True)
本周模型中加入了 BatchNorm2d，BatchNorm 的作用可以简单理解为：在训练过程中，对每一批数据的特征进行标准化，让数据分布更稳定，从而帮助模型更快、更稳定地训练。
具体来说，BatchNorm 会：
- 计算当前 batch 中每个通道的均值和方差；
- 用这些统计量对数据进行归一化；
- 引入可学习的缩放参数（gamma）和平移参数（beta），让网络自己决定是否需要恢复原始分布。
为什么使用 BatchNorm？
- 加速训练：归一化后的数据分布更稳定，可以使用更大的学习率；
- 减少 Internal Covariate Shift（内部协变量偏移）：即减少网络各层之间数据分布的变化；
- 有一定正则化效果：因为每个 batch 的统计量不同，相当于给网络引入了噪声，减少了过拟合的风险。
P3 周天气识别也使用了 BatchNorm，P1 和 P2 周没有使用。
3. torch.nn.MaxPool2d() 池化层
池化层用于压缩特征图尺寸，减少计算量，同时保留比较明显的特征。
函数原型：
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1,
return_indices=False, ceil_mode=False)
| 参数 | 含义 |
|---|---|
kernel_size |
最大的窗口大小 |
stride |
窗口的步幅，默认值为 kernel_size |
本周使用 nn.MaxPool2d(2, 2)，使用 2 × 2 的最大池化窗口，步长也是 2，这一句表示所以每经过一次池化，图片的高和宽大约都会缩小一半。
4. torch.nn.Linear() 全连接层
卷积和池化之后，模型得到的是多维特征图。但是全连接层需要的是二维数据，所以要先把特征图展平成一维向量。
函数原型：
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
全连接层：
self.fc1 = nn.Linear(24*50*50, len(classeNames))
因为猴痘识别有 2 个类别（Monkeypox 和 Others），len(classeNames) 等于 2，所以输出是 2 个分类分数。
这里 24*50*50 = 60000，是经过卷积和池化后展平的维度。
5. 卷积层和全连接层之间的转换
在卷积层和全连接层之间，可以使用 torch.flatten()、x.view() 或 torch.nn.Flatten()。本周代码中使用的是 x.view(-1, 24*50*50)。
torch.flatten()：返回一个新的展平后的张量，不会改变原张量；x.view()：直接在原有数据上进行形状变换，不复制数据；torch.nn.Flatten()：是一个 nn.Module，可以像其他层一样放在 nn.Sequential 中使用。
6. 定义 CNN 模型
import torch.nn.functional as F
class Network_bn(nn.Module):
def __init__(self):
super(Network_bn, self).__init__()
"""
nn.Conv2d()函数：
第一个参数（in_channels）是输入的channel数量
第二个参数（out_channels）是输出的channel数量
第三个参数（kernel_size）是卷积核大小
第四个参数（stride）是步长，默认为1
第五个参数（padding）是填充大小，默认为0
"""
self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
self.bn1 = nn.BatchNorm2d(12)
self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
self.bn2 = nn.BatchNorm2d(12)
self.pool = nn.MaxPool2d(2,2)
self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
self.bn4 = nn.BatchNorm2d(24)
self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
self.bn5 = nn.BatchNorm2d(24)
self.fc1 = nn.Linear(24*50*50, len(classeNames))
def forward(self, x):
x = F.relu(self.bn1(self.conv1(x)))
x = F.relu(self.bn2(self.conv2(x)))
x = self.pool(x)
x = F.relu(self.bn4(self.conv4(x)))
x = F.relu(self.bn5(self.conv5(x)))
x = self.pool(x)
x = x.view(-1, 24*50*50)
x = self.fc1(x)
return x
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
model = Network_bn().to(device)
model
Using cpu device
Network_bn(
(conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
(bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, bias=True, track_running_stats=True)
(conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
(bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, bias=True, track_running_stats=True)
(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
(bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, bias=True, track_running_stats=True)
(conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
(bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, bias=True, track_running_stats=True)
(fc1): Linear(in_features=60000, out_features=2, bias=True)
)
网络结构分析：
P4 周的网络和 P3 周几乎完全相同，有以下特点：
- 使用了 BatchNorm：每个卷积层后面都紧跟一个
nn.BatchNorm2d，P1 和 P2 周没有； - 卷积核大小是 5×5：P1 和 P2 周使用的是 3×3，P3 和 P4 周使用的是 5×5，每次卷积后尺寸减少 4；
- 没有中间全连接层：P1 和 P2 周都有
fc1 → fc2两个全连接层，P3 和 P4 周只有一个fc1； - 输入尺寸更大：224 × 224 的图片经过网络处理后，展平维度达到了 60000。
P3 周和 P4 周网络结构对比：
| 项目 | P3 周天气识别 | P4 周猴痘识别 |
|---|---|---|
| 卷积核大小 | 5 × 5 | 5 × 5 |
| 卷积层数 | 4 层 | 4 层 |
| 池化层数 | 2 层 | 2 层 |
| BatchNorm 层数 | 4 层 | 4 层 |
| 全连接层数 | 1 层 | 1 层 |
| 展平维度 | 60000 | 60000 |
| 输出类别数 | 4 | 2 |
| 总参数量 | ~254,320 | ~254,318 |
P3 周和 P4 周的模型结构几乎完全一致，唯一的区别是最后一层全连接层的输出维度不同——P3 周输出 4（4 类天气），P4 周输出 2（猴痘/其他）。
三、CNN 网络 shape 变化推导
本周输入图片被统一 resize 成：[3, 224, 224]，其中：3：RGB 三个通道、224 ：图片高度、224：图片宽度。
1. 卷积层输出尺寸公式
普通卷积层，输出尺寸公式是：
输出尺寸 = floor((输入尺寸 + 2 × padding - kernel_size) / stride + 1)
本周代码中，卷积层基本使用默认参数：
kernel_size = 5
stride = 1
padding = 0
所以公式可以简化成：
输出尺寸 = 输入尺寸 - 5 + 1 = 输入尺寸 - 4
也就是说，每经过一个 5 × 5 且不加 padding 的卷积层，高和宽都会减少 4。
2. 池化层输出尺寸公式
池化层是：
nn.MaxPool2d(2, 2)
当 stride 不设置时，默认等于 kernel_size，所以这里相当于：
kernel_size = 2
stride = 2
可以简单理解为：每经过一次 2 × 2 最大池化，高和宽大约变成原来的一半。
3. 完整 shape 推导
输入图片
[3, 224, 224]
第一层卷积 conv1
self.conv1 = nn.Conv2d(3, 12, kernel_size=5)
输入通道数从 3 变成输出通道数 12。
图片大小变化：
224 × 224 → 220 × 220
所以输出变成：
[12, 220, 220]
第二层卷积 conv2
self.conv2 = nn.Conv2d(12, 12, kernel_size=5)
输入通道数从 12 变成输出通道数 12。
图片大小变化：
220 × 220 → 216 × 216
所以输出变成：
[12, 216, 216]
第一层池化 pool1
self.pool1 = nn.MaxPool2d(2, 2)
图片大小减半：
216 × 216 → 108 × 108
所以输出变成：
[12, 108, 108]
第三层卷积 conv4
self.conv4 = nn.Conv2d(12, 24, kernel_size=5)
输入通道数从 12 变成输出通道数 24。
图片大小变化：
108 × 108 → 104 × 104
所以输出变成：
[24, 104, 104]
第四层卷积 conv5
self.conv5 = nn.Conv2d(24, 24, kernel_size=5)
通道数不变，图片大小变化：
104 × 104 → 100 × 100
所以输出变成：
[24, 100, 100]
第二层池化 pool1
self.pool2 = nn.MaxPool2d(2, 2)
图片大小减半：
100 × 100 → 50 × 50
所以输出变成：
[24, 50, 50]
Flatten 展平
进入全连接层之前，需要把多维特征图展平成一维向量：
24 × 50 × 50 = 60000
所以：
self.fc1 = nn.Linear(24*50*50, len(classeNames))
这里的 60000 就是这样来的。
完整结构汇总
输入：3, 224, 224
↓
Conv2d(3, 12, kernel_size=5)
输出：12, 220, 220
↓
BatchNorm2d(12) + ReLU
↓
Conv2d(12, 12, kernel_size=5)
输出：12, 216, 216
↓
BatchNorm2d(12) + ReLU
↓
MaxPool2d(2, 2)
输出：12, 108, 108
↓
Conv2d(12, 24, kernel_size=5)
输出：24, 104, 104
↓
BatchNorm2d(24) + ReLU
↓
Conv2d(24, 24, kernel_size=5)
输出：24, 100, 100
↓
BatchNorm2d(24) + ReLU
↓
MaxPool2d(2, 2)
输出：24, 50, 50
↓
Flatten 展平：24 × 50 × 50 = 60000
↓
Linear(60000, 2)
↓
输出：2 个类别分数
这一部分和 P3 周完全一致，区别主要是最后输出类别数从 4 变成 2。
四、模型参数量理解
本周的模型参数量可以分成三部分：卷积层参数、BatchNorm 参数、全连接层参数。
1. 卷积层参数量怎么算
卷积层参数量公式：参数量 = 输出通道数 × (输入通道数 × 卷积核高 × 卷积核宽 + bias)
其中 + bias 是因为每个输出通道通常都有一个偏置项。
conv1 参数量
nn.Conv2d(3, 12, kernel_size=5)
12 × (3 × 5 × 5 + 1)
= 12 × 76
= 912
conv2 参数量
nn.Conv2d(12, 12, kernel_size=5)
12 × (12 × 5 × 5 + 1)
= 12 × 301
= 3612
conv4 参数量
nn.Conv2d(12, 24, kernel_size=5)
24 × (12 × 5 × 5 + 1)
= 24 × 301
= 7224
conv5 参数量
nn.Conv2d(24, 24, kernel_size=5)
24 × (24 × 5 × 5 + 1)
= 24 × 601
= 14424
卷积层参数量合计：
912 + 3612 + 7224 + 14424 = 26172
2. BatchNorm 参数量
BatchNorm 的参数量 = 2 × num_features（gamma 和 beta 各一个）。gamma：缩放参数；beta：平移参数。
| BatchNorm 层 | num_features | 参数量 |
|---|---|---|
| bn1 | 12 | 24 |
| bn2 | 12 | 24 |
| bn4 | 24 | 48 |
| bn5 | 24 | 48 |
| 合计 | 144 |
3. 全连接层参数量
全连接层参数量公式：参数量 = 输入特征数 × 输出特征数 + 输出特征数对应的 bias
全连接层是：
nn.Linear(24*50*50, 2)
也就是：nn.Linear(60000, 2)
参数量为：60000 × 2 + 2 = 120002
可以看出，本周模型的大部分参数仍然来自最后的全连接层。这是因为输入图片尺寸是 224 × 224，经过卷积和池化后展平维度仍然有 60000。
4. 模型参数量对比
| 模型 | 总参数量 | 主要差异 |
|---|---|---|
| MNIST CNN | 121,930 | 2 卷积 + 2 池化，输入 28×28，2 个全连接层 |
| CIFAR10 CNN | 246,474 | 3 卷积 + 3 池化，输入 32×32，2 个全连接层 |
| 天气识别 CNN | ~254,320 | 4 卷积 + 2 池化 + 4 BatchNorm，输入 224×224，4 类输出 |
| 猴痘识别 CNN | ~254,318 | 4 卷积 + 2 池化 + 4 BatchNorm，输入 224×224，2 类输出 |
五、训练模型
1. 设置损失函数、学习率和优化器
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)
这部分和前周基本一样。
nn.CrossEntropyLoss() 常用于多分类任务。本周猴痘识别虽然是 2 分类任务，但仍然可以使用交叉熵损失函数。对于二分类问题 nn.CrossEntropyLoss() 内部会自动使用 Softmax 计算概率。
- 如果模型最后输出 2 个类别分数，可以用
CrossEntropyLoss； - 如果模型最后只输出 1 个概率值，通常会用
BCEWithLogitsLoss。
learn_rate = 1e-4 比 P1、P2 周（1e-2）更小，和 P3 周保持一致。因为 P4 周的网络更深、输入更大，使用较小的学习率可以让训练更稳定。SGD优化器的作用是根据梯度更新模型参数。model.parameters() 表示把模型中所有可训练参数交给优化器。
2. 编写训练函数
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小，一共60000张图片
num_batches = len(dataloader) # 批次数目，1875（60000/32）
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 获取图片及其标签
X, y = X.to(device), y.to(device)
# 计算预测误差
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
# 反向传播
optimizer.zero_grad() # grad属性归零
loss.backward() # 反向传播
optimizer.step() # 每一步自动更新
# 记录acc与loss
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
训练函数的核心仍然是三步：
第一步：optimizer.zero_grad() 清空梯度
PyTorch 中梯度默认会累加，所以每个 batch 开始训练前，需要先把上一轮的梯度清空。
第二步：loss.backward() 反向传播
根据当前损失值，自动计算每个参数的梯度。
第三步：optimizer.step() 更新参数
优化器根据梯度更新模型参数。以 SGD 为例，参数更新公式为：param.data = param.data - learning_rate * param.grad
3. 编写测试函数
def test (dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小，一共10000张图片
num_batches = len(dataloader) # 批次数目，313（10000/32=312.5，向上取整）
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
测试函数和训练函数很像，但是有两个关键区别：
- 测试时不调用
optimizer.step()，所以不会更新模型参数； - 测试时使用
torch.no_grad()，关闭梯度计算，节省内存和计算量。
4. 正式训练
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []
for epoch in range(epochs):
model.train()
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')
Epoch: 1, Train_acc:58.3%, Train_loss:0.693, Test_acc:64.8%, Test_loss:0.636
Epoch: 2, Train_acc:67.3%, Train_loss:0.622, Test_acc:55.0%, Test_loss:0.804
Epoch: 3, Train_acc:70.5%, Train_loss:0.565, Test_acc:67.1%, Test_loss:0.586
Epoch: 4, Train_acc:74.3%, Train_loss:0.527, Test_acc:64.6%, Test_loss:0.645
Epoch: 5, Train_acc:78.2%, Train_loss:0.486, Test_acc:72.5%, Test_loss:0.538
Epoch: 6, Train_acc:78.1%, Train_loss:0.468, Test_acc:74.4%, Test_loss:0.525
Epoch: 7, Train_acc:80.3%, Train_loss:0.449, Test_acc:76.0%, Test_loss:0.496
Epoch: 8, Train_acc:82.7%, Train_loss:0.424, Test_acc:76.9%, Test_loss:0.491
Epoch: 9, Train_acc:83.7%, Train_loss:0.402, Test_acc:73.7%, Test_loss:0.508
Epoch:10, Train_acc:84.8%, Train_loss:0.392, Test_acc:75.3%, Test_loss:0.469
Epoch:11, Train_acc:86.3%, Train_loss:0.373, Test_acc:78.8%, Test_loss:0.462
Epoch:12, Train_acc:86.9%, Train_loss:0.357, Test_acc:77.4%, Test_loss:0.460
Epoch:13, Train_acc:87.0%, Train_loss:0.358, Test_acc:79.3%, Test_loss:0.446
Epoch:14, Train_acc:87.6%, Train_loss:0.338, Test_acc:79.7%, Test_loss:0.447
Epoch:15, Train_acc:88.4%, Train_loss:0.338, Test_acc:80.4%, Test_loss:0.451
Epoch:16, Train_acc:88.6%, Train_loss:0.324, Test_acc:80.0%, Test_loss:0.431
Epoch:17, Train_acc:90.0%, Train_loss:0.309, Test_acc:79.5%, Test_loss:0.432
Epoch:18, Train_acc:90.7%, Train_loss:0.296, Test_acc:81.4%, Test_loss:0.436
Epoch:19, Train_acc:90.4%, Train_loss:0.289, Test_acc:82.5%, Test_loss:0.420
Epoch:20, Train_acc:90.9%, Train_loss:0.284, Test_acc:81.6%, Test_loss:0.415
Done
model.train() 和 model.eval() 的作用：
1. model.train()：训练模式
- Dropout 层：启用（随机丢弃部分神经元）
- BatchNorm 层：使用当前 batch 的均值和方差进行标准化，并更新内部的 running_mean 和 running_var
2. model.eval()：评估模式（推理模式）
- Dropout 层：关闭（不再随机丢弃神经元）
- BatchNorm 层：使用训练时记录的 running_mean 和 running_var，不再更新
训练结果分析：
- 训练准确率：从 58.3% 提升到 90.9%，说明模型正在有效学习；
- 测试准确率：从 64.8% 提升到 82.5%，没有达到要求的 88%；
- 损失值：训练损失和测试损失整体都在下降，说明模型在收敛。
为什么测试准确率没有达到 88%？
目前基础模型的测试准确率约为 82%，距离目标的 88% 还有一定差距。要达到更高的准确率，可以考虑以下优化方向：
- 调整网络结构：增加卷积层深度、增加通道数、添加 Dropout 层等；
- 调整模型参数：尝试不同的学习率、batch_size 等；
- 设置动态学习率：随着训练进行逐渐降低学习率；
- 数据增强：对训练图片进行随机翻转、裁剪等操作，增加数据多样性。
六、结果可视化
训练结束后，仍然使用 Matplotlib 绘制训练集和测试集的准确率、损失曲线。
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore") #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100 #分辨率
from datetime import datetime
current_time = datetime.now() # 获取当前时间
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
这部分和前几周完全一样，主要作用是观察训练过程，
- 准确率曲线：观察模型分类能力是否随 epoch 增加而提高；
- 损失曲线：观察模型预测误差是否随 epoch 增加而下降。
这是我的结果
从训练结果可以观察到：
训练损失 0.3 持续下降，拟合很好
测试损失 0.4 前期波动大，后期平稳
两条线之间的差距（约 9%）说明模型在训练集上记住了太多细节，泛化到测试集时表现不佳。Dropout(0.5) 抑制了一部分，但还不够。
七、指定图片进行预测
这是本周的一个新增重点，训练完成后，加载模型并对本地某一张图片进行预测。在前几周的学习中，我们只对整个测试集进行了批量测试，而本周学会了如何对单张本地图片进行预测。
1. torch.squeeze()
对数据的维度进行压缩，去掉维数为 1 的维度。
函数原型：
torch.squeeze(input, dim=None, *, out=None)
关键参数说明：
input (Tensor)：输入 Tensordim (int, optional)：如果给定，输入将只在这个维度上被压缩
实战案例：
>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])
2. torch.unsqueeze()
对数据维度进行扩充。给指定位置加上维数为一的维度。
函数原型：
torch.unsqueeze(input, dim)
关键参数说明：
input (Tensor)：输入 Tensordim (int)：插入单例维度的索引
实战案例：
>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1, 2, 3, 4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],
[ 2],
[ 3],
[ 4]])
模型训练时输入数据 shape 是：[batch_size, channels, height, width]
也就是[32, 3, 224, 224]
但是当我们只预测一张图片时，图片经过 transform 后的 shape 是[3, 224, 224]，少了 batch 这一维。模型仍然要求输入是四维，所以要使用unsqueeze(0)，把图片变成[1, 3, 224, 224]，这里的 1 表示当前 batch 中只有 1 张图片。
torch.squeeze() 和 torch.unsqueeze() 对比
| 函数 | 作用 | 示例 |
|---|---|---|
torch.squeeze() |
删除维度为 1 的维度 | [1, 28, 28] → [28, 28] |
torch.unsqueeze() |
在指定位置增加一个维度 | [3, 224, 224] → [1, 3, 224, 224] |
P1 周显示 MNIST 图片时用过 np.squeeze()，是为了去掉灰度图多余的通道维度；P4 周单张图片预测时用 unsqueeze(0)，是为了增加 batch 维度。
3. 单张图片预测函数
from PIL import Image
classes = list(total_data.class_to_idx)
def predict_one_image(image_path, model, transform, classes):
test_img = Image.open(image_path).convert('RGB')
# plt.imshow(test_img) # 展示预测的图片
test_img = transform(test_img)
img = test_img.to(device).unsqueeze(0)
model.eval()
output = model(img)
_,pred = torch.max(output,1)
pred_class = classes[pred]
print(f'预测结果是：{pred_class}')
这段代码的意思是：
Image.open(image_path).convert('RGB')：用 PIL 打开图片，并转换为 RGB三通道模式；transform(test_img)：对图片进行和训练时完全相同的预处理（Resize + ToTensor + Normalize）；test_img.to(device).unsqueeze(0)：把图片移动到和模型相同的设备，并在第 0 维增加一个 batch 维度。因为模型输入要求是[N, C, H, W]，单张图片预处理后是[C, H, W]，所以需要用unsqueeze(0)变成[1, C, H, W]；model.eval()：切换到预测模式；torch.max(output, 1)：找到输出中概率最大的类别的索引；取分数最高的类别作为预测结果；- 根据索引从
classes列表中取出类别名称。
4. 预测示例
# 预测训练集中的某张照片
# 预测训练集中的某张照片
predict_one_image(image_path='./data/Monkeypox/M01_01_00.jpg',
model=model,
transform=train_transforms,
classes=classes)
预测结果是：Monkeypox
这说明模型把这张图片预测为 Monkeypox 类别。
单张图片预测的意义：
在实际项目中，模型训练完成后，最重要的应用就是对新的、未见过的图片进行分类预测。掌握单张图片预测的方法，是从模型训练走向模型部署和应用的关键一步。
预测时使用的 transform 必须和训练时保持一致。如果训练时用了 Resize、ToTensor、Normalize，预测时也必须用同样的预处理，否则图片数据分布不一致，预测结果可能会变差。
八、保存并加载模型
在实际项目中，训练一个模型可能需要很长时间，如果每次使用时都重新训练，效率会非常低。因此，学会保存和加载模型参数是非常重要的技能。
1. 保存模型
# 模型保存
PATH = './model.pth' # 保存的参数文件名
torch.save(model.state_dict(), PATH)
model.state_dict()保存的是模型中的参数，比如卷积层权重、全连接层权重、BatchNorm 参数等。这种方式只保存模型参数，不保存模型结构，所以之后加载时必须先重新定义同样的模型结构。torch.save()：将state_dict保存到指定路径；- 保存的文件名是
model.pth，.pth是 PyTorch 模型参数的常用后缀。
2. 加载模型
# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))
<All keys matched successfully>
torch.load(PATH, map_location=device)：从指定路径加载模型参数，map_location=device确保在不同设备（CPU/GPU）之间都能正确加载；model.load_state_dict(...)：将加载的参数填充到模型中；<All keys matched successfully>这说明保存的参数名称和当前模型结构完全匹配，参数已经成功加载。
如果模型结构发生变化，比如卷积层名字变了、输出类别数变了、全连接层输入维度变了，就可能出现参数不匹配的问题。
总结
本周学习的是 PyTorch 入门第 P4 周：猴痘病图片识别任务。相比 P3 周的天气识别，P4 周在数据流程上保持了一致（都是本地数据集 + ImageFolder 加载），但新增了保存并加载模型和指定图片进行预测两个非常实用的模块。
本周最重要的收获：
- 继续熟悉本地数据集读取：使用
datasets.ImageFolder从本地文件夹读取图片，并根据文件夹名称自动生成类别标签。本周类别是Monkeypox和Others，属于二分类任务。 - 复习 BatchNorm CNN 结构：模型中每个卷积层后面加入
BatchNorm2d，再接 ReLU，这样可以让训练过程更稳定。网络最终输出 2 个类别分数，对应Monkeypox和Others。 - 保存并加载模型：学会了使用
torch.save(model.state_dict(), PATH)保存模型参数，使用model.load_state_dict(torch.load(PATH, map_location=device))加载模型参数。这是从"训练模型"走向"部署应用"的必备技能。 - 指定图片进行预测：学会了编写
predict_one_image()函数，对单张本地图片进行预测。核心步骤是：PIL 打开图片 → 同样的 transform 预处理 →unsqueeze(0)增加 batch 维度 → 模型推理 → 取概率最大的类别。 torch.squeeze()和torch.unsqueeze()：理解了这两个函数的作用——squeeze去掉维度为 1 的轴，unsqueeze在指定位置增加维度为 1 的轴。单张图片预测时，unsqueeze(0)把[C, H, W]变成[1, C, H, W]是关键一步。- 二分类与多分类的统一处理：本周是 2 分类问题（Monkeypox vs Others），但仍然使用
nn.CrossEntropyLoss()，这说明 PyTorch 的交叉熵损失函数可以同时处理二分类和多分类问题。 - 准确率提升的挑战：基础模型测试准确率约为 82.5%，没有达到要求的 88%。后续可以尝试：调整网络结构（增加深度/宽度）、添加 Dropout 正则化、使用动态学习率、数据增强等方法来提升性能。
通过四周学习，我对 PyTorch 图像分类的流程已经有了更完整的认识：数据准备 → 数据预处理 → DataLoader → 模型构建 → 训练 → 测试 → 可视化 → 保存模型 → 加载模型 → 单张图片预测
接下来可以继续学习更复杂的网络结构（如 ResNet）、更多的优化技巧（如学习率调度、数据增强），以及尝试将测试准确率提升到 88% 甚至 90% 以上。
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
6
0- 0
已为社区贡献1条内容
所有评论(0)