PyTorch实现MNIST手写数字识别

最近在学习神经网络，这里做一个小实践。本文为转载，点击这里跳转原文。

1. 环境配置

这里使用PyTorch来训练模型。安装PyTorch与机器的显卡似乎有一定关系，安装教程网上搜索即可。配置完成后，在Jupyter Notebook中编写代码。首先引入PyTorch。

import torch
import torchvision
from torch.utils.data import DataLoader

2. 准备数据集

定义一些超参数：

n_epochs = 3 			#循环整个训练数据集的次数
batch_size_train = 64
batch_size_test = 1000
learning_rate = 0.01	#优化器的超参数
momentum = 0.5			#优化器的超参数
log_interval = 10

random_seed = 1
torch.backends.cudnn.enabled = False
torch.manual_seed(random_seed)

对于可以重复的实验要设置随机数种子产生随机数，另外可以禁用非确定性算法cuDNN。
接着我们需要数据集的DataLoaders。TorchVision可以很容易地将MNIST数据集加载进来。使用batch_size=64进行训练，并使用size=1000对数据集进行测试。Normalize()转换使用的值0.1307和0.3081是MNIST数据集的全局平均值和标准偏差，这里将它们作为定值。

train_loader = torch.utils.data.DataLoader(
  torchvision.datasets.MNIST('/files/', train=True, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ])),
  batch_size=batch_size_train, shuffle=True)

test_loader = torch.utils.data.DataLoader(
  torchvision.datasets.MNIST('/files/', train=False, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ])),
  batch_size=batch_size_test, shuffle=True)

接着可以看看一批测试数据由什么组成。example_targets是图片实际对应的数字标签，一批测试数据是一个形状张量，运行后可以看到torch.Size([1000,1,28,28])，这意味着有1000个例子的28x28像素的灰度图(即没有rgb通道)。

examples = enumerate(test_loader)
batch_idx, (example_data, example_targets) = next(examples)
print(example_targets)
print(example_data.shape)

可以使用matplotlib来绘制其中的一些图片。

import matplotlib.pyplot as plt

fig = plt.figure()
for i in range(6):
  plt.subplot(2,3,i+1)
  plt.tight_layout()
  plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
  plt.title("Ground Truth: {}".format(example_targets[i]))
  plt.xticks([])
  plt.yticks([])
fig

3. 构建网络

现在开始建立网络。我们将使用两个2d卷积层，然后是两个全连接(或线性)层。我们将选择整流线性单元(简称ReLUs)作为激活函数，将使用两个dropout层作为正则化的手段。首先导入一些子模块，使代码更具可读性。

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

在PyTorch中，构建网络的一个好方法是为希望构建的网络创建一个新类。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x)

接着初始化网络和优化器。

network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
                      momentum=momentum)

4. 模型训练

建立训练循环：首先要确保网络处于训练模式。然后，每个epoch对所有训练数据进行一次迭代。加载单独批次由DataLoader处理。

首先，需要使用optimizer.zero_grad()手动将梯度设置为零，因为PyTorch在默认情况下会累积梯度。然后，生成网络的输出(前向传递)，并计算输出与真值标签之间的负对数概率损失。现在，我们收集一组新的梯度，并使用optimizer.step()将其传播回每个网络参数。

我们还将使用一些打印输出来跟踪进度。为了在以后创建一个良好的训练曲线，还创建了两个列表来节省训练和测试损失。在x轴上，我们希望显示网络在训练期间看到的训练示例的数量。

train_losses = []
train_counter = []
test_losses = []
test_counter = [i*len(train_loader.dataset) for i in range(n_epochs + 1)]

在开始训练之前，我们将运行一次测试循环，看看仅使用随机初始化的网络参数可以获得多大的精度/损失。

def train(epoch):
  network.train()
  for batch_idx, (data, target) in enumerate(train_loader):
    optimizer.zero_grad()
    output = network(data)
    loss = F.nll_loss(output, target)
    loss.backward()
    optimizer.step()
    if batch_idx % log_interval == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        epoch, batch_idx * len(data), len(train_loader.dataset),
        100. * batch_idx / len(train_loader), loss.item()))
      train_losses.append(loss.item())
      train_counter.append(
        (batch_idx*64) + ((epoch-1)*len(train_loader.dataset)))
      torch.save(network.state_dict(), './model.pth')
      torch.save(optimizer.state_dict(), './optimizer.pth')
          
train(1)

神经网络模块以及优化器能够使用.state_dict()保存和加载它们的内部状态。这样，如果需要，就可以继续从以前保存的状态dict中进行训练——只需调用.load_state_dict(state_dict)。

现在进入测试循环。这里总结了测试损失，并跟踪正确分类的数字来计算网络的精度。

def test():
  network.eval()
  test_loss = 0
  correct = 0
  with torch.no_grad():
    for data, target in test_loader:
      output = network(data)
      test_loss += F.nll_loss(output, target, size_average=False).item()
      pred = output.data.max(1, keepdim=True)[1]
      correct += pred.eq(target.data.view_as(pred)).sum()
  test_loss /= len(test_loader.dataset)
  test_losses.append(test_loss)
  print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_loader.dataset),
    100. * correct / len(test_loader.dataset)))

使用上下文管理器no_grad()，我们可以避免将生成网络输出的计算结果存储在计算图中。

开始训练！我们将在循环遍历n_epochs之前手动添加test()调用，以使用随机初始化的参数来评估我们的模型。

test()
for epoch in range(1, n_epochs + 1):
  train(epoch)
  test()

5. 评估模型的性能

经过3个阶段的训练，测试集的准确率已经很高。来画一下训练曲线。

fig = plt.figure()
plt.plot(train_counter, train_losses, color='blue')
plt.scatter(test_counter, test_losses, color='red')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('negative log likelihood loss')
fig

从训练曲线来看，看起来我们甚至可以继续训练几个epoch。但在此之前，让我们再看看几个例子，正如我们之前所做的，并比较模型的输出。

with torch.no_grad():
  output = network(example_data)
fig = plt.figure()
for i in range(6):
  plt.subplot(2,3,i+1)
  plt.tight_layout()
  plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
  plt.title("Prediction: {}".format(
    output.data.max(1, keepdim=True)[1][i].item()))
  plt.xticks([])
  plt.yticks([])
fig

模型对这些例子的预测似乎是正确的。

6. 检查点的持续训练

现在继续对网络进行训练，或者看看如何从第一次训练运行时保存的state_dicts中继续进行训练。初始化一组新的网络和优化器。

continued_network = Net()
continued_optimizer = optim.SGD(network.parameters(), lr=learning_rate, momentum=momentum)

使用.load_state_dict()，我们现在可以加载网络的内部状态，并在最后一次保存它们时优化它们。

network_state_dict = torch.load('model.pth')
continued_network.load_state_dict(network_state_dict)
optimizer_state_dict = torch.load('optimizer.pth')
continued_optimizer.load_state_dict(optimizer_state_dict)

同样，运行一个训练循环应该立即恢复我们之前的训练。为了检查这一点，只需使用与前面相同的列表来跟踪损失值。由于我们为所看到的训练示例的数量构建测试计数器的方式，我们必须在这里手动添加它。

for i in range(4,9):
  test_counter.append(i*len(train_loader.dataset))
  train(i)
  test()

我们再次看到测试集的准确性从一个epoch到另一个epoch有了(运行更慢的，慢的多了)提高。让我们用图像来进一步检查训练进度。

fig = plt.figure()
plt.plot(train_counter, train_losses, color='blue')
plt.scatter(test_counter, test_losses, color='red')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('negative log likelihood loss')
fig