• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

---

前言

本篇是我训练营的第三次学习，主要目标是使用 PyTorch 实现天气识别任务。P1 周跑通了 MNIST 手写数字识别，P2 周在 CIFAR10 彩色图片上进一步理解了 CNN 的 shape 变化，而 P3 周的任务则更进一步——从使用公开数据集转向加载本地自定义数据集，并尝试达到更高的测试准确率。
本周天气识别任务一共有 4 个类别：
cloudy 阴天、rain 雨天、shine 晴天、sunrise 日出
P1 周让先跑通了“数据导入 → 模型构建 → 模型训练 → 结果可视化”的完整流程；P2 周理解了彩色图片和 CNN 结构变化；本周数据需要自己整理到本地文件夹中，再通过 PyTorch 读取。

感谢K同学啊老师的教学，以及ChatGPT和Kimi。

---

一、准备工作

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')

这一步和 P1、P2 周完全相同，程序会自动判断当前电脑能不能使用 CUDA。如果可以使用，就把模型和数据放到 GPU 上运行；如果不可以，就放到 CPU 上运行。我自己安装的是 CPU 版本 PyTorch，所以只有CPU

---

2. 关于天气识别数据集

本周使用的是天气识别数据集，它不是一个内置在 torchvision.datasets 中的公开数据集，而是需要自己准备图片文件并放在本地data 文件夹下，文件夹结构如下：

data/
├── cloudy/          # 多云图片
├── rain/            # 雨天图片
├── shine/           # 晴天图片
└── sunrise/         # 日出图片

数据集共包含 4 个类别：

类别（英文）	中文含义	图片内容
cloudy	多云	多云天气的图片
rain	雨天	下雨天气的图片
shine	晴天	晴朗天气的图片
sunrise	日出	日出场景的图片

MNIST 和 CIFAR10 是 PyTorch 已经封装好的数据集，只要设置 download=True 就可以下载，并且数据集本身就分好了训练集和测试集；本周的数据是本地文件夹，需要自己保证文件夹路径和类别目录正确并且用代码来加载、划分训练集和测试集。

---

3. 导入本地数据集

使用 pathlib.Path 和 datasets.ImageFolder 来加载本地图片数据。

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

['cloudy', 'rain', 'shine', 'sunrise']

这一段的意思是：

1. 使用 pathlib.Path() 把字符串路径 ./data/ 转换成 Path 对象；pathlib 是 Python 中处理文件路径的现代化模块，比传统的字符串路径操作更方便。
2. 使用 glob('*') 获取 data_dir 路径下的所有子文件夹路径。* 是通配符，表示匹配所有内容。data_paths 中存储的是 4 个子文件夹的路径。
3. 通过 split("\\") 对每条路径进行分割，提取出文件夹名称（即类别名称），存入 classeNames 列表中，每一个子文件夹对应一个类别；

关于 pathlib.Path 和 os.path 的对比：

操作	pathlib.Path	os.path
获取当前目录	Path.cwd()	os.getcwd()
获取家目录	Path.home()	os.path.expanduser("~")
路径拼接	Path("a") / "b"	os.path.join("a", "b")
判断文件是否存在	Path("file.txt").exists()	os.path.exists("file.txt")
遍历目录	Path("dir").iterdir()	os.listdir("dir")

---

4. 查看部分图片

为了确认数据是否读取正确，可以先从某一个类别文件夹中读取图片并显示出来。

import matplotlib.pyplot as plt
from PIL import Image

# 指定图像文件夹路径
image_folder = './data/cloudy/'

# 获取文件夹中的所有图像文件
image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg", ".png", ".jpeg"))]

# 创建 Matplotlib 图像
fig, axes = plt.subplots(3, 8, figsize=(16, 6))

# 加载并显示图像
for ax, img_file in zip(axes.flat, image_files):
    img_path = os.path.join(image_folder, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.axis('off')

plt.tight_layout()
plt.show()

这一段的意思是：从 cloudy 文件夹中读取图片文件，用 PIL.Image.open() 打开每张图片，然后用 matplotlib 以 3 行 × 8 列 的方式展示出来。ax.axis('off') 表示不显示坐标轴，plt.tight_layout() 让子图之间排列更紧凑。

与 P2 周 CIFAR10 的可视化对比：

项目	P2 周 CIFAR10	P3 周天气识别
数据来源	从 DataLoader 中取 batch	直接从本地文件夹读取
图片格式转换	transpose((1, 2, 0))	Image.open() 直接显示
通道处理	[C, H, W] → [H, W, C]	PIL 读取的图片本身就是 [H, W, C]
显示方式	plt.imshow(npimg)	ax.imshow(img)

---

5. 数据预处理：transforms.Compose()

本周图片来自不同文件夹，原始图片尺寸可能并不统一，所以在送入模型之前，需要先做统一处理。

total_datadir = './data/'

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])
])

total_data = datasets.ImageFolder(total_datadir, transform=train_transforms)
total_data

运行结果：

Dataset ImageFolder
    Number of datapoints: 1125
    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])
           )

**transforms.Resize([224, 224])**将不同大小的原始图片统一 resize 成 224 × 224 像素。为什么需要 resize？因为神经网络要求输入图片的尺寸是固定的，原始天气图片可能有不同的大小，如果不统一尺寸，模型无法处理。
** transforms.ToTensor()**将 PIL Image 或 numpy.ndarray 格式的图片转换为 PyTorch 的 Tensor 格式，同时会把像素值从 0-255 缩放到 0-1 之间。
**transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])**对RGB 三个通道进行标准化处理。具体做法是对每个通道的像素值执行：标准化后的值 = (原始值 - mean) / std ，这一步的作用是让数据分布更接近标准正态分布，使得模型训练时更容易收敛。
mean=[0.485, 0.456, 0.406] 、std=[0.229, 0.224, 0.225]

🌟 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

ImageFolder 是 PyTorch 中专门用于从文件夹加载图片数据集的工具。它会按照以下规则自动组织数据：

• 假设文件夹结构中，每个子文件夹的名称就是一个类别；
• 子文件夹内的所有图片都属于该类别；
• 自动为每个类别分配一个标签。

所以本周不需要像 MNIST 或 CIFAR10 那样选择 train=True 或 train=False，而是先读取全部数据，再自己划分训练集和测试集。

---

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]
)

(<torch.utils.data.dataset.Subset at 0x1c644caa7e0>,
 <torch.utils.data.dataset.Subset at 0x1c646b06300>)

这一段的意思是：
train_size = int(0.8 * len(total_data))：训练集大小为总数据量的 80%。总数据量是 1125，所以训练集大小为 int(0.8 × 1125) = 900。
test_size = len(total_data) - train_size：测试集大小为剩余的 20%，即 1125 - 900 = 225。
torch.utils.data.random_split(total_data, [train_size, test_size])：将数据集随机打乱后，按照 [900, 225] 的比例划分为训练集和测试集。因为是随机划分，所以每次运行得到的训练集和测试集可能不完全一样。如果想让结果更稳定，可以设置随机种子。
查看训练集和测试集大小：

train_size, test_size

运行结果：

(900, 225)

---

7. 创建 DataLoader 数据加载器

划分好数据集后，用 DataLoader 包装成可以批量加载的数据迭代器。

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True)
)

DataLoader 的作用和前两周一样，都是把数据按 batch 分批送入模型。这里设置 batch_size = 32，表示每次送入 32 张图片。shuffle=True 表示每个 epoch 开始前打乱数据顺序，这样可以减少模型记住固定顺序的可能。

---

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 张图片

和前两周对比：

MNIST:    [32, 1, 28, 28]
CIFAR10:  [32, 3, 32, 32]
天气图像: [32, 3, 224, 224]

项目	P1 周 MNIST	P2 周 CIFAR10	P3 周天气识别
shape	[32, 1, 28, 28]	[32, 3, 32, 32]	[32, 3, 224, 224]
通道数 C	1（灰度）	3（RGB）	3（RGB）
高 H	28	32	224
宽 W	28	32	224
单张图像素数	784	3072	150528

可以看出，本周天气图片和 CIFAR10 一样都是 RGB 彩色图，所以通道数是 3，但本周图片尺寸变成了 224 × 224，比 CIFAR10 的 32 × 32 大很多。

---

二、构建简单的 CNN 网络

对于一般的 CNN 网络来说，通常可以分为两部分：

1. 特征提取网络：用卷积层、池化层提取图片特征；
2. 分类网络：用全连接层根据提取到的特征进行分类。
   本周的天气图片分类任务有 4 个类别，所以最后一层输出维度是：len(classeNames)，也就是 4。本周的网络相比 前两周还引入了 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 的统计量不同，相当于给网络引入了噪声，减少了过拟合的风险。

---

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))

因为天气识别有 4 个类别，len(classeNames) 等于 4（cloudy、rain、shine、sunrise），所以输出是 4 个分类分数。

---

5. 卷积层和全连接层之间的转换

在卷积层和全连接层之间，可以使用 torch.flatten()、x.view() 或 torch.nn.Flatten()。这三者的区别：

torch.flatten()：返回一个新的展平后的张量，不会改变原张量；
x.view()：直接在原有数据上进行形状变换，不复制数据；
torch.nn.Flatten()：是一个 nn.Module，可以像其他层一样放在nn.Sequential 中使用。

x.view(-1, 24*50*50)，最后一层特征图尺寸是：24 × 50 × 50 = 60000

---

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.pool1 = 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.pool2 = nn.MaxPool2d(2,2)
        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.pool1(x)                        
        x = F.relu(self.bn4(self.conv4(x)))     
        x = F.relu(self.bn5(self.conv5(x)))  
        x = self.pool2(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 cuda 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)
  (pool1): 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)
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=60000, out_features=4, bias=True)
)

网络结构分析：

P3 周的网络相比 P1、P2 周有以下特点：

1. 使用了 BatchNorm：每个卷积层后面都紧跟一个 nn.BatchNorm2d，这在 P1 和 P2 周是没有的；
2. 卷积核大小是 5×5：P1 和 P2 周使用的是 3×3，P3 周使用的是 5×5，所以每次卷积后尺寸减少得更多（减少 4 而不是 2）；
3. 没有中间全连接层：P1 和 P2 周都有 fc1 → fc2 两个全连接层，P3 周只有一个 fc1，直接从展平后的特征映射到 4 个类别；
4. 输入尺寸更大：224 × 224 的图片经过网络处理后，展平维度达到了 60000。

---

三、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, 4)
↓
输出：4 个类别分数

---

四、模型参数量理解

---

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

---

2. BatchNorm 参数量

BatchNorm 的参数量 = 2 × num_features（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, 4)

也就是：nn.Linear(60000, 4)
参数量为：60000 × 4 + 4 = 240004

可以看出，本周模型参数量很大一部分来自最后的全连接层。这是因为输入图片尺寸是 224 × 224，经过卷积和池化后展平维度仍然有 60000。

---

4. 三周模型参数量对比

模型	总参数量	主要差异
MNIST CNN	121,930	2 卷积 + 2 池化，输入 28×28
CIFAR10 CNN	246,474	3 卷积 + 3 池化，输入 32×32
天气识别 CNN	~254,320	4 卷积 + 2 池化 + 4 BatchNorm，输入 224×224

本周模型参数量较大的主要原因：

1. 使用了 5×5 的大卷积核，参数量比 3×3 更多；
2. 增加了 BatchNorm 层；
3. 输入图片尺寸更大（224×224）。

---

五、训练模型

1. 设置损失函数、学习率和优化器

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=Alearn_rate)

这部分和前周基本一样。

nn.CrossEntropyLoss() 常用于多分类任务。本周天气识别是 4 分类任务，所以仍然可以使用交叉熵损失函数。
learn_rate = 1e-4 比 P1、P2 周（1e-2）更小，因为 P3 周的网络更深、输入更大，使用较小的学习率可以让训练更稳定。
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:63.1%, Train_loss:0.956, Test_acc:58.7%，Test_loss:0.821
Epoch: 2, Train_acc:79.2%, Train_loss:0.665, Test_acc:75.1%，Test_loss:0.678
Epoch: 3, Train_acc:83.6%, Train_loss:0.574, Test_acc:82.7%，Test_loss:0.607
Epoch: 4, Train_acc:86.8%, Train_loss:0.475, Test_acc:87.1%，Test_loss:0.438
Epoch: 5, Train_acc:89.0%, Train_loss:0.405, Test_acc:88.0%，Test_loss:0.369
Epoch: 6, Train_acc:88.9%, Train_loss:0.380, Test_acc:88.0%，Test_loss:0.433
Epoch: 7, Train_acc:90.7%, Train_loss:0.353, Test_acc:88.4%，Test_loss:0.381
Epoch: 8, Train_acc:90.7%, Train_loss:0.322, Test_acc:89.3%，Test_loss:0.324
Epoch: 9, Train_acc:91.2%, Train_loss:0.299, Test_acc:89.3%，Test_loss:0.371
Epoch:10, Train_acc:91.8%, Train_loss:0.314, Test_acc:88.4%，Test_loss:0.315
Epoch:11, Train_acc:91.7%, Train_loss:0.274, Test_acc:90.7%，Test_loss:0.479
Epoch:12, Train_acc:91.6%, Train_loss:0.292, Test_acc:86.7%，Test_loss:0.333
Epoch:13, Train_acc:91.4%, Train_loss:0.259, Test_acc:90.2%，Test_loss:0.377
Epoch:14, Train_acc:92.1%, Train_loss:0.256, Test_acc:89.8%，Test_loss:0.308
Epoch:15, Train_acc:93.0%, Train_loss:0.220, Test_acc:91.1%，Test_loss:0.273
Epoch:16, Train_acc:93.6%, Train_loss:0.224, Test_acc:91.6%，Test_loss:0.263
Epoch:17, Train_acc:93.1%, Train_loss:0.222, Test_acc:89.8%，Test_loss:0.277
Epoch:18, Train_acc:94.0%, Train_loss:0.196, Test_acc:90.7%，Test_loss:0.259
Epoch:19, Train_acc:93.9%, Train_loss:0.205, Test_acc:91.6%，Test_loss:0.302
Epoch:20, Train_acc:94.0%, Train_loss:0.210, Test_acc:91.6%，Test_loss:0.292
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. 训练准确率：从 63.1% 提升到 94.0%，说明模型正在有效学习；
2. 测试准确率：从 58.7% 提升到 91.6%，没有达到教程的93%；
3. 损失值：训练损失和测试损失整体都在下降，说明模型在收敛。

---

六、结果可视化

训练结束后，可以把训练准确率、测试准确率、训练损失和测试损失画出来，这样更直观地观察模型训练效果。

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()

这一部分和 P1、P2 周完全相同，主要作用是：

• 准确率曲线：观察模型分类能力是否随 epoch 增加而提高；
• 损失曲线：观察模型预测误差是否随 epoch 增加而下降。

从训练结果可以观察到：

1. 训练准确率和测试准确率都稳步上升；
2. 训练损失和测试损失都稳步下降；
3. 没有明显的过拟合现象（测试准确率没有持续低于训练准确率）。

这是我的结果

---

总结

本周学习的是 PyTorch 入门第 P3 周：天气识别任务。相比 P1 周的 MNIST 和 P2 周的 CIFAR10，P3 周的任务在流程上增加了很多新内容，让我对深度学习图像分类的完整工作流有了更深入的理解。

本周最重要的收获：

1. 本地数据加载：学会了使用 pathlib.Path 处理文件路径，使用 datasets.ImageFolder 从本地文件夹加载自定义数据集，这是实际项目中最常用的数据加载方式。

2. 数据预处理：理解了 transforms.Compose 的作用，掌握了 Resize、ToTensor、Normalize 三个预处理步骤的顺序和原理。特别是理解了 mean=[0.485, 0.456, 0.406] 和 std=[0.229, 0.224, 0.225] 来自 ImageNet 数据集统计值。

3. 手动划分数据集：使用 torch.utils.data.random_split 将数据集按 8:2 划分为训练集和测试集，理解了划分比例对模型评估的影响。

4. BatchNorm 的理解：明白了批归一化层的作用——加速训练、稳定分布、减少内部协变量偏移。在卷积层后添加 nn.BatchNorm2d 是一种标准的网络设计模式。

5. CNN shape 推导：手动推导了从 [3, 224, 224] 到最终 60000 维展平向量的完整过程。因为使用了 5×5 的卷积核，每次卷积尺寸减少 4，经过 4 次卷积和 2 次池化后，最终得到 [24, 50, 50]，展平后 24 × 50 × 50 = 60000。

6. 准确率达标：最终测试准确率达到了 91.6%，准备换原来的电脑再去试试，这一台机器也不够稳定。

通过三周的学习，我对 PyTorch 图像分类的完整流程——数据准备 → 预处理 → 模型构建 → 训练 → 测试 → 可视化——已经有了比较系统的认识。P1 周学会了跑通流程，P2 周理解了 CNN shape 变化，P3 周掌握了本地数据加载和 BatchNorm。接下来可以继续学习更复杂的网络结构和优化技巧。