MNIST手写数字辨识

**

MNIST手写数字辨识

**

---

前言

本文主要描述了如何使用Pytorch(深度学习框架)构建一个简单的卷积神经网络，并对MNIST数据集进行了训练和测试。MNIST数据集是一个28*28的手写数字图片集合，使用测试集来验证训练出的模型对手写数字的识别准确率。

---

以下是本篇文章正文内容

一、MNIST是什么？

MNIST相当于是机器学习的Hello World，
MNIST包含70,000张手写数字图像: 60,000张用于训练，10,000张用于测试。图像是灰度的，28x28像素的，并且居中的，以减少预处理和加快运行。

二、使用步骤

1.引入库

在一开始导入需要导入PyTorch的两个核心库文件torch和torchvision，这两个库基本包含了PyTorch会用到的许多方法和函数
代码如下：

import torchvision
import torch
from torchvision import datasets, transforms
from torch.autograd import Variable

2.读入数据

torchvision的datasets可以很方便的自动下载数据集，这里使用的是MNIST数据集。另外的COCO，ImageNet，CIFCAR等数据集也可以很方的下载并使用，导入命令也非常简单
代码如下：

data_train = datasets.MNIST(root = "./data/",
                            transform = transforms.ToTensor(),
                            train = True,
                            download = True)

data_test = datasets.MNIST(root="./data/",
                           transform = transforms.ToTensor(),
                           train = False,
                           download = True)

root指定了数据集存放的路径，transform指定导入数据集时需要进行何种变换操作，train设置为True说明导入的是训练集合，否则为测试集合，download设置为True说明要下载数据集，如果已经下载好了就设置为False。

transform里面还有很多好的方法，可以用在图片资源较少的数据集做Data Argumentation操作，这里只是做了个简单的Tensor格式转换

transform = transforms.ToTensor()

3.装载数据

数据下载完成后还需要做数据装载操作

data_loader_train = torch.utils.data.DataLoader(dataset=data_train,
                                                batch_size = 64,
                                                shuffle = True)

data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
                                               batch_size = 64,
                                               shuffle = True)

batch_size设置了每批装载的数据图片为64个，shuffle设置为True在装载过程中为随机乱序

4.构建神经网络

完成数据装载后就可以构建核心程序了，这里构建的是一个包含了卷积层和全连接层的神经网络，其中卷积层使用torch.nn.Conv2d来构建，激活层使用torch.nn.ReLU来构建，池化层使用torch.nn.MaxPool2d来构建，全连接层使用torch.nn.Linear来构建

class Model(torch.nn.Module):
    
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = torch.nn.Sequential(torch.nn.Conv2d(1,64,kernel_size=3,stride=1,padding=1),
                                         torch.nn.ReLU(),
                                         torch.nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),
                                         torch.nn.ReLU(),
                                         torch.nn.MaxPool2d(stride=2,kernel_size=2))
        self.dense = torch.nn.Sequential(torch.nn.Linear(14*14*128,1024),
                                         torch.nn.ReLU(),
                                         torch.nn.Dropout(p=0.5),
                                         torch.nn.Linear(1024, 10))
    def forward(self, x):
        x = self.conv1(x)
        x = x.view(-1, 14*14*128)
        x = self.dense(x)
        return x

其中定义了torch.nn.Dropout(p=0.5)防止模型的过拟合

forward函数定义了前向传播，其实就是正常卷积路径。首先经过self.conv1(x)卷积处理，然后进行x.view(-1, 14*14*128)压缩扁平化处理，最后通过self.dense(x)全连接进行分类

之后就是对Model对象进行调用，然后定义loss计算使用交叉熵，优化计算使用Adam自动化方式，最后就可以开始训练了

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Model().to(device)
cost = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
print(model)

在训练前可以查看神经网络架构，print一下即可。

Model(
  (conv1): Sequential(
    (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (dense): Sequential(
    (0): Linear(in_features=25088, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=10, bias=True)
  )
)

5.开始训练

最好有个Nvidia的GPU，或者去网上白嫖一些GPU资源，CPU实在是太慢了。

if __name__=="__main__":
    epochs = 5
    for epoch in range(epochs):
        sum_loss = 0.0
        train_correct = 0
        print("Epoch {}/{}".format(epoch, epochs))
        print("-"*10)
        for data in data_loader_train:
            X_train, y_train = data
            X_train, y_train = Variable(X_train).cuda(), Variable(y_train).cuda()
            outputs = model(X_train)
            _,pred = torch.max(outputs.data, 1)
            optimizer.zero_grad()
            loss = cost(outputs, y_train)
            loss.backward()
            optimizer.step()
            sum_loss += loss.item()
            train_correct += torch.sum(pred == y_train.data)
            test_correct = 0
        for data in data_loader_test:
            X_test, y_test = data
            X_test, y_test = Variable(X_test).cuda(), Variable(y_test).cuda()
            outputs = model(X_test)
            _, pred = torch.max(outputs.data, 1)
            test_correct += torch.sum(pred == y_test.data)
        print("Loss is:{:.4f}, Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(sum_loss/len(data_train),
        100*train_correct/len(data_train),
        100*test_correct/len(data_test)))
torch.save(model.state_dict(), "model_parameter.pkl")

结果如下：

Epoch 0/5
----------
Loss is:0.0001, Train Accuracy is:99.8767%, Test Accuracy is:99.0700
Epoch 1/5
----------
Loss is:0.0001, Train Accuracy is:99.8767%, Test Accuracy is:98.8500
Epoch 2/5
----------
Loss is:0.0001, Train Accuracy is:99.8717%, Test Accuracy is:98.7900
Epoch 3/5
----------
Loss is:0.0001, Train Accuracy is:99.8783%, Test Accuracy is:98.8900
Epoch 4/5
----------
Loss is:0.0001, Train Accuracy is:99.8900%, Test Accuracy is:98.9000

从结果上看还不错，训练准确率最高达到了99.89%，测试最高准确率为98.90%。结果有轻微的过拟合迹象，如果使用更加健壮的卷积模型测试集会取得更加好的结果。

本文是自己学习记录所用，文章内容大多来自于光头老师，加上自己的见解，如有错误欢迎指正。