【PyTorch深度學習60分鍾快速入門 】Part4：訓練一個分類器

 

太棒啦！到目前為止，你已經了解了如何定義神經網絡、計算損失，以及更新網絡權重。不過，現在你可能會思考以下幾個方面：

0x01 數據集

通常，當你需要處理圖像、文本、音頻或視頻數據時，你可以使用標准的python包將數據加載到numpy數組中。然后你可以將該數組轉換成一個torch.*Tensor。

• 對於圖像，Pillow、OpenCV這些包將有所幫助。
• 對於音頻，可以使用scipy和librosa包。
• 對於文本，無論是基於原始的Python還是Cython的加載，或者NLTK和SpaCy都將有所幫助。

具體對於圖像來說，我們已經創建了一個名為torchvision的包，它為像Imagenet、CIFAR10、MNIST等公共數據集提供了數據加載器，並為圖像提供了數據轉換器，即torchvision.datasets和torch.utils.data.DataLoader。

這提供了極大的便利，避免了編寫樣板代碼。

對於本教程，我們將使用CIFAR10數據集。它包含以下10個分類：飛機、汽車、鳥、貓、鹿、狗、青蛙、馬、輪船和卡車。CIFAR-10數據集中的圖像大小為3x32x32，即大小為32x32像素的3通道彩色圖像。

0x02 訓練一個圖像分類器

我們將按順序執行以下步驟：

1. 使用torchvision加載並歸一化CIFAR10訓練和測試數據集
2. 定義一個卷積神經網絡
3. 定義一個損失函數
4. 利用訓練數據來訓練網絡
5. 利用測試數據來測試網絡

1. 加載和歸一化CIFAR10

使用torchvision可以很容易地加載CIFAR10。

import torch
import torchvision
import torchvision.transforms as transforms

torchvision數據集的輸出結果為像素值在[0,1]范圍內的PILImage圖像。我們將它們轉換成標准化范圍[-1,1]的張量：

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

輸出結果：

Files already downloaded and verified
Files already downloaded and verified

為了增添一些樂趣，我們來展示一些訓練圖片：

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

輸出結果：

frog  ship  bird truck

2. 定義一個卷積神經網絡

從前面“神經網絡”一節中拷貝神經網絡並對其進行修改，使它接受3通道的圖像（而不是原先定義的單通道圖像）。

from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

3. 定義損失函數和優化器

讓我們用一個分類交叉熵的損失函數，以及帶動量的SGD：

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4. 訓練網絡

這里正是事情開始變得有趣的地方。我們只需循環遍歷我們的數據迭代器，並將輸入量輸入到網絡並進行優化：

for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data

        # wrap them in Variable
        inputs, labels = Variable(inputs), Variable(labels)

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.data[0]
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

輸出結果：

[1,  2000] loss: 2.204
[1,  4000] loss: 1.855
[1,  6000] loss: 1.677
[1,  8000] loss: 1.577
[1, 10000] loss: 1.508
[1, 12000] loss: 1.485
[2,  2000] loss: 1.403
[2,  4000] loss: 1.392
[2,  6000] loss: 1.355
[2,  8000] loss: 1.332
[2, 10000] loss: 1.300
[2, 12000] loss: 1.282
Finished Training

5. 在測試數據上測試網絡

我們已經利用訓練數據集對網絡訓練了2次。但是，我們需要檢查網絡是否已經學到了什么。

我們將通過預測神經網絡輸出的類標簽來檢查它，並根據實際情況對其進行檢查。如果預測是正確的，那么我們將該樣本添加到正確的預測列表中。

OK！第一步，讓我們展示測試集中的一個圖像，以便於我們熟悉它。

dataiter = iter(testloader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

輸出結果：

GroundTruth:    cat  ship  ship plane

現在讓我們看看神經網絡認為上面例子中的對象是什么：

outputs = net(Variable(images))

輸出結果是10個類的能量值。如果一個類的能量值越高，那么網絡就越可能認為圖像是該特定類。所以，我們來獲取最高能量值對應的索引：

_, predicted = torch.max(outputs.data, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

輸出結果：

Predicted:    cat   car   car  ship

結果看起來相當不錯。

下面，我們看一下該網絡在整個數據集上的表現。

correct = 0
total = 0
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

輸出結果：

Accuracy of the network on the 10000 test images: 53 %

結果看起來比隨機概率要好，隨機概率為10%的准確率（隨機從10個類中挑選一個類）。看起來似乎該網絡學到了一些東西。

下面，我們看一下到底是哪些類別表現的很好，哪些類別表現的不好：

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    c = (predicted == labels).squeeze()
    for i in range(4):
        label = labels[i]
        class_correct[label] += c[i]
        class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

輸出結果：

Accuracy of plane : 43 %
Accuracy of   car : 67 %
Accuracy of  bird : 27 %
Accuracy of   cat : 60 %
Accuracy of  deer : 44 %
Accuracy of   dog : 36 %
Accuracy of  frog : 64 %
Accuracy of horse : 56 %
Accuracy of  ship : 55 %
Accuracy of truck : 73 %

Ok，下一步我們將學習如何在GPU上運行神經網絡。

0x03 在GPU上訓練

將神經網絡轉移到GPU上，就像將一個張量轉移到GPU上一樣。這將遞歸地遍歷所有模塊，並將它們的參數和緩沖器轉換為CUDA張量：

net.cuda()

記住，你還必須將每一步的輸入和目標都發送到GPU上：

inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())

為什么與CPU相比，我沒有看到速度的明顯提升？那是因為你的網絡實在是太小了。

練習： 嘗試增加網絡的寬度（第一個nn.Conv2d的參數2，以及第二個nn.Conv2d的參數1，它們必須為同一個數字），然后看下速度提升效果。

實現的目標：

• 以更高的角度理解PyTorch的Tensor庫和神經網絡
• 訓練一個小型的神經網絡來對圖像進行分類

0x04 在多個GPU上訓練

如果你想使用所有GPU來得到速度更大的提升，可以閱讀下一節“數據並行性”。

0x05 擴展閱讀

• Train neural nets to play video games
• Train a state-of-the-art ResNet network on imagenet
• Train a face generator using Generative Adversarial Networks
• Train a word-level language model using Recurrent LSTM networks
• More examples
• More tutorials
• Discuss PyTorch on the Forums
• Chat with other users on Slack