RNN做影象識別原理：MNIST資料集中一張圖片資料包含28*28的畫素點。RNN是將一張圖片資料的一行作為一個向量總體輸入一個X中。也就是說，RNN有28個輸入X，一個輸入X有28個畫素點。
輸出最後一個結果做為預測值。
 

TensorFlow入門學習程式碼：

# -*- coding: utf-8 -*-
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import os.path as ops
import os

# LOG 等級說明
# '1' 這是預設的顯示等級，顯示所有資訊
# '2' 只顯示 warning 和 Error
# '3' 只顯示 Error
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # 設定 LOG 輸出等級  

tf.reset_default_graph()  # 清除預設圖形堆疊並重置全域性預設圖形

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

# 定義超引數
training_iters = 20001
batch_size = 100  

n_inputs = n_steps = 28  # n_inputs是每步輸入值，對應影象列數； n_steps是時間步數，對應影象行數
n_hidden_number = 128  #隱藏層神經元個數
n_outputs = 10  #輸出層神經元個數，對應數字的10個類

x = tf.placeholder(tf.float32,[None,n_steps,n_inputs],name='x')  # 新增一個新的佔位符用於輸入正確值， 使用placeholder()來傳遞一個tensor到session.run()中
Y = tf.placeholder(tf.float32,[None,n_outputs],name='Y')

# 初始化引數
weights = {
        # shape = (28,128)  tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)  shape: 輸出張量的形狀，必選
        'in':tf.Variable(tf.random_normal([n_inputs,n_hidden_number])),  # tf.random_normal從服從指定正太分佈的數值中取出指定個數的值
        # shape = (128,10)
        'out':tf.Variable(tf.random_normal([n_hidden_number,n_outputs]))
        }

biases = {
        # shape = (128,)
        'in':tf.Variable(tf.constant(0.1,shape = [n_hidden_number,])),  # tf.constant生成一個給定值的常量
        # shape = (10,)
        'out':tf.Variable(tf.constant(0.1,shape = [n_outputs,]))
        }

# 模型
def RNN(X, weights, biases):
    ### 輸入層到核運算 ###
    # X shape = (100batch,28steps,28inputs) ==> (100batch*28steps,28inputs)
    X = tf.reshape(X,[-1,n_inputs])  # 將tensor變換為引數shape的形式  -1表示自動計算
    # X_in shape ==> (100batch*28steps,128hidden)
    X_in = tf.matmul(X,weights['in'])+biases['in']  #tf.matmul 矩陣乘法
    # X_in shape ==> (100batch,28steps,128hidden)
    X_in = tf.reshape(X_in,[-1,n_steps,n_hidden_number])
    
    ### cell核內運算 ###
    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(n_hidden_number,forget_bias = 1.0)  # 選擇的cell是BasicLSTMCell
    # LSTM cell is divided into two parts-->(c_state,m_state)
    # RNN的中間狀態會得到兩部分——一個是當前輸出outputs，另一個是下時刻的記憶states，RNN在init_state中用c_state、m_state分別儲存這兩部分
    init_state = lstm_cell.zero_state(batch_size,dtype=tf.float32)  
    # 用dynamic_rnn的方法，用輸入值X_in進行核內運算，將輸出分別存入相應陣列中
    outputs,states = tf.nn.dynamic_rnn(lstm_cell,X_in,initial_state=init_state,time_major=False)
    
    ### 核內運算到輸出層 ###
    # 在核內以X_in為輸入，得到輸出outputs與states，當所有行都代入計算得到最後的輸出預測值。其中states[1] = outputs[-1]，相當於最後一個輸出值。
    result = tf.matmul(states[1],weights['out'])+biases['out']
    return  result

# 儲存模型
saver = tf.train.Saver(max_to_keep=2)
# 儲存模型的路徑
ckpt_file_path = "./models/"  # models是資料夾，mnist是檔案命名使用的
path = os.path.dirname(os.path.abspath(ckpt_file_path))
if os.path.isdir(path) is False:
    os.makedirs(path)

# 代價函式和優化器
prediction = RNN(x,weights,biases)
tf.add_to_collection('predict', prediction)
#二次代價函式:預測值與真實值的誤差
# softmax_cross_entropy_with_logits分為兩步：第一步是先對網路最後一層的輸出做一個softmax，第二步是softmax的輸出向量[Y1，Y2,Y3...]和樣本的實際標籤做一個交叉熵
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=prediction))  # labels：實際的標籤，logits：就是神經網路最後一層的輸出
#梯度下降法:資料龐大,選用AdamOptimizer優化器
train_step = tf.train.AdamOptimizer(1e-3).minimize(loss)

#結果存放在一個布林型列表中
correct_prediction = tf.equal(tf.argmax(prediction,1), tf.argmax(Y,1))
#求準確率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32),name="accuracy")

# 訓練
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    step = 0
    
    while step*batch_size < training_iters:
        batch_xs,batch_ys = mnist.train.next_batch(batch_size)
        # batch_xs shape = [100,28,28]
        batch_xs = batch_xs.reshape([batch_size,n_steps,n_inputs])
#        batch_ys = batch_ys.reshape([batch_size,n_outputs])
    
        train_step.run(feed_dict = {x:batch_xs,Y:batch_ys,})  # 使用feed_dict來傳入tensor
#        sess.run([train_step], feed_dict = {x:batch_xs, Y:batch_ys,})
        
        if step % 50 == 0:
            train_accuracy = accuracy.eval(feed_dict={x:batch_xs,Y:batch_ys,})  # 評估模型，得出訓練的準確率
            print("step", step, "training accuracy", train_accuracy)
            
        if step % 100 == 0:
            model_name = 'mnist_{:s}'.format(str(step+1))
            model_save_path = ops.join(ckpt_file_path, model_name)
            saver.save(sess, model_save_path, write_meta_graph=True)  # 儲存模型 
            
        step += 1       

    # 用測試資料再評估下
    test_len = 100  # 必須跟batch_size相等
    test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_inputs))
    test_label = mnist.test.labels[:test_len]
    print ("Testing Accuracy:", \
           sess.run(accuracy, feed_dict={x: test_data, Y: test_label}))
 

載入模型程式碼：

# -*- coding: utf-8 -*-
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "3"

mnist = input_data.read_data_sets("./mnist", one_hot=True)

n_input = 28
n_steps = 28
n_classes = 10

with tf.Session() as sess:
    new_saver = tf.train.import_meta_graph('./models/mnist_201.meta')
    new_saver.restore(sess, tf.train.latest_checkpoint('./models'))
    print("model loaded")

    graph = tf.get_default_graph()
    predict = tf.get_collection('predict')[0]
    input_x = graph.get_operation_by_name("x").outputs[0]
    y = graph.get_tensor_by_name("Y:0")
    Accuracy = graph.get_tensor_by_name("accuracy:0")
    print("arg init")

    x = mnist.test.images[0].reshape((-1, n_steps, n_input))
    y = mnist.test.labels[0].reshape(-1, n_classes)  # 轉為one-hot形式
    print("reshape done")   
    
    res = sess.run(predict, feed_dict={input_x: x })
    print("demo run")

    print("Actual class: ", str(sess.run(tf.argmax(y, 1))), \
          ", predict class ",str(sess.run(tf.argmax(res, 1))), \
          ", predict ", str(sess.run(tf.equal(tf.argmax(y, 1), tf.argmax(res, 1))))
          )