pytorch例子學習——TRAINING A CLASSIFIER

參考：https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py

TRAINING A CLASSIFIER

到這里，你已經知道怎么定義神經網絡，計算損失和更新網絡的權重

現在你應該考慮：

What about data?

通常，當你必須要處理一些圖片、文本、音頻或視頻數據時，你可以使用標准的python包去下載數據到一個numpy數組中。然后你可以轉換該數組為torch.*Tensor

• 對於圖像，如Pillow、OpenCV這些包就很有用
• 對於音頻，如scipy、librosa這些包
• 對於文本，要么是原始python，要么是基於下載的Cython,或者是NLTK和SpaCy也都很有用

尤其是對於視圖，我們創建了一個名為torchvision的包，有着用於如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的圖像,即32*32像素大小的3通道顏色的圖像

Training an image classifier訓練一個圖像分類器

我們將會按順序進行下面的操作：

1.使用torchvision下載和歸一化訓練和測試數據集

2.定義卷積神經網絡

3.定義損失函數

4.在訓練數據中訓練網絡

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

1. Loading and normalizing 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,  #是否隨機打亂圖片進行分批，是則為true
    num_workers=2  #獲取數據的線程為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')

 運行后首先進行數據的下載：

(deeplearning2) userdeMBP:classifier cifar user$ python cifar10_tutorial.py 
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
100.0%Files already downloaded and verified

 

下面展示一些訓練圖像：

import matplotlib.pyplot as plt
import numpy as np

# 用來展示圖像的函數


def imshow(img):
    img = img / 2 + 0.5     # 非歸一化
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0))) #是因為plt.imshow在顯示時需要的輸入是（imgsize,imgsieze,channels)，但是這里是（channels,imgsize,imgsieze)，所以需要將位置換換
    plt.show()


# 隨機得到一些訓練圖像
dataiter = iter(trainloader) #生成迭代器
images, labels = dataiter.next() #每次運行next()就會調用trainloader，獲得一個之前定義的batch_size=4的批處理圖片集，即4張圖片

# 展示圖像
imshow(torchvision.utils.make_grid(images)) #make_grid的作用是將若干幅圖像拼成一幅圖像,在想要展示一批數據的時候十分有用
# 輸出圖像標簽
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

然后點擊關閉圖片，就會繼續向下運行，就能夠得到預測的結果：

horse horse  bird   car

 

2. Define a Convolutional Neural Network定義一個卷積神經網絡

從之前的神經網絡部分復制神經網絡，並修改其應用於3通道圖片（而不是之前的1通道圖片）

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) #卷積層，參數為（inchannel,outchannel=number of filter,siza of filter,stride,padding）
        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) #全連接層，最后輸出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展平成16 * 5 * 5，然后就可以進行下面的全連接層操作
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

 

3. Define a Loss function and optimizer定義一個損失函數和優化器

使用分類Cross-Entropy損失和帶有動量的SGD優化

import torch.optim as optim

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

 

4. Train the network 訓練網絡

循環數據迭代，並輸入到網絡，然后進行優化

for epoch in range(2):  # 多次循環數據集，這里循環訓練整個數據集兩次

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0): #enumerate枚舉數據並從下標0開始
        # 得到輸入數據
        inputs, labels = data

        # 將參數的梯度都設為0
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs) #forward
        loss = criterion(outputs, labels) #計算損失
        loss.backward() #后向傳播
        optimizer.step() #將優化后的參數輸入網絡，再次進行訓練

        #打印數據
        running_loss += loss.item() #用於從tensor中獲取python數字
        if i % 2000 == 1999:    # 每處理2000次小批處理數據后打印一次結果
            print('[%d, %5d] loss: %.3f' %(epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0 #然后清0

print('Finished Training')

 然后返回輸出為：

[1,  2000] loss: 2.195
[1,  4000] loss: 1.848
[1,  6000] loss: 1.654
[1,  8000] loss: 1.578
[1, 10000] loss: 1.511
[1, 12000] loss: 1.459
[2,  2000] loss: 1.382
[2,  4000] loss: 1.375
[2,  6000] loss: 1.344
[2,  8000] loss: 1.314
[2, 10000] loss: 1.317
[2, 12000] loss: 1.284
Finished Training

 

5. Test the network on the test data在測試數據中測試網絡

我們對網絡進行了兩次遍歷訓練數據集的訓練。但我們還是需要查看網絡是否學習了所有的東西

我們將會通過預測神經網絡輸出的類型標簽來檢查它，並與事實相對照。如果預測是正確的，我們將樣本添加到正確預測列表中。

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

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

# 打印圖片
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(images)

 

輸出是這10個類的能量。一個類的能量越高，網絡越認為圖像屬於特定的類。所以，讓我們得到最高能量的指數:

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

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

 返回預測值：

('Predicted: ', '  cat plane truck plane')

 

 

讓我們看看網絡在整個數據集中表現得怎么樣

correct = 0
total = 0
with 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))

 ⚠️(predicted == labels).sum().item()作用：可見(predicted == labels).sum().item()作用

返回：

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))
with torch.no_grad(): #設置在進行forward時不計算梯度
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            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 : 45 %
Accuracy of   car : 67 %
Accuracy of  bird : 45 %
Accuracy of   cat : 31 %
Accuracy of  deer : 53 %
Accuracy of   dog : 24 %
Accuracy of  frog : 66 %
Accuracy of horse : 58 %
Accuracy of  ship : 69 %
Accuracy of truck : 77 %

 

 

接下來就是設置運行在GPU上：

就像你把張量傳輸到GPU上一樣，你把神經網絡傳輸到GPU上。
讓我們首先定義我們的設備為第一個可見的cuda設備，如果我們有cuda可用:

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

# Assuming that we are on a CUDA machine, this should print a CUDA device:

print(device)

因為我是在CPU上運行的，所以這里print(device)會返回cpu

 

本節的其余部分假設設備是CUDA設備。
然后這些方法遞歸遍歷所有模塊，將它們的參數和緩沖區轉換為CUDA張量:

net.to(device)

記住，你必須在每一步都把輸入和目標值的發送到GPU中：

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

為什么我沒有注意到GPU與CPU相比的巨大加速?因為你的網絡實在是太小了。

練習:

嘗試增加網絡的寬度(即第一個nn.Conv2d卷積層的參數2)和第二個nn.Conv2d卷積層的參數1 — 他們需要相同的數字，看看你得到什么樣的加速。
實現目標:

• 高層次地理解PyTorch張量庫和神經網絡。
• 訓練一個小的神經網絡對圖像進行分類