前言
本文參考PyTorch官網的教程，分爲五個基本模塊來介紹PyTorch。爲了避免文章過長，這五個模塊分別在五篇博文中介紹。
本文是關於Part4的內容。
Part4：訓練一個神經網絡分類器
前面已經介紹了定義神經網絡，計算損失和更新權重，這裏介紹訓練神經網絡分類器。
1 關於數據
通常，當你需要處理圖像、文本、飲品或者視頻數據，你可以使用標準的python包將數據導入到numpy 的array中。之後，你可以將array轉換到torch.*Tensor。
（1） 對於圖像，Pillow、OpenCV等包非常有用。
（2） 對於音頻，scipy和librosa等包非常好。
（3） 對於文本，原始Python或基於Cython的加載，或者NLTK和SpaCy都是有用的。
尤其對於視覺，我們創建了一個叫做torchvision的包，包含了對於常用數據集（如ImageNet，CIFAR10，MNIST等）的數據加載器和對於images、viz的數據轉換器，torchvision.datasets和 torch.utils.data.DataLoader。
在該教程中，我們使用CIFAR10數據集。它含有這些類：‘airplane’, ‘automobile’, ‘bird’, ‘cat’,‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’. 這些圖像的尺寸是3*32*32，即3通道的彩色圖像，尺寸爲32*32。
2 訓練圖像分類器
我們按照如下步驟：
（1） 使用torchvision導入並且正規化CIFAR10的訓練集和測試集
（2） 定義一個卷積神經網絡
（3） 定義一個損失函數
（4） 在測試數據上訓練該網絡
（5） 在測試數據上測試該網絡
2.1 導入和正規化CIFAR10
使用torchvision，加載CIFAR10很容易。
import torch import torchvision import torchvision.transforms as transforms
torchvision數據集的輸出是[0,1]區間的PILImage。我們把這些圖像轉換到[-1,1]區間的Tensor。
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')
我們來顯示一些訓練圖像。
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)))
2.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()
2.3 定義損失函數和優化器
使用分類交叉熵損失和帶有動量的隨機梯度下降。
import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
2.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.191
[1, 4000] loss: 1.866
[1, 6000] loss: 1.696
[1, 8000] loss: 1.596
[1, 10000] loss: 1.502
[1, 12000] loss: 1.496
[2, 2000] loss: 1.422
[2, 4000] loss: 1.370
[2, 6000] loss: 1.359
[2, 8000] loss: 1.321
[2, 10000] loss: 1.311
[2, 12000] loss: 1.275
FinishedTraining
2.5 在測試數據上測試網絡
我們已經訓練了一個網絡。現在對其在測試數據上測試。第一步，顯示一個來自測試集的圖像。
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 ship car plane
現在看一下網絡在整個數據集上的表現。
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: 54 %
這看起來比偶然準確率（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]))
預期輸出：
Accuracyofplane : 60 %
Accuracyof car : 46 %
Accuracyof bird : 44 %
Accuracyof cat : 35 %
Accuracyof deer : 38 %
Accuracyof dog : 43 %
Accuracyof frog : 57 %
Accuracyofhorse : 76 %
Accuracyof ship : 71 %
Accuracyoftruck : 74 %
3 在GPU上訓練
下面這句話會遞歸遍歷全部的模塊並且將它們的參數和緩衝區轉到CUDA tensors。
net.cuda()
記住，還需要在每一步將輸入和目標值發送到GPU。
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
當網絡非常大而複雜的時候，這種加速是非常明顯的。