使用Tensorflow實現簡單的RNN

使用Tensorflow實現簡單的RNN

來自專欄 Python程序員

作者：石曉文 Python愛好者社區專欄作者

個人公眾號：小小挖掘機

博客專欄:wenwen

之前我們用word2vec訓練了詞向量，但光詞向量其實沒有什麼實際的用處，我們還要結合深度學習模型比如rnn，LSTM，seq2seq才行，所以我們首先來介紹一下如何使用時下最為流行的tensorflow模型實現一個簡單的循環神經網路

1、循環神經網路簡介

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

基本神經網路

其中x是一個向量，它表示輸入層的值（這裡面沒有畫出來表示神經元節點的圓圈）；s是一個向量，它表示隱藏層的值（這裡隱藏層面畫了一個節點，你也可以想像這一層其實是多個節點，節點數與向量s的維度相同）；U是輸入層到隱藏層的權重矩陣；o也是一個向量，它表示輸出層的值；V是隱藏層到輸出層的權重矩陣。

再看下圖中一個簡單的循環神經網路圖，它由輸入層、一個隱藏層和一個輸出層組成。我們可以看到，循環神經網路的隱藏層的值s不僅僅取決於當前這次的輸入x，還取決於上一次隱藏層的值s。權重矩陣W就是隱藏層上一次的值作為這一次的輸入的權重。

如果我們把上面的圖展開，循環神經網路也可以畫成下面這個樣子：

現在看起來就清楚不少了，這個網路在t時刻接收到輸入Xt之後，隱藏層的值是St，輸出值是ot。關鍵一點是，st的值不僅僅取決於Xt，還取決於St?1。我們可以使用下面的公式來表示循環神經網路的計算方法：

ot=g(Vst) （1）

st=f(Uxt+Wst?1) （2）

式1是輸出層的計算公式，輸出層是一個全連接層，也就是它的每個節點都和隱藏層的每個節點相連。V是輸出層的權重矩陣，g是激活函數。式2是隱藏層的計算公式，它是循環層。U是輸入x的權重矩陣，W是上一次的值st?1作為這一次的輸入的權重矩陣，f是激活函數。

從上面的公式可以看出，循環層和全連接層的區別就是多了一個權重矩陣W。

若反覆把式2代入帶式1，我們將得到：

ot=g(Vst)=g(Vf(Uxt+Wst?1))

=g(Vf(Uxt+Wf(Uxt?1+Wst?2)))

=g(Vf(Uxt+Wf(Uxt?1+Wf(Uxt?2+Wst?3))))

從上面可以看出，循環神經網路的輸出值otot，是受前面歷次輸入值xt、xt?1、xt?2……的影響的，這就是為什麼循環神經網路可以往前看任意多個輸入值的原因。

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 npimport tensorflow as tfimport matplotlib.pyplot as pltdef 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 = 3num_classes = 2state_size = 4num_steps = 10learning_rate = 0.2x = 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_staternn_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 labelsy_as_list = tf.unstack(y, num=num_steps, axis=1)#losses and train_steplosses = [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("
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_lossestraining_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，這樣模型可以學習到兩條規則，但模型的信息熵並不是在0.45附近，而是在0.52附近：

num_steps=10

7、問題探討

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

反向傳播

在本例中，我們猜想對前面8步的依賴出現了梯度消失的情況，為了驗證我們的猜想，我們將規則二中Xt-8修改為Xt-5，再次運行代碼，可以發現交叉熵已經接近於我們之前計算的值，說明梯度消失的情況的確存在。

修改規則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_staternn_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 tfimport numpy as npimport matplotlib.pyplot as pltdef 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 = 5num_steps = 10state_size = 10n_classes = 2learning_rate = 0.1x = 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_staternn_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 labelsy_as_lists = tf.unstack(y,num=num_steps,axis=1)#losses and train_steplosses = [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_lossestraining_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.jianshu.com/p/75eeaee7f67d

推薦閱讀：