Pytorch作為深度學習庫，常被使用。原因在于，pytorch代碼更為簡單。不管是深度學習新手還是老手，pytorch都是一大利器。為增進大家對pytorch的了解，本文將對pytorch的簡單知識加以講解。如果你對本文內容具有興趣，不妨繼續(xù)往下閱讀哦。

1. overview

不同于 theano，tensorflow 等低層程序庫，或者 keras、sonnet 等高層 wrapper，pytorch 是一種自成體系的深度學習庫(圖1)。

圖1. 幾種深度學習程序庫對比

如圖2所示，pytorch 由低層到上層主要有三大塊功能模塊。

圖2. pytorch 主要功能模塊

1.1 張量計算引擎(tensor computaTIon)

Tensor 計算引擎，類似 numpy 和 matlab，基本對象是tensor(類比 numpy 中的 ndarray 或 matlab 中的 array)。除提供基于 CPU 的常用操作的實現外，pytorch 還提供了高效的 GPU 實現，這對于深度學習至關重要。

1.2 自動求導機制(autograd)

由于深度學習模型日趨復雜，因此，對自動求導的支持對于學習框架變得必不可少。pytorch 采用了動態(tài)求導機制，使用類似方法的框架包括： chainer，dynet。作為對比，theano，tensorflow 采用靜態(tài)自動求導機制。

1.3 神經網絡的高層庫(NN)

pytorch 還提供了高層的。對于常用的網絡結構，如全連接、卷積、RNN 等。同時，pytorch 還提供了常用的、opTImizer 及參數。

這里，我們重點關注如何自定義神經網絡結構。

2. 自定義 Module

圖3. pytorch Module

module 是 pytorch 組織神經網絡的基本方式。Module 包含了模型的參數以及計算邏輯。FuncTIon 承載了實際的功能，定義了前向和后向的計算邏輯。

下面以最簡單的 MLP 網絡結構為例，介紹下如何實現自定義網絡結構。完整代碼可以參見repo。

2.1 FuncTIon

Function 是 pytorch 自動求導機制的核心類。Function 是無參數或者說無狀態(tài)的，它只負責接收輸入，返回相應的輸出;對于反向，它接收輸出相應的梯度，返回輸入相應的梯度。

這里我們只關注如何自定義 Function。Function 的定義見。下面是簡化的代碼段：

class Function(object):

def forward(self, *input):

raise NotImplementedError

def backward(self, *grad_output):

raise NotImplementedError

forward 和 backward 的輸入和輸出都是 Tensor 對象。

Function 對象是 callable 的，即可以通過()的方式進行調用。其中調用的輸入和輸出都為 Variable 對象。下面的示例了如何實現一個 ReLU 激活函數并進行調用：

import torch

from torch.autograd import Function

class ReLUF(Function)：

def forward(self, input):

self.save_for_backward(input)

output = input.clamp(min=0)

return output

def backward(self, output_grad):

input = self.to_save[0]

input_grad = output_grad.clone()

input_grad[input < 0] = 0

return input_grad

## Test

if __name__ == "__main__":

from torch.autograd import Variable

torch.manual_seed(1111)

a = torch.randn(2, 3)

va = Variable(a, requires_grad=True)

vb = ReLUF()(va)

print va.data, vb.data

vb.backward(torch.ones(va.size()))

print vb.grad.data, va.grad.data

如果 backward 中需要用到 forward 的輸入，需要在 forward 中顯式的保存需要的輸入。在上面的代碼中，forward 利用self.save_for_backward函數，將輸入暫時保存，并在 backward 中利用saved_tensors (python tuple 對象) 取出。

顯然，forward 的輸入應該和 backward 的輸入相對應;同時，forward 的輸出應該和 backward 的輸入相匹配。

由于 Function 可能需要暫存 input tensor，因此，建議不復用 Function 對象，以避免遇到內存提前釋放的問題。如所示，forward的每次調用都重新生成一個 ReLUF 對象，而不能在初始化時生成在 forward 中反復調用。

2.2 Module

類似于 Function，Module 對象也是 callable 是，輸入和輸出也是 Variable。不同的是，Module 是[可以]有參數的。Module 包含兩個主要部分：參數及計算邏輯(Function 調用)。由于ReLU激活函數沒有參數，這里我們以最基本的全連接層為例來說明如何自定義Module。

全連接層的運算邏輯定義如下 Function:

import torch

from torch.autograd import Function

class LinearF(Function):

def forward(self, input, weight, bias=None):

self.save_for_backward(input, weight, bias)

output = torch.mm(input, weight.t())

if bias is not None:

output += bias.unsqueeze(0).expand_as(output)

return output

def backward(self, grad_output):

input, weight, bias = self.saved_tensors

grad_input = grad_weight = grad_bias = None

if self.needs_input_grad[0]:

grad_input = torch.mm(grad_output, weight)

if self.needs_input_grad[1]:

grad_weight = torch.mm(grad_output.t(), input)

if bias is not None and self.needs_input_grad[2]:

grad_bias = grad_output.sum(0).squeeze(0)

if bias is not None:

return grad_input, grad_weight, grad_bias

else:

return grad_input, grad_weight

為一個元素為 bool 型的 tuple，長度與 forward 的參數數量相同，用來標識各個輸入是否輸入計算梯度;對于無需梯度的輸入，可以減少不必要的計算。

Function(此處為 LinearF) 定義了基本的計算邏輯，Module 只需要在初始化時為參數分配內存空間，并在計算時，將參數傳遞給相應的 Function 對象。代碼如下：

import torch

import torch.nn as nn

class Linear(nn.Module):

def __init__(self, in_features, out_features, bias=True):

super(Linear, self).__init__()

self.in_features = in_features

self.out_features = out_features

self.weight = nn.Parameter(torch.Tensor(out_features, in_features))

if bias:

self.bias = nn.Parameter(torch.Tensor(out_features))

else:

self.register_parameter('bias', None)

def forward(self, input):

return LinearF()(input, self.weight, self.bias)

需要注意的是，參數是內存空間由 tensor 對象維護，但 tensor 需要包裝為一個Parameter 對象。Parameter 是 Variable 的特殊子類，僅有是不同是 Parameter 默認requires_grad為 True。Varaible 是自動求導機制的核心類，此處暫不介紹，參見。

3. 自定義循環(huán)神經網絡(RNN)

我們嘗試自己定義一個更復雜的 Module ——RNN。這里，我們只定義最基礎的 vanilla RNN(圖4)，基本的計算公式如下：

ht=relu(W?x+U?ht?1)

圖4. RNN

更復雜的 LSTM、GRU 或者其他變種的實現也非常類似。

3.1 定義 Cell

import torch

from torch.nn import Module, Parameter

class RNNCell(Module):

def __init__(self, input_size, hidden_size):

super(RNNCell, self).__init__()

self.input_size = input_size

self.hidden_size = hidden_size

self.weight_ih = Parameter(torch.Tensor(hidden_size, input_size))

self.weight_hh = Parameter(torch.Tensor(hidden_size, hidden_size))

self.bias_ih = Parameter(torch.Tensor(hidden_size))

self.bias_hh = Parameter(torch.Tensor(hidden_size))

self.reset_parameters()

def reset_parameters(self):

stdv = 1.0 / math.sqrt(self.hidden_size)

for weight in self.parameters():

weight.data.uniform_(-stdv, stdv)

def forward(self, input, h):

output = LinearF()(input, self.weight_ih, self.bias_ih) + LinearF()(h, self.weight_hh, self.bias_hh)

output = ReLUF()(output)

return output

3.2 定義完整的 RNN

import torch

from torch.nn import Module

class RNN(Moudule):

def __init__(self, input_size, hidden_size):

super(RNN, self).__init__()

self.input_size = input_size

self.hidden_size = hidden_size

sef.cell = RNNCell(input_size, hidden_size)

def forward(self, inputs, initial_state):

time_steps = inputs.size(1)

state = initial_state

outputs = []

for t in range(time_steps):

state = self.cell(inputs[:, t, :], state)

outputs.append(state)

return outputs

討論

pytorch 的 Module 結構是傳承自 torch，這一點也同樣被 keras (functional API)所借鑒。 在 caffe 等一些[早期的]深度學習框架中，network 是由于若干 layer ，經由不同的拓撲結構組成的。而在 (pyt)torch 中沒有 layer 和 network 是區(qū)分，一切都是 callable 的 Module。Module 的調用的輸入和輸出都是 tensor (由 Variable 封裝)，用戶可以非常自然的構造任意有向無環(huán)的網絡結構(DAG)。

同時， pytorch 的 autograd 機制封裝的比較淺，可以比較容易的定制反傳或修改梯度。這對有些算法是非常重要。

總之，僅就自定義算法而言，pytorch 是一個非常優(yōu)雅的深度學習框架。

以上便是此次小編帶來的“pytorch”相關內容，通過本文，希望大家對上述知識具備一定的了解。如果你喜歡本文，不妨持續(xù)關注我們網站哦，小編將于后期帶來更多精彩內容。最后，十分感謝大家的閱讀，have a nice day!