81、Tensorflow實現LeNet-5模型，多層卷積層，識別mnist數據集

'''
Created on 2017年4月22日

@author: weizhen
'''
import os
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

# 加載mnist_inference.py中定義的常量和前向傳播的函數
import LeNet5_infernece

# 配置神經網絡的參數
BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARAZTION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99

# 模型保存的路徑和文件名
MODEL_SAVE_PATH = "/path/to/model/"
MODEL_NAME = "model.ckpt"

def train(mnist):
    # 定義輸入輸出placeholder
    x = tf.placeholder(tf.float32, [BATCH_SIZE,
                                    LeNet5_infernece.IMAGE_SIZE,#第一維表示一個batch中樣例的個數
                                    LeNet5_infernece.IMAGE_SIZE,#第二維和第三維表示圖片的尺寸
                                    LeNet5_infernece.NUM_CHANNELS],#第四維表示圖片的深度，對於RGB格式的圖片，深度為5
                                    name='x-input')
    y_ = tf.placeholder(tf.float32, [None, LeNet5_infernece.OUTPUT_NODE], name='y-input')
    
    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    # 直接使用mnist_inference.py中定義的前向傳播過程
    y = LeNet5_infernece.inference(x,True,regularizer)
    global_step = tf.Variable(0, trainable=False)
    
    # 和5.2.1小節樣例中類似地定義損失函數、學習率、滑動平均操作以及訓練過程
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    variable_averages_op = variable_averages.apply(tf.trainable_variables())
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
    learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, mnist.train.num_examples / BATCH_SIZE, LEARNING_RATE_DECAY)
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step);
    with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name='train')
    
    # 初始化Tensorflow持久化類
    saver = tf.train.Saver()
    with tf.Session() as sess:
        tf.initialize_all_variables().run()
        
        # 在訓練過程中不再測試模型在驗證數據上的表現，驗證和測試的過程將會有一個獨立的程序來完成
        for i in range(TRAINING_STEPS):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            reshaped_xs=np.reshape(xs,(BATCH_SIZE,
                                       LeNet5_infernece.IMAGE_SIZE,
                                       LeNet5_infernece.IMAGE_SIZE,
                                       LeNet5_infernece.NUM_CHANNELS))
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x:reshaped_xs, y_:ys})
            
            # 每1000輪保存一次模型
            if i % 1000 == 0:
                # 輸出當前訓練情況。這里只輸出了模型在當前訓練batch上的損失函數大小
                # 通過損失函數的大小可以大概了解訓練的情況。在驗證數據集上的正確率信息
                # 會有一個單獨的程序來生成
                print("After %d training step(s),loss on training batch is %g" % (step, loss_value))
                
                # 保存當前的模型。注意這里給出了global_step參數，這樣可以讓每個被保存模型的文件末尾加上訓練的輪數
                # 比如"model.ckpt-1000"表示訓練1000輪之后得到的模型
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
    
    

def main(argv=None):
    mnist = input_data.read_data_sets("/tmp/data", one_hot=True)
    train(mnist)

if __name__ == '__main__':
    tf.app.run()
    

上面是LeNet-5train.py文件的內容。

與全連接層相比，卷積層的train.py文件主要調整了輸入參數的維度，和增加了過濾器的深度

下面是構造六層卷積層的程序

'''
Created on 2017年4月22日

@author: weizhen
'''
import tensorflow as tf
from tensorflow.python.debug.examples.debug_mnist import NUM_LABELS
#配置神經網絡的參數
INPUT_NODE=784
OUTPUT_NODE=10
IMAGE_SIZE=28
NUM_CHANNELS=1

#第一層卷積層的尺寸和深度
CONV1_DEEP=32
CONV1_SIZE=5

#第二層卷積層的尺寸和深度
CONV2_DEEP=64
CONV2_SIZE=5

#全連接層的節點個數
FC_SIZE=512

#定義卷積神經網絡的前向傳播過程。這里添加了一個新的參數train，用於區分訓練過程和測試過程
#在這個程序中將用到dropout方法，dropout方法可以進一步提升模型可靠性並防止過擬合
#dropout過程只在訓練時使用
def inference(input_tensor,train,regularizer):
    #聲明第一層卷積層的變量並實現前向傳播過程。
    #通過使用不同的命名空間來隔離不同層的變量，這可以讓每一層中的變量命名
    #只需要考慮當前層的作用，而不需要擔心重命名的問題。和標准LeNet-5模型不大一樣，
    #這里定義的卷積層輸入為28*28*1的原始MNIST圖片像素，因為卷積層中使用了全0填充
    #所以輸出為28*28*32的矩陣
    with tf.variable_scope('layer1-conv1'):
        conv1_weights=tf.get_variable("weight", 
                                      [CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_DEEP],
                                       initializer=tf.truncated_normal_initializer(stddev=0.1)
                                    )
        conv1_biases=tf.get_variable("bias",[CONV1_DEEP],initializer=tf.constant_initializer(0.0))
        #使用邊長為5，深度為32的過濾器，過濾器移動的步長為1，且使用全0填充
        conv1=tf.nn.conv2d(input_tensor,conv1_weights,strides=[1,1,1,1],padding='SAME')
        relu1=tf.nn.relu(tf.nn.bias_add(conv1,conv1_biases))
    
    #實現第二城池化層的前向傳播過程。這里選用最大池化層，池化層過濾器的邊長為2，
    #使用全0填充且移動的步長為2.這一層的輸入是上一層的輸出，也就是28*28*32
    #的矩陣。輸出為14*14*32的矩陣
    with tf.name_scope('layer2-pool1'):
        pool1=tf.nn.max_pool(relu1, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
    
    #聲明第三層卷積層的變量並實現前向傳播過程。這一層輸入為14*14*32的矩陣
    #輸出為14*14*64的矩陣
    with tf.variable_scope('layer3-conv2'):
        conv2_weights=tf.get_variable("weight",[CONV2_SIZE,CONV2_SIZE,CONV1_DEEP,CONV2_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))
        conv2_biases=tf.get_variable("bias",[CONV2_DEEP],initializer=tf.constant_initializer(0.0))
        #使用邊長為5，深度為64的過濾器，過濾器移動的步長為1，且使用全0填充
        conv2=tf.nn.conv2d(pool1,conv2_weights,strides=[1,1,1,1],padding='SAME')
        relu2=tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))
    
    #實現第四層池化層的前向傳播過程。這一層和第二層的結構是一樣的。這一層的輸入為
    #14*14*64的矩陣，輸出為7*7*64的矩陣
    with tf.name_scope('layer4-pool2'):
        pool2=tf.nn.max_pool(relu2,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    
    #將第四層池化層的輸出轉化為第五層全連接層的輸入格式，第四層的輸出為7*7*64的矩陣
    #然而第五層全連接層需要的輸入格式為向量，所以在這里需要將這個7*7*64的矩陣拉直成一個向量
    #pool2.get_shape函數可以得到第四層輸出矩陣的維度而不需要手工計算
    #注意因為每一層神經網絡的輸入輸出都為一個batch的矩陣，所以這里得到的維度也包含了一個batch中數據的個數
    pool_shape=pool2.get_shape().as_list()
    #計算將矩陣拉直成向量之后的長度，這個長度就是矩陣長寬及深度的乘積。注意在這里pool_shape[0]為一個batch中數據的個數
    nodes=pool_shape[1]*pool_shape[2]*pool_shape[3]
    
    #通過tf.reshape函數將第四層的輸出變成一個batch向量
    reshaped=tf.reshape(pool2,[pool_shape[0],nodes])
    
    #聲明第五層全連接的變量並實現前向傳播過程。這一層的輸入是拉直之后的一組向量
    #向量長度為3136，輸出是一組長度為512的向量。這一層和之前介紹的基本一致
    #唯一的區別就是引入了dropout的概念。dropout在訓練時會隨機將部分節點的輸出改為0
    #dropout可以避免過擬合問題，從而使得模型在測試數據上的效果更好
    #dropout一般只在全連接層而不是卷積層或者池化層使用
    with tf.variable_scope('layer5-fc1'):
        fc1_weights=tf.get_variable("weight",[nodes,FC_SIZE],initializer=tf.truncated_normal_initializer(stddev=0.1))
        #只用全連接層的權重需要加入正則化
        if regularizer!=None:
            tf.add_to_collection('losses',regularizer(fc1_weights))
        fc1_biases=tf.get_variable("bias",[FC_SIZE],initializer=tf.constant_initializer(0.1))
        fc1=tf.nn.relu(tf.matmul(reshaped,fc1_weights)+fc1_biases)
        if train:
            fc1=tf.nn.dropout(fc1, 0.5)
    
    #聲明第六層的變量並實現前向傳播過程。這一層的輸入為一組長度為512的向量
    #輸出為一組長度為10的向量。這一層的輸出通過Softmax之后就得到了最后的分類結果
    with tf.variable_scope('layer6-fc2'):
        fc2_weights=tf.get_variable("weight",[FC_SIZE,NUM_LABELS],initializer=tf.truncated_normal_initializer(stddev=0.1))
        if regularizer!=None:
            tf.add_to_collection('losses',regularizer(fc2_weights))
        fc2_biases=tf.get_variable("bias",[NUM_LABELS],initializer=tf.constant_initializer(0.1))
        logit=tf.matmul(fc1,fc2_weights)+fc2_biases
    
    return logit

下面是運行的結果，由於該程序運行的速度很慢，所以在筆記本上並沒有跑出來

打算回到公司里去跑

下面是跑過了2000遍之后得到的結果

After 1 training step(s),loss on training batch is 5.68176
After 1001 training step(s),loss on training batch is 2.88521

可以看到誤差是在逐漸縮小的，2000遍之后，正確率已經可以達到97....%了