本文使用的tensorflow版本：1.4
tensorflow安裝：pip install tensorflow

1、循環神經網絡簡介

開始前，我們先回顧一下，簡單的MLP三層神經網絡模型：

基本神經網絡

循環神經網絡

循環神經網絡展開

2、數據集

為簡單起見，本篇就以簡單的二進制序列作為訓練數據，而不實現具體的論文仿真，主要目的是理解RNN的原理和如何在TensorFlow中構造一個簡單基礎的模型架構。
首先我們看一下實驗數據的構造：
輸入數據X：在時間t，Xt的值有50%的概率為1，50%的概率為0；
輸出數據Y：在實踐t，Yt的值有50%的概率為1，50%的概率為0，除此之外，如果Xt-3 == 1，Yt為1的概率增加50%， 如果Xt-8 == 1，則Yt為1的概率減少25%， 如果上述兩個條件同時滿足，則Yt為1的概率為75%。

如果RNN沒有學習到任何一條依賴，那么Yt為1的概率就是0.625（0.5+0.5*0.5-0.5*0.25），所以所獲得的交叉熵應該是0.66。
如果RNN學習到第一條依賴關系，即Xt-3為1時Yt一定為1。那么，所以最終的交叉熵應該是0.52（-0.5* (0.875 * np.log(0.875) + 0.125 * np.log(0.125)) -0.5 * (0.625* np.log(0.625) + 0.375* np.log(0.375))）。
如果RNN學習到了兩條依賴， 那么有0.25的概率全對，0.5的概率正確率是75%，還有0.25的概率正確率是0.5。所以其交叉熵為0.45（-0.50 * (0.75* np.log(0.75) + 0.25* np.log(0.25)) - 0.25 * (2 * 0.50 * np.log (0.50)) - 0.25 * (0)）。

這里的交叉熵的計算可能有些難以理解，不過沒有關系，小編搞了很久，終于明白了其中的緣由，RNN如果能學到規則，也就是說明在某些特定的條件下，即Xt-8和Xt-3取不同的值時，Y滿足不同的概率分布，而這個概率分布，由下圖所示：

交叉熵計算

3、數據生成及預處理

根據我們上述定義的規則，我們使用如下的代碼生成數據集：

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt


def gen_data(size = 1000000):
    """生成數據
    輸入數據X：在時間t，Xt的值有50%的概率為1，50%的概率為0；
    輸出數據Y：在實踐t，Yt的值有50%的概率為1，50%的概率為0，除此之外，如果`Xt-3 == 1`，Yt為1的概率增加50%， 如果`Xt-8 == 1`，則Yt為1的概率減少25%， 如果上述兩個條件同時滿足，則Yt為1的概率為75%。
    """
    X = np.array(np.random.choice(2,size=(size,)))
    Y = []
    for i in range(size):
        threshold = 0.5
        if X[i-3] == 1:
            threshold += 0.5
        if X[i-8] == 1:
            threshold -= 0.25
        if np.random.rand() > threshold:
            Y.append(0)
        else:
            Y.append(1)
    return X,np.array(Y)

接下來，我們要將產生的數據集按照參數進行切分，主要參數是batch_size和num_steps，batch_size 指將數據分成多少塊，而num_steps指輸入rnn_cell中的窗口的大小，即下圖中的n的大小

循環神經網絡

def gen_batch(raw_data, batch_size, num_steps):
    #raw_data是使用gen_data()函數生成的數據，分別是X和Y
    raw_x, raw_y = raw_data
    data_length = len(raw_x)

    # 首先將數據切分成batch_size份，0-batch_size，batch_size-2*batch_size。。。
    batch_partition_length = data_length // batch_size
    data_x = np.zeros([batch_size, batch_partition_length], dtype=np.int32)
    data_y = np.zeros([batch_size, batch_partition_length], dtype=np.int32)
    for i in range(batch_size):
        data_x[i] = raw_x[batch_partition_length * i:batch_partition_length * (i + 1)]
        data_y[i] = raw_y[batch_partition_length * i:batch_partition_length * (i + 1)]

    #因為RNN模型一次只處理num_steps個數據，所以將每個batch_size在進行切分成epoch_size份，每份num_steps個數據。注意這里的epoch_size和模型訓練過程中的epoch不同。 
    epoch_size = batch_partition_length // num_steps

    #x是0-num_steps， batch_partition_length -batch_partition_length +num_steps。。。共batch_size個
    for i in range(epoch_size):
        x = data_x[:, i * num_steps:(i + 1) * num_steps]
        y = data_y[:, i * num_steps:(i + 1) * num_steps]
        yield (x, y)

#這里的n就是訓練過程中用的epoch，即在樣本規模上循環的次數
def gen_epochs(n, num_steps):
    for i in range(n):
        yield gen_batch(gen_data(), batch_size, num_steps)

我們可以用下圖來看一下數據生成的過程，下圖中每一行為一個batch，可以看到這里的batch_size = 3,每一列為一個num_step,下圖中的num_steps為3，那么gen_batch函數每次yield的數據就是下圖虛線中的數據。

數據形式

4、模型構建

使用TensorFlow構建RNN模型，主要就是定義rnn_cell類型，然后將其復用即可。代碼如下：

batch_size = 3
num_classes = 2
state_size = 4
num_steps = 10
learning_rate = 0.2

x = tf.placeholder(tf.int32, [batch_size, num_steps], name='input_placeholder')
y = tf.placeholder(tf.int32, [batch_size, num_steps], name='labels_placeholder')
#RNN的初始化狀態，全設為零。注意state是與input保持一致，接下來會有concat操作，所以這里要有batch的維度。即每個樣本都要有隱層狀態
init_state = tf.zeros([batch_size, state_size])

#將輸入轉化為one-hot編碼，兩個類別。[batch_size, num_steps, num_classes]
x_one_hot = tf.one_hot(x, num_classes)
#將輸入unstack，即在num_steps上解綁，方便給每個循環單元輸入。這里可以看出RNN每個cell都處理一個batch的輸入（即batch個二進制樣本輸入）
rnn_inputs = tf.unstack(x_one_hot, axis=1)

#定義rnn_cell的權重參數，
with tf.variable_scope('rnn_cell'):
"""由于tf.Variable() 每次都在創建新對象，所有reuse=True 和它并沒有什么關系。對于get_variable()，來說，如果已經創建的變量對象，就把那個對象返回，如果沒有創建變量對象的話，就創建一個新的。"""
    W = tf.get_variable('W', [num_classes + state_size, state_size])
    b = tf.get_variable('b', [state_size], initializer=tf.constant_initializer(0.0))
#使之定義為reuse模式，循環使用，保持參數相同
def rnn_cell(rnn_input, state):
    with tf.variable_scope('rnn_cell', reuse=True):
        W = tf.get_variable('W', [num_classes + state_size, state_size])
        b = tf.get_variable('b', [state_size], initializer=tf.constant_initializer(0.0))
    #定義rnn_cell具體的操作，這里使用的是最簡單的rnn，不是LSTM
    return tf.tanh(tf.matmul(tf.concat([rnn_input, state], 1), W) + b)

state = init_state
rnn_outputs = []
#循環num_steps次，即將一個序列輸入RNN模型
for rnn_input in rnn_inputs:
    state = rnn_cell(rnn_input, state)
    rnn_outputs.append(state)
final_state = rnn_outputs[-1]

#定義softmax層
with tf.variable_scope('softmax'):
    W = tf.get_variable('W', [state_size, num_classes])
    b = tf.get_variable('b', [num_classes], initializer=tf.constant_initializer(0.0))
#注意，這里要將num_steps個輸出全部分別進行計算其輸出，然后使用softmax預測
logits = [tf.matmul(rnn_output, W) + b for rnn_output in rnn_outputs]
predictions = [tf.nn.softmax(logit) for logit in logits]

# Turn our y placeholder into a list of labels
y_as_list = tf.unstack(y, num=num_steps, axis=1)

#losses and train_step
losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(labels=label, logits=logit) for \
          logit, label in zip(logits, y_as_list)]
total_loss = tf.reduce_mean(losses)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)

5、模型訓練

def train_network(num_epochs, num_steps, state_size=4, verbose=True):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        training_losses = []
        #得到數據，因為num_epochs==5，所以外循環只執行五次
        for idx, epoch in enumerate(gen_epochs(num_epochs, num_steps)):
            training_loss = 0
            #保存每次執行后的最后狀態，然后賦給下一次執行
            training_state = np.zeros((batch_size, state_size))
            if verbose:
                print("\nEPOCH", idx)
            #這是具體獲得數據的部分
            for step, (X, Y) in enumerate(epoch):
                tr_losses, training_loss_, training_state, _ = \
                    sess.run([losses,
                              total_loss,
                              final_state,
                              train_step],
                                  feed_dict={x:X, y:Y, init_state:training_state})
                training_loss += training_loss_
                if step % 100 == 0 and step > 0:
                    if verbose:
                        print("Average loss at step", step,
                              "for last 100 steps:", training_loss/100)
                    training_losses.append(training_loss/100)
                    training_loss = 0

    return training_losses
training_losses = train_network(5,num_steps)
plt.plot(training_losses)
plt.show()

6、模型測試

我們首先將num_steps設置為2，這樣模型肯定學習不到三步前的結果,可以發現交叉熵在0.66附近，與上述結果吻合：

num_steps=2

接下來我們將num_steps設置為5，這樣模型可以學習到第一條規則，但是無法學習到第二條規則，可以發現交叉熵在0.52附近，與上述結果吻合：

num_steps=5

num_steps=10

7、問題探討

為什么會出現上述的結果呢?這是因為RNN存在梯度消失的問題，RNN的訓練也是反向傳播算法，只不過比基本神經網絡的算法復雜一些，在訓練過程中，根據鏈式法則不斷推倒的過程中，對越前面參數的更新，所涉及的連乘項就會增多，當其中一部分接近于0時，整個更新的值就接近于0，導致對前面的參數的更新幾乎為0，模型輸出對越靠前的輸入的依賴越來越小。

反向傳播

修改規則2

8、模型改進

上述的代碼完整展示了RNN的神經元的運作方式，但是Tensorflow已經提供了相關的函數，直接幫我們構建RNN的模型，我們可以對代碼進行如下改進：

#定義rnn_cell的權重參數，
with tf.variable_scope('rnn_cell'):
    W = tf.get_variable('W', [num_classes + state_size, state_size])
    b = tf.get_variable('b', [state_size], initializer=tf.constant_initializer(0.0))
#使之定義為reuse模式，循環使用，保持參數相同
def rnn_cell(rnn_input, state):
    with tf.variable_scope('rnn_cell', reuse=True):
        W = tf.get_variable('W', [num_classes + state_size, state_size])
        b = tf.get_variable('b', [state_size], initializer=tf.constant_initializer(0.0))
    #定義rnn_cell具體的操作，這里使用的是最簡單的rnn，不是LSTM
    return tf.tanh(tf.matmul(tf.concat([rnn_input, state], 1), W) + b)

state = init_state
rnn_outputs = []
#循環num_steps次，即將一個序列輸入RNN模型
for rnn_input in rnn_inputs:
    state = rnn_cell(rnn_input, state)
    rnn_outputs.append(state)
final_state = rnn_outputs[-1]


#----------------------上面是原始代碼，定義了rnn_cell，然后使用循環的方式對其進行復用，簡化之后我們可以直接調用BasicRNNCell和static_rnn兩個函數實現------------------------


cell = tf.contrib.rnn.BasicRNNCell(state_size)
rnn_outputs, final_state = tf.contrib.rnn.static_rnn(cell, rnn_inputs, initial_state=init_state)

我們可以看到static_rnn接受的輸入格式還是[batch_size,n_classes],這樣就需要加一步unstack對數據進行處理。除了使用static_rnn 之外，也可以使用dynamic_rnn,使用dynamic_rnn 時，我們直接將輸入表示成[batch_size, num_steps, features]的三維Tensor即可，但是后面的計算損失的代碼段也需要進行相應的修改，代碼如下：

x = tf.placeholder(tf.int32, [batch_size, num_steps], name='input_placeholder')
y = tf.placeholder(tf.int32, [batch_size, num_steps], name='labels_placeholder')
init_state = tf.zeros([batch_size, state_size])

rnn_inputs = tf.one_hot(x, num_classes)
#注意這里去掉了這行代碼，因為我們不需要將其表示成列表的形式在使用循環去做。
#rnn_inputs = tf.unstack(x_one_hot, axis=1)

cell = tf.contrib.rnn.BasicRNNCell(state_size)
#使用dynamic_rnn函數，動態構建RNN模型
rnn_outputs, final_state = tf.nn.dynamic_rnn(cell, rnn_inputs, initial_state=init_state)

with tf.variable_scope('softmax'):
    W = tf.get_variable('W', [state_size, num_classes])
    b = tf.get_variable('b', [num_classes], initializer=tf.constant_initializer(0.0))
logits = tf.reshape(
            tf.matmul(tf.reshape(rnn_outputs, [-1, state_size]), W) + b,
            [batch_size, num_steps, num_classes])
predictions = tf.nn.softmax(logits)

losses = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)
total_loss = tf.reduce_mean(losses)
train_step = tf.train.AdagradOptimizer(learning_rate).minimize(total_loss)

9、完整代碼

本文的完整代碼如下：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt


def gen_data(size=100000):
    """
    生成數據:
        輸入數據X：在時間t，Xt的值有50%的概率為1，50%的概率為0；
        輸出數據Y：在實踐t，Yt的值有50%的概率為1，50%的概率為0，除此之外，如果`Xt-3 == 1`，Yt為1的概率增加50%， 如果`Xt-8 == 1`，則Yt為1的概率減少25%， 如果上述兩個條件同時滿足，則Yt為1的概率為75%。
    """
    X = np.random.choice(2,(size,))
    Y = []
    for i in range(size):
        threshold = 0.5
        # 判斷X[i-3]和X[i-8]是否為1，修改閾值
        if X[i-3] == 1:
            threshold += 0.5
        if X[i-8] == 1:
            threshold -= 0.25
        # 生成隨機數，以threshold為閾值給Yi賦值
        if np.random.rand() > threshold:
            Y.append(0)
        else:
            Y.append(1)
    return X,np.array(Y)


def gen_batch(raw_data,batch_size,num_steps):
    # raw_data是使用gen_data()函數生成的數據，分別是X和Y
    raw_x,raw_y = raw_data
    data_length = len(raw_x)

    # 首先將數據切分成batch_size份，0-batch_size，batch_size-2*batch_size。。。
    batch_partition_length = data_length // batch_size
    data_x = np.zeros([batch_size,batch_partition_length],dtype=np.int32)
    data_y = np.zeros([batch_size,batch_partition_length],dtype=np.int32)

    # 因為RNN模型一次只處理num_steps個數據，所以將每個batch_size在進行切分成epoch_size份，每份num_steps個數據。注意這里的epoch_size和模型訓練過程中的epoch不同。
    for i in range(batch_size):
        data_x[i] = raw_x[i*batch_partition_length:(i+1)*batch_partition_length]
        data_y[i] = raw_y[i*batch_partition_length:(i+1)*batch_partition_length]

    # x是0-num_steps， batch_partition_length -batch_partition_length +num_steps。。。共batch_size個
    epoch_size = batch_partition_length // num_steps
    for i in range(epoch_size):
        x = data_x[:,i*num_steps:(i+1)*num_steps]
        y = data_y[:,i*num_steps:(i+1)*num_steps]
        yield (x,y)


def gen_epochs(n,num_steps):
    '''這里的n就是訓練過程中用的epoch，即在樣本規模上循環的次數'''
    for i in range(n):
        yield gen_batch(gen_data(),batch_size,num_steps=num_steps)


batch_size = 5
num_steps = 10
state_size = 10
n_classes = 2
learning_rate = 0.1

x = tf.placeholder(tf.int32,[batch_size,num_steps])
y = tf.placeholder(tf.int32,[batch_size,num_steps])

#RNN的初始化狀態，全設為零。注意state是與input保持一致，接下來會有concat操作，所以這里要有batch的維度。即每個樣本都要有隱層狀態
init_state = tf.zeros([batch_size,state_size])

#將輸入轉化為one-hot編碼，兩個類別。[batch_size, num_steps, num_classes]
x_one_hot = tf.one_hot(x,n_classes)
#將輸入unstack，即在num_steps上解綁，方便給每個循環單元輸入。這里可以看出RNN每個cell都處理一個batch的輸入（即batch個二進制樣本輸入）
rnn_inputs = tf.unstack(x_one_hot,axis=1)
#定義rnn_cell的權重參數，
with tf.variable_scope('rnn_cell'):
    W = tf.get_variable('W',[n_classes +state_size,state_size])
    b = tf.get_variable('b',[state_size],initializer=tf.constant_initializer(0.0))

#使之定義為reuse模式，循環使用，保持參數相同
def rnn_cell(rnn_input,state):
    with tf.variable_scope('rnn_cell',reuse=True):
        W = tf.get_variable('W', [n_classes + state_size, state_size])
        b = tf.get_variable('b', [state_size], initializer=tf.constant_initializer(0.0))

    # 定義rnn_cell具體的操作，這里使用的是最簡單的rnn，不是LSTM
    return tf.tanh(tf.matmul(tf.concat((rnn_input,state),1),W)+b)


state = init_state
rnn_outputs = []

#循環num_steps次，即將一個序列輸入RNN模型
for rnn_input in rnn_inputs:
    state = rnn_cell(rnn_input,state)
    rnn_outputs.append(state)
final_state = rnn_outputs[-1]

#cell = tf.contrib.rnn.BasicRNNCell(state_size)
#rnn_outputs,final_state = tf.contrib.rnn.static_rnn(cell,rnn_inputs,initial_state=init_state)

# rnn_inputs = x_one_hot
# rnn_outputs,final_state = tf.nn.dynamic_rnn(cell,rnn_inputs,initial_state=init_state)

#定義softmax層
with tf.variable_scope('softmax'):
    W = tf.get_variable('W',[state_size,n_classes])
    b = tf.get_variable('b',[n_classes])
#注意，這里要將num_steps個輸出全部分別進行計算其輸出，然后使用softmax預測
logits = [tf.matmul(rnn_output,W)+b for rnn_output in rnn_outputs]
predictions = [tf.nn.softmax(logit) for logit in logits]
# Turn our y placeholder into a list of labels
y_as_lists = tf.unstack(y,num=num_steps,axis=1)

#losses and train_step
losses = [tf.nn.sparse_softmax_cross_entropy_with_logits(labels=label,logits=logit) for label,logit in zip(y_as_lists,predictions)]
total_loss = tf.reduce_mean(losses)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)
#使用動態rnn時改為下面的代碼
# logits = tf.reshape(
#             tf.matmul(tf.reshape(rnn_outputs, [-1, state_size]), W) + b,
#             [batch_size, num_steps, n_classes])
# predictions = tf.nn.softmax(logits)
#
# losses = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits)
# total_loss = tf.reduce_mean(losses)
# train_step = tf.train.AdagradOptimizer(learning_rate).minimize(total_loss)

def train_network(num_epochs,num_steps,state_size,verbose=True):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        training_losses = []
        # 得到數據
        for idx,epoch in enumerate(gen_epochs(num_epochs,num_steps)):
            training_loss = 0
            # 保存每次執行后的最后狀態，然后賦給下一次執行
            training_state = np.zeros((batch_size,state_size))
            if verbose:
                print('\EPOCH', idx)
            # 這是具體獲得數據的部分
            for step,(X,Y) in enumerate(epoch):
                tr_losses, training_loss_, training_state, _ = \
                    sess.run([losses,
                              total_loss,
                              final_state,
                              train_step],
                             feed_dict={x: X, y: Y, init_state: training_state})
                training_loss += training_loss_
                if step % 100 == 0 and step > 0:
                    if verbose:
                        print("Average loss at step", step,
                              "for last 100 steps:", training_loss / 100)
                    training_losses.append(training_loss / 100)
                    training_loss = 0

            return training_losses

training_losses = train_network(1, num_steps,state_size)
plt.plot(training_losses)
plt.show()

10、參考文獻

使用TensorFlow實現RNN模型入門篇1
深度學習系列（4）：循環神經網絡（RNN）https://plushunter.github.io/2017/04/23/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E7%B3%BB%E5%88%97%EF%BC%884%EF%BC%89%EF%BC%9A%E5%BE%AA%E7%8E%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C%EF%BC%88RNN%EF%BC%89/
RNN, LSTM 理解：http://www.lxweimin.com/p/75eeaee7f67d