pytorch 是一個(gè)基于 python 的深度學(xué)習(xí)庫(kù)。pytorch 源碼庫(kù)的抽象層次少，結(jié)構(gòu)清晰，代碼量適中。相比于非常工程化的 tensorflow，pytorch 是一個(gè)更易入手的，非常棒的深度學(xué)習(xí)框架。

對(duì)于系統(tǒng)學(xué)習(xí) pytorch，官方提供了非常好的入門教程?，同時(shí)還提供了面向深度學(xué)習(xí)的示例，同時(shí)熱心網(wǎng)友分享了更簡(jiǎn)潔的示例。

1. overview

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

圖1. 幾種深度學(xué)習(xí)程序庫(kù)對(duì)比

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

圖2. pytorch 主要功能模塊

1.1 張量計(jì)算引擎（tensor computation）

Tensor 計(jì)算引擎，類似 numpy 和 matlab，基本對(duì)象是tensor（類比 numpy 中的 ndarray 或 matlab 中的 array）。除提供基于 CPU 的常用操作的實(shí)現(xiàn)外，pytorch 還提供了高效的 GPU 實(shí)現(xiàn)，這對(duì)于深度學(xué)習(xí)至關(guān)重要。

1.2 自動(dòng)求導(dǎo)機(jī)制（autograd）

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

1.3 神經(jīng)網(wǎng)絡(luò)的高層庫(kù)（NN）

pytorch 還提供了高層的。對(duì)于常用的網(wǎng)絡(luò)結(jié)構(gòu)，如全連接、卷積、RNN 等。同時(shí)，pytorch 還提供了常用的、optimizer?及參數(shù)。

這里，我們重點(diǎn)關(guān)注如何自定義神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)。

2. 自定義 Module

圖3. pytorch Module

module 是 pytorch 組織神經(jīng)網(wǎng)絡(luò)的基本方式。Module 包含了模型的參數(shù)以及計(jì)算邏輯。Function 承載了實(shí)際的功能，定義了前向和后向的計(jì)算邏輯。

下面以最簡(jiǎn)單的 MLP 網(wǎng)絡(luò)結(jié)構(gòu)為例，介紹下如何實(shí)現(xiàn)自定義網(wǎng)絡(luò)結(jié)構(gòu)。完整代碼可以參見repo。

2.1 Function

Function 是 pytorch 自動(dòng)求導(dǎo)機(jī)制的核心類。Function 是無(wú)參數(shù)或者說(shuō)無(wú)狀態(tài)的，它只負(fù)責(zé)接收輸入，返回相應(yīng)的輸出；對(duì)于反向，它接收輸出相應(yīng)的梯度，返回輸入相應(yīng)的梯度。

這里我們只關(guān)注如何自定義 Function。Function 的定義見。下面是簡(jiǎn)化的代碼段：
class Function(object):
def forward(self, *input):
raise NotImplementedError

def backward(self, *grad_output):
raise NotImplementedError

forward 和 backward 的輸入和輸出都是 Tensor 對(duì)象。

Function 對(duì)象是 callable 的，即可以通過(guò)()的方式進(jìn)行調(diào)用。其中調(diào)用的輸入和輸出都為 Variable 對(duì)象。下面的示例了如何實(shí)現(xiàn)一個(gè) ReLU 激活函數(shù)并進(jìn)行調(diào)用：
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函數(shù)，將輸入暫時(shí)保存，并在 backward 中利用saved_tensors (python tuple 對(duì)象) 取出。

顯然，forward 的輸入應(yīng)該和 backward 的輸入相對(duì)應(yīng)；同時(shí)，forward 的輸出應(yīng)該和 backward 的輸入相匹配。

由于 Function 可能需要暫存 input tensor，因此，建議不復(fù)用 Function 對(duì)象，以避免遇到內(nèi)存提前釋放的問(wèn)題。如所示，forward的每次調(diào)用都重新生成一個(gè) ReLUF 對(duì)象，而不能在初始化時(shí)生成在 forward 中反復(fù)調(diào)用。

2.2 Module

類似于 Function，Module 對(duì)象也是 callable 是，輸入和輸出也是 Variable。不同的是，Module 是[可以]有參數(shù)的。Module 包含兩個(gè)主要部分：參數(shù)及計(jì)算邏輯（Function 調(diào)用）。由于ReLU激活函數(shù)沒(méi)有參數(shù)，這里我們以最基本的全連接層為例來(lái)說(shuō)明如何自定義Module。

全連接層的運(yùn)算邏輯定義如下 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

為一個(gè)元素為 bool 型的 tuple，長(zhǎng)度與 forward 的參數(shù)數(shù)量相同，用來(lái)標(biāo)識(shí)各個(gè)輸入是否輸入計(jì)算梯度；對(duì)于無(wú)需梯度的輸入，可以減少不必要的計(jì)算。

Function（此處為 LinearF） 定義了基本的計(jì)算邏輯，Module 只需要在初始化時(shí)為參數(shù)分配內(nèi)存空間，并在計(jì)算時(shí)，將參數(shù)傳遞給相應(yīng)的 Function 對(duì)象。代碼如下：
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)

需要注意的是，參數(shù)是內(nèi)存空間由 tensor 對(duì)象維護(hù)，但 tensor 需要包裝為一個(gè)Parameter?對(duì)象。Parameter 是?Variable?的特殊子類，僅有是不同是 Parameter 默認(rèn)requires_grad為 True。Varaible 是自動(dòng)求導(dǎo)機(jī)制的核心類，此處暫不介紹，參見。

3. 自定義循環(huán)神經(jīng)網(wǎng)絡(luò)（RNN）

我們嘗試自己定義一個(gè)更復(fù)雜的 Module ——RNN。這里，我們只定義最基礎(chǔ)的 vanilla RNN（圖4），基本的計(jì)算公式如下：

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

圖4. RNN【來(lái)源】

更復(fù)雜的 LSTM、GRU 或者其他變種的實(shí)現(xiàn)也非常類似。

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

可運(yùn)行的完整代碼見repo。

討論

pytorch 的 Module 結(jié)構(gòu)是傳承自 torch，這一點(diǎn)也同樣被 keras （functional API）所借鑒。 在 caffe 等一些[早期的]深度學(xué)習(xí)框架中，network 是由于若干 layer ，經(jīng)由不同的拓?fù)浣Y(jié)構(gòu)組成的。而在 (pyt)torch 中沒(méi)有 layer 和 network 是區(qū)分，一切都是 callable 的 Module。Module 的調(diào)用的輸入和輸出都是 tensor （由 Variable 封裝），用戶可以非常自然的構(gòu)造任意有向無(wú)環(huán)的網(wǎng)絡(luò)結(jié)構(gòu)（DAG）。

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

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