从 Siri 到谷歌翻译，深度神经网络已经在机器理解自然语言方面取得了巨大突破。这些模型大多数将语言视为单调的单词或字符序列，并使用一种称为循环神经网络(recurrent neural network/RNN)的模型来处理该序列。但是许多语言学家认为语言最好被理解为具有树形结构的层次化词组，一种被称为递归神经网络(recursive neural network)的深度学习模型考虑到了这种结构，这方面已经有大量的研究。虽然这些模型非常难以实现且效率很低，但是一个全新的深度学习框架 PyTorch 能使它们和其它复杂的自然语言处理模型变得更加容易。

虽然递归神经网络很好地显示了 PyTorch 的灵活性，但它也广泛支持其它的各种深度学习框架，特别的是，它能够对计算机视觉(computer vision)计算提供强大的支撑。PyTorch 是 Facebook AI Research 和其它几个实验室的开发人员的成果，该框架结合了 Torch7 高效灵活的 GPU 加速后端库与直观的 Python 前端，它的特点是快速成形、代码可读和支持最广泛的深度学习模型。

开始 SPINN

链接中的文章详细介绍了一个递归神经网络的 PyTorch 实现，它具有一个循环跟踪器(recurrent tracker)和 TreeLSTM 节点，也称为 SPINN——SPINN 是深度学习模型用于自然语言处理的一个例子，它很难通过许多流行的框架构建。这里的模型实现部分运用了批处理(batch)，所以它可以利用 GPU 加速，使得运行速度明显快于不使用批处理的版本。

SPINN 的意思是堆栈增强的解析器-解释器神经网络(Stack-augmented Parser-Interpreter Neural Network)，由 Bowman 等人于 2016 年作为解决自然语言推理任务的一种方法引入，该论文中使用了斯坦福大学的 SNLI 数据集。

该任务是将语句对分为三类：假设语句 1 是一幅看不见的图像的准确标题，那么语句 2(a)肯定(b)可能还是(c)绝对不是一个准确的标题?(这些类分别被称为蕴含(entailment)、中立(neutral)和矛盾(contradiction))。例如，假设一句话是「两只狗正跑过一片场地」，蕴含可能会使这个语句对变成「户外的动物」，中立可能会使这个语句对变成「一些小狗正在跑并试图抓住一根棍子」，矛盾能会使这个语句对变成「宠物正坐在沙发上」。

特别地，研究 SPINN 的初始目标是在确定语句的关系之前将每个句子编码(encoding)成固定长度的向量表示(也有其它方式，例如注意模型(attention model)中将每个句子的每个部分用一种柔焦(soft focus)的方法相互比较)。

数据集是用句法解析树(syntactic parse tree)方法由机器生成的，句法解析树将每个句子中的单词分组成具有独立意义的短语和子句，每个短语由两个词或子短语组成。许多语言学家认为，人类通过如上面所说的树的分层方式来组合词意并理解语言，所以用相同的方式尝试构建一个神经网络是值得的。下面的例子是数据集中的一个句子，其解析树由嵌套括号表示：

1. ( ( The church ) ( ( has ( cracks ( in ( the ceiling ) ) ) ) . ) ) 

这个句子进行编码的一种方式是使用含有解析树的神经网络构建一个神经网络层 Reduce，这个神经网络层能够组合词语对(用词嵌入(word embedding)表示，如 GloVe)、 和/或短语，然后递归地应用此层(函数)，将最后一个 Reduce 产生的结果作为句子的编码：

1. X = Reduce(“the”, “ceiling”) 
2. Y = Reduce(“in”, X) 
3. ... etc. 

但是，如果我希望网络以更类似人类的方式工作，从左到右阅读并保留句子的语境，同时仍然使用解析树组合短语?或者，如果我想训练一个网络来构建自己的解析树，让解析树根据它看到的单词读取句子?这是一个同样的但方式略有不同的解析树的写法：

1. The church ) has cracks in the ceiling ) ) ) ) . ) ) 

或者用第 3 种方式表示，如下：

1. WORDS:  The church   has cracks in the ceiling         . 
2. PARSES: S   S      R S   S      S  S   S       R R R R S R R 

我所做的只是删除开括号，然后用「S」标记「shift」，并用「R」替换闭括号用于「reduce」。但是现在可以从左到右读取信息作为一组指令来操作一个堆栈(stack)和一个类似堆栈的缓冲区(buffer)，能得到与上述递归方法完全相同的结果：

1. 将单词放入缓冲区。
2. 从缓冲区的前部弹出「The」，将其推送(push)到堆栈上层，紧接着是「church」。
3. 弹出前 2 个堆栈值，应用于 Reduce，然后将结果推送回堆栈。
4. 从缓冲区弹出「has」，然后推送到堆栈，然后是「cracks」，然后是「in」，然后是「the」，然后是「ceiling」。
5. 重复四次：弹出 2 个堆栈值，应用于 Reduce，然后推送结果。
6. 从缓冲区弹出「.」，然后推送到堆栈上层。
7. 重复两次：弹出 2 个堆栈值，应用于 Reduce，然后推送结果。
8. 弹出剩余的堆栈值，并将其作为句子编码返回。

我还想保留句子的语境，以便在对句子的后半部分应用 Reduce 层时考虑系统已经读取的句子部分的信息。所以我将用一个三参数函数替换双参数的 Reduce 函数，该函数的输入值为一个左子句、一个右子句和当前句的上下文状态。该状态由神经网络的第二层(称为循环跟踪器(Tracker)的单元)创建。Tracker 在给定当前句子上下文状态、缓冲区中的顶部条目 b 和堆栈中前两个条目 s1\s2 时，在堆栈操作的每个步骤(即，读取每个单词或闭括号)后生成一个新状态：

1. context[t+1] = Tracker(context[t], b, s1, s2) 

容易设想用你最喜欢的编程语言来编写代码做这些事情。对于要处理的每个句子，它将从缓冲区加载下一个单词，运行跟踪器，检查是否将单词推送入堆栈或执行 Reduce 函数，执行该操作;然后重复，直到对整个句子完成处理。通过对单个句子的应用，该过程构成了一个大而复杂的深度神经网络，通过堆栈操作的方式一遍又一遍地应用它的两个可训练层。但是，如果你熟悉 TensorFlow 或 Theano 等传统的深度学习框架，就知道它们很难实现这样的动态过程。你值得花点时间回顾一下，探索为什么 PyTorch 能有所不同。

图 1：一个函数的图结构表示

深度神经网络本质上是有大量参数的复杂函数。深度学习的目的是通过计算以损失函数(loss)度量的偏导数(梯度)来优化这些参数。如果函数表示为计算图结构(图 1)，则向后遍历该图可实现这些梯度的计算，而无需冗余工作。每个现代深度学习框架都是基于此反向传播(backpropagation)的概念，因此每个框架都需要一个表示计算图的方式。

在许多流行的框架中，包括 TensorFlow、Theano 和 Keras 以及 Torch7 的 nngraph 库，计算图是一个提前构建的静态对象。该图是用像数学表达式的代码定义的，但其变量实际上是尚未保存任何数值的占位符(placeholder)。图中的占位符变量被编译进函数，然后可以在训练集的批处理上重复运行该函数来产生输出和梯度值。

这种静态计算图(static computation graph)方法对于固定结构的卷积神经网络效果很好。但是在许多其它应用中，有用的做法是令神经网络的图结构根据数据而有所不同。在自然语言处理中，研究人员通常希望通过每个时间步骤中输入的单词来展开(确定)循环神经网络。上述 SPINN 模型中的堆栈操作很大程度上依赖于控制流程(如 for 和 if 语句)来定义特定句子的计算图结构。在更复杂的情况下，你可能需要构建结构依赖于模型自身的子网络输出的模型。

这些想法中的一些(虽然不是全部)可以被生搬硬套到静态图系统中，但几乎总是以降低透明度和增加代码的困惑度为代价。该框架必须在其计算图中添加特殊的节点，这些节点代表如循环和条件的编程原语(programming primitive)，而用户必须学习和使用这些节点，而不仅仅是编程代码语言中的 for 和 if 语句。这是因为程序员使用的任何控制流程语句将仅运行一次，当构建图时程序员需要硬编码(hard coding)单个计算路径。

例如，通过词向量(从初始状态 h0 开始)运行循环神经网络单元(rnn_unit)需要 TensorFlow 中的特殊控制流节点 tf.while_loop。需要一个额外的特殊节点来获取运行时的词长度，因为在运行代码时它只是一个占位符。

1. # TensorFlow 
2. # (this code runs once, during model initialization) 
3. # “words” is not a real list (it’s a placeholder variable) so 
4. # I can’t use “len” 
5. cond = lambda i, h: i < tf.shape(words)[0] 
6. cell = lambda i, h: rnn_unit(words[i], h) 
7. i = 0 
8. _, h = tf.while_loop(cond, cell, (i, h0)) 

基于动态计算图(dynamic computation graph)的方法与之前的方法有根本性不同，它有几十年的学术研究历史，其中包括了哈佛的 Kayak、自动微分库(autograd)以及以研究为中心的框架 Chainer和 DyNet。在这样的框架(也称为运行时定义(define-by-run))中，计算图在运行时被建立和重建，使用相同的代码为前向通过(forward pass)执行计算，同时也为反向传播(backpropagation)建立所需的数据结构。这种方法能产生更直接的代码，因为控制流程的编写可以使用标准的 for 和 if。它还使调试更容易，因为运行时断点(run-time breakpoint)或堆栈跟踪(stack trace)将追踪到实际编写的代码，而不是执行引擎中的编译函数。可以在动态框架中使用简单的 Python 的 for 循环来实现有相同变量长度的循环神经网络。

1. # PyTorch (also works in Chainer) 
2. # (this code runs on every forward pass of the model) 
3. # “words” is a Python list with actual values in it 
4. h = h0 
5. for word in words:    h = rnn_unit(word, h) 

PyTorch 是第一个 define-by-run 的深度学习框架，它与静态图框架(如 TensorFlow)的功能和性能相匹配，使其能很好地适合从标准卷积神经网络(convolutional network)到最疯狂的强化学习(reinforcement learning)等思想。所以让我们来看看 SPINN 的实现。

代码

在开始构建网络之前，我需要设置一个数据加载器(data loader)。通过深度学习，模型可以通过数据样本的批处理进行操作，通过并行化(parallelism)加快训练，并在每一步都有一个更平滑的梯度变化。我想在这里可以做到这一点(稍后我将解释上述堆栈操作过程如何进行批处理)。以下 Python 代码使用内置于 PyTorch 的文本库的系统来加载数据，它可以通过连接相似长度的数据样本自动生成批处理。运行此代码之后，train_iter、dev_iter 和 test_itercontain 循环遍历训练集、验证集和测试集分块 SNLI 的批处理。

1. from torchtext import data, datasets TEXT = datasets.snli.ParsedTextField(lower=True) 
2. TRANSITIONS = datasets.snli.ShiftReduceField() 
3. LABELS = data.Field(sequential=False)train, dev, test = datasets.SNLI.splits(    TEXT, TRANSITIONS, LABELS, wv_type='glove.42B')TEXT.build_vocab(train, dev, test) 
4. train_iter, dev_iter, test_iter = data.BucketIterator.splits(    (train, dev, test), batch_size=64) 

你可以在 train.py中找到设置训练循环和准确性(accuracy)测量的其余代码。让我们继续。如上所述，SPINN 编码器包含参数化的 Reduce 层和可选的循环跟踪器来跟踪句子上下文，以便在每次网络读取单词或应用 Reduce 时更新隐藏状态;以下代码代表的是，创建一个 SPINN 只是意味着创建这两个子模块(我们将很快看到它们的代码)，并将它们放在一个容器中以供稍后使用。

1. import torchfrom torch import nn 
2. # subclass the Module class from PyTorch’s neural network package 
3. class SPINN(nn.Module):    
4.  def __init__(self, config):         
5. super(SPINN, self).__init__()        
6.  self.config = config        
7.  self.reduce = Reduce(config.d_hidden, config.d_tracker)         
8. if config.d_tracker is not None:            
9.  self.tracker = Tracker(config.d_hidden, config.d_tracker) 

当创建模型时，SPINN.__init__ 被调用了一次;它分配和初始化参数，但不执行任何神经网络操作或构建任何类型的计算图。在每个新的批处理数据上运行的代码由 SPINN.forward 方法定义，它是用户实现的方法中用于定义模型向前过程的标准 PyTorch 名称。上面描述的是堆栈操作算法的一个有效实现，即在一般 Python 中，在一批缓冲区和堆栈上运行，每一个例子都对应一个缓冲区和堆栈。我使用转移矩阵(transition)包含的「shift」和「reduce」操作集合进行迭代，运行 Tracker(如果存在)，并遍历批处理中的每个样本来应用「shift」操作(如果请求)，或将其添加到需要「reduce」操作的样本列表中。然后在该列表中的所有样本上运行 Reduce 层，并将结果推送回到它们各自的堆栈。

1. def forward(self, buffers, transitions): 
2.         # The input comes in as a single tensor of word embeddings; 
3.         # I need it to be a list of stacks, one for each example in 
4.         # the batch, that we can pop from independently. The words in 
5.         # each example have already been reversed, so that they can 
6.         # be read from left to right by popping from the end of each 
7.         # list; they have also been prefixed with a null value. 
8.         buffers = [list(torch.split(b.squeeze(1), 1, 0)) 
9.                    for b in torch.split(buffers, 1, 1)] 
10.         # we also need two null values at the bottom of each stack, 
11.         # so we can copy from the nulls in the input; these nulls 
12.         # are all needed so that the tracker can run even if the 
13.         # buffer or stack is empty 
14.         stacks = [[buf[0], buf[0]] for buf in buffers] 
15.         if hasattr(self, 'tracker'): 
16.             self.tracker.reset_state() 
17.         for trans_batch in transitions: 
18.             if hasattr(self, 'tracker'): 
19.                 # I described the Tracker earlier as taking 4 
20.                 # arguments (context_t, b, s1, s2), but here I 
21.                 # provide the stack contents as a single argument 
22.                 # while storing the context inside the Tracker 
23.                 # object itself. 
24.                 tracker_states, _ = self.tracker(buffers, stacks) 
25.             else: 
26.                 tracker_states = itertools.repeat(None) 
27.             lefts, rights, trackings = [], [], [] 
28.             batch = zip(trans_batch, buffers, stacks, tracker_states) 
29.             for transition, buf, stack, tracking in batch: 
30.                 if transition == SHIFT: 
31.                     stack.append(buf.pop()) 
32.                 elif transition == REDUCE: 
33.                     rights.append(stack.pop()) 
34.                     lefts.append(stack.pop()) 
35.                     trackings.append(tracking) 
36.             if rights: 
37.                 reduced = iter(self.reduce(lefts, rights, trackings)) 
38.                 for transition, stack in zip(trans_batch, stacks): 
39.                     if transition == REDUCE: 
40.                         stack.append(next(reduced)) 
41.         return [stack.pop() for stack in stacks] 

在调用 self.tracker 或 self.reduce 时分别运行 Tracker 或 Reduce 子模块的向前方法，该方法需要在样本列表上应用前向操作。在主函数的向前方法中，在不同的样本上进行独立的操作是有意义的，即为批处理中每个样本提供分离的缓冲区和堆栈，因为所有受益于批处理执行的重度使用数学和需要 GPU 加速的操作都在 Tracker 和 Reduce 中进行。为了更干净地编写这些函数，我将使用一些 helper(稍后将定义)将这些样本列表转化成批处理张量(tensor)，反之亦然。

我希望 Reduce 模块自动批处理其参数以加速计算，然后解批处理(unbatch)它们，以便可以单独推送和弹出。用于将每对左、右子短语表达组合成父短语(parent phrase)的实际组合函数是 TreeLSTM，它是普通循环神经网络单元 LSTM 的变型。该组合函数要求每个子短语的状态实际上由两个张量组成，一个隐藏状态 h 和一个存储单元(memory cell)状态 c，而函数是使用在子短语的隐藏状态操作的两个线性层(nn.Linear)和将线性层的结果与子短语的存储单元状态相结合的非线性组合函数 tree_lstm。在 SPINN 中，这种方式通过添加在 Tracker 的隐藏状态下运行的第 3 个线性层进行扩展。

图 2：TreeLSTM 组合函数增加了第 3 个输入(x，在这种情况下为 Tracker 状态)。在下面所示的 PyTorch 实现中，5 组的三种线性变换(由蓝色、黑色和红色箭头的三元组表示)组合为三个 nn.Linear 模块，而 tree_lstm 函数执行位于框内的所有计算。图来自 Chen et al. (2016)。

1. def tree_lstm(c1, c2, lstm_in): 
2.     # Takes the memory cell states (c1, c2) of the two children, as 
3.     # well as the sum of linear transformations of the children’s 
4.     # hidden states (lstm_in) 
5.     # That sum of transformed hidden states is broken up into a 
6.     # candidate output a and four gates (i, f1, f2, and o). 
7.     a, i, f1, f2, o = lstm_in.chunk(5, 1) 
8.     c = a.tanh() * i.sigmoid() + f1.sigmoid() * c1 + f2.sigmoid() * c2 
9.     h = o.sigmoid() * c.tanh() 
10.     return h, cclass Reduce(nn.Module): 
11.     def __init__(self, size, tracker_size=None): 
12.         super(Reduce, self).__init__() 
13.         self.left = nn.Linear(size, 5 * size) 
14.         self.right = nn.Linear(size, 5 * size, bias=False) 
15.         if tracker_size is not None: 
16.             self.track = nn.Linear(tracker_size, 5 * size, bias=False) 
17.  
18.     def forward(self, left_in, right_in, tracking=None): 
19.         left, right = batch(left_in), batch(right_in) 
20.         tracking = batch(tracking) 
21.         lstm_in = self.left(left[0]) 
22.         lstm_in += self.right(right[0]) 
23.         if hasattr(self, 'track'): 
24.             lstm_in += self.track(tracking[0]) 
25.         return unbatch(tree_lstm(left[1], right[1], lstm_in)) 

由于 Reduce 层和类似实现方法的 Tracker 都用 LSTM 进行工作，所以批处理和解批处理帮助函数在隐藏状态和存储状态对(h,c)上运行。

1. def batch(states): 
2.     if states is None: 
3.         return None 
4.     states = tuple(states) 
5.     if states[0] is None: 
6.         return None 
7.     # states is a list of B tensors of dimension (1, 2H) 
8.     # this returns two tensors of dimension (B, H) 
9.     return torch.cat(states, 0).chunk(2, 1)def unbatch(state): 
10.     if state is None: 
11.         return itertools.repeat(None) 
12.     # state is a pair of tensors of dimension (B, H) 
13.     # this returns a list of B tensors of dimension (1, 2H) 
14.     return torch.split(torch.cat(state, 1), 1, 0) 

这就是所有。其余的必要代码(包括 Tracker)，在 spinn.py中，同时分类器层可以从两个句子编码中计算 SNLI 类别，并在给出最终损失(loss)变量的情况下将此结果与目标进行比较，代码在 model.py中。SPINN 及其子模块的向前代码产生了非常复杂的计算图(图 3)，最终计算出损失函数，其细节在数据集中的每个批处理中都完全不同，但是每次只需很少的开销(overhead)即可自动反向传播，通过调用 loss.backward()，一个内置于 PyTorch 中的函数，它可以从图中的任何一点执行反向传播。

完整代码中的模型和超参数可以与原始 SPINN 论文中报告的性能相匹配，但是充分利用了批处理加工和 PyTorch 的效率后，在 GPU 上训练的速度要快几倍。虽然原始实现需要21 分钟来编译计算图(意味着实施过程中的调试周期至少要那么长)，然后训练大约 5 天时间，这里描述的版本没有编译步骤，它的训练在 Tesla K40 的 GPU 上需要约 13 个小时，或者在 Quadro GP100 上约 9 小时。

图 3：具有批大小为 2 的 SPINN 计算图的一小部分，它运行的是本文中提供的 Chainer 代码版本。

调用所有的强化学习

上述没有跟踪器(Tracker)的模型版本实际上非常适合 TensorFlow 的新 tf.fold 域特定语言，它针对动态图形的特殊情况，但是有跟踪器的版本将难以实现。这是因为添加跟踪器意味着从递归(recursive)方法切换到基于堆栈的方法。这(如上面的代码)是最直接地使用依赖于输入值的条件分支(conditional branch)来实现的。但是 Fold 缺少内置的条件分支操作，所以使用它构建的模型中的图形结构只能取决于输入的结构而不是其数值。此外，构建一个其跟踪器在读取输入句子时就决定如何解析输入句子的 SPINN 的版本是完全没有可能的，因为一旦加载了一个输入样本 Fold 中的图结构必须完全固定(图结构依赖于输入样本的结构)。

DeepMind 和谷歌大脑的研究人员研究了一个这样的模型，他们应用强化学习来训练一个 SPINN 的跟踪器解析输入句子，而不使用任何外部解析数据。本质上，这样一个模型从随机猜测开始，当它的解析在整体分类任务上恰好产生良好的准确性时，它产生一个自我奖励(reward)并通过奖励来学习。研究人员写道，他们「使用的批处理大小为 1，因为在每次迭代中计算图需要根据每个来自策略网络(policy network)的样本重新构建 [Tracker]」——但 PyTorch 使得在像这样一个复杂的、结构随机变化的网络上进行批处理训练成为可能。

PyTorch 也是第一个以随机计算图(stochastic computation graph)形式建立强化学习(RL)库的框架，使得策略梯度(policy gradient)强化学习如反向传播一样易于使用。要将其添加到上述模型中，你只需重新编写主 SPINN 的 for 循环的前几行，如下所示，使得 Tracker 能够定义进行每种解析转移矩阵的概率。

1. !# nn.functional contains neural network operations without parametersfrom torch.nn import functional as F 
2. transitions = []for i in range(len(buffers[0]) * 2 - 3):   
3.     # we know how many steps 
4.     # obtain raw scores for each kind of parser transition 
5.     tracker_states, transition_scores = self.tracker(buffers, stacks) 
6.     # use a softmax function to normalize scores into probabilities, 
7.     # then sample from the distribution these probabilities define 
8.     transition_batch = F.softmax(transition_scores).multinomial() 
9.     transitions.append(transition_batch 

然后，随着批处理一直运行，模型会得出它预测的类别的准确程度，我可以通过这些随机计算图的节点发出奖励信号，另外在图的其余部分以传统方式进行反向传播：

1. # losses should contain a loss per example, while mean and std  
2. # represent averages across many batches 
3. rewards = (-losses - mean) / std 
4. for transition in transitions: 
5.     transition.reinforce(rewards) 
6. # connect the stochastic nodes to the final loss variable 
7. # so that backpropagation can find them, multiplying by zero 
8. # because this trick shouldn’t change the loss value 
9. loss = losses.mean() + 0 * sum(transitions).sum() 
10. # perform backpropagation through deterministic nodes and 
11. # policy gradient RL for stochastic nodesloss.backward() 

谷歌研究人员报告了包含强化学习的 SPINN 的结果，比原始的在 SNLI 数据集的 SPINN 上获得的结果要好一些——尽管强化学习版本不使用预先计算的解析树信息。自然语言处理的深度强化学习领域是全新的，该领域的研究课题非常广泛;通过将强化学习构建到框架中，PyTorch 大大降低了进入门槛。

从今天起开始使用 PyTorch

遵循 pytorch.org 网站上的说明安装，选择安装平台(即将推出 Windows 版本的支持)。PyTorch 支持 Python 2 和 3 以及使用 CUDA 7.5 或 8.0 和 CUDNN 5.1 或 6.0 的 CPU 或 NVIDIA GPU 上的计算。它有针对 conda 和 pip 的 Linux 二进制文件甚至含有 CUDA 本身，因此你不需要自己设置它。

官方教程包含 60 分钟的介绍和深度 Q-学习(Deep Q-Learning，一种现代强化学习模型)的演练。斯坦福的 Justin Johnson 教授有一个非常全面的教程，官方示例还包括——深度卷积生成对抗网络(DCGAN)、ImageNet 模型和神经机器翻译模型(neural machine translation)。新加坡国立大学的 Richie Ng 制作了最新的其它 PyTorch 实现、示例和教程的列表。PyTorch 开发人员和用户社区在讨论论坛上的第一时间回答问题，但你应该首先检查 API 文档。

尽管 PyTorch 仅使用了较短时间，但三篇研究论文已经使用了它，几个学术实验室和业界实验室也采用了 PyTorch。回溯过去，在当时动态计算图比现在模糊时，我与同事在 Salesforce Research(https://metamind.io/research.html)也曾经考虑过 Chainer 作为我们的秘密配方;现在，在大公司的支持下，我们很高兴 PyTorch 将这一水平的能力和灵活性带入了主流。

本文作者：James Bradbury

来源：51CTO