标签: lstm

当StanfordNLP的TreeLSTM与具有> 30K实例的数据集一起使用时,会导致LuaJit错误地显示"Not Enough Memory".我正在使用LuaJit Data Structures解决这个问题.为了将数据集放在lua堆之外,需要将树放在LDS.Vector中.

由于LDS.Vector包含cdata,第一步是将Tree类型转换为cdata对象:

local ffi = require('ffi')

ffi.cdef([[
typedef struct CTree {
   struct CTree* parent;
   int num_children;
   struct CTree* children [25];
   int idx;
   int gold_label;
   int leaf_idx;
} CTree;
]])

在read_data.lua中还需要进行一些小的更改来处理新的cdata CTree类型.到目前为止,使用LDS似乎是解决内存限制的合理方法; 但是,CTree需要一个名为"composer"的字段.

Composer的类型为nn.gModule.继续使用此解决方案将涉及将nn.gModule的typedef创建为cdata,包括为其成员创建typedef.在继续之前,这似乎是正确的方向吗？有没有人遇到过这个问题？

我正在使用一个大数据集,所以我试图使用train_on_batch(或适合epoch = 1)

model = Sequential()
model.add(LSTM(size,input_shape=input_shape,return_sequences=False))
model.add(Dense(output_dim))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=["accuracy"])

for e in range(nb_epoch):
    for batch_X, batch_y in batches:
        model.train_on_batch(batch_X,batch_y)
        # or
        # model.fit(batch_X,batch_y,batch_size=batch_size,nb_epoch=1,verbose=1,shuffle=True,)

但是当训练开始时,会发生这种情况

(0, 128)
Epoch 1/1
128/128 [==============================] - 2s - loss: 0.3262 - acc: 0.1130

(129, 257)
Epoch 1/1
128/128 [==============================] - 2s - loss: -0.0000e+00 - acc: 0.0000e+00

无论我等了多少个时代,它都没有改变.即使我改变批量大小,也会发生同样的事情:第一批具有良好的值,然后它再次进入"损失:-0.0000e + 00 - acc:0.0000e + 00".

有人可以帮助理解这里发生的事情吗？

提前致谢

我正在运行单词RNN的张量流的RNN实现

如何计算RNN的困惑度.

以下是培训中的代码,显示每个时期的培训损失和其他事项:

for e in range(model.epoch_pointer.eval(), args.num_epochs):
        sess.run(tf.assign(model.lr, args.learning_rate * (args.decay_rate ** e)))
        data_loader.reset_batch_pointer()
        state = sess.run(model.initial_state)
        speed = 0
        if args.init_from is None:
            assign_op = model.batch_pointer.assign(0)
            sess.run(assign_op)
            assign_op = model.epoch_pointer.assign(e)
            sess.run(assign_op)
        if args.init_from is not None:
            data_loader.pointer = model.batch_pointer.eval()
            args.init_from = None
        for b in range(data_loader.pointer, data_loader.num_batches):
            start = time.time()
            x, y = data_loader.next_batch()
            feed = {model.input_data: x, model.targets: y, model.initial_state: state,
                    model.batch_time: speed}
            summary, train_loss, state, _, _ = sess.run([merged, model.cost, model.final_state,
                                                         model.train_op, model.inc_batch_pointer_op], feed)
            train_writer.add_summary(summary, …

• 如何明确并tensorflow申请退学调用tf.nn.rnn_cell.DropoutWrapper()的时候？

我读到的关于将退出应用于rnn的所有内容都参考了Zaremba等人的论文.al表示不在经常性连接之间应用辍学.应在LSTM层之前或之后随机丢弃神经元,而不是LSTM间层.好.

• 我的问题是神经元是如何关闭时间的？

在每个人都引用的论文中,似乎在每个时间步长应用一个随机的"丢失掩码",而不是生成一个随机的"丢失掩码"并重新使用它,将它应用于丢弃的给定层中的所有时间步长.然后在下一批产生一个新的"辍学掩码".

此外,可能更重要的是,tensorflow是如何做到的？我已经检查了tensorflow api,并试图寻找详细的解释,但还没有找到一个.

• 有没有办法深入研究实际的tensorflow源代码？

我想知道如何在Keras中实现具有批量标准化(BN)的biLSTM.我知道BN层应该在线性和非线性之间,即激活.使用CNN或Dense图层很容易实现.但是,如何用biLSTM做到这一点？

提前致谢.

我最近发现LayerNormBasicLSTMCell是LSTM的一个版本,它实现了Layer Normalization和dropout.因此,我使用LSTMCell替换了我的原始代码和LayerNormBasicLSTMCell.这种变化不仅将测试精度从~96%降低到~92%,而且需要更长的时间(~33小时)进行训练(原始训练时间约为6小时).所有参数都相同:历元数(10),堆叠层数(3),隐藏矢量大小数(250),丢失保持概率(0.5),......硬件也相同.

我的问题是:我在这里做错了什么？

我原来的模型(使用LSTMCell):

# Batch normalization of the raw input
tf_b_VCCs_AMs_BN1 = tf.layers.batch_normalization(
    tf_b_VCCs_AMs, # the input vector, size [#batches, #time_steps, 2]
    axis=-1, # axis that should be normalized 
    training=Flg_training, # Flg_training = True during training, and False during test
    trainable=True,
    name="Inputs_BN"
    )

# Bidirectional dynamic stacked LSTM

##### The part I changed in the new model (start) #####
dropcells = []
for iiLyr in range(3):
    cell_iiLyr = tf.nn.rnn_cell.LSTMCell(num_units=250, state_is_tuple=True)
    dropcells.append(tf.nn.rnn_cell.DropoutWrapper(cell=cell_iiLyr, output_keep_prob=0.5))
##### The part I changed in the …

我已经将一系列图像读入一个具有形状的numpy数组,(7338, 225, 1024, 3)其中7338是样本大小,225是时间步长,1024 (32x32)是3通道(RGB)中的平坦图像像素.

我有一个带LSTM层的顺序模型:

model = Sequential()
model.add(LSTM(128, input_shape=(225, 1024, 3))

但这会导致错误:

Input 0 is incompatible with layer lstm_1: expected ndim=3, found ndim=4

该文件提到,对于LSTM层输入张量应该是3D tensor with shape (batch_size, timesteps, input_dim),但对我来说我input_dim是2D的.

在Keras中将3通道图像输入LSTM层的建议方法是什么？

我有一个包含整年数据的时间序列数据集(日期是索引).每15分钟(全年)测量数据,这导致每天96个步骤.数据已经标准化.变量是相关的.除VAR之外的所有变量都是天气测量.

VAR在一天和一周内是季节性的(因为它在周末看起来有点不同,但每个周末更不一样).VAR值是固定的.我想预测接下来两天(前面192步)和未来七天(未来672步)的VAR值.

以下是数据集的示例:

DateIdx               VAR       dewpt       hum         press       temp
2017-04-17 00:00:00   0.369397  0.155039    0.386792    0.196721    0.238889
2017-04-17 00:15:00   0.363214  0.147287    0.429245    0.196721    0.233333
2017-04-17 00:30:00   0.357032  0.139535    0.471698    0.196721    0.227778
2017-04-17 00:45:00   0.323029  0.127907    0.429245    0.204918    0.219444
2017-04-17 01:00:00   0.347759  0.116279    0.386792    0.213115    0.211111
2017-04-17 01:15:00   0.346213  0.127907    0.476415    0.204918    0.169444
2017-04-17 01:30:00   0.259660  0.139535    0.566038    0.196721    0.127778
2017-04-17 01:45:00   0.205564  0.073643    0.523585    0.172131    0.091667
2017-04-17 02:00:00   0.157650  0.007752    0.481132    0.147541    0.055556
2017-04-17 02:15:00   0.122101  0.003876    0.476415    0.122951    0.091667

输入数据集图 …

在我原来的环境中

X1 = (1200,40,1)
y1 = (1200,10)

然后，我可以完美地使用我的代码：

model = Sequential()
model.add(LSTM(12, input_shape=(40, 1), return_sequences=True))
model.add(LSTM(12, return_sequences=True))
model.add(LSTM(6, return_sequences=False))
model.add((Dense(10)))

现在，我进一步获得了另一个与X1和相同大小的时间序列数据y1。即

X2 = (1200,40,1)
y2 = (1200,10)

现在，我叠X1，X2并且y1，y2作为3D阵列：

X_stack = (1200,40,2)
y_stack = (1200,10,2)

然后，我尝试修改我的keras代码，例如：

model = Sequential()
model.add(LSTM(12, input_shape=(40, 2), return_sequences=True))
model.add(LSTM(12, return_sequences=True))
model.add(LSTM(6, return_sequences=False))
model.add((Dense((10,2))))

我希望我的代码直接与3D数组一起使用X_stack，y_stack而不希望将其重塑为2D数组。您能帮我修改设置吗？谢谢。

这似乎是 PyTorch 中 LSTM 最常见的问题之一，但我仍然无法弄清楚 PyTorch LSTM 的输入形状应该是什么。

即使遵循了几个帖子（1、2、3）并尝试了解决方案，它似乎也不起作用。

背景：我已经对一批大小为 12 的文本序列（可变长度）进行了编码，并且使用pad_packed_sequence功能对序列进行了填充和打包。MAX_LEN对于每个序列是 384，序列中的每个标记（或单词）的维度为 768。因此，我的批处理张量可能具有以下形状之一：[12, 384, 768]或[384, 12, 768]。

该批次将是我对 PyTorch rnn 模块（此处为 lstm）的输入。

根据用于PyTorch文档LSTMs，其输入尺寸是(seq_len, batch, input_size)我的理解如下。
seq_len- 每个输入流中的时间步数（特征向量长度）。
batch- 每批输入序列的大小。
input_size- 每个输入标记或时间步长的维度。

lstm = nn.LSTM(input_size=?, hidden_size=?, batch_first=True)

这里的确切值input_size和hidden_size值应该是什么？