資料

通常，當您必須處理影象，文字，音訊或視訊資料時，可以使用將資料載入到 NumPy 陣列中的標準 Python 包。 然後，您可以將該陣列轉換為torch.*Tensor。

• 對於影象，Pillow，OpenCV 等包很有用
• 對於音訊，請使用 SciPy 和 librosa 等包
• 對於文字，基於 Python 或 Cython 的原始載入，或者 NLTK 和 SpaCy 很有用

專門針對視覺，我們建立了一個名為torchvision的包，其中包含用於常見資料集（例如 Imagenet，CIFAR10，MNIST 等）的資料載入器，以及用於影象（即torchvision.datasets和torch.utils.data.DataLoader

這提供了極大的便利，並且避免了編寫樣板程式碼。

在本教程中，我們將使用 CIFAR10 資料集。 它具有以下類別：“飛機”，“汽車”，“鳥”，“貓”，“鹿”，“狗”，“青蛙”，“馬”，“船”，“卡車”。 CIFAR-10 中的影象尺寸為3x32x32，即尺寸為32x32畫素的 3 通道彩色影象。

訓練影象分類器

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

1. 使用torchvision載入並標準化 CIFAR10 訓練和測試資料集
2. 定義卷積神經網路
3. 定義損失函式
4. 根據訓練資料訓練網路
5. 在測試資料上測試網路

1.載入並標準化 CIFAR10

使用torchvision，載入 CIFAR10 非常容易。

1 import torch
2 import torchvision
3 import torchvision.transforms as transforms

TorchVision 資料集的輸出是[0, 1]範圍的PILImage影象。 我們將它們轉換為歸一化範圍[-1, 1]的張量。 .. 注意：

1 If running on Windows and you get a BrokenPipeError, try setting
2 the num_worker of torch.utils.data.DataLoader() to 0.

 1 transform = transforms.Compose(
 
 2     [transforms.ToTensor(),
 3      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
 4 
 5 trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
 6                                         download=True, transform=transform)
 7 trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
 8                                           shuffle=True, num_workers=2)
 9 
10 testset = torchvision.datasets.CIFAR10(root='./data', train=False,
11                                        download=True, transform=transform)
12 testloader = torch.utils.data.DataLoader(testset, batch_size=4,
13                                          shuffle=False, num_workers=2)
14 
15 classes = ('plane', 'car', 'bird', 'cat',
16            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

出：

1 Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
2 Extracting ./data/cifar-10-python.tar.gz to ./data
3 Files already downloaded and verified

讓我們展示一些訓練影象，很有趣。

 1 import matplotlib.pyplot as plt
 2 import numpy as np
 3 
 4 # functions to show an image
 5 
 6 def imshow(img):
 7     img = img / 2 + 0.5     # unnormalize
 8     npimg = img.numpy()
 9     plt.imshow(np.transpose(npimg, (1, 2, 0)))
10     plt.show()
11 
12 # get some random training images
13 dataiter = iter(trainloader)
14 images, labels = dataiter.next()
15 
16 # show images
17 imshow(torchvision.utils.make_grid(images))
18 # print labels
19 print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

出：

1 dog truck  frog horse

2.定義卷積神經網路

之前從“神經網路”部分複製神經網路，然後對其進行修改以獲取 3 通道影象（而不是定義的 1 通道影象）。

 1 import torch.nn as nn
 2 import torch.nn.functional as F
 3 
 4 class Net(nn.Module):
 5     def __init__(self):
 6         super(Net, self).__init__()
 7         self.conv1 = nn.Conv2d(3, 6, 5)
 8         self.pool = nn.MaxPool2d(2, 2)
 9         self.conv2 = nn.Conv2d(6, 16, 5)
10         self.fc1 = nn.Linear(16 * 5 * 5, 120)
11         self.fc2 = nn.Linear(120, 84)
12         self.fc3 = nn.Linear(84, 10)
13 
14     def forward(self, x):
15         x = self.pool(F.relu(self.conv1(x)))
16         x = self.pool(F.relu(self.conv2(x)))
17         x = x.view(-1, 16 * 5 * 5)
18         x = F.relu(self.fc1(x))
19         x = F.relu(self.fc2(x))
20         x = self.fc3(x)
21         return x
22 
23 net = Net()

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

讓我們使用分類交叉熵損失和帶有動量的 SGD。

1 import torch.optim as optim
2 
3 criterion = nn.CrossEntropyLoss()
4 optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4.訓練網路

這是事情開始變得有趣的時候。 我們只需要遍歷資料迭代器，然後將輸入饋送到網路並進行優化即可。

 1 for epoch in range(2):  # loop over the dataset multiple times
 2 
 3     running_loss = 0.0
 4     for i, data in enumerate(trainloader, 0):
 5         # get the inputs; data is a list of [inputs, labels]
 6         inputs, labels = data
 7 
 8         # zero the parameter gradients
 9         optimizer.zero_grad()
10 
11         # forward + backward + optimize
12         outputs = net(inputs)
13         loss = criterion(outputs, labels)
14         loss.backward()
15         optimizer.step()
16 
17         # print statistics
18         running_loss += loss.item()
19         if i % 2000 == 1999:    # print every 2000 mini-batches
20             print('[%d, %5d] loss: %.3f' %
21                   (epoch + 1, i + 1, running_loss / 2000))
22             running_loss = 0.0
23 
24 print('Finished Training')

出：

 1 [1,  2000] loss: 2.196
 2 [1,  4000] loss: 1.849
 3 [1,  6000] loss: 1.671
 4 [1,  8000] loss: 1.589
 5 [1, 10000] loss: 1.547
 6 [1, 12000] loss: 1.462
 7 [2,  2000] loss: 1.382
 8 [2,  4000] loss: 1.389
 9 [2,  6000] loss: 1.369
10 [2,  8000] loss: 1.332
11 [2, 10000] loss: 1.304
12 [2, 12000] loss: 1.288
13 Finished Training

讓我們快速儲存我們訓練過的模型：

1 PATH = './cifar_net.pth'
2 torch.save(net.state_dict(), PATH)

5.根據測試資料測試網路

我們已經在訓練資料集中對網路進行了 2 次訓練。 但是我們需要檢查網路是否學到了什麼。

我們將通過預測神經網路輸出的類別標籤並根據實際情況進行檢查來進行檢查。 如果預測正確，則將樣本新增到正確預測列表中。

好的，第一步。 讓我們顯示測試集中的影象以使其熟悉。

1 dataiter = iter(testloader)
2 images, labels = dataiter.next()
3 
4 # print images
5 imshow(torchvision.utils.make_grid(images))
6 print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

出：

1 GroundTruth:    cat  ship  ship plane

接下來，讓我們重新載入儲存的模型（注意：這裡不需要儲存和重新載入模型，我們只是為了說明如何這樣做）：

1 net = Net()
2 net.load_state_dict(torch.load(PATH))

好的，現在讓我們看看神經網路對以上這些示例的看法：

1 outputs = net(images)

輸出是 10 類的能量。 一個類別的能量越高，網路就認為該影象屬於特定類別。 因此，讓我們獲取最高能量的指數：

1 _, predicted = torch.max(outputs, 1)
2 
3 print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
4                               for j in range(4)))

出：

1 Predicted:    cat  ship  ship plane

結果似乎還不錯。

讓我們看一下網路在整個資料集上的表現。

 1 correct = 0
 2 total = 0
 3 with torch.no_grad():
 4     for data in testloader:
 5         images, labels = data
 6         outputs = net(images)
 7         _, predicted = torch.max(outputs.data, 1)
 8         total += labels.size(0)
 9         correct += (predicted == labels).sum().item()
10 
11 print('Accuracy of the network on the 10000 test images: %d %%' % (
12     100 * correct / total))

出：

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

看起來比偶然更好，準確率是 10%（從 10 個類中隨機選擇一個類）。 好像網路學到了一些東西。

嗯，哪些類的表現良好，哪些類的表現不佳：

 1 class_correct = list(0. for i in range(10))
 2 class_total = list(0. for i in range(10))
 3 with torch.no_grad():
 4     for data in testloader:
 5         images, labels = data
 6         outputs = net(images)
 7         _, predicted = torch.max(outputs, 1)
 8         c = (predicted == labels).squeeze()
 9         for i in range(4):
10             label = labels[i]
11             class_correct[label] += c[i].item()
12             class_total[label] += 1
13 
14 for i in range(10):
15     print('Accuracy of %5s : %2d %%' % (
16         classes[i], 100 * class_correct[i] / class_total[i]))

出：

 1 Accuracy of plane : 50 %
 2 Accuracy of   car : 62 %
 3 Accuracy of  bird : 51 %
 4 Accuracy of   cat : 32 %
 5 Accuracy of  deer : 31 %
 6 Accuracy of   dog : 35 %
 7 Accuracy of  frog : 77 %
 8 Accuracy of horse : 70 %
 9 Accuracy of  ship : 71 %
10 Accuracy of truck : 52 %

好的，那下一步呢？

我們如何在 GPU 上執行這些神經網路？

在 GPU 上進行訓練

就像將張量轉移到 GPU 上一樣，您也將神經網路轉移到 GPU 上。

如果可以使用 CUDA，首先將我們的裝置定義為第一個可見的 cuda 裝置：

1 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
2 
3 # Assuming that we are on a CUDA machine, this should print a CUDA device:
4 
5 print(device)

出：

1 cuda:0

本節的其餘部分假定device是 CUDA 裝置。

然後，這些方法將遞迴遍歷所有模組，並將其引數和緩衝區轉換為 CUDA 張量：

1 net.to(device)

請記住，您還必須將每一步的輸入和目標也傳送到 GPU：

1 inputs, labels = data[0].to(device), data[1].to(device)