首頁.jpg

• 從更高水平理解Pytorch的Tensor（張量）和神經網絡
• 訓練一個小的圖像分類神經網絡
  注意確定已經安裝了torch和torchvision

構建神經網絡

可以使用torch.nn包來做神經網絡。
之前對autograd有了一點點認識，而nn是基于autograd來定義模型并進行區(qū)分。一個nn.Module包括了層和一個forward(input)這樣可以返回output。
教程以數(shù)字圖片分類網絡為例。

image.png

這是一個簡單的feed-forward前饋網絡，它接受輸入，一個接一個地通過幾個層輸入，然后最終給出輸出。
神經網絡的典型訓練程序如下：

• 定義神經網絡，該網絡包括了一些學習參數(shù)（或是權重）
• 迭代輸入數(shù)據集
• 通過網絡處理輸入數(shù)據集
• 計算損失函數(shù)
• 反饋
• 更新神經網絡權重，使用一個簡單的更新規(guī)則

定義神經網絡

先來試試定義一個神經網絡

from __future__ import print_function
import torch
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(1, 6, 5)
        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)

    def forward(self,x):
        x=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 x

    def num_flat_features(self,x):
        size=x.size()[1:]
        num_feature=1
        for s in size:
            num_feature*=s

        return num_feature


if __name__ == '__main__':
    net = Net()
    print(net)

用戶只需定義forward函數(shù)，并使用自動編程自動為用戶定義backward函數(shù)（計算梯度的位置）。您可以在轉發(fā)功能中使用任何Tensor操作。
模型中的參數(shù)可以通過net.parameters()

if __name__ == '__main__':
    params=list(net.parameters())
    print(len(params))
    print(params[0].size())

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

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

tensor([[-0.0054, -0.0305,  0.0345,  0.0430,  0.0299, -0.0436,  0.0299,
         -0.1239, -0.0808,  0.0694]])

注意: torch.nn 只接受小批量的數(shù)據
整個torch.nn包只接受那種小批量樣本的數(shù)據，而非單個樣本。 例如，nn.Conv2d能夠結構一個四維的TensornSamples x nChannels x Height x Width。
如果你拿的是單個樣本，使用input.unsqueeze(0)來加一個假維度就可以了。

扼要重述

• torch.Tensor是一個多維度排列，它支持autograd操作（backward()），同時包含著和張量相關的梯度。
• nn.Module是一個神經網絡模塊，封裝了多個參數(shù)，同時能夠移植GPU，導出，重載。
• nn.Parameter是一種Tensor，當給Module賦值時能夠自動注冊為一個參數(shù)。
• autograd.Function能夠使用自動求導實現(xiàn)forward和backward。每個Variable的操作都會生成至少一個獨立的Function節(jié)點，與生成了Variable的函數(shù)相連之后記錄下操作歷史。

OK，到這里掌握的有

• 如何定義神經網絡
• 處理輸入和調用backward

還剩下

• 計算損失函數(shù)
• 更新網絡中的權重

計算損失函數(shù)

一個損失函數(shù)將（output, target）作為輸入，計算數(shù)值并評估之前的輸出output距離target目標值有多少距離。
有多種損失函數(shù)公式，在這里使用nn.MSELoss來計算輸入和目標之間的均方誤差。
舉個栗子

if __name__ == '__main__':
    net = Net()
    input=torch.randn(1,1,32,32)
    output=net(input)
    print(output)
    target=torch.randn(10)
    target=target.view(1,-1)
    criterion=nn.MSELoss()
    loss=criterion(output,target)
    print(loss)
    
tensor([[ 0.0923,  0.0274,  0.1043, -0.0715, -0.0499,  0.0079,  0.0866,
         -0.0800, -0.0133, -0.1014]])
tensor(0.9399)

此時，如果用戶想查看整個計算流程，可以使用.grad_fn查看。

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

Backprop反向傳遞

要完成反向傳播，我們所要做的就是loss.backward()。用戶要清空現(xiàn)有的梯度值，否則梯度將被計算為已有梯度。
現(xiàn)在我們將調用loss.backward（），并查看conv1在backward之前和之后的偏置梯度。

net.zero_grad() #歸零操作
print('conv1.bias.grad before backward',net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

conv1.bias.grad before backward 
None
conv1.bias.grad after backward
tensor(1.00000e-02 *
       [-0.2610, -0.2729,  1.6355,  0.9463, -0.0689, -1.1425])

更新權重

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

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

然而在你使用神經網絡的時候你想要使用不同種類的方法諸如：SGD, Nesterov-SGD, Adam, RMSProp, etc.
我們構建了一個小的包torch.optim來實現(xiàn)這個功能，其中包含著所有的這些方法。 用起來也非常簡單:

import torch.optim as optim

# 創(chuàng)建自己的優(yōu)化
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 在訓練循環(huán)中
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update