利用卷积神经网络实现手写数字集识别

我们在之前的博客，已经学习了用KNN和dense SIFT算法实现图像分类，今天我们学习另一种新的方法来实现图像分类，用卷积神经网络实现手写数字集的分类。

一、卷积神经网络（CNN）

1.卷积神经网络概述

2.卷积​

二、leNet

三、数据集分析

四、实现

1.训练和测试模型

2.可视化

3.结果分析

（1）准确率

（2）可视化测试

一、卷积神经网络（CNN）

1.卷积神经网络概述

 受Hubel和Wiesel对猫视觉皮层电生理研究启发，有人提出卷积神经网络（CNN），Yann Lecun 最早将CNN用于手写数字识别并一直保持了其在该问题的霸主地位。近年来卷积神经网络在多个方向持续发力，在语音识别、人脸识别、通用物体识别、运动分析、自然语言处理甚至脑电波分析方面均有突破。

2.卷积

卷积是CNN的核心，使用卷积核来扫描图像，我们可以将卷积核理解成滤波器，传统的滤波器中每个格子的权重都是事先人为规定好的，而卷积核的权重是一步步学习的来的。局部卷积的作用是建立起每个神经元与图像的部分连接，这是与传统的神经网络最大的不同。

传统的神经网络采用的是全连接的结构，这样存在参数爆炸的问题，如果对1000*1000的图像进行全连接，大约需要1000*1000 * 1000*1000个参数。利用局部卷积替换全连接结构，可将参数降低至1000*1000 *10*10≈100M。这样可以提高效率，减少参数。传统神经网络和CNN对比图如下：

以上是我们对卷积神经网络感性的认识，接下来将具体介绍lenet网络，这是一种应用及其广泛的卷积神经网络。

二、leNet

LeNet网络是一种用于手写体字符识别的非常高效的卷积神经网络。虽然简单，但便于理解，而且涉及到卷积，池化，全连接，激活函数，softmax分类等等这些卷积网络的基本知识。

首先，了解一下leNet网络结构图：

从图中，我们可以清楚的看到leNet网络有7层，接下来我们就具体介绍每层网络吧！

输入：数据输入INPUT，图像尺寸归一化为32*32

C1层：对输入图像进行第一次卷积运算，使用的是6个大小为5*5的卷积核，所以卷积结果C1层是6幅大小为28*28（32-5+1=28）的特征图。如下图所示：

我们再来看看需要多少参数，卷积核的大小为5*5，总共有6*（5*5+1）=156个参数，其中+1是表示一个核有一个bias。对于卷积层C1，C1内的每个像素都与输入图像中的5*5个像素和1个bias有连接，所以总共有156*28*28=122304个连接（connection）。有122304个连接，但是我们只需要学习156个参数，主要是通过权值共享实现的 。

C1层具有如下特点：
   拓扑结构：输入层相邻节点卷积后仍然相邻
   稀疏连接：每个像素仅与输入层的相邻结点相连
   权值共享：同一副特征图共享相同的卷积核

S2层：第一次卷积之后紧接着是池化运算，使用2*2的核进行池化，于是得到了于是得到了S2，6个14*14的 特征图（28/2=14）。S2这个pooling层是对C1中的2*2区域内的像素相加，乘以一个权值系数再加上一个可训练偏置得到的，其中结果是通过sigmoid函数计算的。每个池化核有两个训练参数，所以共有2*6=12个训练参数，但是有14*14*（2*2+1）*6=5880个连接。如下图所示：
 

C3层：第一次池化之后是第二次卷积，卷积核的大小是5*5，得到的16幅10*10的特征图。如下图所示：

我们知道S2层是6幅14*14的特征图，而C3是16幅10*10的特征图，这6个特征图到16个特征图是怎么变的呢？这里是通过对S2的特征图进行特殊的组合计算得到的，具体如下：

如上表所示，我们将S2的6个特征图编号为0-5，即上表中的6行；C3层的16个特征图编号为0-15，即上表中的16列。 

C3层中的0-5个特征图是与S2层相连的3个特征图相连接（即红框部分），6-11个特征图是与S2层特征图相连的4个特征图相连接（即篮框部分），12-14个特征图是与S2层部分不相连的4个特征图相连接（即绿框部分），最后一个15特征图是与S2层所有的特征图相连接（即橙框部分），所以总共有

6*(3*5*5+1)+6*(4*5*5+1)+3*(4*5*5+1)+1*(6*5*5+1)=1516个参数。而图像大小为10*10，所以共有151600个连接。

C3层中的0-5个特征图是与S2层相连的3个特征图相连接（即红框部分）的卷积结构如下图所示：

上图对应的参数是3*5*5+1=76个参数，一共进行了6次卷积，得到6个特征图，所以共有6*76=456个参数，这样做的目的是：①减少参数②这种不对称的组合连接的方式更有利于提取多种组合特征。

S4层：S4层和S2层一样，也是池化层，窗口大小还是2*2，所以得到16个5*5的特征图。这层共有2*16=32个训练参数，有5*5*（2*2+1）*16=2000个连接，连接方式与S2类似。如下图所示：

C5层：C5层是一个卷积层，采用的全连接的方式。S4层是16个5*5的特征图，与卷积核大小相同，所以卷积吼形成的图大小为1*1.这里形成120个卷积结果。每个都与上一层的16个图相连（全连接），所以共有（5*5*16+1）*120=48120个参数，同样有48120个连接。

F6层：F6层是全连接层。F6层有84个节点，对应于一个7*12的比特兔，-1表示白色，1表示黑色。这样每个符号的比特图的黑白色就对应于一个编码。该层的训练参数和连接数是（120+1）*84=10164。如下图所示：

OUTPUT层：输出层也是全连接层，共有10个节点，分别代表0-9这10个数字。每个神经元的激活值表示对应字符的响应强度，最大值则为对应的识别结果。

三、数据集分析

本次采用的是MNIST手写数字集，有6万张训练图像和1万张测试图像组成，每张图像大小都是28*28的灰度图像，已经分好类，放在各自的文件夹下：

      

            训练数据集                                                                            测试数据集

通过数据的规模，我们已经看到每类平均有6000个训练数据，其中包括正常标准的数据（数字的大小和粗细会不同）和一些奇异的数据，比如数字旋转、数字缺失、数字扭曲（完全是书写不规范，肉眼也很难识别）、长得很像的数字、数字增添，如：

                                                   

1（旋转）     8（缺失）     8（扭曲）     1                7 （长很像）    7（增添）

四、实现

1.训练和测试模型

#coding:utf8
import os 
import cv2 
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

sess = tf.InteractiveSession()


def getTrain():
    train=[[],[]] # 指定训练集的格式，一维为输入数据，一维为其标签
    # 读取所有训练图像，作为训练集
    train_root="mnist_train" 
    labels = os.listdir(train_root)
    for label in labels:
        imgpaths = os.listdir(os.path.join(train_root,label))
        for imgname in imgpaths:
            img = cv2.imread(os.path.join(train_root,label,imgname),0)
            array = np.array(img).flatten() # 将二维图像平铺为一维图像
            array=MaxMinNormalization(array)  #数据归一化
            train[0].append(array)     #保存训练数据
            label_ = [0,0,0,0,0,0,0,0,0,0]
            label_[int(label)] = 1
            train[1].append(label_)    #保存训练数据标签
    train = shuff(train)    #打乱训练数据，使训练具有随机性，不会出现大范围波动
    return train

def getTest():
    test=[[],[]] # 指定训练集的格式，一维为输入数据，一维为其标签
    # 读取所有训练图像，作为训练集
    test_root="mnist_test" 
    labels = os.listdir(test_root)
    for label in labels:
        imgpaths = os.listdir(os.path.join(test_root,label))
        for imgname in imgpaths:
            img = cv2.imread(os.path.join(test_root,label,imgname),0)
            array = np.array(img).flatten() # 将二维图像平铺为一维图像
            array=MaxMinNormalization(array)
            test[0].append(array)
            label_ = [0,0,0,0,0,0,0,0,0,0]
            label_[int(label)] = 1
            test[1].append(label_)
    test = shuff(test)
    return test[0],test[1]

def shuff(data):
    #打乱数据集
    temp=[]
    for i in range(len(data[0])):
        temp.append([data[0][i],data[1][i]])
    import random
    random.shuffle(temp)
    data=[[],[]]
    for tt in temp:
        data[0].append(tt[0])
        data[1].append(tt[1])
    return data

count = 0
def getBatchNum(batch_size,maxNum):
    global count
    if count ==0:
        count=count+batch_size
        return 0,min(batch_size,maxNum)
    else:
        temp = count
        count=count+batch_size
        if min(count,maxNum)==maxNum:
            count=0
            return getBatchNum(batch_size,maxNum)
        return temp,min(count,maxNum)
    
def MaxMinNormalization(x):
    #归一化
    x = (x - np.min(x)) / (np.max(x) - np.min(x))
    return x


# 1、权重初始化,偏置初始化
# 为了创建这个模型，我们需要创建大量的权重和偏置项
# 为了不在建立模型的时候反复操作，定义两个函数用于初始化
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.1)#正太分布的标准差设为0.1
    return tf.Variable(initial)
def bias_variable(shape):
    initial = tf.constant(0.1,shape=shape)
    return tf.Variable(initial)


# 2、卷积层和池化层也是接下来要重复使用的，因此也为它们定义创建函数
# tf.nn.conv2d是Tensorflow中的二维卷积函数，参数x是输入，w是卷积的参数
# strides代表卷积模块移动的步长，都是1代表会不遗漏地划过图片的每一个点，padding代表边界的处理方式
# padding = 'SAME'，表示padding后卷积的图与原图尺寸一致，激活函数relu()
# tf.nn.max_pool是Tensorflow中的最大池化函数，这里使用2 * 2 的最大池化，即将2 * 2 的像素降为1 * 1的像素
# max_pool:最大池化会保留原像素块中灰度值最高的那一个像素，即保留最显著的特征，因为希望整体缩小图片尺寸
# ksize：池化窗口的大小，取一个四维向量，一般是[1,height,width,1]
# 因为我们不想再batch和channel上做池化，一般也是[1,stride,stride,1]
def conv2d(x, w):
    return tf.nn.conv2d(x, w, strides=[1,1,1,1],padding='SAME') # 保证输出和输入是同样大小
def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1],padding='SAME')
    
iterNum = 10
batch_size=1024

print("load train dataset.")
train=getTrain()
print("load test dataset.")
test0,test1=getTest()


# 3、参数
# 这里的x,y_并不是特定的值，它们只是一个占位符，可以在TensorFlow运行某一计算时根据该占位符输入具体的值
# 输入图片x是一个2维的浮点数张量，这里分配给它的shape为[None, 784]，784是一张展平的MNIST图片的维度
# None 表示其值的大小不定，在这里作为第1个维度值，用以指代batch的大小，means x 的数量不定
# 输出类别y_也是一个2维张量，其中每一行为一个10维的one_hot向量，用于代表某一MNIST图片的类别
x = tf.placeholder(tf.float32, [None,784], name="x-input")
y_ = tf.placeholder(tf.float32,[None,10]) # 10列


# 4、第一层卷积，它由一个卷积接一个max pooling完成
# 张量形状[5,5,1,32]代表卷积核尺寸为5 * 5，1个颜色通道，32个通道数目
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32]) # 每个输出通道都有一个对应的偏置量
# 我们把x变成一个4d 向量其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(灰度图的通道数为1，如果是RGB彩色图，则为3)
x_image = tf.reshape(x,[-1,28,28,1])
# 因为只有一个颜色通道，故最终尺寸为[-1，28，28，1]，前面的-1代表样本数量不固定，最后的1代表颜色通道数量
h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1) # 使用conv2d函数进行卷积操作，非线性处理
h_pool1 = max_pool_2x2(h_conv1)                          # 对卷积的输出结果进行池化操作


# 5、第二个和第一个一样，是为了构建一个更深的网络，把几个类似的堆叠起来
# 第二层中，每个5 * 5 的卷积核会得到64个特征
w_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2)# 输入的是第一层池化的结果
h_pool2 = max_pool_2x2(h_conv2)

# 6、密集连接层
# 图片尺寸减小到7 * 7，加入一个有1024个神经元的全连接层，
# 把池化层输出的张量reshape(此函数可以重新调整矩阵的行、列、维数)成一些向量，加上偏置，然后对其使用Relu激活函数
w_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1,7 * 7 * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)

# 7、使用dropout，防止过度拟合
# dropout是在神经网络里面使用的方法，以此来防止过拟合
# 用一个placeholder来代表一个神经元的输出
# tf.nn.dropout操作除了可以屏蔽神经元的输出外，
# 还会自动处理神经元输出值的scale，所以用dropout的时候可以不用考虑scale
keep_prob = tf.placeholder(tf.float32, name="keep_prob")# placeholder是占位符
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


# 8、输出层，最后添加一个softmax层
w_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2, name="y-pred")


# 9、训练和评估模型
# 损失函数是目标类别和预测类别之间的交叉熵
# 参数keep_prob控制dropout比例，然后每100次迭代输出一次日志
cross_entropy = tf.reduce_sum(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# 预测结果与真实值的一致性，这里产生的是一个bool型的向量
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
# 将bool型转换成float型，然后求平均值，即正确的比例
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 初始化所有变量，在2017年3月2号以后,用 tf.global_variables_initializer()替代tf.initialize_all_variables()
sess.run(tf.initialize_all_variables())

# 保存最后一个模型
saver = tf.train.Saver(max_to_keep=1)


for i in range(iterNum):
    for j in range(int(len(train[1])/batch_size)):
        imagesNum=getBatchNum(batch_size,len(train[1]))
        batch = [train[0][imagesNum[0]:imagesNum[1]],train[1][imagesNum[0]:imagesNum[1]]]
        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    if i % 2 == 0:
        train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1],keep_prob: 1.0})
        print("Step %d ,training accuracy %g" % (i, train_accuracy))
print("test accuracy %f " % accuracy.eval(feed_dict={x: test0, y_:test1, keep_prob: 1.0})) 
# 保存模型于文件夹
saver.save(sess,"save/model")

首先用getTrian（）和getTest（）分别读取、处理训练集和测试集并保存。因为训练集和测试集是二维的灰度图，所以我们要将二维数据转化为一维数据（np.array(img).flatten()）并将数据归一化（MaxMinNormalization(））。同时，训练集和测试集的数据都是0-9排列好的，这样会出现大范围波动，不利于训练和测试，所以我们先把训练集和测试集，加上标签并打乱数据（shuff（））。再进行训练和测试。然后我们设置卷积和池化初始函数，然后设置每层网络进行训练，训练之后再进行测试计算出正确率，迭代多次，提高准确率。最后保存模型，以便后面使用。

2.可视化

import tensorflow as tf
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
from tkinter import filedialog
import time


def creat_windows():
    win = tk.Tk() # 创建窗口
    sw = win.winfo_screenwidth()
    sh = win.winfo_screenheight()
    ww, wh = 400, 450
    x, y = (sw-ww)/2, (sh-wh)/2
    win.geometry("%dx%d+%d+%d"%(ww, wh, x, y-40)) # 居中放置窗口

    win.title('手写体识别') # 窗口命名

    bg1_open = Image.open("timg.jpg").resize((300, 300))
    bg1 = ImageTk.PhotoImage(bg1_open)
    canvas = tk.Label(win, image=bg1)
    canvas.pack()


    var = tk.StringVar() # 创建变量文字
    var.set('')
    tk.Label(win, textvariable=var, bg='#C1FFC1', font=('宋体', 21), width=20, height=2).pack()

    tk.Button(win, text='选择图片', width=20, height=2, bg='#FF8C00', command=lambda:main(var, canvas), font=('圆体', 10)).pack()
    
    win.mainloop()

def main(var, canvas):
    file_path = filedialog.askopenfilename()
    bg1_open = Image.open(file_path).resize((28, 28))
    pic = np.array(bg1_open).reshape(784,)
    bg1_resize = bg1_open.resize((300, 300))
    bg1 = ImageTk.PhotoImage(bg1_resize)
    canvas.configure(image=bg1)
    canvas.image = bg1

    init = tf.global_variables_initializer()

    with tf.Session() as sess:
            sess.run(init)
            saver = tf.train.import_meta_graph('save/model.meta')  # 载入模型结构
            saver.restore(sess, 'save/model')  # 载入模型参数
            graph = tf.get_default_graph()       # 加载计算图
            x = graph.get_tensor_by_name("x-input:0")  # 从模型中读取占位符变量
            keep_prob = graph.get_tensor_by_name("keep_prob:0")
            y_conv = graph.get_tensor_by_name("y-pred:0")  # 关键的一句  从模型中读取占位符变量
            prediction = tf.argmax(y_conv, 1)
            predint = prediction.eval(feed_dict={x: [pic], keep_prob: 1.0}, session=sess)  # feed_dict输入数据给placeholder占位符
            answer = str(predint[0])
    var.set("预测的结果是：" + answer)

if __name__ == "__main__":
    creat_windows()

3.结果分析

（1）准确率

选用没迭代两次输出一次正确率，我们可以看到0次迭代时准确率是88.48%,到了8次迭代后正确率已经达到98%以上了，说明只需很少的迭代次数就可以达到很好的正确率。同时，我们也可以发现，迭代前期正确率提高和很快，越往后，正确率提高的程度越小，所以说要达到接近100%正确率需要很多迭代次数。

（2）可视化测试

运用MNIST提供的测试集准确率很高，测试结果我就不展示了，直接展示自己写的数字的测试结果：

自己手写的测试集，包括正常的、缺失的、增添和粗细不一致的数据：

测试结果：

①正确识别：

②错误识别

    

这两组识别错误，是由于输出是10个节点，每个神经元的激活值表示对应字符的响应强度，最大值则为对应的识别结果。我们可以看到9→1中，像1的竖太长，而像9的圈又太小，所以可能是1的激活值大于9的激活值，最后识别成1了。9→4中，由于9的圈过于有棱角，所以更像4一些，同时，这个9是通过喷漆写出来的，所以不连贯，这可能也是错误识别的原因之一。

参考：

https://blog.csdn.net/yunpiao123456/article/details/52437794

https://blog.csdn.net/zhangjunhit/article/details/53536915