我试图使用RNN(特别是LSTM)进行序列预测.但是,我遇到了可变序列长度的问题.例如,

sent_1 = "I am flying to Dubain"
sent_2 = "I was traveling from US to Dubai"

我正在尝试使用基于此Benchmark的简单RNN来预测当前的下一个词,以构建PTB LSTM模型.

但是,num_steps参数(用于展开到先前的隐藏状态)应该在每个Tensorflow的纪元中保持相同.基本上,由于句子的长度不同,因此无法批量处理句子.

 # inputs = [tf.squeeze(input_, [1])
 #           for input_ in tf.split(1, num_steps, inputs)]
 # outputs, states = rnn.rnn(cell, inputs, initial_state=self._initial_state)

在这里,num_steps每个句子都需要改变我的情况.我尝试了几次黑客攻击,但似乎没有任何效果.

我正在尝试使用Keras和Tensorflow后端使用LSTM实现序列到序列任务.输入是具有可变长度的英语句子.为了构建具有二维形状[batch_number,max_sentence_length]的数据集,我在行尾添加EOF并用足够的占位符填充每个句子,例如"#".然后将句子中的每个字符转换为单热矢量,现在数据集具有3-D形状[batch_number,max_sentence_length,character_number].在LSTM编码器和解码器层之后,计算输出和目标之间的softmax交叉熵.

为了消除模型训练中的填充效应,可以在输入和丢失功能上使用掩蔽.Keras中的掩码输入可以通过使用"layers.core.Masking"来完成.在Tensorflow中,可以按如下方式 屏蔽损失函数:Tensorflow中的自定义屏蔽损失函数

但是,我没有找到在Keras中实现它的方法,因为keras中使用定义的损失函数只接受参数y_true和y_pred.那么如何将真正的sequence_lengths输入到丢失函数和掩码？

此外,我在\ keras\engine\training.py中找到了一个函数"_weighted_masked_objective(fn)".它的定义是"为目标函数添加对屏蔽和样本加权的支持."但似乎该函数只能接受fn(y_true,y_pred).有没有办法使用这个函数来解决我的问题？

具体来说,我修改了余阳的例子.

from keras.models import Model
from keras.layers import Input, Masking, LSTM, Dense, RepeatVector, TimeDistributed, Activation
import numpy as np
from numpy.random import seed as random_seed
random_seed(123)

max_sentence_length = 5
character_number = 3 # valid character 'a, b' and placeholder '#'

input_tensor = Input(shape=(max_sentence_length, character_number))
masked_input = Masking(mask_value=0)(input_tensor)
encoder_output = LSTM(10, return_sequences=False)(masked_input)
repeat_output = RepeatVector(max_sentence_length)(encoder_output)
decoder_output = LSTM(10, return_sequences=True)(repeat_output)
output = Dense(3, activation='softmax')(decoder_output)

model = Model(input_tensor, output)
model.compile(loss='categorical_crossentropy', optimizer='adam')
model.summary()

X = np.array([[[0, 0, 0], …

我目前正在尝试构建一个用于预测时间序列的简单模型.目标是使用序列训练模型,以便模型能够预测未来值.

我正在使用tensorflow和lstm单元格来执行此操作.该模型通过时间截断反向传播进行训练.我的问题是如何构建培训数据.

例如,假设我们想要学习给定的序列:

[1,2,3,4,5,6,7,8,9,10,11,...]

我们将网络展开num_steps=4.

选项1

input data               label     
1,2,3,4                  2,3,4,5
5,6,7,8                  6,7,8,9
9,10,11,12               10,11,12,13
...

选项2

input data               label     
1,2,3,4                  2,3,4,5
2,3,4,5                  3,4,5,6
3,4,5,6                  4,5,6,7
...

选项3

input data               label     
1,2,3,4                  5
2,3,4,5                  6
3,4,5,6                  7
...

选项4

input data               label     
1,2,3,4                  5
5,6,7,8                  9
9,10,11,12               13
...

任何帮助,将不胜感激.

我正试图在TensorFlow中实现一个Siamese神经网络,但我无法在互联网上找到任何有用的例子(参见Yann LeCun论文).

我正在尝试构建的体系结构将包含两个共享权重的LSTM,并且仅在网络末端连接.

我的问题是:如何在TensorFlow中构建两个不同的神经网络共享其权重(绑定权重)以及如何在末尾连接它们？

谢谢 :)

编辑:我实现了一个连体网络的简单工作示例这里上MNIST.

LSTM/RNN可用于文本生成. 这显示了为Keras模型使用预先训练的GloVe字嵌入的方法.

1. 如何使用预先训练过的Word2Vec字嵌入与Keras LSTM模型？这篇文章确实有帮助.
2. 当模型被提供单词序列作为输入时,如何预测/生成下一个单词？

尝试了示例方法:

# Sample code to prepare word2vec word embeddings    
import gensim
documents = ["Human machine interface for lab abc computer applications",
             "A survey of user opinion of computer system response time",
             "The EPS user interface management system",
             "System and human system engineering testing of EPS",
             "Relation of user perceived response time to error measurement",
             "The generation of random binary unordered trees",
             "The intersection graph of paths in trees",
             "Graph minors …

几天来,我正在尝试使用LSTM构建一个简单的正弦波序列生成,到目前为止还没有任何成功的一瞥.

我从时间序列预测示例开始

我想要做的就是:

• 使用与LBFGS不同的优化器(例如RMSprob)
• 尝试不同的信号(更多的正弦波成分)

这是我的代码的链接."experiment.py"是主文件

我所做的是:

• 我生成人工时间序列数据(正弦波)
• 我将这些时间序列数据切割成小序列
• 我的模型的输入是时间序列0 ... T,输出是时间序列1 ... T + 1

会发生什么:

• 培训和验证损失平稳下降
• 测试损失非常低
• 但是,当我尝试从种子(测试数据中的随机序列)开始生成任意长度的序列时,一切都会出错.输出总是平坦的

我根本看不出问题所在.我现在正在玩这个星期一周,没有任何进展.我会非常感谢任何帮助.

谢谢

我一直试图通过https://www.tensorflow.org/tutorials/recurrent来了解示例代码 ,您可以在https://github.com/tensorflow/models/blob/master/tutorials/rnn/ptb找到它./ptb_word_lm.py

(使用tensorflow 1.3.0.)

我总结(我认为是)关键部分,对于我的问题,如下:

 size = 200
 vocab_size = 10000
 layers = 2
 # input_.input_data is a 2D tensor [batch_size, num_steps] of
 #    word ids, from 1 to 10000

 cell = tf.contrib.rnn.MultiRNNCell(
    [tf.contrib.rnn.BasicLSTMCell(size) for _ in range(2)]
    )

 embedding = tf.get_variable(
      "embedding", [vocab_size, size], dtype=tf.float32)
 inputs = tf.nn.embedding_lookup(embedding, input_.input_data)

inputs = tf.unstack(inputs, num=num_steps, axis=1)
outputs, state = tf.contrib.rnn.static_rnn(
    cell, inputs, initial_state=self._initial_state)

output = tf.reshape(tf.stack(axis=1, values=outputs), [-1, size])
softmax_w = tf.get_variable(
    "softmax_w", [size, vocab_size], dtype=data_type()) …

我需要澄清一下如何使用torch.nn模块的不同组件正确准备批量培训的输入.具体来说,我正在寻找为seq2seq模型创建编码器 - 解码器网络.

假设我有一个包含这三层的模块,按顺序:

1. nn.Embedding
2. nn.LSTM
3. nn.Linear

nn.Embedding

输入: batch_size * seq_length
输出: batch_size * seq_length * embedding_dimension

我在这里没有任何问题,我只想明确输入和输出的预期形状.

nn.LSTM

输入: seq_length * batch_size * input_size(embedding_dimension在这种情况下)
输出: seq_length * batch_size * hidden_size
last_hidden_​​state: batch_size * hidden_size
last_cell_state: batch_size * hidden_size

要使用Embedding图层的输出作为图层的输入LSTM,我需要转置轴1和2.

我在网上发现的许多例子都有类似的东西x = embeds.view(len(sentence), self.batch_size , -1),但这让我很困惑.该视图如何确保同一批次的元素保留在同一批次中？当尺寸len(sentence)和self.batch尺寸相同时会发生什么？

nn.Linear

输入: batch_size x input_size(在这种情况下LSTM的hidden_​​size或??)
输出: batch_size xoutput_size

如果我只需要last_hidden_state的LSTM话,我可以把它作为输入nn.Linear.

但是,如果我想利用输出(其中包含所有中间隐藏状态),那么我需要改变 …

这就是代码:

X = tf.placeholder(tf.float32, [batch_size, seq_len_1, 1], name='X')
labels = tf.placeholder(tf.float32, [None, alpha_size], name='labels')

rnn_cell = tf.contrib.rnn.BasicLSTMCell(512)
m_rnn_cell = tf.contrib.rnn.MultiRNNCell([rnn_cell] * 3, state_is_tuple=True)
pre_prediction, state = tf.nn.dynamic_rnn(m_rnn_cell, X, dtype=tf.float32)

这是完整的错误:

ValueError:尝试共享变量rnn/multi_rnn_cell/cell_0/basic_lstm_cell/kernel,但指定形状(1024,2048)并找到形状(513,2048).

我正在使用GPU版本的tensorflow.

我目前的LSTM网络看起来像这样.

rnn_cell = tf.contrib.rnn.BasicRNNCell(num_units=CELL_SIZE)
init_s = rnn_cell.zero_state(batch_size=1, dtype=tf.float32)  # very first hidden state
outputs, final_s = tf.nn.dynamic_rnn(
    rnn_cell,              # cell you have chosen
    tf_x,                  # input
    initial_state=init_s,  # the initial hidden state
    time_major=False,      # False: (batch, time step, input); True: (time step, batch, input)
)

# reshape 3D output to 2D for fully connected layer
outs2D = tf.reshape(outputs, [-1, CELL_SIZE])
net_outs2D = tf.layers.dense(outs2D, INPUT_SIZE)

# reshape back to 3D
outs = tf.reshape(net_outs2D, [-1, TIME_STEP, INPUT_SIZE])

通常,我申请tf.layers.batch_normalization批量标准化.但我不确定这是否适用于LSTM网络.

b1 = …