持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第32天，点击查看活动详情

前言

本文将介绍如何在 PyTorch 中构建一个简单的卷积神经网络，并训练它使用 MNIST 数据集识别手写数字，这将可以被看做是图像识别的 “Hello, World!”；

在【项目实战】MNIST 手写数字识别（上）中，我已经介绍过了如何配置环境，准备数据集以及使用数据集，接下来将要进行构建网络、训练模型、评估模型、优化模型等；

构建网络

现在让我们继续构建我们的网络。我们将使用两个二维卷积层，然后是两个全连接（或线性）层。作为激活函数，我们将选择校正线性单元（简称 ReLU），作为正则化的手段，我们将使用两个 dropout 层。在 PyTorch 中，构建网络的一种好方法是为我们希望构建的网络创建一个新类。让我们在这里导入一些子模块以获得更易读的代码。

1
2
3

py复制代码import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

py复制代码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)

从广义上讲，我们可以认为 torch.nn 层包含可训练的参数，而 torch.nn.functional 是纯函数式的。 forward() 传递定义了我们使用给定层和函数计算输出的方式。在前向传递中的某处打印张量以方便调试是非常好的。这在尝试更复杂的模型时会派上用场。请注意，前向传递可以利用例如一个成员变量甚至数据本身来确定执行路径——它也可以使用多个参数！

现在让我们初始化网络和优化器。

1
2
3

py复制代码network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
                      momentum=momentum)

注意：如果我们使用 GPU 进行训练，我们还应该将网络参数发送到 GPU，例如 network.cuda()。在将网络参数传递给优化器之前，将它们传输到适当的设备非常重要，否则优化器将无法以正确的方式跟踪它们。

训练模型

是时候建立我们的训练循环了。

首先，我们要确保我们的网络处于训练模式。

然后我们每个 epoch 对所有训练数据进行一次迭代。

再由 DataLoader 加载单个批次。我们需要使用 optimizer.zero_grad() 手动将梯度设置为零，因为 PyTorch 默认会累积梯度。然后产生网络的输出（前向传递）并计算输出和地面实况标签之间的负对数似然损失。

现在，backward() 调用收集了一组新的梯度，我们使用 optimizer.step() 将其传播回每个网络参数。

我们还将通过一些打印输出跟踪进度。为了稍后创建一个漂亮的训练曲线，我们还创建了两个列表来保存训练和测试损失。在 x 轴上，我们希望显示网络在训练期间看到的训练示例的数量。

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

我们将在开始训练之前运行一次测试循环，看看我们仅使用随机初始化的网络参数实现了什么样的准确度损失。你能猜出我们在这种情况下的准确性如何吗？

py复制代码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(), f'{BASEPATH}/results/model.pth')
            torch.save(optimizer.state_dict(), f'{BASEPATH}/results/optimizer.pth')

神经网络模块和优化器能够使用 .state_dict() 保存和加载它们的内部状态。有了这个，我们可以通过调用 .load_state_dict(state_dict)，继续从以前保存的状态字典中训练。

现在为我们的测试循环。在这里，我们总结了测试损失并跟踪正确分类的数字以计算网络的准确性。

py复制代码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() 调用，以使用随机初始化的参数评估我们的模型。

py复制代码test()
for epoch in range(1, n_epochs + 1):
    train(epoch)
    test()

评估模型

仅通过 3 个 epoch 的训练，我们就已经成功地在测试集上达到了 97% 的准确率！我们从随机初始化的参数开始，正如预期的那样，在开始训练之前，测试集的准确率只有大约 10%。

绘制一下我们的训练曲线：

py复制代码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')

看起来我们甚至可以继续训练几个 epoch！

但在此之前，让我们再看几个例子，就像我们之前所做的一样，并比较模型的输出。

1 2	py复制代码with torch.no_grad(): output = network(example_data)

py复制代码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([])

我们模型的预测似乎与这些示例相符！

继续训练

现在让我们继续训练网络，或者更确切地说，看看我们如何从我们在第一次训练运行期间保存的 state_dicts 继续训练。我们将初始化一组新的网络和优化器。

1
2
3

py复制代码continued_network = Net()
continued_optimizer = optim.SGD(network.parameters(), lr=learning_rate,
                                momentum=momentum)

使用 .load_state_dict() 可以加载上次保存时网络和优化器的内部状态。

py复制代码network_state_dict = torch.load(f'{BASEPATH}/results/model.pth')
continued_network.load_state_dict(network_state_dict)

optimizer_state_dict = torch.load(f'{BASEPATH}/results/optimizer.pth')
continued_optimizer.load_state_dict(optimizer_state_dict)

再次运行一个训练循环，应该从我们离开的地方继续训练。

要检查这一点，让我们简单地使用与以前相同的列表来跟踪损失值

由于我们为看到的训练示例数量构建测试计数器，因此我们必须在此处手动追加。

py复制代码for i in range(4,9):
    test_counter.append(i*len(train_loader.dataset))
    train(i)
    test()

我们再次看到测试集准确性从一个时期到另一个时期的增加（慢得多）。让我们将其可视化以进一步检查训练进度。

py复制代码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')

这看起来仍然是一条相当平滑的学习曲线，就像我们最初会训练 8 个 epoch 一样！请记住，我们只是从第 5 个红点开始将值附加到相同的列表中。

由此我们可以得出两个结论：

从检查点内部状态继续按预期工作。
我们似乎仍然没有遇到过拟合问题！看起来我们的 dropout 层在规范化模型方面做得很好。

后记

MNIST 手写数字识别的内容到这里就结束了；

PyTorch 和 TorchVision 构建了一个新环境，用它来分类 MNIST 数据集中的手写数字，并希望使用 PyTorch 开发出良好的直觉。

📝 上篇精讲：【项目实战】MNIST 手写数字识别（上）

💖 我是 𝓼𝓲𝓭𝓲𝓸𝓽，期待你的关注；

👍 创作不易，请多多支持；

🔥 系列专栏：项目实战 AI

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有