雷锋网(公众号：雷锋网)按：本文为《从原理到实战 英伟达教你用PyTorch搭建RNN》的下篇，阅读上篇请点击这里。文章原载于英伟达博客，雷锋网编译。
代码实操
在开始创建神经网络之前，我需要设置一个 data loader。对于深度学习而言，在数据样例的 batch 上运行模型十分常见，这能通过并行计算加速训练，并在每一步有更加平滑的梯度。现在我们就开始，下文会解释上篇描述的如何对 stack-manipulation 进行 batch。 PyTorch text library 内置的系统，能把相近长度的样例组合起来自动生成 batch，以下 Python 代码便向该系统加载了一些数据。运行这些代码之后，, train_iter、dev_iter、test_iter 中的迭代器，会在 SNLI 训练、验证、测试阶段在 batch 上循环。
from torchtext import data, datasets
TEXT = datasets.snli.ParsedTextField(lower=True)
TRANSITIONS = datasets.snli.ShiftReduceField()
LABELS = data.Field(sequential=False)
train, dev, test = datasets.SNLI.splits(
TEXT, TRANSITIONS, LABELS, wv_type='glove.42B')
TEXT.build_vocab(train, dev, test)
train_iter, dev_iter, test_iter = data.BucketIterator.splits(
(train, dev, test), batch_size=64)
你可以在 train.py 找到其余代码，包括训练循环（loop）的和衡量精度的。现在讲模型。如同上篇所描述，一个 SPINN 编码器包含一个参数化的 Reduce 层，以及可选的 recurrent Tracker，以追踪语境。这通过在神经网络每读取一个词语、或应用 Reduce 的时候，更新隐藏状态来实现。下面的代码其实表示了，创建一个 SPINN 只是意味着创建这两个子模块而已，以及把它们放到容器里面以日后使用。
import torch
from torch import nn
# subclass the Module class from PyTorch’s neural network package
class SPINN(nn.Module):
def __init__(self, config):
super(SPINN, self).__init__()
self.config = config
self.reduce = Reduce(config.d_hidden, config.d_tracker)
if config.d_tracker is not None:
self.tracker = Tracker(config.d_hidden, config.d_tracker)
创建模型时，SPINN.__init__被调用一次。它分配、初始化参数，但不进行任何神经网络运算，也不涉及创建计算图。每组新数据 batch 上运行的代码，在 SPINN 中定义。PyTorch 里，用户定义模型前馈通道的方法名为 “forward”。事实上，它是对上文提到的 stack-manipulation 算法的实现，在普通 Python 里，它运行于 Buffer 和堆栈的 batch 上——对每个样例使用两者之一。 在转换过程包含的“shift” 和 “reduce” op 上迭代，如果它存在，就运行 Tracker，并运行于 batch 中的每个样例以应用 “shift”op，或加入需要 “reduce” op 的样例列表。然后在列表所有的样例上运行 Reduce 层，把结果 push 回相关堆栈。
def forward(self, buffers, transitions):
# The input comes in as a single tensor of word embeddings;
# I need it to be a list of stacks, one for each example in
# the batch, that we can pop from independently. The words in
# each example have already been reversed, so that they can
# be read from left to right by popping from the end of each
# list; they have also been prefixed with a null value.
buffers = [list(torch.split(b.squeeze(1), 1, 0))
for b in torch.split(buffers, 1, 1)]
# we also need two null values at the bottom of each stack,
# so we can copy from the nulls in the input; these nulls
# are all needed so that the tracker can run even if the
# buffer or stack is empty
stacks = [[buf[0], buf[0]] for buf in buffers]
if hasattr(self, 'tracker'):
self.tracker.reset_state()
for trans_batch in transitions:
if hasattr(self, 'tracker'):
# I described the Tracker earlier as taking 4
# arguments (context_t, b, s1, s2), but here I
# provide the stack contents as a single argument
# while storing the context inside the Tracker
# object itself.
tracker_states, _ = self.tracker(buffers, stacks)
else:
tracker_states = itertools.repeat(None)
lefts, rights, trackings = [], [], []
batch = zip(trans_batch, buffers, stacks, tracker_states)
for transition, buf, stack, tracking in batch:
if transition == SHIFT:
stack.append(buf.pop())
elif transition == REDUCE:
rights.append(stack.pop())
lefts.append(stack.pop())
trackings.append(tracking)
if rights:
reduced = iter(self.reduce(lefts, rights, trackings))
for transition, stack in zip(trans_batch, stacks):
if transition == REDUCE:
stack.append(next(reduced))
return [stack.pop() for stack in stacks]
调用 self.tracker 或 self.reduce，会相对应地运行 Tracker 中的“forward”方式，或 Reduce 子模块。这需要在一个样例列表来执行该 op。所有数学运算密集、用 GPU 加速、收益用 batch 的 op 都发生在 Tracker 和 Reduce 之中。因此，在主要的“forward”方式中，单独在不同样例上运行；对 batch 中的每个样例保持独立的 buffer 和堆栈，都是意义的。为了更干净地写这些函数，我会用一些辅助，把这些样例列表转为 batch 化的张量，反之亦然。
我倾向于让 Reduce 模块自动 batch 参数来加速计算，然后 unbatch 它们，这样之后能单独地 push、pop。把每一组左右子短语放到一起，来表示母短语的合成函数是 TreeLSTM，一个常规 LSTM 的变种。此合成函数要求，所有子树的状态要由两个张量组成，一个隐藏状态 h 和一个内存单元状态 c。定义该函数的因素有两个：运行于子树隐藏状态中的两个线性层 (nn.Linear)，以及非线性合成函数 tree_lstm，后者把线性层的结果和子树内存单元的状态组合起来。在 SPINN 中，这通过加入第三个运行于 Tracker 隐藏状态的 线性层来拓展。
def tree_lstm(c1, c2, lstm_in):
# Takes the memory cell states (c1, c2) of the two children, as
# well as the sum of linear transformations of the children’s
# hidden states (lstm_in)
# That sum of transformed hidden states is broken up into a
# candidate output a and four gates (i, f1, f2, and o).
a, i, f1, f2, o = lstm_in.chunk(5, 1)
c = a.tanh() * i.sigmoid() + f1.sigmoid() * c1 + f2.sigmoid() * c2
h = o.sigmoid() * c.tanh()
return h, cclass Reduce(nn.Module):
def __init__(self, size, tracker_size=None):
super(Reduce, self).__init__()
self.left = nn.Linear(size, 5 * size)
self.right = nn.Linear(size, 5 * size, bias=False)
if tracker_size is not None:
self.track = nn.Linear(tracker_size, 5 * size, bias=False)def forward(self, left_in, right_in, tracking=None):
left, right = batch(left_in), batch(right_in)
tracking = batch(tracking)
lstm_in = self.left(left[0])
lstm_in += self.right(right[0])
if hasattr(self, 'track'):
lstm_in += self.track(tracking[0])
return unbatch(tree_lstm(left[1], right[1], lstm_in))
由于 Reduce 层和以与之类似方式执行的 Tracker 都在 LSTM 上运行，batch 和 unbatch 辅助函数会在成对隐藏、内存状态上运行。
def batch(states):
if states is None:
return None
states = tuple(states)
if states[0] is None:
return None
# states is a list of B tensors of dimension (1, 2H)
# this returns two tensors of dimension (B, H)
return torch.cat(states, 0).chunk(2, 1)def unbatch(state):
if state is None:
return itertools.repeat(None)
# state is a pair of tensors of dimension (B, H)
# this returns a list of B tensors of dimension (1, 2H)
return torch.split(torch.cat(state, 1), 1, 0)
这就是全部的实操讲解了。其余代码，包含 Tracker，都在 spinn.py 里。至于从两个句子编码上计算 SNLI 类别、并把结果与目标做对比，以给出最终损失变量的分类层，在 model.py 里。 SPINN 的 “forward”代码及其子模块，所产生的是极度复杂的计算图（下图），在损失上达到高潮。其细节与数据集中的每一个 batch 都完全不同，但每次都可简单地调用 loss.backward() 以自动反向传播，其成本很低。loss.backward() 是 PyTorch 内置的一个函数，能在计算图的任意一个点上进行反向传播。
完整代码里的模型和超参数，其性能可与原始 SPINN 论文相提并论。但在 GPU 上，它更快好几倍——它的实现充分利用了 batch 和以及 Pytorch 的高效率。原始的 SPINN 编译计算图花费了 21 分钟（意味着执行时的修补漏洞周期至少也这么长），训练花了大约五天。本文描述的这一版本并没有便宜步骤，在 Tesla K40 GPU 上训练只用了 13 小时，相当于 Quadro GP100 上的九个小时。
整合强化学习
上文描述的、该模型不含 Tracker 的版本，其实特别适合 TensorFlow 的 tf.fold，针对动态计算图特殊情形的 TensorFlow 新专用语言。包含 Tracker 的版本实现起来要难得多。这背后的原因是：加入 Tracker，就意味着从 recursive 模式切换为基于堆栈的模式。在上面的代码里，这以最直观的形式表现了出来，这使用的是取决于输入值的 conditional branches。 Fold 并没有内建的 conditional branch op，所以模型里的图结构只取决于输入的结构而非值。另外，创建一个由 Tracker 决定如何解析输入语句的 SPINN 实际上是不可能的。这是因为 Fold 里的图结构——虽然它们取决于输入样例的结构，在一个输入样例加载之后，它必须完全固定下来。
DeepMind 和谷歌大脑的研究人员正在摸索一个类似的模型。他们用强化学习来训练一个 SPINN 的 Tracker，来解析输入语句，而不需要任何外部解析数据。本质上，这样的模型以随机的猜想开始，当它的解析在整体分类任务上生成较好精度时，奖励它自己，以此来学习。研究人员们写道，他们“使用 batch size 1，因为取决于 policy network [Tracker] 的样本， 对于每个样例，计算图需要在每次迭代后重建。”但即便在像本文这么复杂、结构有随机变化特性的神经网络上，在 PyTorch 上，研究人员们也能只用 batch 训练。
PyTorch 还是第一个在算法库内置了强化学习的框架，即它的 stochastic computation graphs （随机计算图）。这使得 policy gradient 强化学习像反向传播一样易于使用。若想要把它加入上面描述的模型，你只需要像重写主 SPINN 的头几行代码，生成下面一样的循环，让 Tracker 来定义做任何一种解析器（parser）转换的概率。
!# nn.functional contains neural network operations without parameters
from torch.nn import functional as F
transitions = []
for i in range(len(buffers[0]) * 2 – 3): # we know how many steps
# obtain raw scores for each kind of parser transition
tracker_states, transition_scores = self.tracker(buffers, stacks)
# use a softmax function to normalize scores into probabilities,
# then sample from the distribution these probabilities define
transition_batch = F.softmax(transition_scores).multinomial()
transitions.append(transition_batch
当 batch 一路运行下来，模型知道了它的类别预测精确程度之后，我可以在反向传播之外，用传统方式通过图的其余部分把奖励信号传回这些随机计算图节点：
# losses should contain a loss per example, while mean and std
# represent averages across many batches
rewards = (-losses – mean) / std
for transition in transitions:
transition.reinforce(rewards)
# connect the stochastic nodes to the final loss variable
# so that backpropagation can find them, multiplying by zero
# because this trick shouldn’t change the loss value
loss = losses.mean() + 0 * sum(transitions).sum()
# perform backpropagation through deterministic nodes and
# policy gradient RL for stochastic nodes
loss.backward()
谷歌研究人员从 SPINN+增强学习报告的结果，比在 SNLI 获得的原始 SPINN 要好一点，虽然它的增强学习版并没有预计算语法树。深度增强学习在 NLP 的应用是一个全新的领域，其中的研究问题十分广泛。通过把增强学习整合到框架里，PyTorch 极大降低了使用门槛。
via nvidia，雷锋网编译。
“TensorFlow & 神经网络算法高级应用班”要开课啦！
从初级到高级，理论+实战，一站式深度了解 TensorFlow！
本课程面向深度学习开发者，讲授如何利用 TensorFlow 解决图像识别、文本分析等具体问题。课程跨度为 10 周，将从 TensorFlow 的原理与基础实战技巧开始，一步步教授学员如何在 TensorFlow 上搭建 CNN、自编码、RNN、GAN 等模型，并最终掌握一整套基于 TensorFlow 做深度学习开发的专业技能。
两名授课老师佟达、白发川身为 ThoughtWorks 的资深技术专家，具有丰富的大数据平台搭建、深度学习系统开发项目经验。
时间：每周二、四晚 20：00-21：00
开课时长：总学时 20 小时，分 10 周完成，每周2次，每次 1 小时
线上授课地址：http://www.leiphone.com/special/custom/mooc04.html
相关文章：
GAN 很复杂？如何用不到 50 行代码训练 GAN（基于 PyTorch）
雷锋网版权文章，未经授权禁止转载。详情见。
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/84046.html