如何用PyTorch实现递归神经网络

2024-05-16 14:18

1. 如何用PyTorch实现递归神经网络

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

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

开始 SPINN

链接中的文章(https://github.com/jekbradbury/examples/tree/spinn/snli)详细介绍了一个递归神经网络的 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)方法由机器生成的,句法解析树将每个句子中的单词分组成具有独立意义的短语和子句,每个短语由两个词或子短语组成。许多语言学家认为,人类通过如上面所说的树的分层方式来组合词意并理解语言,所以用相同的方式尝试构建一个神经网络是值得的。下面的例子是数据集中的一个句子,其解析树由嵌套括号表示:


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



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

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


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

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


或者用第 3 种方式表示,如下:

WORDS:  The church   has cracks in the ceiling         .
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 时,在堆栈操作的每个步骤(即,读取每个单词或闭括号)后生成一个新状态:

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。需要一个额外的特殊节点来获取运行时的词长度,因为在运行代码时它只是一个占位符。


# TensorFlow
# (this code runs once, during model initialization)
# “words” is not a real list (it’s a placeholder variable) so
# I can’t use “len”
cond = lambda i, h: i < tf.shape(words)[0]
cell = lambda i, h: rnn_unit(words[i], h)
i = 0
_, 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 循环来实现有相同变量长度的循环神经网络。


# PyTorch (also works in Chainer)
# (this code runs on every forward pass of the model)
# “words” is a Python list with actual values in it
h = h0
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 的批处理。

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

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

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 或 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)。

如何用PyTorch实现递归神经网络

2. 神经网络如何用单片机实现?

主要考虑三个方向:
1)网络本身,神网本质上是一组矩阵,矩阵在单片机中的表现可以通过数组来实现。
2)输入输出,神网的应用就是把输入阵列与网络本身的矩阵点乘叉乘后算术求和,产生输出矩阵,把输入输出的算法做到单片机里也不是难事。
3)训练,神网的权值矩阵都是训练出来的,采用诸如前向或反向的算法,可以做离线也可以做在线,如果做离线就没有必要把算法实现在单片机内,PC上就可以做,然后导入矩阵即可;如果做在线则是相对较难的技术,需要在单片机上实现,对于单片机本身的资源要求也较高。
简单说,1)是基础,也最容易;1)+2)就已经是神经网络的应用了,也容易实现。1)+2)+Matlab神经网络离线训练是易于实现,且富有弹性的应用方式;1)+2)+在线训练基本上就是具备自己学习能力的机器人,这是学术界一直探索的方向。

3. 怎样用python构建一个卷积神经网络

用keras框架较为方便
首先安装anaconda,然后通过pip安装keras

以下转自wphh的博客。
#coding:utf-8'''    GPU run command:        THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python cnn.py    CPU run command:        python cnn.py2016.06.06更新:这份代码是keras开发初期写的,当时keras还没有现在这么流行,文档也还没那么丰富,所以我当时写了一些简单的教程。现在keras的API也发生了一些的变化,建议及推荐直接上keras.io看更加详细的教程。'''#导入各种用到的模块组件from __future__ import absolute_importfrom __future__ import print_functionfrom keras.preprocessing.image import ImageDataGeneratorfrom keras.models import Sequentialfrom keras.layers.core import Dense, Dropout, Activation, Flattenfrom keras.layers.advanced_activations import PReLUfrom keras.layers.convolutional import Convolution2D, MaxPooling2Dfrom keras.optimizers import SGD, Adadelta, Adagradfrom keras.utils import np_utils, generic_utilsfrom six.moves import rangefrom data import load_dataimport randomimport numpy as npnp.random.seed(1024)  # for reproducibility#加载数据data, label = load_data()#打乱数据index = [i for i in range(len(data))]random.shuffle(index)data = data[index]label = label[index]print(data.shape[0], ' samples')#label为0~9共10个类别,keras要求格式为binary class matrices,转化一下,直接调用keras提供的这个函数label = np_utils.to_categorical(label, 10)################开始建立CNN模型################生成一个modelmodel = Sequential()#第一个卷积层,4个卷积核,每个卷积核大小5*5。1表示输入的图片的通道,灰度图为1通道。#border_mode可以是valid或者full,具体看这里说明:http://deeplearning.net/software/theano/library/tensor/nnet/conv.html#theano.tensor.nnet.conv.conv2d#激活函数用tanh#你还可以在model.add(Activation('tanh'))后加上dropout的技巧: model.add(Dropout(0.5))model.add(Convolution2D(4, 5, 5, border_mode='valid',input_shape=(1,28,28))) model.add(Activation('tanh'))#第二个卷积层,8个卷积核,每个卷积核大小3*3。4表示输入的特征图个数,等于上一层的卷积核个数#激活函数用tanh#采用maxpooling,poolsize为(2,2)model.add(Convolution2D(8, 3, 3, border_mode='valid'))model.add(Activation('tanh'))model.add(MaxPooling2D(pool_size=(2, 2)))#第三个卷积层,16个卷积核,每个卷积核大小3*3#激活函数用tanh#采用maxpooling,poolsize为(2,2)model.add(Convolution2D(16, 3, 3, border_mode='valid')) model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2, 2)))#全连接层,先将前一层输出的二维特征图flatten为一维的。#Dense就是隐藏层。16就是上一层输出的特征图个数。4是根据每个卷积层计算出来的:(28-5+1)得到24,(24-3+1)/2得到11,(11-3+1)/2得到4#全连接有128个神经元节点,初始化方式为normalmodel.add(Flatten())model.add(Dense(128, init='normal'))model.add(Activation('tanh'))#Softmax分类,输出是10类别model.add(Dense(10, init='normal'))model.add(Activation('softmax'))##############开始训练模型###############使用SGD + momentum#model.compile里的参数loss就是损失函数(目标函数)sgd = SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True)model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=["accuracy"])#调用fit方法,就是一个训练过程. 训练的epoch数设为10,batch_size为100.#数据经过随机打乱shuffle=True。verbose=1,训练过程中输出的信息,0、1、2三种方式都可以,无关紧要。show_accuracy=True,训练时每一个epoch都输出accuracy。#validation_split=0.2,将20%的数据作为验证集。model.fit(data, label, batch_size=100, nb_epoch=10,shuffle=True,verbose=1,validation_split=0.2)"""#使用data augmentation的方法#一些参数和调用的方法,请看文档datagen = ImageDataGenerator(        featurewise_center=True, # set input mean to 0 over the dataset        samplewise_center=False, # set each sample mean to 0        featurewise_std_normalization=True, # divide inputs by std of the dataset        samplewise_std_normalization=False, # divide each input by its std        zca_whitening=False, # apply ZCA whitening        rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)        width_shift_range=0.2, # randomly shift images horizontally (fraction of total width)        height_shift_range=0.2, # randomly shift images vertically (fraction of total height)        horizontal_flip=True, # randomly flip images        vertical_flip=False) # randomly flip images# compute quantities required for featurewise normalization # (std, mean, and principal components if ZCA whitening is applied)datagen.fit(data)for e in range(nb_epoch):    print('-'*40)    print('Epoch', e)    print('-'*40)    print("Training...")    # batch train with realtime data augmentation    progbar = generic_utils.Progbar(data.shape[0])    for X_batch, Y_batch in datagen.flow(data, label):        loss,accuracy = model.train(X_batch, Y_batch,accuracy=True)        progbar.add(X_batch.shape[0], values=[("train loss", loss),("accuracy:", accuracy)] )"""

怎样用python构建一个卷积神经网络

4. 递归神经网络RNN怎样加速

定程度认Recurrent NNRecursive NN种变体Recursive NN更general

5. 怎样用python实现深度学习

Python使用Tensorflow读取CSV数据训练DNN深度学习模型

怎样用python实现深度学习

6. 有没有pytorch的高级应用教程推荐一下

深度学习与PyTorch入门实战教程百度网盘免费资源在线学习 
   链接: https://pan.baidu.com/s/1BQtdabkn-aj0SXVv3x62ww
 
提取码: r93i    深度学习与PyTorch入门实战教程 9.卷积神经网络CNN 8.过拟合 7.神经网络与全连接层 6.随机梯度下降 5.PyTorch进阶教程 4.PyTorch基础教程 3.回归问题 2.开发环境安装 17.【选看】Numpy实战BP神经网络 16.【选看】人工智能发展简史 15.【选看】Ubuntu开发环境安装 14.对抗生成网络GAN 13.自编码器Auto-Encoders 12.迁移学习-实战宝可梦精灵    
教程配套的工程文件和素材百度网盘免费资源在线学习   
 链接: https://pan.baidu.com/s/1tZy7q_S8zBBkQc9FZNbRTg
 提取码: yiii    教程配套的工程文件和素材 Lo_Res_Media_Ex_Files.zip Ex_Files_FCPX_10_3_EssT.zip    

7. pytorch0.1.12怎么使用多GPU训练

傻瓜的是真的回复的感觉很

pytorch0.1.12怎么使用多GPU训练

8. win10怎样安装pytorch

先到python的官方网站下载软件,打开官网后,选择downlad项目,然后选择需要下载的大版本,2.7还是3.4。

选择完版本后,进入后一个页面,在这个页面可以选择操作系统及对应的版本,win下注意分64位和32位版本,不要下错了。

32位的程序大约为17.5M,建议非官网下载的还是要比对下MD5以防万一,在上一个页面就有MD5值。核对完成后双击安装,首先是询问是为所有用户还是为当前用户安装,用缺省的就行。

下一步后是选择安装目录,这个看个人喜好了,不过还是要记一下目录,因为缺省的代码也会放在这个目录下。

下面继续缺省配置选择就开始安装了,python在安装过程中要执行一些角本,因些需要至少有system的权限才可以安装。

安装完成,但在win10在任务栏和桌面上都未生成图标,使用起来麻烦些,在开始窗口打开所有应,按字母找到python程序项,右键选择固定在任务栏或屏幕。
最新文章
热门文章
推荐阅读