本文用到的公式基本來自Alex的論文，其中a表示彙集計算的值，b表示經過啟用函式計算的值，w是不同節點之間連線的引數（具體睡誰連誰看下標），帶下標k的是輸出層，帶下標h的是隱藏層相關的，除此之外你看到所有帶括號的的函式都是啟用函式， ϵ 和 δ 的定義看公式，L 是最後的Loss function，這裡沒有給出具體的計算方法，因為這和NN是一樣的，可以看到輸出層和普通的NN是完全一樣的，接收隱藏層傳入的資料並乘以引數求和，只是每一個計算出來的值都有個時間上標t，表示它是t時刻的那個節點。

而隱藏層的計算就是和NN不同的地方，從之前的拓撲圖也看到了，隱藏層會接受來自上一時間隱藏層傳入的資料，在公式裡也體現出來了：第一個求和是和NN一致的，接收來自輸入層的資料，第二個是接收來自上一隱藏層的資料。

參考連結：https://blog.csdn.net/Dark_Scope/article/details/47056361

LSTM（Long-Short Term Memory）

原生的RNN會遇到一個很大的問題，叫做 The vanishing gradient problem for RNNs，也就是後面時間的節點對於前面時間的節點感知力下降，也就是忘事兒，這也是NN在很長一段時間內不得志的原因，網路一深就沒法訓練了，深度學習那一套東西暫且不表，RNN解決這個問題用到的就叫LSTM，簡單來說就是你不是忘事兒嗎？我給你拿個小本子把事記上，好記性不如爛筆頭嘛，所以LSTM引入一個核心元素就是Cell。

怎麼這麼複雜……不要怕，下文慢慢幫你縷清楚。理解LSTM最方便的就是結合上面這個圖，先簡單介紹下里面有幾個東西：

1. Cell，就是我們的小本子，有個叫做state的引數東西來記事兒的
2. Input Gate，Output Gate，在引數輸入輸出的時候起點作用，算一算東西
3. Forget Gate：不是要記東西嗎，咋還要Forget呢。這個沒找到為啥就要加入這樣一個東西，因為原始的LSTM在這個位置就是一個值1，是連線到下一時間的那個引數，估計是以前的事情記太牢了，最近的記不住就不好了，所以要選擇性遺忘一些東西。（沒找到解釋設定這個東西的動機，還望指正）

在閱讀下面公式說明的時候時刻記得這個block上面有一個輸出節點，下面有一個輸入節點，block只是中間的隱層小圓圈

參考連結：

1. 常用類https://blog.csdn.net/u010089444/article/details/60963053

class tf.contrib.rnn.BasicLSTMCell

BasicLSTMCell 是最簡單的一個LSTM類，沒有實現clipping，projection layer，peep-hole等一些LSTM的高階變種，僅作為一個基本的basicline結構存在，如果要使用這些高階變種，需用class tf.contrib.rnn.LSTMCell這個類。

使用方式：

lstm = rnn.BasicLSTMCell(lstm_size, forget_bias=1.0, state_is_tuple=True)

• 1

Args:

• num_units: int, The number of units in the LSTM cell.

• forget_bias: float, The bias added to forget gates.

• state_is_tuple: If True, accepted and returned states are 2-tuples of the c_state and m_state. If False, they are concatenated along the column axis. The latter behavior will soon be deprecated.

• activation: Activation function of the inner states.

說明：

• num_units 是指一個Cell中神經元的個數，並不是迴圈層的Cell個數。這裡有人可能會疑問：迴圈層的Cell數目怎麼表示？答案是通過如下程式碼中的 time_step_size確定（X_split 中劃分出的arrays數量為迴圈層的Cell個數）：

    X_split = tf.split(XR, time_step_size, 0)

• 1

• 在任意時刻 t ，LSTM Cell會產生兩個內部狀態 ct和ht （關於RNN與LSTM的介紹可參考：迴圈神經網路與LSTM）。當state_is_tuple=True時，上面講到的狀態ct和ht 就是分開記錄，放在一個二元tuple中返回，如果這個引數沒有設定或設定成False，兩個狀態就按列連線起來返回。官方說這種形式馬上就要被deprecated了，所有我們在使用LSTM的時候要加上state_is_tuple=True。

class tf.contrib.rnn.DropoutWrapper

RNN中的dropout和cnn不同，在RNN中，時間序列方向不進行dropout，也就是說從t-1時刻的狀態傳遞到t時刻進行計算時，這個中間不進行memory的dropout；如下圖所示，Dropout僅應用於虛線方向的輸入，即僅針對於上一層的輸出做Dropout。

lstm = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=keep_prob)

• 1

Args:

• cell: an RNNCell, a projection to output_size is added to it.

• input_keep_prob: unit Tensor or float between 0 and 1, input keep probability; if it is float and 1, no input dropout will be added.

• output_keep_prob: unit Tensor or float between 0 and 1, output keep probability; if it is float and 1, no output dropout will be added.

• seed: (optional) integer, the randomness seed.

class tf.contrib.rnn.MultiRNNCell

如果希望整個網路的層數更多（例如上圖表示一個兩層的RNN，第一層Cell的output還要作為下一層Cell的輸入），應該堆疊多個LSTM Cell，tensorflow給我們提供了MultiRNNCell，因此堆疊多層網路只生成這個類即可：

lstm = tf.nn.rnn_cell.MultiRNNCell([lstm] * num_layers, state_is_tuple=True)

• 1

2. 程式碼

MNIST資料集的格式與資料預處理程式碼 input_data.py的講解請參考 :Tutorial (2)

# -*- coding: utf-8 -*-
import tensorflow as tf
from tensorflow.contrib import rnn

import numpy as np
import input_data

# configuration
#                        O * W + b -> 10 labels for each image, O[? 28], W[28 10], B[10]
#                       ^ (O: output 28 vec from 28 vec input)
#                       |
#      +-+  +-+       +--+
#      |1|->|2|-> ... |28| time_step_size = 28
#      +-+  +-+       +--+
#       ^    ^    ...  ^
#       |    |         |
# img1:[28] [28]  ... [28]
# img2:[28] [28]  ... [28]
# img3:[28] [28]  ... [28]
# ...
# img128 or img256 (batch_size or test_size 256)
#      each input size = input_vec_size=lstm_size=28

# configuration variables
input_vec_size = lstm_size = 28 # 輸入向量的維度
time_step_size = 28 # 迴圈層長度

batch_size = 128
test_size = 256

def init_weights(shape):
    return tf.Variable(tf.random_normal(shape, stddev=0.01))


def model(X, W, B, lstm_size):
    # X, input shape: (batch_size, time_step_size, input_vec_size)
    # XT shape: (time_step_size, batch_size, input_vec_size)
    XT = tf.transpose(X, [1, 0, 2])  # permute time_step_size and batch_size,[28, 128, 28]

    # XR shape: (time_step_size * batch_size, input_vec_size)
    XR = tf.reshape(XT, [-1, lstm_size]) # each row has input for each lstm cell (lstm_size=input_vec_size)

    # Each array shape: (batch_size, input_vec_size)
    X_split = tf.split(XR, time_step_size, 0) # split them to time_step_size (28 arrays),shape = [(128, 28),(128, 28)...]


    # Make lstm with lstm_size (each input vector size). num_units=lstm_size; forget_bias=1.0
    lstm = rnn.BasicLSTMCell(lstm_size, forget_bias=1.0, state_is_tuple=True)

    # Get lstm cell output, time_step_size (28) arrays with lstm_size output: (batch_size, lstm_size)
    # rnn..static_rnn()的輸出對應於每一個timestep，如果只關心最後一步的輸出，取outputs[-1]即可
    outputs, _states = rnn.static_rnn(lstm, X_split, dtype=tf.float32)  # 時間序列上每個Cell的輸出:[... shape=(128, 28)..]

    # Linear activation
    # Get the last output
    return tf.matmul(outputs[-1], W) + B, lstm.state_size # State size to initialize the stat

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 讀取資料

# mnist.train.images是一個55000 * 784維的矩陣, mnist.train.labels是一個55000 * 10維的矩陣
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

# 將每張圖用一個28x28的矩陣表示,(55000,28,28,1)
trX = trX.reshape(-1, 28, 28) 
teX = teX.reshape(-1, 28, 28) 

X = tf.placeholder("float", [None, 28, 28])
Y = tf.placeholder("float", [None, 10])

# get lstm_size and output 10 labels
W = init_weights([lstm_size, 10])  # 輸出層權重矩陣28×10
B = init_weights([10])  # 輸出層bais

py_x, state_size = model(X, W, B, lstm_size)

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y))
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(py_x, 1)

session_conf = tf.ConfigProto()
session_conf.gpu_options.allow_growth = True

# Launch the graph in a session
with tf.Session(config=session_conf) as sess:
    # you need to initialize all variables
    tf.global_variables_initializer().run()

    for i in range(100):
        for start, end in zip(range(0, len(trX), batch_size), range(batch_size, len(trX)+1, batch_size)):
            sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end]})

        test_indices = np.arange(len(teX))  # Get A Test Batch
        np.random.shuffle(test_indices)
        test_indices = test_indices[0:test_size]

        print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
                         sess.run(predict_op, feed_dict={X: teX[test_indices]})))