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。