LSTM循环神经网络/长短时记忆

Long short-term memory

LSTM中的重复模块四个交互的层

1. 绿色的单元可以理解为tensorflow里的基本单元。每个cell底下Xt-1，Xt，Xt+1表示这是一个序列的数据，在每个时间点上都会有一个输入，如果这个问题对应到文本当中可能的xt对应的就是word，如果是对一个用户的行为序列去建模，那么这个Xt对应的就是每个用户的一个行为。RNN算法结构其实就是是一套时序神经网络网络。
2. 图中使用的各种元素的图标:
在上面的图例中，每一条黑线传输着一整个向量，从一个节点的输出到其他节点的输入。粉色的圈代表 pointwise 的操作，诸如向量的和，而黄色的矩阵就是学习到的神经网络层。合在一起的线表示向量的连接，分开的线表示内容被复制，然后分发到不同的位置。

3.LSTM 的核心思想
列表1LSTM中的重复模块四个交互的层,LSTM 的关键就是细胞状态，水平线在图上方贯穿运行。细胞状态类似于传送带。直接在整个链上运行，只有一些少量的线性交互。信息在上面流传保持不变会很容易

原博文地址

用RNN去解决LSTM中手写数字识别

1. 有序列表1数据维度target维度，定义全局参数/超参数

   import numpy as np
   import tensorflow as tf
   from tensorflow.examples.tutorials.mnist import input_data
   from tensorflow.contrib import rnn
   
   mnist = input_data.read_data_sets('data/mnist', one_hot=True)
   
   mnist.train.images.shape
   mnist.train.labels.shape
   
   learning_rate = 0.001
   training_iters = 100000
   batch_size = 128
   display_step = 10

2. 网络参数/超参数MNIST数据输入(shape: 28*28)RNN时序网络和卷积网络，全连接网络是不一样的，循环神经网络是一个时序网络 rnn是一个时序网络，如果做图像识别他是一组一组数据去读的。timesteps总共看28组。每一组有28个像素点。一整副图是份28步去看的，之所取28是因为方便整除。LSTM是把数据拆分若干个时间步骤去看。

   n_input = 28
   n_steps = 28
   n_hidden = 128
   n_classes = 10

3. 准备好placeholdern_steps乘以 n_input 类别数是n_classes

   x = tf.placeholder("float", [None, n_steps, n_input], name='X_placeholder')
   y = tf.placeholder("float", [None, n_classes], name='Y_placeholder')

4. 准备好权重/变量也就是W和B

   weights = {'out': tf.Variable(tf.random_normal([n_hidden, n_classes]), name='Weight')}
   biases = {'out': tf.Variable(tf.random_normal([n_classes]), name='bias')}

5. weights就是权重 biases就是偏执项，为了适应RNN，把原始的输入调整成’n_steps’个(batch_size, n_input)的tensors tensors就是Xt，Xt+1 ，Xt-1。定义一个lstm cell。rnn.static_rnn获取输出我们只取RNN的最后一个输出 outputs去和W相乘

   def RNN(x, weights, biases):
       x = tf.unstack(x, n_steps, 1)
       lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
       outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)
       return tf.matmul(outputs[-1], weights['out']) + biases['out']
   

6. 计算损失函数，初始化全部变量

   pred = RNN(x, weights, biases)
   cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y), name='loss')
   optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
   init = tf.global_variables_initializer()

7. 在session中执行graph定义的网络运算，小于指定的总迭代轮数的情况下，一直训练。对数据形状调整，编程28个28元素的序列。用optimizer进行优化。计算batch上的准确率，计算batch上的loss。

   with tf.Session() as sess:
       sess.run(init)
       writer = tf.summary.FileWriter('./graphs/LSTM_MNIST', sess.graph)
       step = 1
       while step * batch_size < training_iters:
           batch_x, batch_y = mnist.train.next_batch(batch_size)
           batch_x = batch_x.reshape((batch_size, n_steps, n_input))
           sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
           if step % display_step == 0:
               acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
               loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
               print("Iter " + str(step * batch_size) + ", Minibatch Loss= " + \
                     "{:.6f}".format(loss) + ", Training Accuracy= " + \
                     "{:.5f}".format(acc))
           step += 1
       print("Optimization Finished!")
       writer.close()
   
       test_len = 128
       test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
       test_label = mnist.test.labels[:test_len]
       print("Testing Accuracy:", \
             sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

   运行结果