Pytorch入门——手把手教你MNIST手写数字识别

MNIST手写数字识别教程

要开始带组内的小朋友了,特意出一个Pytorch教程来指导一下

[!] 这里是实战教程,默认读者已经学会了部分深度学习原理,若有不懂的地方可以先停下来查查资料


目录

  • MNIST手写数字识别教程
    • 1 什么是MNIST?
    • 2 使用Pytorch实现手写数字识别
      • 2.1 任务目的
      • 2.2 开发环境
      • 2.3 实现流程
    • 3 具体代码实现
      • 3.1 数据预处理部分
        • 3.1.1 初始化全局变量
        • 3.1.2 构建数据集
      • 3.2 训练部分
        • 3.2.1 构建模型
        • 3.2.2 构建迭代器与损失函数
        • 3.2.3 构建训练循环
          • 3.2.3.1 训练部分代码
          • 3.2.3.2 测试部分代码
          • 3.2.3.3 训练循环代码
      • 3.3 数据预后处理部分
        • 3.3.1 训练结果可视化
        • 3.3.2 保存模型
    • 4 完整代码

1 什么是MNIST?

MNIST是计算机视觉领域中最为基础的一个数据集,也是很多人第一个神经网络模型

MNIST数据集(Mixed National Institute of Standards and Technology database)是美国国家标准与技术研究院收集整理的大型手写数字数据集,包含了60,000个样本的训练集以及10,000个样本的测试集。
Pytorch入门——手把手教你MNIST手写数字识别

MNIST中所有样本都会将原本28*28的灰度图转换为长度为784的一维向量作为输入,其中每个元素分别对应了灰度图中的灰度值。MNIST使用一个长度为10的one-hot向量作为该样本所对应的标签,其中向量索引值对应了该样本以该索引为结果的预测概率。


2 使用Pytorch实现手写数字识别

2.1 任务目的

如本文标题所示,MNIST手写数字识别的主要目为:训练出一个模型,让这个模型能够对手写数字图片进行分类。

2.2 开发环境

为了实现本文的目标,你需要安装如下Python库

1. pytorch >= '1.4.0'
2. torchvision
3. tqdm
4. matplotlib

Pytorch官网上有着详细的安装教程,你可以看着来进行安装 - 传送门

tqdm库是Python的一个动态显示库,我们需要他来进行训练可视化

pip install tqdm

matplotlib库是Python的一个数据可视化库,我们需要他来进行训练结果可视化

pip install matploblib

2.3 实现流程

本代码的实现流程如下所示
Pytorch入门——手把手教你MNIST手写数字识别

3 具体代码实现

3.1 数据预处理部分

3.1.1 初始化全局变量

首先,我们需要导入上述提到的库,为了能够更全面的展示程序中每个函数的具体来源,因此本项目中的库不采用缩写的方式

import torch
import torchvision
from tqdm import tqdm
import matplotlib

对于Pytorch,我们需要手动去定义它是在CPU还是在GPU中训练;同时,我们需要使用到torchvision中的图片处理库torchvision.transforms来将图片转换为适用于网络的张量。

#如果网络能在GPU中训练,就使用GPU;否则使用CPU进行训练
device = "cuda:0" if torch.cuda.is_available() else "cpu" #这个函数包括了两个操作:将图片转换为张量,以及将图片进行归一化处理
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean = [0.5],std = [0.5])])

3.1.2 构建数据集

torchvision中的torchvision.datasets库中提供了MNIST数据集的下载地址,因此我们可以直接二调用对应的函数来下载MNIST的训练集和测试集

path = './data/'  #数据集下载后保存的目录

#下载训练集和测试集
trainData = torchvision.datasets.MNIST(path,train = True,transform = transform,download = True)
testData = torchvision.datasets.MNIST(path,train = False,transform = transform)

Pytorch中提供了一种叫做DataLoader的方法来让我们进行训练,该方法自动将数据集打包成为迭代器,能够让我们很方便地进行后续的训练处理

#设定每一个Batch的大小
BATCH_SIZE = 256 #构建数据集和测试集的DataLoader
trainDataLoader = torch.utils.data.DataLoader(dataset = trainData,batch_size = BATCH_SIZE,shuffle = True)
testDataLoader = torch.utils.data.DataLoader(dataset = testData,batch_size = BATCH_SIZE)

至此,数据集已经准备完毕。

3.2 训练部分

3.2.1 构建模型

在这里使用的是一个简单的卷积神经网络,其结构如下

class Net(torch.nn.Module):
def __init__(self):
super(Net,self).__init__()
self.model = torch.nn.Sequential(
#The size of the picture is 28x28
torch.nn.Conv2d(in_channels = 1,out_channels = 16,kernel_size = 3,stride = 1,padding = 1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size = 2,stride = 2), #The size of the picture is 14x14
torch.nn.Conv2d(in_channels = 16,out_channels = 32,kernel_size = 3,stride = 1,padding = 1),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size = 2,stride = 2), #The size of the picture is 7x7
torch.nn.Conv2d(in_channels = 32,out_channels = 64,kernel_size = 3,stride = 1,padding = 1),
torch.nn.ReLU(), torch.nn.Flatten(),
torch.nn.Linear(in_features = 7 * 7 * 64,out_features = 128),
torch.nn.ReLU(),
torch.nn.Linear(in_features = 128,out_features = 10),
torch.nn.Softmax(dim=1)
) def forward(self,input):
output = self.model(input)
return output

其中torch.nn.Sequential函数能够自动将层数合并为一个模型,对于新手而言这种方式能够减少非常多的计算过程

随后,我们需要构建一个模型实例

net = Net()
#将模型转换到device中,并将其结构显示出来
print(net.to(device))

to() 方法用于将张量放入到指定的设备(如CPU或GPU中),记住的是:不同设备的张量是无法进行运算的

如果一切正常,那么输出结果如下

Net(
(model): Sequential(
(0): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(4): ReLU()
(5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(7): ReLU()
(8): Flatten(start_dim=1, end_dim=-1)
(9): Linear(in_features=3136, out_features=128, bias=True)
(10): ReLU()
(11): Linear(in_features=128, out_features=10, bias=True)
(12): Softmax(dim=1)
)
)

读者也可以根据自己的兴趣去修改网络结构。

3.2.2 构建迭代器与损失函数

对于简单的多分类任务,我们可以使用交叉熵损失来作为损失函数;
而对于迭代器而言,我们可以使用Adam迭代器

lossF = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters())

模型在构建迭代器的时候需要将所有参数传入到迭代器中,可以通过**net.parameters()**方法来得到模型的所有参数。

3.2.3 构建训练循环

训练循环是很多新手最头疼的地方,因此将会着重讲解这一部分

对于一个普通的训练循环,他的流程如下:
⋯ → 训 练 → 验 证 → 下 一 轮 训 练 → 下 一 轮 验 证 → … \dots\rightarrow 训练\rightarrow 验证 \rightarrow 下一轮训练 \rightarrow 下一轮验证 \rightarrow \dots ⋯→训练→验证→下一轮训练→下一轮验证→…

我们根据这个流程,构建一个循环框架

EPOCHS = 10 #总的循环

for epoch in range(1,EPOCHS + 1):
"""
训练部分
""" """
测试部分
"""
3.2.3.1 训练部分代码

对于训练部分,我们可以构造的模块为

#构建tqdm进度条
processBar = tqdm(trainDataLoader,unit = 'step')
#打开网络的训练模式
net.train(True) #开始对训练集的DataLoader进行迭代
for step,(trainImgs,labels) in enumerate(processBar): #将图像和标签传输进device中
trainImgs = trainImgs.to(device)
labels = labels.to(device) #清空模型的梯度
net.zero_grad() #对模型进行前向推理
outputs = net(trainImgs) #计算本轮推理的Loss值
loss = lossF(outputs,labels)
#计算本轮推理的准确率
predictions = torch.argmax(outputs, dim = 1)
accuracy = torch.sum(predictions == labels)/labels.shape[0] #进行反向传播求出模型参数的梯度
loss.backward()
#使用迭代器更新模型权重
optimizer.step() #将本step结果进行可视化处理
processBar.set_description("[%d/%d] Loss: %.4f, Acc: %.4f" %
(epoch,EPOCHS,loss.item(),accuracy.item()))
3.2.3.2 测试部分代码

对于测试部分,我们可以构造的模块为

#构造临时变量
correct,totalLoss = 0,0
#关闭模型的训练状态
net.train(False)
#对测试集的DataLoader进行迭代
for testImgs,labels in testDataLoader:
testImgs = testImgs.to(device)
labels = labels.to(device)
outputs = net(testImgs)
loss = lossF(outputs,labels)
predictions = torch.argmax(outputs,dim = 1) #存储测试结果
totalLoss += loss
correct += torch.sum(predictions == labels) #计算总测试的平均准确率
testAccuracy = correct/(BATCH_SIZE * len(testDataLoader))
#计算总测试的平均Loss
testLoss = totalLoss/len(testDataLoader)
#将本step结果进行可视化处理
processBar.set_description("[%d/%d] Loss: %.4f, Acc: %.4f, Test Loss: %.4f, Test Acc: %.4f" %
(epoch,EPOCHS,loss.item(),accuracy.item(),testLoss.item(),testAccuracy.item()))
3.2.3.3 训练循环代码

将上述两个循环进行结合,就是最终的训练循环代码了

EPOCHS = 10
#存储训练过程
history = {'Test Loss':[],'Test Accuracy':[]}
for epoch in range(1,EPOCHS + 1):
processBar = tqdm(trainDataLoader,unit = 'step')
net.train(True)
for step,(trainImgs,labels) in enumerate(processBar):
trainImgs = trainImgs.to(device)
labels = labels.to(device) net.zero_grad()
outputs = net(trainImgs)
loss = lossF(outputs,labels)
predictions = torch.argmax(outputs, dim = 1)
accuracy = torch.sum(predictions == labels)/labels.shape[0]
loss.backward() optimizer.step()
processBar.set_description("[%d/%d] Loss: %.4f, Acc: %.4f" %
(epoch,EPOCHS,loss.item(),accuracy.item())) if step == len(processBar)-1:
correct,totalLoss = 0,0
net.train(False)
for testImgs,labels in testDataLoader:
testImgs = testImgs.to(device)
labels = labels.to(device)
outputs = net(testImgs)
loss = lossF(outputs,labels)
predictions = torch.argmax(outputs,dim = 1) totalLoss += loss
correct += torch.sum(predictions == labels)
testAccuracy = correct/(BATCH_SIZE * len(testDataLoader))
testLoss = totalLoss/len(testDataLoader)
history['Test Loss'].append(testLoss.item())
history['Test Accuracy'].append(testAccuracy.item())
processBar.set_description("[%d/%d] Loss: %.4f, Acc: %.4f, Test Loss: %.4f, Test Acc: %.4f" %
(epoch,EPOCHS,loss.item(),accuracy.item(),testLoss.item(),testAccuracy.item()))
processBar.close()

假如一切正常,能看到以下的训练过程

[1/10] Loss: 1.4614, Acc: 0.9479, Test Loss: 1.5050, Test Acc: 0.9355: 100%|███████| 235/235 [00:12<00:00, 19.04step/s]
[2/10] Loss: 1.4612, Acc: 0.9792, Test Loss: 1.4843, Test Acc: 0.9544: 100%|███████| 235/235 [00:10<00:00, 21.72step/s]
[3/10] Loss: 1.4612, Acc: 0.9688, Test Loss: 1.4824, Test Acc: 0.9571: 100%|███████| 235/235 [00:10<00:00, 22.30step/s]
[4/10] Loss: 1.4612, Acc: 1.0000, Test Loss: 1.4806, Test Acc: 0.9581: 100%|███████| 235/235 [00:10<00:00, 22.40step/s]
[5/10] Loss: 1.4915, Acc: 0.9688: 36%|████████████████ | 84/235 [00:03<00:06, 24.97step/s]

3.3 数据预后处理部分

数据后处理的部分包括训练结果可视化以及模型保存两个环节

3.3.1 训练结果可视化

我们需要使用到matplotlib来对结果进行可视化

#对测试Loss进行可视化
matplotlib.pyplot.plot(history['Test Loss'],label = 'Test Loss')
matplotlib.pyplot.legend(loc='best')
matplotlib.pyplot.grid(True)
matplotlib.pyplot.xlabel('Epoch')
matplotlib.pyplot.ylabel('Loss')
matplotlib.pyplot.show() #对测试准确率进行可视化
matplotlib.pyplot.plot(history['Test Accuracy'],color = 'red',label = 'Test Accuracy')
matplotlib.pyplot.legend(loc='best')
matplotlib.pyplot.grid(True)
matplotlib.pyplot.xlabel('Epoch')
matplotlib.pyplot.ylabel('Accuracy')
matplotlib.pyplot.show()

结果如下图所示
Pytorch入门——手把手教你MNIST手写数字识别
Pytorch入门——手把手教你MNIST手写数字识别

3.3.2 保存模型

对于新手而言,我们选择直接保存整个模型

torch.save(net,'./model.pth')

若想对这一方面有进一步的了解,可以参考这篇文章 传送门


4 完整代码

由于篇幅所限,完整的代码我将放在另一个博客中
Pytorch入门——MNIST手写数字识别代码

上一篇:Android控件显示和隐藏


下一篇:卷积神经网络CNN 手写数字识别