rnn算法

① rnn/lstm具备怎样的特征提取能力

语言模型主要分为规则模型和统计模型两种。统计语言模型是用概率统计的方法来揭示语言单位内在的统计规律，其中N-Gram简单有效，被广泛使用。N-Gram：该模型基于这样一种假设，第n个词的出现只与前面N-1个词相关，而与其它任何词都不相关，整句的概率就是各个词出现概率的乘积。这些概率可以通过直接从语料中统计N个词同时出现的次数得到。常用的是二元的Bi-Gram和三元的Tri-Gram。语言模型的性能通常用交叉熵和复杂度（Perplexity）来衡量。交叉熵的意义是用该模型对文本识别的难度，或者从压缩的角度来看，每个词平均要用几个位来编码。复杂度的意义是用该模型表示这一文本平均的分支数，其倒数可视为每个词的平均概率。平滑是指对没观察到的N元组合赋予一个概率值，以保证词序列总能通过语言模型得到一个概率值。通常使用的平滑技术有图灵估计、删除插值平滑、Katz平滑和Kneser-Ney平滑。

② spark mllib 有rnn算法吗

think in java肯定是必看的 其他的书不建议看.... 不过纯新手建议去看视频 不要看书 尤其是think in java只会打击你的积极性

③ 为什么说Transformer的注意力机制是相对廉价的注意力机制相对更对于RNN系列及CNN系列算法有何优势

基于注意力机制的构造与基于RNN的不同,基于RNN的是在时间步上串联(在每个time step只能输入一个token),而基于注意力机制的是类似于桶状结构(一起将数据输入到模型中去)

④ 递归神经网络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直到稳定即可。

⑤ LSTM与RNN之间存在什么关系

很高兴认为我们之间存在的联系是通过VP s来连接的，它们是相对相辅相成的。

⑥ 谁有RNN凝聚聚类的matlab算法，能直接用的

华人提供发布会功夫突然霍比特人

⑦ 为什么相比于RNN，LSTM在梯度消失上表现更好

在向量微积分中，标量场的梯度是一个向量场。标量场中某一点上的梯度指向标量场增长最快的方向，梯度的长度是这个最大的变化率。更严格的说，从欧几里得空间Rn到R的函数的梯度是在Rn某一点最佳的线性近似。在这个意义上，梯度是雅可比矩阵的一个特殊情况。

⑧ 有哪些LSTM和RNN网络的教

LSTM的三个门输出数字和向量的情况都有。门（input，forget，output）输出的维度和cell状态的维度一致即可。也就是说三个门的输出分别控制被控制向量（cell input，cell（t-1），cell（t））中的元素。举个例子，如果cell状态的维度是1，那么被控制向量（cell input，cell（t-1），cell（t））的维度也都是1，那么三个门的输出都是0-1之间的数字（选用sigmoid激活函数）；如果cell状态的维度是N，那么被控制向量（cell input，cell（t-1），cell（t））的维度也分别都是N，那么三个门的输出都是0-1之间的向量（选用sigmoid激活函数），且门输出向量的维度都是N。