PyTorch 神經(jīng)網(wǎng)絡(luò)

原文： https：/////pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html
譯者： bat67
驗證者： FontTian
作者： Soumith Chintala

可以使用torch.nn包來構(gòu)建神經(jīng)網(wǎng)絡(luò).

我們以及介紹了autograd，nn包依賴于autograd包來定義模型并對它們求導(dǎo)。一個nn.Module包含各個層和一個forward(input)方法，該方法返回output。

例如，下面這個神經(jīng)網(wǎng)絡(luò)可以對數(shù)字進行分類：

這是一個簡單的前饋神經(jīng)網(wǎng)絡(luò)（feed-forward network）。它接受一個輸入，然后將它送入下一層，一層接一層的傳遞，最后給出輸出。

一個神經(jīng)網(wǎng)絡(luò)的典型訓練過程如下：

• 定義包含一些可學習參數(shù)（或者叫權(quán)重）的神經(jīng)網(wǎng)絡(luò)
• 在輸入數(shù)據(jù)集上迭代
• 通過網(wǎng)絡(luò)處理輸入
• 計算損失（輸出和正確答案的距離）
• 將梯度反向傳播給網(wǎng)絡(luò)的參數(shù)
• 更新網(wǎng)絡(luò)的權(quán)重，一般使用一個簡單的規(guī)則：weight = weight - learning_rate * gradient

定義網(wǎng)絡(luò)

讓我們定義這樣一個網(wǎng)絡(luò)：

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




class Net(nn.Module):


    def __init__(self):
        super(Net, self).__init__()
        # 輸入圖像channel：1；輸出channel：6；5x5卷積核
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 仿射變換：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):
        # 2x2 Max pooling
        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:]  # 除去批大小維度的其余維度
        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 函數(shù)，backward函數(shù)會在使用autograd時自動定義，backward函數(shù)用來計算導(dǎo)數(shù)。可以在 forward 函數(shù)中使用任何針對張量的操作和計算。

一個模型的可學習參數(shù)可以通過net.parameters()返回

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

輸出：

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

讓我們嘗試一個隨機的32x32的輸入。注意，這個網(wǎng)絡(luò)（LeNet）的期待輸入是32x32。如果使用MNIST數(shù)據(jù)集來訓練這個網(wǎng)絡(luò)，要把圖片大小重新調(diào)整到32x32。

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

輸出：

tensor([[ 0.0399, -0.0856,  0.0668,  0.0915,  0.0453, -0.0680, -0.1024,  0.0493,
         -0.1043, -0.1267]], grad_fn=<AddmmBackward>)

清零所有參數(shù)的梯度緩存，然后進行隨機梯度的反向傳播：

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

注意：

torch.nn只支持小批量處理（mini-batches）。整個torch.nn包只支持小批量樣本的輸入，不支持單個樣本。

比如，nn.Conv2d 接受一個4維的張量，即nSamples x nChannels x Height x Width

如果是一個單獨的樣本，只需要使用input.unsqueeze(0)來添加一個“假的”批大小維度。

在繼續(xù)之前，讓我們回顧一下到目前為止看到的所有類。

復(fù)習：

• torch.Tensor - 一個多維數(shù)組，支持諸如backward()等的自動求導(dǎo)操作，同時也保存了張量的梯度。

• nn.Module - 神經(jīng)網(wǎng)絡(luò)模塊。是一種方便封裝參數(shù)的方式，具有將參數(shù)移動到GPU、導(dǎo)出、加載等功能。

• nn.Parameter - 張量的一種，當它作為一個屬性分配給一個Module時，它會被自動注冊為一個參數(shù)。

• autograd.Function - 實現(xiàn)了自動求導(dǎo)前向和反向傳播的定義，每個Tensor至少創(chuàng)建一個Function節(jié)點，該節(jié)點連接到創(chuàng)建Tensor的函數(shù)并對其歷史進行編碼。

目前為止，我們討論了：

• 定義一個神經(jīng)網(wǎng)絡(luò)
• 處理輸入調(diào)用backward

還剩下：

• 計算損失
• 更新網(wǎng)絡(luò)權(quán)重

損失函數(shù)

一個損失函數(shù)接受一對(output, target)作為輸入，計算一個值來估計網(wǎng)絡(luò)的輸出和目標值相差多少。

譯者注：output為網(wǎng)絡(luò)的輸出,target為實際值

nn包中有很多不同的損失函數(shù)。nn.MSELoss是比較簡單的一種，它計算輸出和目標的均方誤差（mean-squared error）。

例如：

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()


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

輸出：

tensor(1.0263, grad_fn=<MseLossBackward>)

現(xiàn)在，如果使用loss的.grad_fn屬性跟蹤反向傳播過程，會看到計算圖如下：

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

所以，當我們調(diào)用loss.backward()，整張圖開始關(guān)于loss微分，圖中所有設(shè)置了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 0x7f94c821fdd8>
<AddmmBackward object at 0x7f94c821f6a0>
<AccumulateGrad object at 0x7f94c821f6a0>

反向傳播

我們只需要調(diào)用loss.backward()來反向傳播權(quán)重。我們需要清零現(xiàn)有的梯度，否則梯度將會與已有的梯度累加。

現(xiàn)在，我們將調(diào)用loss.backward()，并查看conv1層的偏置（bias）在反向傳播前后的梯度。

net.zero_grad()     # 清零所有參數(shù)（parameter）的梯度緩存


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.0084,  0.0019, -0.0179, -0.0212,  0.0067, -0.0096])

現(xiàn)在，我們已經(jīng)見到了如何使用損失函數(shù)。

稍后閱讀

神經(jīng)網(wǎng)絡(luò)包包含了各種模塊和損失函數(shù)，這些模塊和損失函數(shù)構(gòu)成了深度神經(jīng)網(wǎng)絡(luò)的構(gòu)建模塊。完整的文檔列表見這里。

現(xiàn)在唯一要學習的是：

* 更新網(wǎng)絡(luò)的權(quán)重

更新權(quán)重

最簡單的更新規(guī)則是隨機梯度下降法（SGD）:

weight = weight - learning_rate * gradient

我們可以使用簡單的python代碼來實現(xiàn):

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

然而，在使用神經(jīng)網(wǎng)絡(luò)時，可能希望使用各種不同的更新規(guī)則，如SGD、Nesterov-SGD、Adam、RMSProp等。為此，我們構(gòu)建了一個較小的包torch.optim，它實現(xiàn)了所有的這些方法。使用它很簡單：

import torch.optim as optim


## 創(chuàng)建優(yōu)化器（optimizer）
optimizer = optim.SGD(net.parameters(), lr=0.01)


## 在訓練的迭代中：
optimizer.zero_grad()   # 清零梯度緩存
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # 更新參數(shù)

注意：
觀察梯度緩存區(qū)是如何使用optimizer.zero_grad()手動清零的。這是因為梯度是累加的，正如前面反向傳播章節(jié)敘述的那樣。