【PyTorch深度學習60分鍾快速入門 】Part3：神經網絡

 

神經網絡可以通過使用torch.nn包來構建。

既然你已經了解了autograd，而nn依賴於autograd來定義模型並對其求微分。一個nn.Module包含多個網絡層，以及一個返回輸出的方法forward(input) 。

例如，查看下圖中的對數字圖片分類的網絡：

這是一個簡單的前饋網絡。它接受輸入，並將輸入依次通過多個層，然后給出輸出結果。
對於神經網絡來說，一個經典的訓練過程包括以下步驟：

• 定義一個包含一些可學習的參數（或權重）的神經網絡
• 對輸入數據集進行迭代
• 通過網絡處理輸入
• 計算損失函數（即輸出距離正確值差多遠）
• 將梯度傳播回網絡參數
• 更新網絡的權重，通常使用一個簡單的更新規則：weight = weight - learning_rate * gradient

0x01 定義網絡

下面，我們定義該網絡：

import torch
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__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

輸出結果為：

Net(
  (conv1): Conv2d (1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d (6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120)
  (fc2): Linear(in_features=120, out_features=84)
  (fc3): Linear(in_features=84, out_features=10)
)

你只需要定義前向（forward）函數，而反向（backward）函數（梯度計算的位置）會使用autograd自動為你定義。你可以在前向函數中使用任何張量操作。

一個模型的可學習參數由net.parameters()返回。

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

輸出結果：

10
torch.Size([6, 1, 5, 5])

前向輸入是一個autograd.Variable，輸出也是如此。注意：該網絡（LeNet）的預期輸入大小為32x32。要在MNIST數據集上使用該網絡，需要將該數據集中的圖片大小調整為32x32。

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)

輸出結果：

Variable containing:
 0.0023 -0.0613 -0.0397 -0.1123 -0.0397  0.0330 -0.0656 -0.1231  0.0412  0.0162
[torch.FloatTensor of size 1x10]

將所有參數的梯度緩沖區置為零，並使用隨機梯度進行后向傳播：

net.zero_grad()
out.backward(torch.randn(1, 10))

注意： torch.nn只支持小批量，整個torch.nn包都只支持小批量樣本的輸入，而不支持單個樣本。例如，nn.Conv2d將接受一個4維的張量nSamples x nChannels x Height x Width。如果你只有單個樣本，那么只需要使用input.unsqueeze(0)來添加一個假的批量維度。

在繼續之前，讓我們回顧一下你目前所見到的所有類。

簡要回顧：

• torch.Tensor：一個多維數組。
• autograd.Variable：封裝了一個張量和對該張量操作的記錄歷史。除了與張量具有相同的API外，還擁有一些如backward()等的操作。此外，還持有對張量的梯度w.r.t.。
• nn.Module：神經網絡模塊。一種封裝參數的便捷方式，並含有將參數移到GPU、導出、加載等的輔助功能。
• nn.Parameter：一種變量，當作為一個屬性分配給一個模塊時，它會自動注冊為一個參數。
• autograd.Function：實現autograd操作的前向和后向定義。每個變量操作，至少創建一個單獨的函數節點，連接到創建了一個變量的函數，並對其歷史進行編碼。

在本節，我們學習了以下內容：

• 定義一個神經網絡
• 處理輸入及后向調用

剩余技能：

• 計算損失
• 更新網絡權重

0x02 損失函數（Loss Function）

損失函數接受（輸出，目標）輸入對，並計算一個值，該值能夠評估輸出與目標的偏差大小。

nn包中有幾個不同的損失函數。一個簡單的損失函數是nn.MSELoss，它會計算輸入和目標之間的均方誤差。

例如：

output = net(input)
target = Variable(torch.arange(1, 11))  # a dummy target, for example
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

輸出結果：

Variable containing:
 38.8243
[torch.FloatTensor of size 1]

現在，如果你沿着后向跟蹤損失，那么可以使用它的``.grad_fn`屬性，你將會看到一個這樣的計算圖：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

所以，當我們調用loss.backward()時，整個計算圖是對損失函數求微分后的，並且圖中所有的變量將使自己的.grad變量與梯度進行累積。

為了便於展示，我們反向跟隨幾步：

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

輸出結果：

<MseLossBackward object at 0x7fe4c18539e8>
<AddmmBackward object at 0x7fe3f5498550>
<ExpandBackward object at 0x7fe4c18539e8>

0x03 反向傳播（Backprop）

為了反向傳播誤差，我們所要做的就是調用loss.backward()。不過，你需要清除現有的梯度，否則梯度就會累積到已有的梯度上。

現在我們應該調用loss.backward()，並在反向之前和之后查看conv1的偏差梯度。

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

輸出結果：

conv1.bias.grad before backward
Variable containing:
 0
 0
 0
 0
 0
 0
[torch.FloatTensor of size 6]

conv1.bias.grad after backward
Variable containing:
1.00000e-02 *
  7.4571
 -0.4714
 -5.5774
 -6.2058
  6.6810
  3.1632
[torch.FloatTensor of size 6]

現在，我們已經看到了如何使用損失函數。

擴展閱讀：
神經網絡包中包含各種各樣的模塊和損失函數，它們構成了深度神經網絡的構造塊。完整的文檔列表可以在這里查看。

唯一剩下的待學習的知識點：

• 更新網絡的權重

0x04 更新權重

在實踐中使用的最簡單的更新規則是隨機梯度下降法（Stochastic Gradient Descent，SGD）：
weight = weight - learning_rate * gradient
我們可以使用簡單的python代碼實現這一點：

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

然而，當你使用神經網絡時，你可能想使用各種不同的更新規則，如SGD、Nesterov-SGD、Adam、RMSProp等等。為了實現這一點，我們構建了一個小的工具包torch.optim，它實現了所有這些方法。使用它非常簡單：

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

注意：
要觀察梯度是如何緩存的，需要手動調用optimizer.zero_grad()將緩沖器設置為0。這是因為梯度會累積，正如在“反向傳播”一節中解釋的那樣。

腳本總運行時間：0分0.129秒。