技術標籤：PyTorch

文章目錄

• Neural Networks
• • 定義網路
  • 損失函式
  • 反向傳播
  • 更新權重

Neural Networks

使用torch.nn包來構建神經網路。

上一講已經講過了autograd，nn包依賴autograd包來定義模型並求導。
一個nn.Module包含各個層和一個forward(input)方法，該方法返回output。

例如：

它是一個簡單的前饋神經網路，它接受一個輸入，然後一層接著一層地傳遞，最後輸出計算的結果。

神經網路的典型訓練過程如下：

1. 定義包含一些可學習的引數(或者叫權重)神經網路模型；
2. 在資料集上迭代；
3. 通過神經網路處理輸入；
4. 計算損失(輸出結果和正確值的差值大小)；
5. 將梯度反向傳播回網路的引數；
6. 更新網路的引數，主要使用如下簡單的更新原則：
   weight = weight - learning_rate * gradient

定義網路

開始定義一個網路：

import torch
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, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

在模型中必須要定義 forward 函式，backward
函式（用來計算梯度）會被autograd自動建立。
可以在 forward 函式中使用任何針對 Tensor 的操作。

net.parameters()返回可被學習的引數（權重）列表和值

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

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

測試隨機輸入32×32。
注：這個網路（LeNet）期望的輸入大小是32×32，如果使用MNIST資料集來訓練這個網路，請把圖片大小重新調整到32×32。

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

tensor([[ 0.1120,  0.0713,  0.1014, -0.0696, -0.1210,  0.0084, -0.0206,  0.1366,
         -0.0455, -0.0036]], grad_fn=<AddmmBackward>)

將所有引數的梯度快取清零，然後進行隨機梯度的的反向傳播：

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

Note

``torch.nn`` 只支援小批量輸入。整個 ``torch.nn`` 包都只支援小批量樣本，而不支援單個樣本。

例如，``nn.Conv2d`` 接受一個4維的張量，
``每一維分別是sSamples * nChannels * Height * Width（樣本數*通道數*高*寬）``。

如果你有單個樣本，只需使用 ``input.unsqueeze(0)`` 來新增其它的維數</p></div>

在繼續之前，我們回顧一下到目前為止用到的類。

回顧:

• torch.Tensor：一個用過自動呼叫 backward()實現支援自動梯度計算的 多維陣列 ，
  並且儲存關於這個向量的梯度 w.r.t.
• nn.Module：神經網路模組。封裝引數、移動到GPU上執行、匯出、載入等。
• nn.Parameter：一種變數，當把它賦值給一個Module時，被 自動 地註冊為一個引數。
• autograd.Function：實現一個自動求導操作的前向和反向定義，每個變數操作至少建立一個函式節點，每一個Tensor的操作都回建立一個接到建立Tensor和 編碼其歷史 的函式的Function節點。

重點如下：

• 定義一個網路
• 處理輸入，呼叫backword

還剩：

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

損失函式

一個損失函式接受一對 (output, target) 作為輸入，計算一個值來估計網路的輸出和目標值相差多少。

譯者注：output為網路的輸出，target為實際值

nn包中有很多不同的損失函式。
nn.MSELoss是一個比較簡單的損失函式，它計算輸出和目標間的均方誤差，
例如：

output = net(input)
target = torch.randn(10)  # 隨機值作為樣例
target = target.view(1, -1)  # 使target和output的shape相同
criterion = nn.MSELoss()

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

tensor(0.8109, grad_fn=<MseLossBackward>)

現在，如果在反向過程中跟隨loss ， 使用它的
.grad_fn 屬性，將看到如下所示的計算圖。

::

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

所以，當我們呼叫 loss.backward()時,整張計算圖都會
根據loss進行微分，而且圖中所有設定為requires_grad=True的張量
將會擁有一個隨著梯度累積的.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 0x7f3b49fe2470>
<AddmmBackward object at 0x7f3bb05f17f0>
<AccumulateGrad object at 0x7f3b4a3c34e0>

反向傳播

呼叫loss.backward()獲得反向傳播的誤差。

但是在呼叫前需要清除已存在的梯度，否則梯度將被累加到已存在的梯度。

現在，我們將呼叫loss.backward()，並檢視conv1層的偏差（bias）項在反向傳播前後的梯度。

net.zero_grad()     # 清除梯度

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
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([ 0.0051,  0.0042,  0.0026,  0.0152, -0.0040, -0.0036])

如何使用損失函式

稍後閱讀：

nn包，包含了各種用來構成深度神經網路構建塊的模組和損失函式，完整的文件請檢視here。

剩下的最後一件事:

• 新網路的權重

更新權重

在實踐中最簡單的權重更新規則是隨機梯度下降（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等，PyTorch中構建了一個包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()``手動將梯度緩衝區設定為零。
  這是因為梯度是按Backprop部分中的說明累積的。