基於PyTorch的深度學習入門教程(五)——訓練神經網路分類器
前言
本文參考PyTorch官網的教程,分為五個基本模組來介紹PyTorch。為了避免文章過長,這五個模組分別在五篇博文中介紹。
本文是關於Part4的內容。
Part4:訓練一個神經網路分類器
前面已經介紹了定義神經網路,計算損失和更新權重,這裡介紹訓練神經網路分類器。
1 關於資料
通常,當你需要處理影象、文字、飲品或者視訊資料,你可以使用標準的python包將資料匯入到numpy 的array中。之後,你可以將array轉換到torch.*Tensor。
(1) 對於影象,Pillow、OpenCV等包非常有用。
(2) 對於音訊,scipy和librosa等包非常好。
(3) 對於文字,原始Python
尤其對於視覺,我們建立了一個叫做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
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]
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: catshipship 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: catshipcar 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 %
Accuracyofcar : 46 %
Accuracyofbird : 44 %
Accuracyofcat : 35 %
Accuracyofdeer : 38 %
Accuracyofdog : 43 %
Accuracyoffrog : 57 %
Accuracyofhorse : 76 %
Accuracyofship : 71 %
Accuracyoftruck : 74 %
3 在GPU上訓練
下面這句話會遞迴遍歷全部的模組並且將它們的引數和緩衝區轉到CUDA tensors。
net.cuda()
記住,還需要在每一步將輸入和目標值傳送到GPU。
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
當網路非常大而複雜的時候,這種加速是非常明顯的。