新的算法理論不斷湧現的同時，各種深度學習框架也不斷出現在人們視野，比如Torch，Caffe等等。TensorFlow是Google開發的第二代機器學習係統，於2015年底開源，成為了新一代流行的機器學習的算法框架。這一章節91视频免费播放將tensorFlow怎麽實現循環神經網絡（RNN）。
單步的RNN：RNNCell

RNNCell是是TensorFlow中實現RNN的基本單元，每個RNNCell都有一個call方法，使用方式是：(output, next_state) = call(input, state)。
假設91视频免费播放有一個初始狀態h0，還有輸入x1，調用call(x1, h0)後就可以得到(output1, h1)：

再調用一次call(x2, h1)就可以得到(output2, h2)：

也就是說，每調用一次RNNCell的call方法，就相當於在時間上“推進了一步”，這就是RNNCell的基本功能。
RNNCell隻是一個抽象類，91视频免费播放用的時候都是用的它的兩個子類BasicRNNCell和BasicLSTMCell。這兩個類的重要屬性。
1.state_size
2.output_size
前者是隱層的大小，後者是輸出的大小。比如91视频免费播放通常是將一個batch送入模型計算，設輸入數據的形狀為(batch_size, input_size)，那麽計算時得到的隱層狀態就是(batch_size, state_size)，輸出就是(batch_size, output_size)。

import tensorflow as tf import numpy as np cell = tf.nn.rnn_cell.BasicRNNCell(num_units=128) # state_size = 128 print(cell.state_size) # 128 inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = cell.zero_state(32, np.float32) # 通過zero_state得到一個全0的初始狀態，形狀為(batch_size, state_size) output, h1 = cell.call(inputs, h0) #調用call函數 print(h1.shape) # (32, 128)

對於BasicLSTMCell，情況有些許不同，因為LSTM可以看做有兩個隱狀態h和c，對應的隱層就是一個Tuple，每個都是(batch_size, state_size)的形狀：

import tensorflow as tf import numpy as np lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=128) inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = lstm_cell.zero_state(32, np.float32) # 通過zero_state得到一個全0的初始狀態 output, h1 = lstm_cell.call(inputs, h0) print(h1.h) # shape=(32, 128) print(h1.c) # shape=(32, 128)

對於單個的RNNCell，91视频免费播放使用它的call函數進行運算時，隻是在序列時間上前進了一步。比如使用x1、h0得到h1，通過x2、h1得到h2等。這樣的h話，如果91视频免费播放的序列長度為10，就要調用10次call函數，比較麻煩。對此，TensorFlow提供了一個tf.nn.dynamic_rnn函數，使用該函數就相當於調用了n次call函數。即通過{h0,x1, x2, …., xn}直接得{h1,h2…,hn}。
具體來說，設91视频免费播放輸入數據的格式為(batch_size, time_steps, input_size)，其中time_steps表示序列本身的長度，如在Char RNN中，長度為10的句子對應的time_steps就等於10。最後的input_size就表示輸入數據單個序列單個時間維度上固有的長度。另外91视频免费播放已經定義好了一個RNNCell，調用該RNNCell的call函數time_steps次，對應的代碼就是：

# inputs: shape = (batch_size, time_steps, input_size) # cell: RNNCell # initial_state: shape = (batch_size, cell.state_size)。初始狀態。一般可以取零矩陣 outputs, state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state)

此時，得到的outputs就是time_steps步裏所有的輸出。它的形狀為(batch_size, time_steps, cell.output_size)。state是最後一步的隱狀態，它的形狀為(batch_size, cell.state_size)。

import tensorflow as tf import numpy as np # 每調用一次這個函數就返回一個BasicRNNCell def get_a_cell(): return tf.nn.rnn_cell.BasicRNNCell(num_units=128) # 用tf.nn.rnn_cell MultiRNNCell創建3層RNN cell = tf.nn.rnn_cell.MultiRNNCell([get_a_cell() for _ in range(3)]) # 3層RNN # 得到的cell實際也是RNNCell的子類 # 它的state_size是(128, 128, 128) # (128, 128, 128)並不是128x128x128的意思 # 而是表示共有3個隱層狀態，每個隱層狀態的大小為128 print(cell.state_size) # (128, 128, 128) # 使用對應的call函數 inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size h0 = cell.zero_state(32, np.float32) # 通過zero_state得到一個全0的初始狀態 output, h1 = cell.call(inputs, h0) print(h1) # tuple中含有3個32x128的向量

經典RNN結構圖：

import tensorflow as tf
import numpy as np
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
from PIL import Image
import numpy as np
# import scipy
import matplotlib.pyplot as plt
import numpy as np
import pylab
config = tf.ConfigProto()
sess = tf.Session(config=config)
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
print mnist.train.images.shape

# 學習率
lr = 1e-3
# 在訓練和測試的時候，91视频免费播放想用不同的 batch_size.所以采用占位符的方式
batch_size = tf.placeholder(tf.int32, [])
# 每個時刻的輸入特征是28維的，就是每個時刻輸入一行，一行有 28 個像素
input_size = 28
# 時序持續長度為28，即每做一次預測，需要先輸入28行
timestep_size = 28
# 每個隱含層的節點數
hidden_size = 64
# LSTM layer 的層數
layer_num = 2
# 最後輸出分類類別數量，如果是回歸預測的話應該是 1
class_num = 10
_X = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, class_num])
keep_prob = tf.placeholder(tf.float32)

# 把784個點的字符信息還原成 28 * 28 的圖片
# 下麵幾個步驟是實現 RNN / LSTM 的關鍵
X = tf.reshape(_X, [-1, 28, 28])
def unit_lstm():
    # 定義一層 LSTM_cell，隻需要說明 hidden_size, 它會自動匹配輸入的 X 的維度
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
    #添加 dropout layer, 一般隻設置 output_keep_prob
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    return lstm_cell
#調用 MultiRNNCell 來實現多層 LSTM
mlstm_cell = rnn.MultiRNNCell([unit_lstm() for i in range(3)], state_is_tuple=True)#用全零來初始化state
init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)
outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]

# 把784個點的字符信息還原成 28 * 28 的圖片
# 下麵幾個步驟是實現 RNN / LSTM 的關鍵
X = tf.reshape(_X, [-1, 28, 28])
def unit_lstm():
    # 定義一層 LSTM_cell，隻需要說明 hidden_size, 它會自動匹配輸入的 X 的維度
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)
    #添加 dropout layer, 一般隻設置 output_keep_prob
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob)
    return lstm_cell
#調用 MultiRNNCell 來實現多層 LSTM
mlstm_cell = rnn.MultiRNNCell([unit_lstm() for i in range(3)], state_is_tuple=True)#用全零來初始化state
init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)
outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]

W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)
# 損失和評估函數
cross_entropy = -tf.reduce_mean(y * tf.log(y_pre))
train_op = tf.train.AdamOptimizer(lr).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

sess.run(tf.global_variables_initializer())
for i in range(1000):
    _batch_size = 128
    batch = mnist.train.next_batch(_batch_size)
    if (i+1)%200 == 0:
        train_accuracy = sess.run(accuracy, feed_dict={
            _X:batch[0], y: batch[1], keep_prob: 1.0, batch_size: _batch_size})
        # 已經迭代完成的 epoch 數: mnist.train.epochs_completed
        print "Iter%d, step %d, training accuracy %g" % ( mnist.train.epochs_completed, (i+1), train_accuracy)    sess.run(train_op, feed_dict={_X: batch[0], y: batch[1], keep_prob: 0.5, batch_size: _batch_size})

images=mnist.test.images
labels=mnist.test.labels
print "test accuracy %g"% sess.run(accuracy, feed_dict={
    _X: images, y: labels, keep_prob: 1.0, batch_size:mnist.test.images.shape[0]})

掃一掃獲取最新精彩內容與學習資料 

繼續閱讀：

星空人工智能91视频免费观看網 倡導尊重與保護知識產權。如發現本站文章存在版權等問題，煩請30天內提供版權疑問、身份證明、版權證明、聯係方式等發郵件至1851688011@qq.com91视频免费播放將及時溝通與處理。！：首頁 > 大數據 » 循環神經網絡RNN的實現