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个样本的测试集。
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 实现流程
本代码的实现流程如下所示
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()
结果如下图所示
3.3.2 保存模型
对于新手而言，我们选择直接保存整个模型
torch.save(net,'./model.pth')
若想对这一方面有进一步的了解，可以参考这篇文章 传送门
4 完整代码
由于篇幅所限，完整的代码我将放在另一个博客中
Pytorch入门——MNIST手写数字识别代码