Python（TensorFlow框架）实现⼿写数字识别系统
⼿写数字识别算法的设计与实现
本⽂使⽤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-po
oling和mean-pooling，LeNet-5采⽤的是mean-pooling，即取n×n区域内像素的均值。C1通过2×2的窗⼝区域像素求均值再加上本层的阈值，然后经过激活函数的处理，得到S2层。pooling的实现，在保存图⽚信息的基础上，减少了权重参数，降低了计算成本，还能控制过拟合。本层学习参数共有
vba listbox控件的属性
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
"""
javafx项目实例#import modules
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import time
from datetime import timedelta
import math
ist import input_data
def new_weights(shape):
return tf.uncated_normal(shape,stddev=0.05))
def new_biases(length):
return tf.stant(0.1,shape=length))
def conv2d(x,W):
v2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(inputx):
ax_pool(inputx,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#import data
data = ad_data_sets("./data", one_hot=True)  # one_hot means [0 0 1 0 0 0 0 0 0 0] stands for 2
python入门教程 非常详细 pdfprint("Size of:")
print("--Training-set:\t\t{}".format(ain.labels)))
print("--Testing-set:\t\t{}".format(st.labels)))
print("--Validation-set:\t\t{}".format(len(data.validation.labels)))
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]),
layer_conv1 = {"weights":new_weights([5,5,1,32]),
"biases":new_biases([32])}
h_conv1 = lu(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 = lu(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 = lu(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登录界面代码python
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 = _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 = st.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)
j = min(i+test_batch_size,num_test)
# Get the images from the test-set between index i and j            images = st.images[i:j, :]
# Get the associated labels
labels = st.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 = st.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 实现⼿写识别系统

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。