手寫數字識別演算法的設計與實現

本文使用python基於TensorFlow設計手寫數字識別演算法，並程式設計實現GUI介面，構建手寫數字識別系統。這是本人的本科畢業論文課題，當然，這個也是機器學習的基本問題。本博文不會以論文的形式展現，而是以程式設計實戰完成機器學習專案的角度去描述。

專案要求：本文主要解決的問題是手寫數字識別，最終要完成一個識別系統。

設計識別率高的演算法，實現快速識別的系統。

1 LeNet-5模型的介紹

本文實現手寫數字識別，使用的是卷積神經網路，建模思想來自LeNet-5，如下圖所示：



這是原始的應用於手寫數字識別的網路，我認為這也是最簡單的深度網路。

LeNet-5不包括輸入，一共7層，較低層由卷積層和最大池化層交替構成，更高層則是全連線和高斯連線。

LeNet-5的輸入與BP神經網路的不一樣。這裡假設影象是黑白的，那麼LeNet-5的輸入是一個32*32的二維矩陣。同時，輸入與下一層並不是全連線的，而是進行稀疏連線。本層每個神經元的輸入來自於前一層神經元的區域性區域(5×5)，卷積核對原始影象卷積的結果加上相應的閾值，得出的結果再經過啟用函式處理，輸出即形成卷積層（C層）。卷積層中的每個特徵對映都各自共享權重和閾值，這樣能大大減少訓練開銷。降取樣層（S層）為減少資料量同時儲存有用資訊，進行亞抽樣。

第一個卷積層（C1層）由6個特徵對映構成，每個特徵對映是一個28×28的神經元陣列，其中每個神經元負責從5×5的區域通過卷積濾波器提取區域性特徵。一般情況下，濾波器數量越多，就會得出越多的特徵對映，反映越多的原始影象的特徵。本層訓練引數共6×(5×5+1)=156個，每個畫素點都是由上層5×5=25個畫素點和1個閾值連線計算所得，共28×28×156=122304個連線。

S2層是對應上述6個特徵對映的降取樣層（pooling層）。pooling層的實現方法有兩種，分別是max-pooling和mean-pooling，LeNet-5採用的是mean-pooling，即取n×n區域內畫素的均值。C1通過2×2的視窗區域畫素求均值再加上本層的閾值，然後經過啟用函式的處理，得到S2層。pooling的實現，在儲存圖片資訊的基礎上，減少了權重引數，降低了計算成本，還能控制過擬合。本層學習引數共有1*6+6=12個，S2中的每個畫素都與C1層中的2×2個畫素和1個閾值相連，共6×(2×2+1)×14×14=5880個連線。

S2層和C3層的連線比較複雜。C3卷積層是由16個大小為10×10的特徵對映組成的，當中的每個特徵對映與S2層的若干個特徵對映的區域性感受野（大小為5×5）相連。其中，前6個特徵對映與S2層連續3個特徵對映相連，後面接著的6個對映與S2層的連續的4個特徵對映相連，然後的3個特徵對映與S2層不連續的4個特徵對映相連，最後一個對映與S2層的所有特徵對映相連。此處卷積核大小為5×5，所以學習引數共有6×(3×5×5+1)+9×(4×5×5+1)+1×(6×5×5+1)=1516個引數。而影象大小為28×28，因此共有151600個連線。

S4層是對C3層進行的降取樣，與S2同理，學習引數有16×1+16=32個，同時共有16×(2×2+1)×5×5=2000個連線。

C5層是由120個大小為1×1的特徵對映組成的卷積層，而且S4層與C5層是全連線的，因此學習引數總個數為120×(16×25+1)=48120個。

F6是與C5全連線的84個神經元，所以共有84×(120+1)=10164個學習引數。

卷積神經網路通過通過稀疏連線和共享權重和閾值，大大減少了計算的開銷，同時，pooling的實現，一定程度上減少了過擬合問題的出現，非常適合用於影象的處理和識別。

2 手寫數字識別演算法模型的構建

2.1 各層設計

有了第一節的基礎知識，在這基礎上，進行完善和改進。

輸入層設計

輸入為28×28的矩陣，而不是向量。

啟用函式的選取

Sigmoid函式具有光滑性、魯棒性和其導數可用自身表示的優點，但其運算涉及指數運算，反向傳播求誤差梯度時，求導又涉及乘除運算，計算量相對較大。同時，針對本文構建的含有兩層卷積層和降取樣層，由於sgmoid函式自身的特性，在反向傳播時，很容易出現梯度消失的情況，從而難以完成網路的訓練。因此，本文設計的網路使用ReLU函式作為啟用函式。

ReLU的表示式：

卷積層設計

本文設計卷積神經網路採取的是離散卷積，卷積步長為1，即水平和垂直方向每次運算完，移動一個畫素。卷積核大小為5×5。

降取樣層

本文降取樣層的pooling方式是max-pooling，大小為2×2。

輸出層設計

輸出層設定為10個神經網路節點。數字0~9的目標向量如下表所示：

2.2 網路模型的總體結構

其實，本文網路的構建，參考自TensorFlow的手寫數字識別的官方教程的，讀者有興趣也可以詳細閱讀。

2.3 程式設計實現演算法

本文使用Python，呼叫TensorFlow的api完成手寫數字識別的演算法。
注：本文程式執行環境是：Win10,python3.5.2。當然，也可以在Linux下執行，由於TensorFlow對py2和py3相容得比較好，在Linux下可以在python2.7中執行。

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 17 19:50:49 2017

@author: Yonghao Huang
"""

#import modules
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import time
from datetime import timedelta
import math
from tensorflow.examples.tutorials.mnist import input_data


def new_weights(shape):
    return tf.Variable(tf.truncated_normal(shape,stddev=0.05))
def new_biases(length):
    return tf.Variable(tf.constant(0.1,shape=length))
def conv2d(x,W):
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(inputx):
    return tf.nn.max_pool(inputx,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

#import data
data = input_data.read_data_sets("./data", one_hot=True)  # one_hot means [0 0 1 0 0 0 0 0 0 0] stands for 2

print("Size of:")
print("--Training-set:\t\t{}".format(len(data.train.labels)))
print("--Testing-set:\t\t{}".format(len(data.test.labels)))
print("--Validation-set:\t\t{}".format(len(data.validation.labels)))
data.test.cls = np.argmax(data.test.labels,axis=1)   # show the real test labels:  [7 2 1 ..., 4 5 6], 10000values

x = tf.placeholder("float",shape=[None,784],name='x')
x_image = tf.reshape(x,[-1,28,28,1])

y_true = tf.placeholder("float",shape=[None,10],name='y_true')
y_true_cls = tf.argmax(y_true,dimension=1)
# Conv 1
layer_conv1 = {"weights":new_weights([5,5,1,32]),
               "biases":new_biases([32])}
h_conv1 = tf.nn.relu(conv2d(x_image,layer_conv1["weights"])+layer_conv1["biases"])
h_pool1 = max_pool_2x2(h_conv1)
# Conv 2
layer_conv2 = {"weights":new_weights([5,5,32,64]),
               "biases":new_biases([64])}
h_conv2 = tf.nn.relu(conv2d(h_pool1,layer_conv2["weights"])+layer_conv2["biases"])
h_pool2 = max_pool_2x2(h_conv2)
# Full-connected layer 1
fc1_layer = {"weights":new_weights([7*7*64,1024]),
            "biases":new_biases([1024])}
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,fc1_layer["weights"])+fc1_layer["biases"])
# Droupout Layer
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
# Full-connected layer 2
fc2_layer = {"weights":new_weights([1024,10]),
             "biases":new_weights([10])}
# Predicted class
y_pred = tf.nn.softmax(tf.matmul(h_fc1_drop,fc2_layer["weights"])+fc2_layer["biases"])  # The output is like [0 0 1 0 0 0 0 0 0 0]
y_pred_cls = tf.argmax(y_pred,dimension=1)  # Show the real predict number like '2'
# cost function to be optimized
cross_entropy = -tf.reduce_mean(y_true*tf.log(y_pred))
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cross_entropy)
# Performance Measures
correct_prediction = tf.equal(y_pred_cls,y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    train_batch_size = 50
    def optimize(num_iterations):
        total_iterations=0
        start_time = time.time()
        for i in range(total_iterations,total_iterations+num_iterations):
            x_batch,y_true_batch = data.train.next_batch(train_batch_size)
            feed_dict_train_op = {x:x_batch,y_true:y_true_batch,keep_prob:0.5}
            feed_dict_train = {x:x_batch,y_true:y_true_batch,keep_prob:1.0}
            sess.run(optimizer,feed_dict=feed_dict_train_op)
            # Print status every 100 iterations.
            if i%100==0:
                # Calculate the accuracy on the training-set.
                acc = sess.run(accuracy,feed_dict=feed_dict_train)
                # Message for printing.
                msg = "Optimization Iteration:{0:>6}, Training Accuracy: {1:>6.1%}"
                # Print it.
                print(msg.format(i+1,acc))
        # Update the total number of iterations performed
        total_iterations += num_iterations
        # Ending time
        end_time = time.time()
        # Difference between start and end_times.
        time_dif = end_time-start_time
        # Print the time-usage
        print("Time usage:"+str(timedelta(seconds=int(round(time_dif)))))
    test_batch_size = 256
    def print_test_accuracy():
        # Number of images in the test-set.
        num_test = len(data.test.images)
        cls_pred = np.zeros(shape=num_test,dtype=np.int)
        i = 0
        while i < num_test:
            # The ending index for the next batch is denoted j.
            j = min(i+test_batch_size,num_test)
            # Get the images from the test-set between index i and j
            images = data.test.images[i:j, :]
            # Get the associated labels
            labels = data.test.labels[i:j, :]
            # Create a feed-dict with these images and labels.
            feed_dict={x:images,y_true:labels,keep_prob:1.0}
            # Calculate the predicted class using Tensorflow.
            cls_pred[i:j] = sess.run(y_pred_cls,feed_dict=feed_dict)
            # Set the start-index for the next batch to the
            # end-index of the current batch
            i = j
        cls_true = data.test.cls
        correct = (cls_true==cls_pred)
        correct_sum = correct.sum()
        acc = float(correct_sum) / num_test
        # Print the accuracy
        msg = "Accuracy on Test-Set: {0:.1%} ({1}/{2})"
        print(msg.format(acc,correct_sum,num_test))
    # Performance after 10000 optimization iterations

執行結果顯示：測試集中準確率大概為99.2%。
我還寫了一些輔助函式，可以檢視部分識別錯誤的圖片，



還可以檢視混淆矩陣，

2.3 實現手寫識別系統

最後，將訓練好的引數儲存，封裝進一個GUI介面中，形成一個手寫識別系統。


系統中還添加了一點影象預處理的操作，比如灰度化，影象資訊的歸一化等，更貼近實際應用。
系統可進行快速識別，如下圖

3 總結

本文實現的系統其實是基於卷積神經網路的手寫數字識別系統。該系統能快速實現手寫數字識別，成功識別率高。缺點：只能正確識別單個數字，影象預處理還不夠，沒有進行影象分割，讀者也可以自行新增，進行完善。

4 收穫

本人之前的本科期間，雖然努力學習高數、線性代數和概率論，但是沒有認真學習過機器學習，本人是2017年才開始系統學習機器學習相關知識，而且本科畢業論文也選擇了相關的課題，雖然比較基礎，但是認真完成後，有一種學以致用的滿足感，同時也激勵著我進行更深入的理論學習和實踐探討，與所有讀者共勉。

========================================

2018年6月6日更新更新！！

python(TensorFlow)實現手寫字元識別

此處的“手寫字元”，其實指的是notMNIST資料庫中的手寫字元，其實和MNIST資料庫是一樣的。這裡實現手寫字元識別，主要是展示TensorFlow框架的可拓展性很強，具體來說，就是可以通過改動少部分的程式碼，從而實現一個新的識別功能。

NotMnist資料庫

這個資料庫和MNIST資料庫基本一樣，只是把10個數字換成了10個字母，即：A,B,C,D,E,F,G,H,I,J,K
當然，這個資料庫的識別難度大一些，因為資料噪聲更多一些，詳情讀者可以搜一搜瞭解一下。

實戰

將NotMNIST資料庫下載以後，放在本博文上述的網路中，基本不需要修改程式碼，直接訓練，即可得到一個能識別字符的網路模型。

最後在測試集中的準確率，比MNIST的會低一些，大概為96%左右。

本文也將訓練好的網路模型封裝在和上述系統相似的GUI系統中，

識別效果還可以！


同樣，將卷積卷積層視覺化。

結語

TensorFlow框架可拓展性很強，只要設計好了網路，就能很容易的實現出來；同時，使用基本的CNN識別整體架構也是大同小異的，很多識別任務是通用的。當然，在具體的實踐中需要得到接近完美的效果，還是要下很大功夫的！努力學習吧，加油！
（如果你/您有什麼有趣的想法，可以在下面留言，如果我也感興趣同時又有時間的話，我會嘗試做一做，^_^）