使用Pytorch訓練分類器詳解（附python演練）

作者 | 荔枝boy

編輯 | 安可

出品 | 磐創AI技術團隊

【前言】：你已經瞭解瞭如何定義神經網路，計算loss值和網路裡權重的更新。現在你也許會想資料怎麼樣？

目錄：

一．資料

二．訓練一個影像分類器

1. 使用torchvision載入並且歸一化CIFAR10的訓練和測試資料集

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

3. 定義一個損失函式

4. 在訓練樣本資料上訓練網路

5. 在測試樣本資料上測試網路

三．在GPU上訓練

四．在多個GPU上訓練

五．還可以學哪些？

一、資料

通常來說，當你處理影像，文字，語音或者影片資料時，你可以使用標準python包將資料載入成numpy陣列格式，然後將這個陣列轉換成torch.*Tensor

對於影像，可以用Pillow，OpenCV
對於語音，可以用scipy，librosa
對於文字，可以直接用Python或Cython基礎資料載入模組，或者用NLTK和SpaCy

特別是對於視覺，我們已經建立了一個叫做totchvision的包，該包含有支援載入類似Imagenet，CIFAR10，MNIST等公共資料集的資料載入模組torchvision.datasets和支援載入影像資料資料轉換模組torch.utils.data.DataLoader。

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

對於本教程，我們將使用CIFAR10資料集，它包含十個類別：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10中的影像尺寸為3*32*32，也就是RGB的3層顏色通道，每層通道內的尺寸為32*32。

使用Pytorch訓練分類器詳解（附python演練）

圖片一 cifar10

二、訓練一個影像分類器

我們將按次序的做如下幾步：

1. 使用torchvision載入並且歸一化CIFAR10的訓練和測試資料集

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

3. 定義一個損失函式

4. 在訓練樣本資料上訓練網路

5. 在測試樣本資料上測試網路

1. 載入並歸一化CIFAR10

使用torchvision,用它來載入CIFAR10資料非常簡單

import torch
import torchvision
import torchvision.transformsastransforms

torchvision資料集的輸出是範圍在[0,1]之間的PILImage，我們將他們轉換成歸一化範圍為[-1,1]之間的張量Tensors。

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')

輸出：

Downloading ~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz Files already downloaded and verified

讓我們來展示其中的一些訓練圖片。

import matplotlib.pyplot as plt
import numpy as np

# 影像顯示函式
defimshow(img):
    img = img /2+0.5     # 非標準的（unnormalized）
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# 得到一些隨機影像
dataiter =iter(trainloader)images, labels = dataiter.next()

# 顯示影像
imshow(torchvision.utils.make_grid(images))

# 列印類標
print(' '.join('%5s'% classes[labels[j]] for j inrange(4)))

使用Pytorch訓練分類器詳解（附python演練）

圖片二

輸出：

cat   car   dog   cat

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

在這之前先從神經網路章節複製神經網路，並修改它為3通道的圖片(在此之前它被定義為1通道)

import torch.nn as nn
import torch.nn.functional as F

classNet(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)

    defforward(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. 定義一個損失函式和最佳化器

讓我們使用分類交叉熵Cross-Entropy 作損失函式，動量SGD做最佳化器。

import torch.optim as optim

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

4. 訓練網路

這裡事情開始變得有趣，我們只需要在資料迭代器上迴圈傳給網路和最佳化器輸入就可以。

for epoch inrange(2):  # 多次迴圈遍歷資料集
    running_loss =0.0
    for i, data inenumerate(trainloader, 0):
        # 獲取輸入
        inputs, labels = data

        # 引數梯度置零
        optimizer.zero_grad()

        # 前向+ 反向 + 最佳化
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 輸出統計       
running_loss += loss.item()

        if i %2000==1999:    # 每2000 mini-batchs輸出一次                                  print('[%d, %5d] loss: %.3f'%
                  (epoch +1, i +1, running_loss /2000))

            running_loss =0.0

print('Finished Training')

輸出：

[1,  2000] loss: 2.211
[1,  4000] loss: 1.837
[1,  6000] loss: 1.659
[1,  8000] loss: 1.570
[1, 10000] loss: 1.521
[1, 12000] loss: 1.451
[2,  2000] loss: 1.411
[2,  4000] loss: 1.393
[2,  6000] loss: 1.348
[2,  8000] loss: 1.340
[2, 10000] loss: 1.363
[2, 12000] loss: 1.320

Finished Training

5. 在測試集上測試網路

我們已經透過訓練資料集對網路進行了2次訓練，但是我們需要檢查網路是否已經學到了東西。

我們將用神經網路的輸出作為預測的類標來檢查網路的預測效能，用樣本的真實類標來校對。如果預測是正確的，我們將樣本新增到正確預測的列表裡。

好的，第一步，讓我們從測試集中顯示一張影像來熟悉它。

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

# 列印圖片
imshow(torchvision.utils.make_grid(images))

print('GroundTruth: ', ' '.join('%5s'% classes[labels[j]] for j inrange(4)))

使用Pytorch訓練分類器詳解（附python演練）

圖片三

輸出：

GroundTruth:    cat  ship  ship plane

現在讓我們看看神經網路認為這些樣本應該預測成什麼：

outputs = net(images)

輸出是預測與十個類的近似程度，與某一個類的近似程度越高，網路就越認為影像是屬於這一類別。所以讓我們列印其中最相似類別類標：

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

print('Predicted: ', ' '.join('%5s'% classes[predicted[j]]

                              for j inrange(4)))

輸出：

Predicted:    cat   car   car  ship

結果看起開非常好，讓我們看看網路在整個資料集上的表現。

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

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 inrange(10))class_total =list(0.for i inrange(10))with torch.no_grad():

    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()

        for i inrange(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] +=1
 
for i inrange(10):

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

輸出：

Accuracy of plane : 52 %
Accuracy of   car : 73 %
Accuracy of  bird : 34 %
Accuracy of   cat : 54 %
Accuracy of  deer : 48 %
Accuracy of   dog : 26 %
Accuracy of  frog : 68 %
Accuracy of horse : 51 %
Accuracy of  ship : 63 %
Accuracy of truck : 60 %

所以接下來呢？我們怎麼在GPU上跑這些神經網路？

三、在GPU上訓練

就像你怎麼把一個張量轉移到GPU上一樣，你要將神經網路轉到GPU上。

如果CUDA可以用，讓我們首先定義下我們的裝置為第一個可見的cuda裝置。

device = torch.device("cuda:0"if torch.cuda.is_available() else"cpu")

# 假設在一臺CUDA機器上執行，那麼這裡將輸出一個CUDA裝置號：
print(device)

輸出：

cuda:0

本節剩餘部分都會假定裝置就是臺CUDA裝置。接著這些方法會遞迴地遍歷所有模組，並將它們的引數和緩衝器轉換為CUDA張量。

net.to(device)

記住你也必須在每一個步驟向GPU傳送輸入和目標：

inputs, labels = inputs.to(device), labels.to(device)

為什麼沒有注意到與CPU相比巨大的加速？因為你的網路非常小。

練習：嘗試增加你的網路寬度（首個nn.Conv2d引數設定為2，第二個nn.Conv2d引數設定為1--它們需要有相同的個數），看看會得到怎麼的速度提升。

目標：

深度理解了PyTorch的張量和神經網路
訓練了一個小的神經網路來分類影像
四、在多個GPU上訓練

如果你想要來看到大規模加速，使用你的所有GPU，請檢視：資料並行性（）。

五、 接下來可以學哪些？

訓練神經網路玩電子遊戲（）
在imagenet上訓練最優ResNet網路（/tree/master/imagenet）
使用生成網路來訓練面部生成器（）
使用週期性LSTM網路訓練一個詞級（word-level）語言模型（）
更多例子（）
更多教程（）
在論壇上討論PyTorch（https://discuss.pytorch.org/）
在Slack上與其他使用者交流（）

指令碼總執行時間：（9分48.748秒）

下載python原始碼檔案：cifar10_tutorial.py（）

下載Jupyternotebook檔案：cifar10_tutorial.ipynb

（）

使用Pytorch訓練分類器詳解（附python演練）

使用torchvision,用它來載入CIFAR10資料非常簡單

3. 定義一個損失函式和最佳化器

4. 訓練網路

三、 在GPU上訓練

相關文章

三、在GPU上訓練