婚姻家庭
当前位置: 主页 >> 婚姻家庭

从原理到实战英伟达教你用PyTorch搭注意

作者:  来源:  日期:2020年11月19日

从原理到实战 英伟达教你用PyTorch搭建RNN(下)

按:本文为《从原理到实战 英伟达教你用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 = rsedTextField(lower=True)

TRANSITIONS = iftReduceField()

LABELS = eld(sequential=False)

train, dev, test = lits(

TEXT, TRANSITIONS, LABELS, wv_type=glove.42B)

ild_vocab(train, dev, test)

train_iter, dev_iter, test_iter = lits(

(train, dev, test), batch_size=64)

你可以在 找到其余代码,包括训练循环(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(dule):

def __init__(self, config):

super(SPINN, self).__init__()

nfig = config

duce = Reduce(config.d_hidden, config.d_tracker)

if config.d_tracker is not None:

acker = 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(lit(ueeze(1), 1, 0))

for b in lit(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):

set_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, _ = acker(buffers, stacks)

else:

tracker_states = peat(None)

lefts, rights, trackings = [], [], []

batch = zip(trans_batch, buffers, stacks, tracker_states)

for transition, buf, stack, tracking in batch:

if transition == SHIFT:

pend(p())

elif transition == REDUCE:

pend(p())

pend(p())

pend(tracking)

if rights:

reduced = iter(duce(lefts, rights, trackings))

for transition, stack in zip(trans_batch, stacks):

if transition == REDUCE:

pend(next(reduced))

return [p() for stack in stacks]

调用 acker 或 duce,会相对应地运行 Tracker 中的“forward”方式,或 Reduce 子模块。这需要在一个样例列表来执行该 op。所有数学运算密集、用 GPU 加速、收益用 batch 的 op 都发生在 Tracker 和 Reduce 之中。因此,在主要的“forward”方式中,单独在不同样例上运行;对 batch 中的每个样例保持独立的 buffer 和堆栈,都是意义的。为了更干净地写这些函数,我会用一些辅助,把这些样例列表转为 batch 化的张量,反之亦然。

我倾向于让 Reduce 模块自动 batch 参数来加速计算,然后 unbatch 它们,这样之后能单独地 push、pop。把每一组左右子短语放到一起,来表示母短语的合成函数是 TreeLSTM,一个常规 LSTM 的变种。此合成函数要求,所有子树的状态要由两个张量组成,一个隐藏状态 h 和一个内存单元状态 c。定义该函数的因素有两个:运行于子树隐藏状态中的两个线性层 (near),以及非线性合成函数 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_unk(5, 1)

c = nh() * gmoid() + gmoid() * c1 + gmoid() * c2

h = gmoid() * nh()

return h, c

class Reduce(dule):

def __init__(self, size, tracker_size=None):

super(Reduce, self).__init__()

ft = near(size, 5 * size)

ght = near(size, 5 * size, bias=False)

if tracker_size is not None:

ack = near(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 = ft(left[0])

lstm_in += ght(right[0])

if hasattr(self, track):

lstm_in += ack(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 t(states, 0).chunk(2, 1)

def unbatch(state):

if state is None:

return peat(None)

# state is a pair of tensors of dimension (B, H)

# this returns a list of B tensors of dimension (1, 2H)

return lit(t(state, 1), 1, 0)

这就是全部的实操讲解了。其余代码,包含 Tracker,都在 里。至于从两个句子编码上计算 SNLI 类别、并把结果与目标做对比,以给出最终损失变量的分类层,在 里。 SPINN 的 “forward”代码及其子模块,所产生的是极度复杂的计算图(下图),在损失上达到高潮。其细节与数据集中的每一个 batch 都完全不同,但每次都可简单地调用 ckward() 以自动反向传播,其成本很低。ckward() 是 PyTorch 内置的一个函数,能在计算图的任意一个点上进行反向传播。

完整代码里的模型和超参数,其性能可与原始 SPINN 论文相提并论。但在 GPU 上,它更快好几倍——它的实现充分利用了 batch 和以及 Pytorch 的高效率。原始的 SPINN 编译计算图花费了 21 分钟(意味着执行时的修补漏洞周期至少也这么长),训练花了大约五天。本文描述的这一版本并没有便宜步骤,在 Tesla K40 GPU 上训练只用了 13 小时,相当于 Quadro GP100 上的九个小时。

整合强化学习上文描述的、该模型不含 Tracker 的版本,其实特别适合 TensorFlow 的 ld,针对动态计算图特殊情形的 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)转换的概率。

!# nctional contains neural network operations without parameters

from 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 = acker(buffers, stacks)

# use a softmax function to normalize scores into probabilities,

# then sample from the distribution these probabilities define

transition_batch = ftmax(transition_scores).multinomial()

pend(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:

inforce(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 = an() + 0 * sum(transitions).sum()

# perform backpropagation through deterministic nodes and

# policy gradient RL for stochastic nodes

ckward()

谷歌研究人员从 SPINN+增强学习报告的结果,比在 SNLI 获得的原始 SPINN 要好一点,虽然它的增强学习版并没有预计算语法树。深度增强学习在 NLP 的应用是一个全新的领域,其中的研究问题十分广泛。通过把增强针对媒体关切台南议长选举的相关后续事件学习整合到框架里,PyTorch 极大降低了使用门槛。

vianvidia,(公众号:)编译。

“TensorFlow 神经络算法高级应用班”要开课啦!

从初级到高级,理论+实战,一站式深度了解 TensorFlow!

本课程面向深度学习开发者,讲授如何利用 TensorFlow 解决图像识别、文本分析等具体问题。课程跨度为 10 周,将从 TensorFlow 的原理与基础实战技巧开始,一步步教授学员如何在 TensorFlow 上搭建 CNN、自编码、RNN、GAN 等模型,并最终掌握一整套基于 TensorFlow 做深度学习开发的专业技能。

两名授课老师佟达、白发川身为 ThoughtWorks 的资深技术专家,具有丰富的大数据平台搭建、深度学习系统开发项目经验。

时间:每周二、四晚 20::00

开课时长:总学时 20 小时,分 10 周完成,每周2次,每次 1 小时

线上授课地址:

相关文章:

GAN 很复杂?如何用不到 50 行代码训练 GAN(基于 PyTorch)

PyTorch 的预训练,是时候学习一下了

从原理到实战 英伟达教你用PyTorch搭建RNN(上)

版权文章,未经授权禁止转载。详情见转载须知。

酒泉看白癜风医院哪家好
梧州白癜风专业治疗医院
吉林妇产科