• 🍨 本文为🔗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']

这一段的意思是：

1. pathlib.Path(data_dir)：把字符串路径 ./data/ 转换成 Path 对象；
2. 使用 glob('*') 获取 data_dir 路径下的所有子文件夹路径；
3. 通过 split("\\") 对每条路径进行分割，提取出文件夹名称（即类别名称），存入 classeNames 列表中。
4. 每一个子文件夹名称就是一个类别；
5. 最终得到 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 通道均值和标准差得出的，具体计算过程如下：

1. 获取 ImageNet 数据集：ImageNet 包含约 120 万张训练图像，每张图像有 RGB 三个通道。
2. 计算均值（Mean）：
   • Red 通道均值 ≈ 0.485
   • Green 通道均值 ≈ 0.456
   • Blue 通道均值 ≈ 0.406
3. 计算标准差（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 网络。整体结构可以分为两部分：

1. 特征提取网络：用卷积层、池化层提取图片特征；
2. 分类网络：用全连接层根据提取到的特征进行分类。
   本周的猴痘病图片分类任务有 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 会：

1. 计算当前 batch 中每个通道的均值和方差；
2. 用这些统计量对数据进行归一化；
3. 引入可学习的缩放参数（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 周几乎完全相同，有以下特点：

1. 使用了 BatchNorm：每个卷积层后面都紧跟一个 nn.BatchNorm2d，P1 和 P2 周没有；
2. 卷积核大小是 5×5：P1 和 P2 周使用的是 3×3，P3 和 P4 周使用的是 5×5，每次卷积后尺寸减少 4；
3. 没有中间全连接层：P1 和 P2 周都有 fc1 → fc2 两个全连接层，P3 和 P4 周只有一个 fc1；
4. 输入尺寸更大：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

测试函数和训练函数很像，但是有两个关键区别：

1. 测试时不调用 optimizer.step()，所以不会更新模型参数；
2. 测试时使用 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，不再更新

训练结果分析：

1. 训练准确率：从 58.3% 提升到 90.9%，说明模型正在有效学习；
2. 测试准确率：从 64.8% 提升到 82.5%，没有达到要求的 88%；
3. 损失值：训练损失和测试损失整体都在下降，说明模型在收敛。

为什么测试准确率没有达到 88%？

目前基础模型的测试准确率约为 82%，距离目标的 88% 还有一定差距。要达到更高的准确率，可以考虑以下优化方向：

1. 调整网络结构：增加卷积层深度、增加通道数、添加 Dropout 层等；
2. 调整模型参数：尝试不同的学习率、batch_size 等；
3. 设置动态学习率：随着训练进行逐渐降低学习率；
4. 数据增强：对训练图片进行随机翻转、裁剪等操作，增加数据多样性。

---

六、结果可视化

训练结束后，仍然使用 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)：输入 Tensor
• dim (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)：输入 Tensor
• dim (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}')

这段代码的意思是：

1. Image.open(image_path).convert('RGB')：用 PIL 打开图片，并转换为 RGB三通道模式；
2. transform(test_img)：对图片进行和训练时完全相同的预处理（Resize + ToTensor + Normalize）；
3. test_img.to(device).unsqueeze(0)：把图片移动到和模型相同的设备，并在第 0 维增加一个 batch 维度。因为模型输入要求是 [N, C, H, W]，单张图片预处理后是 [C, H, W]，所以需要用 unsqueeze(0) 变成 [1, C, H, W]；
4. model.eval()：切换到预测模式；
5. torch.max(output, 1)：找到输出中概率最大的类别的索引；取分数最高的类别作为预测结果；
6. 根据索引从 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 加载），但新增了保存并加载模型和指定图片进行预测两个非常实用的模块。

本周最重要的收获：

1. 继续熟悉本地数据集读取：使用 datasets.ImageFolder 从本地文件夹读取图片，并根据文件夹名称自动生成类别标签。本周类别是 Monkeypox 和 Others，属于二分类任务。
2. 复习 BatchNorm CNN 结构：模型中每个卷积层后面加入 BatchNorm2d，再接 ReLU，这样可以让训练过程更稳定。网络最终输出 2 个类别分数，对应 Monkeypox 和 Others。
3. 保存并加载模型：学会了使用 torch.save(model.state_dict(), PATH) 保存模型参数，使用 model.load_state_dict(torch.load(PATH, map_location=device)) 加载模型参数。这是从"训练模型"走向"部署应用"的必备技能。
4. 指定图片进行预测：学会了编写 predict_one_image() 函数，对单张本地图片进行预测。核心步骤是：PIL 打开图片 → 同样的 transform 预处理 → unsqueeze(0) 增加 batch 维度 → 模型推理 → 取概率最大的类别。
5. torch.squeeze() 和 torch.unsqueeze()：理解了这两个函数的作用——squeeze 去掉维度为 1 的轴，unsqueeze 在指定位置增加维度为 1 的轴。单张图片预测时，unsqueeze(0) 把 [C, H, W] 变成 [1, C, H, W] 是关键一步。
6. 二分类与多分类的统一处理：本周是 2 分类问题（Monkeypox vs Others），但仍然使用 nn.CrossEntropyLoss()，这说明 PyTorch 的交叉熵损失函数可以同时处理二分类和多分类问题。
7. 准确率提升的挑战：基础模型测试准确率约为 82.5%，没有达到要求的 88%。后续可以尝试：调整网络结构（增加深度/宽度）、添加 Dropout 正则化、使用动态学习率、数据增强等方法来提升性能。

通过四周学习，我对 PyTorch 图像分类的流程已经有了更完整的认识：数据准备 → 数据预处理 → DataLoader → 模型构建 → 训练 → 测试 → 可视化 → 保存模型 → 加载模型 → 单张图片预测
接下来可以继续学习更复杂的网络结构（如 ResNet）、更多的优化技巧（如学习率调度、数据增强），以及尝试将测试准确率提升到 88% 甚至 90% 以上。