手把手教你用CNN实现MNIST手写数字识别——深度学习入门（1）

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

1. 项目背景与目标

1.1 为什么选择MNIST数据集？

MNIST作为深度学习入门首选数据集，具备以下优势：

• 数据质量高：60,000张训练图+10,000张测试图，均经过尺寸标准化和居中处理
• 特征复杂度适中：28x28像素灰度图，兼顾计算效率与特征学习需求
• 丰富的基准结果：学术界已积累大量模型对比数据（如MLP 98%、CNN 99.5%+）
• 快速验证可行性：单GPU训练仅需数分钟，适合教学演示与原型验证

---

1.2 新手价值点

即使零基础，通过本项目也能掌握图像分类任务的通用方法论，为后续实战（如医学影像识别、自动驾驶标志检测）打下坚实基础！ 🚀

---

2、环境配置与工具准备

2.1 PyTorch框架安装与GPU加速设置

如果设备上支持GPU就使用GPU,否则使用CPU（一般游戏本都有GPU）
【超详细教程】2024最新Pytorch安装教程（同时讲解安装CPU和GPU版本）

2.2 依赖库导入与硬件检查（torch.cuda验证）

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
import numpy as np
# 设置硬件设备，如果有GPU则使用，没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device  
 # 如果输出结果是“device(type='cuda')”，则说明GPU版本的pytorch安装成功

3、MNIST数据集深度解析

3.1 数据集加载与基本统计

这里先构建训练集和测试集，因为torchvision.datasets里有现成的MNIST数据集，我们可以直接下载，下载后再探索数据集。
由于PyTorch/TensorFlow的底层计算依赖Tensor，我们需要把数据转换成Tensor格式。
· 原始图像的像素值范围不符合神经网络输入要求
MNIST原始数据是0-255的整数像素值，直接输入会导致两个问题：

• ○ 梯度爆炸/消失：大范围数值导致反向传播不稳定
• ○ 收敛速度慢：不同特征尺度差异大

· ToTensor()转换的核心作用

• 将PIL Image或NumPy数组 → PyTorch Tensor（维度变为 [C, H, W]）
• 像素值归一化：[0,255] → [0.0, 1.0]（浮点数）

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

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

3.2 数据格式对比：Tensor转换 vs PIL图像 vs NumPy数组

（1）先查看已经转换成Tensor格式的MNIST数据长什么样

image_,label_=train_ds[0]
# 打印数据类型和基本信息
print("原始数据类型:", type(image_))  # 原始数据类型: <class 'torch.Tensor'>
print("图像模式:", image_.mode)       # 图像模式: <built-in method mode of Tensor object at 0x0000021FD5BEFEF0>
print("图像大小:", image_.size)       # 图像大小: <built-in method size of Tensor object at 0x0000021FD5BEFEF0>
print("标签:", label_)                # 标签: 5
print("Tensor形状:", image_.shape)         # 输出: torch.Size([1, 28, 28])
print("像素值范围:", image_.min(), "-", image_.max())  # 输出: 0.0 - 1.0

（2）查看原始数据类型（PIL.Image）

# 加载MNIST数据集，不设置transform（默认返回PIL图像）
raw_train_ds = torchvision.datasets.MNIST(
    root='data', 
    train=True, 
    download=True  # 不指定transform，默认返回PIL.Image
)
# 获取第一个样本的图像和标签
image, label = raw_train_ds[0]

# 打印数据类型和基本信息
print("原始数据类型:", type(image))  # 输出: <class 'PIL.Image.Image'>
print("图像模式:", image.mode)       # 输出: 'L'（表示灰度图）
print("图像大小:", image.size)       # 输出: (28, 28)
print("标签:", label)               # 输出: 5（示例标签）

# 显示图像
image.show()  # 会调用系统默认图片查看器显示

系统会自动弹出这样的图片，这是MNIST数据集的第一个图片

（3） 查看原始像素值（转换为NumPy数组）
如果想进一步查看原始的像素值（0-255的整数），可以将PIL图像转为NumPy数组：

# 将PIL图像转为NumPy数组
image_np = np.array(image)
print("\nNumPy数组形状:", image_np.shape)  # 输出: (28, 28)
print("像素值范围:", np.min(image_np), "-", np.max(image_np))  # 输出: 0 - 255
print("第一行像素值示例:", image_np)  # 打印像素值

关键点总结

1. 默认返回类型：
   MNIST数据集未经转换时返回的是PIL.Image对象（单通道灰度图，模式为'L'）。
2. 像素值范围：
   原始像素值为0-255的整数，ToTensor()会将其归一化为0.0-1.0的浮点数。
3. 维度差异：
   • PIL/Numpy格式：(H, W)
   • Tensor格式：(C, H, W)（自动添加通道维度）。

3.3数据加载器（DataLoader）的配置与优化 与 随机样本展示与像素值分析

为了简化操作，我们这里直接构建dataloader数据加载器查看数据，后面会用到它训练模型。

• 数据加载器的核心功能:
  • 核心功能：批量数据加载
  • 数据随机化：防止模型过拟合
  • 多进程加速：提升数据加载效率
  • 处理不完整批次（drop_last）
  • 支持自定义数据集和复杂操作

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)  # 为什么测试集不用shuffle？
                                                               # 测试是为了检查真实能力，就像考试不能打乱考卷顺序。
# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
print(imgs.shape)     # 输出：torch.Size([32, 1, 28, 28])

这里取dataloader的第一个batchsize的前20个样本进行可视化
我简述一下enumerate函数的作用，方便初学者理解。

enumerate 函数的作用

作用	参数说明	返回值	使用场景
在循环中同时获取 索引 和 元素值	1. iterable: 可迭代对象（如列表、元组、字符串等） 2. start (可选): 索引起始值（默认从0开始）	生成 (索引, 元素) 格式的元组迭代器	需要同时操作索引和元素的场景（例如：遍历列表时记录位置、生成带序号的数据、批量处理数据时定位问题）

import numpy as np

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

输出结果如下：

3.4 探索dataloader的常用属性

本篇文章中训练集的dataloader被命名为train_dl，后续提到的train_dl都是dataloader，还请各位初学者注意。

字段	值/描述
Dataset	MNIST（手写数字数据集）
Number of datapoints	60,000（训练样本总数）
Root location	data（本地存储路径）
Split	Train（训练集分支）
StandardTransform	PyTorch 标准数据预处理流程
Transform	ToTensor()（将图像转换为张量，归一化像素值到 [0.0, 1.0] 范围）

查看数据集信息

train_dl.dataset 

输出结果：

Dataset MNIST
    Number of datapoints: 60000
    Root location: data
    Split: Train
    StandardTransform
Transform: ToTensor()

查看数据集的类别标签

train_dl.dataset.classes 

输出结果：

['0 - zero',
 '1 - one',
 '2 - two',
 '3 - three',
 '4 - four',
 '5 - five',
 '6 - six',
 '7 - seven',
 '8 - eight',
 '9 - nine']

len(train_dl.dataset)    # 训练样本总数，输出结果：60000
len(train_dl)            # 批次数目，1875（60000/32）

4、卷积神经网络（CNN）模型构建

4.1 网络结构设计：卷积层、池化层与全连接层

import torch.nn.functional as F

num_classes = 10  # 图片的类别数

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

        x = torch.flatten(x, start_dim=1)

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

4.2 使用torchinfo分析模型参数（12.2万可训练参数）

使用torchinfo可以更好的查看已经搭建好的神经网路的参数。

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

summary(model)

输出结果如下：

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            320
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            18,496
├─MaxPool2d: 1-4                         --
├─Linear: 1-5                            102,464
├─Linear: 1-6                            650
=================================================================
Total params: 121,930
Trainable params: 121,930
Non-trainable params: 0
=================================================================

5、模型训练与验证

5.1 损失函数（CrossEntropyLoss）与优化器（SGD）选择

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)  # 这里使用SGD随机梯度下降,MNIST数据简单，SGD足以胜任

5.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

测试函数

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

5.4 模型训练与评估

epochs     = 5
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:76.5%, Train_loss:0.766, Test_acc:93.5%，Test_loss:0.225
Epoch: 2, Train_acc:94.4%, Train_loss:0.185, Test_acc:96.6%，Test_loss:0.120
Epoch: 3, Train_acc:96.4%, Train_loss:0.120, Test_acc:97.2%，Test_loss:0.092
Epoch: 4, Train_acc:97.2%, Train_loss:0.093, Test_acc:97.7%，Test_loss:0.072
Epoch: 5, Train_acc:97.6%, Train_loss:0.077, Test_acc:98.1%，Test_loss:0.060
Done

6 、可视化与结果展示

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

运行结果如下：

7 、个人总结与复盘

经过本次手写数字识别项目，掌握PyTorch数据管道构建全流程，特别是DataLoader这个完全新的概念，重点感受到了深度学习与机器学习在数据预处理与模型训练的区别；在探索数据集的过程中，对Tensor这个torch中特有的格式有个比较直观的认识。对整个整个CNN神经网络的前向传播与反向传播有了更清晰的认识，着重记忆反向传播三部曲“梯度归零”、“梯度计算”与“梯度更新”。