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

🏡 我的环境：使用01中创建的虚拟环境mnist

• 虚拟环境：mnist

Python 3.10.19

Name: torch, Version: 2.10.0+cu130

Name: torchvision,Version: 0.25.0+cu130

• 编译器：Positron
• 深度学习环境：Pytorch

一、 前期准备

1. 设置GPU

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

2. 导入数据

使用dataset下载CIFAR10数据集，并划分好训练集与测试集

使用dataloader加载数据，并设置好基本的batch_size

train_ds = torchvision.datasets.CIFAR10('data', 
                                      train=True, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.CIFAR10('data', 
                                      train=False, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

含义：

• torchvision.datasets.CIFAR10
  使用 PyTorch 自带的函数读取 CIFAR10 数据集。
• 'data'
  数据保存的文件夹路径。下载的数据会放在 data 文件夹里。
• train=True
  表示 加载训练集（50000 张图片）。
• transform=torchvision.transforms.ToTensor()
  把图片转换成 Tensor 张量格式，这样神经网络才能处理。
• download=True
  如果电脑里没有 CIFAR10 数据集，就自动下载。

CIFAR10 数据集结构是：

数据集	数量
训练集	50000 张
测试集	10000 张

CIFAR10有10类照片分别是：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船、卡车

CIFAR10 是一个彩色图片分类数据集。

32 × 32 像素， 并且是 RGB 彩色图像。

所以图片结构是：

[3, 32, 32]

含义：
通道数 = 3 （RGB）
高度 = 32
宽度 = 32

在 PyTorch 中的 shape

如果 batch_size = 32，那么数据形状通常是

[32, 3, 32, 32]

对比MNIST 是 灰度图，像素是28 × 28

所以结构是：

[1, 28, 28]

通道 = 1
高度 = 28
宽度 = 28

把数据集转换成可以用于训练模型的数据加载器（DataLoader），并且 按批次（batch）读取数据。 同01项目只能的mnist

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_ds, 
                                       batch_size=batch_size, 
                                       shuffle=True)

test_dl  = torch.utils.data.DataLoader(test_ds, 
                                       batch_size=batch_size)

从训练数据中取出一个 batch，并查看图片数据的形状（shape），目的是 确认数据格式是否正确。

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
imgs.shape

# 返回
torch.Size([32, 3, 32, 32])

3. 数据可视化

import numpy as np

# 指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5)) 
for i, imgs in enumerate(imgs[:20]):
    # 进行轴变换
    npimg = imgs.numpy().transpose((1, 2, 0))
    # 将整个figure分成2行10列，绘制第i+1个子图。
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')
    
#plt.show()  如果你使用的是Pycharm编译器，请加上这行代码

此处代码在01项目中已有详细解释

二、构建简单的CNN网络

import torch.nn.functional as F

num_classes = 10  # 图片的类别数

class Model(nn.Module):
     def __init__(self):
        super().__init__()
         # 特征提取网络
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)   # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(kernel_size=2)       # 设置池化层，池化核大小为2*2
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3)  # 第二层卷积,卷积核大小为3*3   
        self.pool2 = nn.MaxPool2d(kernel_size=2) 
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3) # 第二层卷积,卷积核大小为3*3   
        self.pool3 = nn.MaxPool2d(kernel_size=2) 
                                      
        # 分类网络
        self.fc1 = nn.Linear(512, 256)          
        self.fc2 = nn.Linear(256, num_classes)
     # 前向传播
     def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))     
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.pool3(F.relu(self.conv3(x)))
        
        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)
       
        return x

整体流程是：

图片输入
→ 卷积提取特征
→ 池化压缩信息
→ 再卷积提取更复杂特征
→ 展平
→ 全连接分类
→ 输出10类结果

卷积层 → 池化层 → 卷积层 → 池化层 → 卷积层 → 池化层 → 展平 → 全连接层 → 输出10类结果。

主要流程是：

1. 卷积层（Conv）：从图片中提取特征，例如边缘、形状等。
2. 池化层（Pool）：缩小特征图尺寸，减少计算量，同时保留重要信息。
3. ReLU 激活函数：增加网络的非线性能力，让模型能学习更复杂的模式。
4. flatten：把多维特征图拉直成一维向量。
5. 全连接层（Linear）：根据提取到的特征进行分类。
6. 输出层：输出 10 个数，对应 CIFAR10 的 10 个类别。

---

和前面的 MNIST 模型相比主要有三个区别：

1. 输入通道不同

• • MNIST：灰度图 → 输入通道 = 1
  • CIFAR10：彩色图 → 输入通道 = 3

1. 网络更深

• • MNIST：2 个卷积层
  • CIFAR10：3 个卷积层

1. 特征数量更多
   CIFAR10 模型的卷积通道数和全连接层规模更大，因为彩色图片识别更复杂。

上述代码在01中详细解释了

加载并打印模型

from torchinfo import summary
# 将模型转移到GPU中（我们模型运行均在GPU中进行）
model = Model().to(device)
summary(model)

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            1,792
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            36,928
├─MaxPool2d: 1-4                         --
├─Conv2d: 1-5                            73,856
├─MaxPool2d: 1-6                         --
├─Linear: 1-7                            131,328
├─Linear: 1-8                            2,570
=================================================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
=================================================================

三、 训练模型

1. 设置超参数

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

2. 编写训练函数

不执行这里的代码

param.data = param.data - learning_rate * param.grad

# 训练循环
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

这段代码定义了一个 训练函数 train()，作用是：

让模型用训练集数据进行一轮训练，并返回这一轮的训练准确率和训练损失。

主要流程是：

1. 读取一批图片和标签
2. 把数据放到 GPU 或 CPU 上
3. 将图片输入模型，得到预测结果
4. 计算预测结果和真实标签之间的损失
5. 通过反向传播计算梯度
6. 用优化器更新模型参数
7. 累计这一轮的准确率和损失
8. 最后求平均，返回整轮训练结果

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

这段代码定义了一个 测试函数 test()，作用是：

用测试集检查模型的分类效果，并计算测试准确率和测试损失。

主要流程是：

1. 读取测试集的一批图片和标签
2. 把数据放到 GPU 或 CPU 上
3. 将图片输入模型，得到预测结果
4. 计算预测结果和真实标签之间的损失
5. 统计预测正确的数量
6. 累计所有 batch 的损失和准确率
7. 最后求平均，返回整轮测试结果

其中：

• with torch.no_grad() 表示 测试时不计算梯度
• 这样可以 节省内存、加快计算
• 并且测试时 不会更新模型参数

一句话总结：

这段代码就是让模型在测试集上“做题并打分”，看看它当前的识别效果怎么样。

4. 正式训练

epochs     = 10
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:13.5%, Train_loss:2.283, Test_acc:20.9%，Test_loss:2.195
Epoch: 2, Train_acc:25.8%, Train_loss:2.015, Test_acc:31.0%，Test_loss:1.891
Epoch: 3, Train_acc:34.5%, Train_loss:1.804, Test_acc:36.1%，Test_loss:1.788
Epoch: 4, Train_acc:40.8%, Train_loss:1.631, Test_acc:41.5%，Test_loss:1.604
Epoch: 5, Train_acc:44.6%, Train_loss:1.528, Test_acc:43.1%，Test_loss:1.545
Epoch: 6, Train_acc:47.8%, Train_loss:1.441, Test_acc:49.9%，Test_loss:1.407
Epoch: 7, Train_acc:51.0%, Train_loss:1.366, Test_acc:49.6%，Test_loss:1.395
Epoch: 8, Train_acc:53.8%, Train_loss:1.300, Test_acc:55.2%，Test_loss:1.261
Epoch: 9, Train_acc:56.0%, Train_loss:1.238, Test_acc:57.2%，Test_loss:1.205
Epoch:10, Train_acc:58.2%, Train_loss:1.184, Test_acc:54.0%，Test_loss:1.337
Done

这段代码是在 控制整个模型训练过程，让模型一共训练 10 轮（epochs=10），并且 每训练完一轮就测试一次。

主要做了这些事：

1. epochs = 10
   表示模型要把训练集完整学习 10 遍。
2. train_loss、train_acc、test_loss、test_acc
   这 4 个列表用来保存每一轮的：

• • 训练损失
  • 训练准确率
  • 测试损失
  • 测试准确率

1. for epoch in range(epochs):
   开始循环训练，每次循环代表 1 个 epoch。
2. model.train()
   把模型切换到 训练模式。
3. train(...)
   用训练集训练一轮，得到这一轮的训练准确率和训练损失。
4. model.eval()
   把模型切换到 测试模式。
5. test(...)
   用测试集测试一轮，得到这一轮的测试准确率和测试损失。
6. append(...)
   把每一轮的训练和测试结果保存到列表里，方便后面画图。
7. print(...)
   打印当前这一轮的训练结果和测试结果。
8. print('Done')
   表示全部训练结束。

一句话总结：

这段代码就是让模型 训练 10 轮，每轮结束后测试一次，并记录、打印每轮的准确率和损失。

四、 结果可视化

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

这段代码的作用是 把模型训练过程中的结果画成图，方便直观看出模型效果。

主要画了两张图：

1. 左图：准确率曲线

• • train_acc：训练准确率
  • test_acc：测试准确率

1. 右图：损失曲线

• • train_loss：训练损失
  • test_loss：测试损失