本文详细介绍了如何使用PyTorch构建一个简单的CNN模型来实现MNIST手写数字识别，包括环境设置、数据预处理、模型设计、训练与测试流程，以及结果的可视化分析。
- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊 | 接辅导、项目定制
实现mnist手写数字识别
这是一篇关于使用卷积神经网络（CNN）实现MNIST手写数字识别的教程， 是深度学习领域一个经典的入门级问题。本教程详细介绍了环境配置、数据准备、模型构建、训练和测试以及结果可视化的整个过程。
环境配置
需要注意，安装torch版本whl文件时选择对应的python和cuda版本的链接
- conda create -n py38 python=3.8
- cuda安装：https://developer.nvidia.com/cuda-toolkit-archive （安装12.1.0版本）
- Pytorch官网安装https://pytorch.org/get-started/locally/获取对应的pip安装命令
- pip install numpy matplotlib torchvision
# 验证运行环境
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
# 设置硬件设备，如果有GPU则使用，没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
下载数据
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)
注意可能发生错误
OMP: Error #15: Initializing libiomp5md.dll, but found libiomp5md.dll already initialized.
解决方法：添加环境变量:KMP_DUPLICATE_LIB_OK 值为:TRUE
import torch
print(torch.version.cuda)
12.1
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision
# 设置硬件设备，如果有GPU则使用，没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
device(type='cuda')
import torchvision
import torch
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)
batch_size = 200
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)
# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
imgs.shape
结果：
torch.Size([200, 1, 28, 28])
数据可视化
import numpy as np
import matplotlib.pyplot as plt
# 指定图片大小，图像大小为5宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(5, 5))
# 显示200个图片
for i, imgs in enumerate(imgs[:200]):
# i 是当前元素的索引。
#npimg 是 imgs[:200] 列表中的当前元素。
npimg = np.squeeze(imgs.numpy())
# 将整个figure分成2行10列，绘制第i+1个子图。
plt.subplot(20, 10, i+1)
plt.imshow(npimg, cmap=plt.cm.binary)
plt.axis('off')
构建简单的CNN网络
网络结构图
卷积层：
- 目的：卷积层的主要目的是提取输入数据（如图像）中的特征。这是通过使用一系列可学习的滤波器（或卷积核）来实现的，这些滤波器在输入数据上滑动（卷积操作），提取局部特征。
- 操作：在卷积操作中，每个滤波器与其覆盖的输入数据的局部区域进行元素乘法，结果的总和形成了输出特征图（feature map）中的一个单元。
结果：卷积层的输出是一系列特征图，每个特征图对应于一个卷积核，突出显示输入中该滤波器特定的特征。
池化层：
- 目的：池化层的主要目的是减少特征图的空间尺寸（高度和宽度），这有助于减少计算需求和参数的数量，从而减轻过拟合。池化操作通常保留重要信息，同时丢弃不那么重要的信息。
- 操作：池化层通常执行最大池化（max pooling）或平均池化（average pooling）操作。在最大池化中，从输入特征图的局部区域中选取最大值；在平均池化中，计算局部区域的平均值。
结果：池化操作输出的是缩小了的特征图。尽管特征图的尺寸减小了，但重要的特征仍然被保留。
关系：
- 卷积层和池化层在CNN中通常交替出现。卷积层负责提取特征，而池化层负责降低这些特征的空间维度，使模型更加高效且对小的位置变化更加不变。
- 池化层通常跟在卷积层之后，用来降维和减少计算，同时提高特征的转移不变性（即当对象在图像中移动时，特征检测的稳定性）。
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
加载并打印模型
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
=================================================================
编写训练函数
# 设置超参数
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)
# 训练循环
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
正式训练
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:92.1%, Train_loss:0.264, Test_acc:93.4%，Test_loss:0.223
Epoch: 2, Train_acc:93.1%, Train_loss:0.231, Test_acc:94.2%，Test_loss:0.201
Epoch: 3, Train_acc:94.0%, Train_loss:0.205, Test_acc:94.5%，Test_loss:0.188
Epoch: 4, Train_acc:94.5%, Train_loss:0.184, Test_acc:95.4%，Test_loss:0.156
Epoch: 5, Train_acc:95.1%, Train_loss:0.165, Test_acc:95.7%，Test_loss:0.148
Done
结果可视化
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 #分辨率
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.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()
总结
- 环境配置：确保Python环境和相关库（如PyTorch）的安装与配置正确。特别是CUDA的安装，对于加速模型训练至关重要。
- 数据加载与预处理：使用torchvision库下载MNIST数据集，并通过transform将图像数据转换为张量，这是模型训练所必需的数据格式。
- 模型构建：模型包含多个卷积层和池化层，这些层交替出现，用于提取图像特征和降低特征维度。紧接着是全连接层，用于分类任务。
- 训练与测试：定义损失函数和优化器，并编写训练和测试函数。这些函数在每个epoch中对整个训练集和测试集进行迭代，优化模型参数并评估模型性能。
- 结果可视化：通过绘制训练和验证的准确率与损失函数值，可以直观地观察模型性能随训练过程的变化，帮助判断模型是否出现过拟合或欠拟合。
- 注意事项：
- 数据归一化：确保输入数据被适当地归一化，这有助于模型的收敛和性能。
- 超参数调整：学习率、批次大小、epoch数量等超参数的选择会影响模型的训练效果，可能需要多次实验来找到最优配置。
- 个人小结：通过这个项目，可以加深对CNN结构、训练和测试过程以及PyTorch框架的理解。此外，实践中解决问题、调整模型参数和分析结果的过程对深化理论知识和提升实践技能都非常有帮助。
扫一扫
4162
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
