通过字符序列预测的 Tensorflow LSTM 字符

Question

我正在尝试使用 Tensorflow 复制优秀文章 http://karpathy.github.io/2015/05/21/rnn-effectiveness/ 中演示的字符级语言建模。

到目前为止我的尝试都失败了。我的网络通常在处理 800 个左右的字符后输出一个字符。我相信我从根本上误解了张量流实现 LSTM 的方式，也许还有一般的 rnn。我发现文档很难理解。

这是我的代码的本质：

图形定义

idata = tf.placeholder(tf.int32,[None,1])   #input byte, use value 256 for start and end of file
odata = tf.placeholder(tf.int32,[None,1])    #target output byte, ie, next byte in sequence..
source =  tf.to_float(tf.one_hot(idata,257)) #input byte as 1-hot float
target = tf.to_float(tf.one_hot(odata,257))  #target output as 1-hot float

with tf.variable_scope("lstm01"):
    cell1 = tf.nn.rnn_cell.BasicLSTMCell(257)
    val1, state1 = tf.nn.dynamic_rnn(cell1, source, dtype=tf.float32)

output = val1

损失计算

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, target))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)  
output_am = tf.argmax(output,2)
target_am = tf.argmax(target,2)
correct_prediction = tf.equal(output_am, target_am)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

培训

for i in range(0, source_data.size-1, batch_size):
    start = i
    stop = i + batch_size
    i_data = source_data[start:stop].reshape([-1,1])
    o_data = source_data[start+1:stop+1].reshape([-1,1])

    train_step.run(feed_dict={idata: i_data, odata: o_data})

    if i%(report_interval*batch_size) == 0:
        batch_out, fa = sess.run([output_am, accuracy], feed_dict={idata: i_data, odata: o_data, keep_prob: 1.0})

        print("step %d, training accuracy %s"%(i, str(fa)))
        print("i_data sample: %s"%str(squeeze(i_data)))
        print("o_data sample: %s"%str(squeeze(o_data)))
        print("batch sample: %s"%str(squeeze(batch_out)))

输出，使用1MB莎士比亚文件训练

step 0, training accuracy 0.0
i_data sample: [ 256.   70.  105.  114.  115.  116.   32.   67.  105.  116.]
o_data sample: [  70.  105.  114.  115.  116.   32.   67.  105.  116.  105.]
batch sample: [254  18 151  64  51 199  83 174 151 199]

step 400, training accuracy 0.2
i_data sample: [  32.   98.  101.   32.  100.  111.  110.  101.   58.   32.]
o_data sample: [  98.  101.   32.  100.  111.  110.  101.   58.   32.   97.]
batch sample: [ 32 101  32  32  32  32  10  32 101  32]

step 800, training accuracy 0.0
i_data sample: [ 112.   97.  114.  116.  105.   99.  117.  108.   97.  114.]
o_data sample: [  97.  114.  116.  105.   99.  117.  108.   97.  114.  105.]
batch sample: [101 101 101  32 101 101  32 101 101 101]

step 1200, training accuracy 0.1
i_data sample: [  63.   10.   10.   70.  105.  114.  115.  116.   32.   67.]
o_data sample: [  10.   10.   70.  105.  114.  115.  116.   32.   67.  105.]
batch sample: [ 32  32  32 101  32  32  32  32  32  32]

step 1600, training accuracy 0.2
i_data sample: [  32.  116.  105.  108.  108.   32.  116.  104.  101.   32.]
o_data sample: [ 116.  105.  108.  108.   32.  116.  104.  101.   32.   97.]
batch sample: [32 32 32 32 32 32 32 32 32 32]

这显然是不正确的。

我想我对 'batches' 和 'sequences' 之间的区别感到困惑，以及我所说的 'batches' 之间是否保留了 LSTM 的状态（即，子序列）

我得到的印象是我使用 'batches' 长度为 1 的序列训练它，并且在每批之间，状态数据被丢弃。因此，它只是找到最常出现的符号。

任何人都可以证实这一点，或者以其他方式纠正我的错误，并给出一些指示，说明我应该如何使用非常长的训练序列来完成一个字符一个字符的预测任务吗？

非常感谢。

Answer 1

因此您的 idata 的形状应为：[batch_size, maximum_sequence_length, 257]。（如果不是批次中的所有序列都具有相同的长度，则需要根据需要进行填充，并且在计算损失时要小心，因为这仅在 non-padded 个值上完成。）

dynamic_rnn 会按时间逐步完成您的输入。所以，你只需要遍历批次。

因为，你的 idata 的第二个维度是 1 你是对的，你的有效序列长度是 1。

对于不是 character-based 但使用词嵌入的语言模型，请查看 this 教程。

其他说明：

如果您想在 LSTM 中试验不同数量的单元 - 考虑在输出顶部添加一个线性层以将每个输出（对于时间 t 的批次条目 i）向下投影到 257这是你的目标类的数量。
无需对目标进行 one-hot 编码。看看 sparse_softmax_cross_entropy。

通过字符序列预测的 Tensorflow LSTM 字符

Tensorflow LSTM character by character sequence prediction

sequences

lstm

tensorflow