CNN（卷積神經網絡）實現手寫數字識別並與django集成

任務

設計一個卷積神經網絡來實現對MNIST手寫數字集的識別任務。
爲了增加模型複雜度並進一步練習tensorflow的使用方法，所以模型設計的稍微複雜一些。網路結構總共包括五個層級，包括四個隱藏單元、一個輸出單元。 層級結構如下圖所示

包、數據集載入

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

# 載入數據集
data = input_data.read_data_sets('MNIST_data/', one_hot=True)

層級結構設計

輸入層中輸入的張量設爲x，類型爲32位浮點型，x以佔位符形式定義，並且其維度爲784。並且每次迭代樣本個數並不確定，主要由迭代batch的大小決定。由於我們設計的是卷積神經網絡，跟bp神經網絡不同的地方在於增加了卷積操作、池化操作等。故輸入進去的圖像數據需要從原來的1*784的行向量變爲28*28*1的張量（tensor）。

x = tf.placeholder(dtype=tf.float32, shape=[None, 784])
x_in = tf.reshape(x, [-1, 28, 28, 1])

隱層牽涉到權值參數與偏置項的設定。在未運行算法之前，需要對權重參數與偏置項進行初始化。
爲防止權重參數恆爲0，我們採用tensorflow的內置方法，將權重參數初始化爲擁有固定標準差的高斯分佈的張量，方法如下：

def weight_variable(shape):
    #權重的初始化
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

對於偏置項，我們可以直接將其初始化爲某一固定常量，方法如下：

def bias_variable(shape):
    #偏置項的初始化
    initial = tf.constant(0.5, shape=shape)
    return tf.Variable(initial)

爲了簡化定義，我們將最大池化操作、2d卷積操作封裝在函數裏。

def conv2d(x, w):
    # 定義卷積的函數
    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')

def max_pooling(x):
    # 定義池化操作的函數
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

四個隱層都在內部定義並實現卷積層，包括卷積運算、非線性轉換（relu函數）、最大池化操作。卷積操作步長設置爲1，池化操作步長設定爲2，且池化層核函數設定爲2*2。並且每個隱層最後將附帶dropout功能結構防止模型過擬合。

隱層1中定義的卷積核大小爲3*3*1，卷積核（filter）個數設定爲32個，則經過非線性映射後輸出32個大小爲28*28的feature map，經過池化操作後feature map大小變爲14*14。

隱層2中定義的卷積核大小爲3*3*32，卷積核設定爲64個，則經過非線性映射後輸出64個大小爲14*14的feature map，經過池化操作後feature map的大小變爲7*7。

隱層3中定義卷積核大小爲3*3*64，卷積核設定爲128個，則經過非線性映射後輸出128個大小爲7*7的feature map，經過池化操作後feature map的大小變爲4*4。

隱層4是全連接層，參數進行類似的定義，不過此處的權值參數恢復到了向量形式，形狀爲625*625，並將由隱層3傳來的feature map轉換爲形狀爲n*625（n代表樣本數，取決於batch的值，代碼中以-1代表不確定）的向量形式，經過全連接操作到達輸出層。

最後在輸出層定義權重參數形狀爲625*10，經過softmax激活，得到n*10（n代表迭代的樣本數）的輸出，表示對n個樣本的預測概率。

通過以上分析可以看出，在通過隱層1之後，輸入隱層2的feature map比一開始輸入隱層1的原始圖像尺寸減少了一半，但深度增加到32，隱層3的輸入情況與此相類似。可以得出結論，該模型卷積層的參數設置較爲合理，能夠分別發揮卷積層有效提取特徵、池化層有效壓縮輸出參數的優勢特點。
結構實現代碼如下：

def convlutional(x, keep_prob):
    
    with tf.name_scope('first_layer'):
        
        w1 = weight_variable([3, 3, 1, 32])
        b1 = bias_variable([32])
        h1 = tf.nn.relu(conv2d(x, w1) + b1)
        p1 = max_pooling(h1)
        L1 = tf.nn.dropout(p1, keep_prob=keep_prob)
        # op -> image
        # input -> [?, 28, 28, 1]
        # conv -> [?, 28, 28, 32]
        # pool -> [?, 14, 14, 32]
    
    with tf.name_scope('second_layer'):
        
        w2 = weight_variable([3, 3, 32, 64])
        b2 = bias_variable([64])
        h2 = tf.nn.relu(conv2d(L1, w2) + b2)
        p2 = max_pooling(h2)
        L2 = tf.nn.dropout(p2, keep_prob=keep_prob)
        # input -> [?, 14, 14, 32]
        # conv -> [?, 14, 14, 64]
        # pool -> [?, 7, 7, 64]
    
    with tf.name_scope('third_layer'):
        
        w3 = weight_variable([3, 3, 64, 128])
        b3 = bias_variable([128])
        h3 = tf.nn.relu(conv2d(L2, w3) + b3)
        p3 = max_pooling(h3)
        L3 = tf.nn.dropout(p3, keep_prob=keep_prob)
        # input -> [?, 7, 7, 64]
        # conv -> [?, 7, 7, 128]
        # pool -> [?, 4, 4, 128]
    
    with tf.name_scope('firth_layer'):
        
        L3_ = tf.reshape(L3, [-1, 128 * 4 * 4])
        w4 = weight_variable([128 * 4 * 4, 625])
        b4 = bias_variable([625])
        h4 = tf.nn.relu(tf.matmul(L3_, w4) + b4)
        L4 = tf.nn.dropout(h4, keep_prob=keep_prob)
        # input -> [?, 128*4*4]
        # line -> [?, 625]
    
    with tf.name_scope('output_layer'):
        
        w5 = weight_variable([625, 10])
        b5 = bias_variable([10])
        h5 = tf.nn.softmax(tf.matmul(L4, w5) + b5)
        
        output = h5
        # input -> [?, 625]
        # output -> [?, 10]
    return output

實現過程

在定義好了層級結構之後，我們還需要定義超參數、標籤、梯度下降優化器、損失函數等。
代碼如下：

# 超參數定義
keep_prob = tf.placeholder(tf.float32)

learning_rate = 0.0001

max_step = 10000

# 輸入數據
x = tf.placeholder(tf.float32, [None, 784])

x_in = tf.reshape(x, [-1, 28, 28, 1])

# 標籤
y_ = tf.placeholder(tf.float32, [None, 10])

y = convlutional(x_in, keep_prob)

# 損失函數
cross_entropy = - tf.reduce_sum(y_ * tf.log(y))

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

我們定義爲佔位符的數據就是需要在會話執行時餵食的數據。 如x、y_、keep_prob。

要知道tensorflow是基於運算圖的框架，所以我們在定義了一系列佔位符、操作、變量等tensor後，需要在會話裏跑起來，不斷地迭代！
迭代代碼如下：

with tf.Session() as sess:
    
    sess.run(tf.global_variables_initializer())
    
    print('--------------------載入訓練集-------------------')
    
    for i in range(max_step):
        
        batch = data.train.next_batch(50)
        
        sess.run(train_step, feed_dict={x : batch[0], y_ : batch[1], keep_prob:0.7})
        
        if i % 100 == 0:
            acc = sess.run(accuracy, feed_dict={x : batch[0], y_ : batch[1], keep_prob:1.0})
            print('準確率：'+str(acc))
            
    print('--------------------載入訓練集-------------------')
    
    acc = []
    
    for i in range(max_step):
        
        batch = data.test.next_batch(50)
        
        a = sess.run(accuracy, feed_dict={x : batch[0], y_ : batch[1], keep_prob : 1.0})
        acc.append(a)
    
    mean_acc = np.mean(acc)
    print('平均精度爲：' + str(mean_acc))

選擇部分項輸出展示如下：

--------------------載入訓練集-------------------
準確率：0.14
準確率：0.26
準確率：0.54
準確率：0.66
準確率：0.64
準確率：0.62
準確率：0.64
準確率：0.76
準確率：0.82
準確率：0.78
準確率：0.86
準確率：0.88
準確率：0.88
準確率：0.88
準確率：0.9
準確率：0.88
準確率：0.86
準確率：0.9
準確率：0.9
準確率：0.94
準確率：0.98
… …
--------------------載入訓練集-------------------
平均精度爲：0.9734

嘛… …最終測試機上表現得不是很好，結構、參數等還有待優化。

loss函數得變化展現如下：

打個小廣告：我最終將該項目和django聯繫在一起的，系統中的模型擬合程度更好一些。實現界面如圖：