python实现rnn
❶ 递归神经网络RNN怎样加速
原文来源：medium
作者：Illia Polosukhin
“机器人圈”编译：多啦A亮
如果你读过我的博客，你可能已经了解到我是一个TensorFlow的贡献者，并在那里建立了很多高级API。
而在2017年2月，我已经离开谷歌并创立了自己的公司——NEAR.ai。我们教机器用自然语言编写代码。
作为这项工作的一部分，我们正在构建以树格式读取或编写代码的深度学习模型。在试图用TensorFlow管理这种复杂性之后，我已经决定尝试用一下PyTorch。
PyTorch是由Facebook AI研究人员构建的框架，并且在自然语言和强化学习研究领域越来越受欢迎。它的主要优点是动态图形构建原理——与Tensorflow相比，其中图形一旦被构建，然后就会被“执行”多次，PyTorch可以使用简单的python逻辑动态重建图形，就像你正在使用numpy数组进行计算一样。
来源： http://pytorch.org/about
这种灵活性吸引了一些人，他们使用复杂输入/输出数据（例如语言、树、图形）或需要在计算中运行一些自定义逻辑（深度强化学习）。
在这里我想谈谈批处理的事情。即使PyTorch利用GPU加速器快速运行，并且通常推进C模块的计算，如果你没有对计算进行批处理——你仍然需要付出代价。
递归神经网络（以树形LSTM为例）特别难以批处理，因为每个示例都是不同的树。
单纯的实现将如下所示：
class TreeLSTM(nn.Mole):
def __init__(self, num_units):
super(TreeLSTM, self).__init__()
self.num_units = num_units
self.left = nn.Linear(num_units, 5 * num_units)
self.right = nn.Linear(num_units, 5 * num_units)
def forward(self, left_in, right_in):
lstm_in = self.left(left_in[0])
lstm_in += self.right(right_in[0])
a, i, f1, f2, o = lstm_in.chunk(5, 1)
c = (a.tanh() * i.sigmoid() + f1.sigmoid() * left_in[1] +
f2.sigmoid() * right_in[1])
h = o.sigmoid() * c.tanh()
return h, c
class SPINN(nn.Mole):
def __init__(self, n_classes, size, n_words):
super(SPINN, self).__init__()
self.size = size
self.tree_lstm = TreeLSTM(size)
self.embeddings = nn.Embedding(n_words, size)
self.out = nn.Linear(size, n_classes)
def leaf(self, word_id):
return self.embeddings(word_id), Variable(torch.FloatTensor(word_id.size()[0], self.size))
def children(self, left_h, left_c, right_h, right_c):
return self.tree_lstm((left_h, left_c), (right_h, right_c))
def logits(self, encoding):
return self.out(encoding)
def encode_tree_regular(model, tree):
def encode_node(node):
if node.is_leaf():
return model.leaf(Variable(torch.LongTensor([node.id])))
else:
left_h, left_c = encode_node(node.left)
right_h, right_c = encode_node(node.right)
return model.children(left_h, left_c, right_h, right_c)
encoding, _ = encode_node(tree.root)
return model.logits(encoding)
...
all_logits, all_labels = [], []
for tree in batch:
all_logits.append(encode_tree_regular(model, tree))
all_labels.append(tree.label)
loss = criterion(torch.cat(all_logits, 0), Variable(torch.LongTensor(all_labels)))
有一种手动批处理的方法：在每次处理输入不同的操作之后，找出如何批处理输入，然后解除输出批处理。这是James Bradbury在其文章中的一个例子。
另一种选择是，根据我们要计算的确切输入/输出，找到一个系统决定为我们的批处理对象。灵感来自Moshe等人的论文中描述的方法。 “动态计算图深度学习”（在TensorFlow Fold 中实现但似乎并不被支持），在这个动画中有很好的描绘：
来源：http://github.com/tensorflow/fold
我已经在一个简单的TorchFold中实现了这个原理：
class TorchFold(object):
def __init__(self, versatible=False, cuda=False):
def add(self, op, *args):
def apply(self, nn, return_values):
现在，如果我们想用以前的gist对树形LSTM / 模型进行编码，那么我们需要这样更改代码：
from pytorch_tools import torchfold
def encode_tree_fold(fold, tree):
return fold.add('leaf', node.id).split(2)
return fold.add('children', left_h, left_c, right_h, right_c).split(2)
return fold.add('logits', encoding)
fold = torchfold.Fold(cuda=args.cuda)
all_logits.append(encode_tree_folded(fold, tree))
res = fold.apply(model, [all_logits, all_labels])
loss = criterion(res[0], res[1])
这里，在每次调用encode_tree_folded时，通过fold.add添加节点来动态构建“折叠”图，其中op是要调用的模型中的函数的名称。它会自动显示哪些op可以组合在一起，哪些应该遵循。
然后在fold.apply，调用传递的模型的操作，传递它们的批处理的输入张量（可能在不同的步骤有不同的批处理大小），并自动输出到接下来的步骤。
比较未折叠和折叠版本之间的速度（在这里的简单模型https://github.com/nearai/pytorch-tools/blob/master/examples/snli/spinn-example.py）：
常规：0.18秒/步（100 dim），2.19秒/步（500 dim）
折叠：0.05秒/步（100 dim），0.22秒/步（500 dim）
由于降低了计算非有效效率，提升了3-10倍的速度。
该工具通常对于任何复杂的架构（包括RNN）都是有用的，因为它至少在第一个实验中不需要考虑批处理。
你可以在这里找到实现和示例：https：//github.com/nearai/pytorch-tools
另外，在撰写本文时，我发现最近有关于这个主题的文章 - https://arxiv.org/pdf/1705.07860.pdf， DyNet的实现。
还有就是，自从升级到PyTorch 0.2.0后，我发现TorchFold的性能略有下降，所以为了最佳速度，尝试运行0.1.12直到稳定即可。
❷ 如何用TensorFlow构建RNN
基本使用
使用 TensorFlow, 你必须明白 TensorFlow:
使用图 （graph） 来表示计算任务。
在被称之为 会话 （Session） 的上下文 （context） 中执行图。
使用 tensor 表示数据。
通过 变量 （Variable） 维护状态。
使用 feed 和 fetch 可以为任意的操作（arbitrary operation） 赋值或者从其中获取数据。
综述
TensorFlow 是一个编程系统， 使用图来表示计算任务。 图中的节点被称之为 op
（operation 的缩写）。 一个 op 获得 0 个或多个 Tensor, 执行计算，
产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组。
例如， 你可以将一小组图像集表示为一个四维浮点数数组，
这四个维度分别是 [batch, height, width, channels].
一个 TensorFlow 图描述了计算的过程。 为了进行计算， 图必须在 会话 里被启动。
会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上， 同时提供执行 op 的方法。
这些方法执行后， 将产生的 tensor 返回。 在 Python 语言中， 返回的 tensor 是
numpy ndarray 对象； 在 C 和 C++ 语言中， 返回的 tensor 是
tensorflow::Tensor 实例。
计算图
TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段。 在构建阶段， op 的执行步骤
被描述成一个图。 在执行阶段， 使用会话执行执行图中的 op.
例如， 通常在构建阶段创建一个图来表示和训练神经网络， 然后在执行阶段反复执行图中的训练 op.
TensorFlow 支持 C, C++, Python 编程语言。 目前， TensorFlow 的 Python 库更加易用，
它提供了大量的辅助函数来简化构建图的工作， 这些函数尚未被 C 和 C++ 库支持。
三种语言的会话库 （session libraries） 是一致的。
构建图
构建图的第一步， 是创建源 op （source op）。 源 op 不需要任何输入， 例如 常量 （Constant）。 源 op 的输出被传递给其它 op 做运算。
Python 库中， op 构造器的返回值代表被构造出的 op 的输出， 这些返回值可以传递给其它
op 构造器作为输入。
TensorFlow Python 库有一个默认图 （default graph）， op 构造器可以为其增加节点。 这个默认图对
许多程序来说已经足够用了。 阅读 Graph 类 文档
来了解如何管理多个图。
import tensorflow as tf
# 创建一个常量 op, 产生一个 1x2 矩阵。 这个 op 被作为一个节点
# 加到默认图中。
#
# 构造器的返回值代表该常量 op 的返回值。
matrix1 = tf.constant（[[3., 3.]]）
# 创建另外一个常量 op, 产生一个 2x1 矩阵。
matrix2 = tf.constant（[[2.],[2.]]）
# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入。
# 返回值 'proct' 代表矩阵乘法的结果。
proct = tf.matmul（matrix1, matrix2）
默认图现在有三个节点， 两个 constant（） op, 和一个matmul（） op. 为了真正进行矩阵相乘运算， 并得到矩阵乘法的
结果， 你必须在会话里启动这个图。
在一个会话中启动图
构造阶段完成后， 才能启动图。 启动图的第一步是创建一个 Session 对象， 如果无任何创建参数，
会话构造器将启动默认图。
欲了解完整的会话 API, 请阅读Session 类。
# 启动默认图。
sess = tf.Session（）
# 调用 sess 的 'run（）' 方法来执行矩阵乘法 op, 传入 'proct' 作为该方法的参数。
# 上面提到， 'proct' 代表了矩阵乘法 op 的输出， 传入它是向方法表明， 我们希望取回
# 矩阵乘法 op 的输出。
#
# 整个执行过程是自动化的， 会话负责传递 op 所需的全部输入。 op 通常是并发执行的。
#
# 函数调用 'run（proct）' 触发了图中三个 op （两个常量 op 和一个矩阵乘法 op） 的执行。
#
# 返回值 'result' 是一个 numpy `ndarray` 对象。
result = sess.run（proct）
print result
# ==> [[ 12.]]
# 任务完成， 关闭会话。
sess.close（）
Session 对象在使用完后需要关闭以释放资源。 除了显式调用 close 外， 也可以使用 "with" 代码块
来自动完成关闭动作。
with tf.Session（） as sess:
result = sess.run（[proct]）
print result
在实现上， TensorFlow 将图形定义转换成分布式执行的操作， 以充分利用可用的计算资源（如 CPU
或 GPU）。 一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测。 如果检测到 GPU, TensorFlow
会尽可能地利用找到的第一个 GPU 来执行操作。
如果机器上有超过一个可用的 GPU, 除第一个外的其它 GPU 默认是不参与计算的。 为了让 TensorFlow
使用这些 GPU, 你必须将 op 明确指派给它们执行。 withDevice 语句用来指派特定的 CPU 或 GPU
❸ python的机器学习是什么
可以算很有关系，因为现在大众说的人工智能 指的是自动化， 在计算机领域 机器学习就是通过数据来学模型，自动做预测的
机器学习是数据分析更上一层楼的任务， 如果你能学号数据分析，那应该也能学得来机器学习
Python有很完善的机器学习工具包 就叫sklearn
❹ 百度paddle会和python一样，成为最流行的深度学习引擎吗
1)Caffe具有出色的CNN实现功能的开发语言，在计算机视觉领域，Caffe仍然是最流行的工具包。Caffe的开发语言支持C++和Cuda，速度很快，但是由于一些历史性的遗留架构问题，它的灵活性不够强。而且对递归网络和语言建模的支持很差。Caffe支持所有主流开发系统，上手难度属于中等水平。
2)TensorFlow是一个理想的RNN
API实现，它使用了向量运算的符号图方法，使得开发的速度可以很快。TensorFlow支持的比较好的系统只有各种Linux系统和OSX，不过其对语言的支持比较全面，包含了Python、C++和Cuda等，开发者文档写得没有Caffe那么全面，所以上手比较难，在性能方面，也不如Caffe及PaddlePaddle。
3)Torch没有跟随Python的潮流，反而选择了C语言实现，用Lua语言进行封装。Torch对卷积网络的支持非常好，运行在C++、C#和Jave等工业语言的速度较快，也不需要额外的编译。但是它的上手难度也很高，对初学者缺乏规范的例子，而且需要先迈过Lua的门槛，这对初学者是很大的障碍。
4)而此次网络的PaddlePaddle性能优先并兼顾灵活，通过使用GPU异构计算来提升每台机器的数据处理能力，获得了业内“相当简洁、设计干净、稳定，速度较快，显存占用较小”等好评。
而在关键的进入门槛上，相比Google TensorFlow和Facebook
Torch，PaddlePaddle的上手难度低得多，且拥有非常优秀的业界特征，包括NLP和推荐等应用场景、对RNN很好的支持、高质量代码、以及分布式训练等，已经足以满足大多数AI场景的需求。且PaddlePaddle更加务实，可解决实际问题。
据徐伟介绍，PaddlePaddle将在本月底发布最新版本，全面支持Mac操作系统、以及Cuda8.0和GCC5.4，同时进一步优化了安装过程，可以帮助更多开放者更好地“上手”。
❺ Python要哪些要点要学习
阶段一：Python开发基础
Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。
阶段二：Python高级编程和数据库开发
Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。
阶段三：前端开发
Python全栈开发与人工智能之前端开发知识学习内容包括：Html、CSS、JavaScript开发、Jquery&bootstrap开发、前端框架VUE开发等。
阶段四：WEB框架开发
Python全栈开发与人工智能之WEB框架开发学习内容包括：Django框架基础、Django框架进阶、BBS+Blog实战项目开发、缓存和队列中间件、Flask框架学习、Tornado框架学习、Restful API等。
阶段五：爬虫开发
Python全栈开发与人工智能之爬虫开发学习内容包括：爬虫开发实战。
阶段六：全栈项目实战
Python全栈开发与人工智能之全栈项目实战学习内容包括：企业应用工具学习、CRM客户关系管理系统开发、路飞学城在线教育平台开发等。
阶段七：算法&设计模式
阶段八：数据分析
Python全栈开发与人工智能之数据分析学习内容包括：金融量化分析。
阶段九：机器学习、图像识别、NLP自然语言处理
Python全栈开发与人工智能之人工智能学习内容包括：机器学习、图形识别、人工智能玩具开发等。
阶段十：Linux系统&百万级并发架构解决方案
阶段十一：高并发语言GO开发
Python全栈开发与人工智能之高并发语言GO开发学习内容包括：GO语言基础、数据类型与文件IO操作、函数和面向对象、并发编程等。
❻ python怎么做快速图像分割算法
时间序列模型最常用最强大的的工具就是递归神经网络（recurrent neural network, RNN）。相比与普通神经网络的各计算结果之间相互独立的特点，RNN的每一次隐含层的计算结果都与当前输入以及上一次的隐含层结果相关。
通过这种方法，RNN的计算结果便具备了记忆之前几次结果的特点。
❼ 深度学习 python怎么入门 知乎
自学深度学习是一个漫长而艰巨的过程。您需要有很强的线性代数和微积分背景，良好的Python编程技能，并扎实掌握数据科学、机器学习和数据工程。即便如此，在你开始将深度学习应用于现实世界的问题，并有可能找到一份深度学习工程师的工作之前，你可能需要一年多的学习和实践。然而，知道从哪里开始，对软化学习曲线有很大帮助。如果我必须重新学习Python的深度学习，我会从Andrew Trask写的Grokking deep learning开始。大多数关于深度学习的书籍都要求具备机器学习概念和算法的基本知识。除了基本的数学和编程技能之外，Trask的书不需要任何先决条件就能教你深度学习的基础知识。这本书不会让你成为一个深度学习的向导(它也没有做这样的声明)，但它会让你走上一条道路，让你更容易从更高级的书和课程中学习。用Python构建人工神经元
大多数深度学习书籍都是基于一些流行的Python库，如TensorFlow、PyTorch或Keras。相比之下，《运用深度学习》（Grokking Deep Learning）通过从零开始、一行一行地构建内容来教你进行深度学习。
《运用深度学习》
你首先要开发一个人工神经元，这是深度学习的最基本元素。查斯克将带领您了解线性变换的基本知识，这是由人工神经元完成的主要计算。然后用普通的Python代码实现人工神经元，无需使用任何特殊的库。
这不是进行深度学习的最有效方式，因为Python有许多库，它们利用计算机的图形卡和CPU的并行处理能力来加速计算。但是用普通的Python编写一切对于学习深度学习的来龙去是非常好的。
在Grokking深度学习中，你的第一个人工神经元只接受一个输入，将其乘以一个随机权重，然后做出预测。然后测量预测误差，并应用梯度下降法在正确的方向上调整神经元的权重。有了单个神经元、单个输入和单个输出，理解和实现这个概念变得非常容易。您将逐渐增加模型的复杂性，使用多个输入维度、预测多个输出、应用批处理学习、调整学习速率等等。
您将通过逐步添加和修改前面章节中编写的Python代码来实现每个新概念，逐步创建用于进行预测、计算错误、应用纠正等的函数列表。当您从标量计算转移到向量计算时，您将从普通的Python操作转移到Numpy，这是一个特别擅长并行计算的库，在机器学习和深度学习社区中非常流行。
Python的深度神经网络
有了这些人造神经元的基本构造块，你就可以开始创建深层神经网络，这基本上就是你将几层人造神经元叠放在一起时得到的结果。
当您创建深度神经网络时，您将了解激活函数，并应用它们打破堆叠层的线性并创建分类输出。同样，您将在Numpy函数的帮助下自己实现所有功能。您还将学习计算梯度和传播错误通过层传播校正跨不同的神经元。
随着您越来越熟悉深度学习的基础知识，您将学习并实现更高级的概念。这本书的特点是一些流行的正规化技术，如早期停止和退出。您还将获得自己版本的卷积神经网络(CNN)和循环神经网络(RNN)。
在本书结束时，您将把所有内容打包到一个完整的Python深度学习库中，创建自己的层次结构类、激活函数和神经网络体系结构(在这一部分，您将需要面向对象的编程技能)。如果您已经使用过Keras和PyTorch等其他Python库，那么您会发现最终的体系结构非常熟悉。如果您没有，您将在将来更容易地适应这些库。
在整本书中，查斯克提醒你熟能生巧;他鼓励你用心编写自己的神经网络，而不是复制粘贴任何东西。
代码库有点麻烦
并不是所有关于Grokking深度学习的东西都是完美的。在之前的一篇文章中，我说过定义一本好书的主要内容之一就是代码库。在这方面，查斯克本可以做得更好。
在GitHub的Grokking深度学习库中，每一章都有丰富的jupiter Notebook文件。jupiter Notebook是一个学习Python机器学习和深度学习的优秀工具。然而，jupiter的优势在于将代码分解为几个可以独立执行和测试的小单元。Grokking深度学习的一些笔记本是由非常大的单元格组成的，其中包含大量未注释的代码。
这在后面的章节中会变得尤其困难，因为代码会变得更长更复杂，在笔记本中寻找自己的方法会变得非常乏味。作为一个原则问题，教育材料的代码应该被分解成小单元格，并在关键区域包含注释。
此外，Trask在Python 2.7中编写了这些代码。虽然他已经确保了代码在Python 3中也能顺畅地工作，但它包含了已经被Python开发人员弃用的旧编码技术(例如使用“for i in range(len(array))”范式在数组上迭代)。
更广阔的人工智能图景
Trask已经完成了一项伟大的工作，它汇集了一本书，既可以为初学者，也可以为有经验的Python深度学习开发人员填补他们的知识空白。
但正如泰温·兰尼斯特(Tywin Lannister)所说(每个工程师都会同意)，“每个任务都有一个工具，每个工具都有一个任务。”深度学习并不是一根可以解决所有人工智能问题的魔杖。事实上，对于许多问题，更简单的机器学习算法，如线性回归和决策树，将表现得和深度学习一样好，而对于其他问题，基于规则的技术，如正则表达式和几个if-else子句，将优于两者。
关键是，你需要一整套工具和技术来解决AI问题。希望Grokking深度学习能够帮助你开始获取这些工具。
你要去哪里?我当然建议选择一本关于Python深度学习的深度书籍，比如PyTorch的深度学习或Python的深度学习。你还应该加深你对其他机器学习算法和技术的了解。我最喜欢的两本书是《动手机器学习》和《Python机器学习》。
你也可以通过浏览机器学习和深度学习论坛，如r/MachineLearning和r/deeplearning subreddits，人工智能和深度学习Facebook组，或通过在Twitter上关注人工智能研究人员来获取大量知识。
AI的世界是巨大的，并且在快速扩张，还有很多东西需要学习。如果这是你关于深度学习的第一本书，那么这是一个神奇旅程的开始。
❽ 如何用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 ) ) ) ) . ) )
这个句子进行编码的一种方式是使用含有解析树的神经网络构建一个神经网络层 Rece，这个神经网络层能够组合词语对（用词嵌入（word embedding）表示，如 GloVe）、 和/或短语，然后递归地应用此层（函数），将最后一个 Rece 产生的结果作为句子的编码：
X = Rece(“the”, “ceiling”)
Y = Rece(“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”替换闭括号用于“rece”。但是现在可以从左到右读取信息作为一组指令来操作一个堆栈（stack）和一个类似堆栈的缓冲区（buffer），能得到与上述递归方法完全相同的结果：
1. 将单词放入缓冲区。
2. 从缓冲区的前部弹出“The”，将其推送（push）到堆栈上层，紧接着是“church”。
3. 弹出前 2 个堆栈值，应用于 Rece，然后将结果推送回堆栈。
4. 从缓冲区弹出“has”，然后推送到堆栈，然后是“cracks”，然后是“in”，然后是“the”，然后是“ceiling”。
5. 重复四次：弹出 2 个堆栈值，应用于 Rece，然后推送结果。
6. 从缓冲区弹出“.”，然后推送到堆栈上层。
7. 重复两次：弹出 2 个堆栈值，应用于 Rece，然后推送结果。
8. 弹出剩余的堆栈值，并将其作为句子编码返回。
我还想保留句子的语境，以便在对句子的后半部分应用 Rece 层时考虑系统已经读取的句子部分的信息。所以我将用一个三参数函数替换双参数的 Rece 函数，该函数的输入值为一个左子句、一个右子句和当前句的上下文状态。该状态由神经网络的第二层（称为循环跟踪器（Tracker）的单元）创建。Tracker 在给定当前句子上下文状态、缓冲区中的顶部条目 b 和堆栈中前两个条目 s1\s2 时，在堆栈操作的每个步骤（即，读取每个单词或闭括号）后生成一个新状态：
context[t+1] = Tracker(context[t], b, s1, s2)
容易设想用你最喜欢的编程语言来编写代码做这些事情。对于要处理的每个句子，它将从缓冲区加载下一个单词，运行跟踪器，检查是否将单词推送入堆栈或执行 Rece 函数，执行该操作；然后重复，直到对整个句子完成处理。通过对单个句子的应用，该过程构成了一个大而复杂的深度神经网络，通过堆栈操作的方式一遍又一遍地应用它的两个可训练层。但是，如果你熟悉 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, ring 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.ShiftReceField()
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 编码器包含参数化的 Rece 层和可选的循环跟踪器来跟踪句子上下文，以便在每次网络读取单词或应用 Rece 时更新隐藏状态；以下代码代表的是，创建一个 SPINN 只是意味着创建这两个子模块（我们将很快看到它们的代码），并将它们放在一个容器中以供稍后使用。
import torchfrom torch import nn
# subclass the Mole class from PyTorch’s neural network package
class SPINN(nn.Mole):
def __init__(self, config):
super(SPINN, self).__init__()
self.config = config self.rece = Rece(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”和“rece”操作集合进行迭代，运行 Tracker（如果存在），并遍历批处理中的每个样本来应用“shift”操作（如果请求），或将其添加到需要“rece”操作的样本列表中。然后在该列表中的所有样本上运行 Rece 层，并将结果推送回到它们各自的堆栈。
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 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:
reced = iter(self.rece(lefts, rights, trackings))
for transition, stack in zip(trans_batch, stacks):
if transition == REDUCE:
stack.append(next(reced))
return [stack.pop() for stack in stacks]
在调用 self.tracker 或 self.rece 时分别运行 Tracker 或 Rece 子模块的向前方法，该方法需要在样本列表上应用前向操作。在主函数的向前方法中，在不同的样本上进行独立的操作是有意义的，即为批处理中每个样本提供分离的缓冲区和堆栈，因为所有受益于批处理执行的重度使用数学和需要 GPU 加速的操作都在 Tracker 和 Rece 中进行。为了更干净地编写这些函数，我将使用一些 helper（稍后将定义）将这些样本列表转化成批处理张量（tensor），反之亦然。
我希望 Rece 模块自动批处理其参数以加速计算，然后解批处理（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)。
❾ 对于Python的学习人员需要掌握哪些技术
1. 网络编程。网络编程在生活和开发中无处不在，哪里有通讯就有网络，它可以称为是一切开发的“基石”。对于所有编程开发人员必须要知其然并知其所以然，所以网络部分将从协议、封包、解包等底层进行深入剖析。
2. 爬虫开发。将网络一切数据作为资源，通过自动化程序进行有针对性的数据采集以及处理。爬虫开发项目包含跨越防爬虫策略、高性能异步IO、分布式爬虫等，并针对Scrapy框架源码进行深入剖析，从而理解其原理并实现自定义爬虫框架。
3.Web开发。Web开发包含前端以及后端两大部分，前端部分，带你从“黑白”到“彩色”世界，手把手开发动态网页;后端部分，带你从10行代码开始到n万行来实现并使用自己的微型Web框架，框架讲解中涵盖了数据、组件、安全等多领域的知识，从底层了解其工作原理并可驾驭任何业内主流的Web框架。
4. IT自动化开发。IT运维自动化是一组将静态的设备结构转化为根据IT服务需求动态弹性响应的策略，目的就是实现减少人工干预、降低人员成本以及出错概率，真刀真枪的带你开发企业中最常用的项目，从设计层面、框架选择、灵活性、扩展性、故障处理、以及如何优化等多个层面接触真实的且来源于各大互联网公司真实案例，如：堡垒机、CMDB、全网监控、主机管理等。
5. 金融分析。金融分析包含金融知识和Python相关模块的学习，手把手带你从金融小白到开发量化交易策略的大拿。学习内容囊括Numpy\Pandas\Scipy数据分析模块等，以及常见金融分析策略如“双均线”、“周规则交易”、“羊驼策略”、“Dual Thrust 交易策略”等，让梦想照进现实，进入金融行业不再是个梦。
6. 人工智能+机器学习。人工智能时代来临，率先引入深度机器学习课程。其中包含机器学习的基础概念以及常用知识，如：分类、聚类、回归、神经网络以及常用类库，并根据身边事件作为案例，一步一步经过预处理、建模、训练以及评估和参调等。
❿ Python在大数据方向的作用除了人工智能与机器学习还有
你可以这样理解，人工智能是一个婴儿的大脑，而深度学习就是让这个婴儿的大脑又能力看世界、听世界、感受世界。直观的说，深度学习只是服务于人工智能一个工具（也许若干年后，一种全新的工具可以代替深度学习实现人工智能），把这个工具用在语音识别领域，就能让机器更会听；把他用在了计算机视觉领域，就能让机器更会看。深度学习的本质就是各种神经网络，从最早最简单的感知机，再到多层神经网络，再到现在很火的CNN、RNN，其目的都是构建一个合适的神经网络结构，让机器有能力“自己思考”——我们也称之为“智能”。关于机器学习，它是比深度学习更为广泛的概念，发展的也比较早。在人工智能届有一种说法：认为机器学习是人工智能领域中最能够体现智能的一个分支。从历史上看，机器学习似乎也是人工智能中发展最快的分支之一。机器学习发展早期，限于计算机计算能力、样本量等因素，很多算法无法实现。而近些年来，计算机的计算能力和存储能力都有了很大的提高，数据发掘引领了大数据时代的到来，使得原来复杂度很高的算法能够实现，得到的结果也更为精细。理论上，只要计算机计算能力足够强、样本数据量足够大，就可以不断增加神经网络的层数以及改变神经网络的结构，这就是“深度学习”，在理论和技术上，并没有太多的创新。只是深度学习代表了机器学习的新方向，同时也推动了机器学习的发展。