2019年年初，ApacheCN組織志愿者翻譯了PyTorch1.0版本中文文檔（github地址），同時也獲得了PyTorch官方授權，我相信已經有許多人在中文文檔官網上看到了。不過目前校對還缺人手，希望大家踴躍參與。之前一段時間我們和PyTorch的有關負責人Bruce Lin一直在進行郵件交流。在之后適當的時候，我們會組織志愿者進行其他有關PyTorch的項目，歡迎大家加入我們，關注我們。更希望我們的一系列工作能夠對大家有所幫助。

譯者：bat67

校對者：FontTian

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

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

例如，下面這個神經網絡可以對數字進行分類：

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

一個神經網絡的典型訓練過程如下：

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

定義網絡

讓我們定義這樣一個網絡：

import torch import torch.nn as nn import torch.nn.functional as Fclass 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)# an affine operation: y = Wx + bself.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 poolingx = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))# 如果是方陣,則可以只使用一個數字進行定義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 xdef num_flat_features(self, x):size = x.size()[1:] # 除去批處理維度的其他所有維度num_features = 1for s in size:num_features *= sreturn num_featuresnet = 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時自動定義，backward函數用來計算導數。可以在 forward 函數中使用任何針對張量的操作和計算。

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

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

輸出：

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

讓我們嘗試一個隨機的32x32的輸入。注意:這個網絡（LeNet）的期待輸入是32x32。如果使用MNIST數據集來訓練這個網絡，要把圖片大小重新調整到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>)

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

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)來添加一個“假的”批大小維度。

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

復習：

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

• nn.Module - 神經網絡模塊。是一種方便封裝參數的方式，具有將參數移動到GPU、導出、加載等功能。

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

• autograd.Function - 實現了自動求導前向和反向傳播的定義，每個Tensor至少創建一個Function節點，該節點連接到創建Tensor的函數并對其歷史進行編碼。

目前為止，我們討論了：

• 定義一個神經網絡
• 處理輸入調用backward

還剩下：

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

損失函數

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

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

例如：

output = net(input) target = torch.randn(10) # 本例子中使用模擬數據 target = target.view(1, -1) # 使目標值與數據值形狀一致 criterion = nn.MSELoss()loss = criterion(output, target) print(loss)

輸出：

tensor(1.0263, 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 0x7f94c821fdd8> <AddmmBackward object at 0x7f94c821f6a0> <AccumulateGrad object at 0x7f94c821f6a0>

反向傳播

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

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

net.zero_grad() # 清零所有參數（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])

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

稍后閱讀

神經網絡包包含了各種模塊和損失函數，這些模塊和損失函數構成了深度神經網絡的構建模塊。完整的文檔列表見這里。

現在唯一要學習的是：

• 更新網絡的權重

更新權重

最簡單的更新規則是隨機梯度下降法（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# 創建優化器（optimizer） optimizer = optim.SGD(net.parameters(), lr=0.01)# 在訓練的迭代中： optimizer.zero_grad() # 清零梯度緩存 output = net(input) loss = criterion(output, target) loss.backward() optimizer.step() # 更新參數

注意：

觀察梯度緩存區是如何使用optimizer.zero_grad()手動清零的。這是因為梯度是累加的，正如前面反向傳播章節敘述的那樣。
m.SGD(net.parameters(), lr=0.01)

在訓練的迭代中：

optimizer.zero_grad() # 清零梯度緩存
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # 更新參數

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

總結

以上是生活随笔為你收集整理的使用PyTorch创建神经网络的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。