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

本文使用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 i0==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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130

運行結果顯示：測試集中準确率大概為99.2%。

我還寫了一些輔助函數，可以查看部分識别錯誤的圖片，

還可以查看混淆矩陣，

2.3 實現手寫識别系統

最後，将訓練好的參數保存，封裝進一個GUI界面中，形成一個手寫識别系統。

系統中還添加了一點圖像預處理的操作，比如灰度化，圖像信息的歸一化等，更貼近實際應用。

系統可進行快速識别，如下圖

3 總結

本文實現的系統其實是基于卷積神經網絡的手寫數字識别系統。該系統能快速實現手寫數字識别，成功識别率高。缺點：隻能正确識别單個數字，圖像預處理還不夠，沒有進行圖像分割，讀者也可以自行添加，進行完善。

4 收獲

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

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

2018年5月13日更新

源碼分享鍊接：https:///s/1BNlifR3DvIvTO5qkOTTpsQ

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

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識别整體架構也是大同小異的，很多識别任務是通用的。當然，在具體的實踐中需要得到接近完美的效果，還是要下很大功夫的！努力學習吧，加油！

（如果你/您有什麼有趣的想法，可以在下面留言，如果我也感興趣同時又有時間的話，我會嘗試做一做，^_^）

,

更多精彩资讯请关注tft每日頭條，我们将持续为您更新最新资讯!

查看全部