深度学习-卷积神经网络-实例及代码3（图像分类LeNet5模型）—利用Tensorflow和mnist数据集训练LeNet5-CNN模型实现手写数字识别

系列文章：

深度学习-卷积神经网络-实例及代码0.8—基于最小均方误差的线性判别函数参数拟合训练

深度学习-卷积神经网络-实例及代码0.9—MNIST数据集介绍、下载及基本操作

深度学习-卷积神经网络-实例及代码1（入门）—利用Tensorflow和mnist数据集训练单层前馈神经网络/感知机实现手写数字识别

深度学习-卷积神经网络-实例及代码2（初级）—利用Tensorflow和mnist数据集训练简单的深度网络模型实现手写数字识别

 

论文Lecun-1998和其中提出的LeNet5模型是深度卷积网络CNN模型的开山之作，其计算机视觉-图像分类领域的重要性不言而喻。

在本文实例中，我们利用Tensorflow和mnist数据集学习LeNet5模型的实现与训练，对手写数字图片实现更加准确的分类识别。

英文原始论文下载：http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf，建议大家能够读一下原作中的原理描述部分，网上转述的往往会有一些理解上的偏差，原文阅读对于模型原理的体会能够更加深刻。

 

1、基础知识准备

（1）深度学习-卷积神经网络的基本原理

卷积层：卷积操作的目的是提取输入的不同特征，第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级，更多层的网路能从低级特征中迭代提取更复杂的特征

Relu层：也叫激活函数层，激活函数是用来加入非线性因素的，因为线性模型的表达能力不够

池化层：也叫下采样层，池化层主要用于压缩数据特征，减少参数的计算量，减小过拟合

全连接层：在整个卷积神经网络中起到“分类器”的作用。如果说卷积层、池化层和激活函数层等操作是将原始数据映射到隐层特征空间的话，全连接层则起到将学到的“分布式特征表示”映射到样本标记空间的作用。在实际使用中，全连接层可由卷积操作实现

（2）Tensorflow基础知识

Tensorflow中的计算图、张量、Session的运行等基本概念

Tensorflow中和卷积、Relu、池化、全连接、梯度下降等操作相关的函数使用

（3）利用Tensorflow进行训练的相关操作方法

Tensorflow的基本使用方法和卷积神经网络CNN模型训练的基本过程，可参考文章：

深度学习-卷积神经网络-实例及代码2（初级）—利用Tensorflow和mnist数据集训练简单的深度网络模型实现手写数字识别

 

2、实例及网络模型主要原理

（1）网络模型的输入

输入采用mnist手写数字识别数据集，图片在数据集中的数据大小为1*784，通过reshape转换为28*28大小的矩阵

需要将输入图片大小从28*28转换为32*32

（2）建立网络模型

网络的第一层：卷积层，卷积核为5*5，通道数/深度为6，不适用全0补充，步长为1
       尺寸变化：32*32*2 to 28*28*6

网络的第二层：池化层，下采样为2*2，使用全0补充，步长为2
       尺寸变化:28*28*6 to 14*14*6

网络的第三层：卷积层，卷积核为5*5，通道数/深度为16，不使用全0补充，步长为1
       尺寸变化：14*14*6 to 10*10*6

网络的第四层：池化层，下采样为2*2，使用全0补充，步长为2
       尺寸变化:10*10*6 to 5*5*16

网络的第五层：卷积层，卷积核为5*5，因为输入为5*5*16的map，所以也可视为全连接层
       尺寸变化：5*5*16=1*400 to 1*120

网络的第六层：全连接层
       尺寸变化：1*120 to 1*84

网络的第七层：输出层，基于径向基，近似为全连接层,经过softmax得到分类结果
       尺寸变化：1*84 to 1*10

计算卷积操作输出维度的公式为：

                               

其中N-输入维度、F-卷积核大小、stride-卷积步长、pad-0填充边缘

（3）准则函数

为了减少过拟合，引入了dropout机制和正则化项L2

损失函数使用目标类别和预测类别之间的交叉熵，通过损失函数最小化达到最小化误差的目的

（4）优化算法

训练优化器采用Adam梯度下降方法以最小化损失函数

（5）评估模型
利用tf.equal检测预测类别标签与真实类别标签是否一致，从而计算在测试数据集上的准确率

 

3、实例实现的主要步骤

（1）下载数据集，mnist数据集，可以直接去Lecun官网下载

      Lecun MNIST数据集网址：

                                 http://yann.lecun.com/exdb/mnist/

      mnist数据集介绍可以参考这篇文章：

                                  深度学习-卷积神经网络-实例及代码0.9—MNIST数据集介绍、下载及基本操作

（2）获取mnist数据集操作的python包，官方github上有（可能迁移了）

      也可参考我项目中的mnist文件夹

                               https://github.com/firemonkeygit/DeepLearningTensorflowMNIST

（3）编写代码

包括建立模型、训练模型和评估模型

利用MNIST训练集mnist.image训练网络模型

利用MNIST测试集mnist.test测试结果进行模型评估

      

4、实例代码分析                                 

本实例项目Github地址（如果对你有所帮助，欢迎关注点赞~）：

                        https://github.com/firemonkeygit/DeepLearningTensorflowMNIST

参考MnistDLTrainLeNet5.py文件，经过调试可用

注意导入操作mnist数据集的python包和配置正确的数据集路径

 

代码执行结果：

step 0,train_accuracy 0.11999999731779099
step 0,test_accuracy 0.11749999970197678
step 100,train_accuracy 0.3799999952316284
step 100,test_accuracy 0.3871000111103058
step 200,train_accuracy 0.6899999976158142
step 200,test_accuracy 0.6510000228881836
step 300,train_accuracy 0.8299999833106995
step 300,test_accuracy 0.8349000215530396
step 400,train_accuracy 0.9100000262260437
step 400,test_accuracy 0.8770999908447266
step 500,train_accuracy 0.8799999952316284
step 500,test_accuracy 0.8921999931335449
step 600,train_accuracy 0.9399999976158142
step 600,test_accuracy 0.909500002861023
step 700,train_accuracy 0.949999988079071
step 700,test_accuracy 0.9081000089645386
step 800,train_accuracy 0.949999988079071
step 800,test_accuracy 0.9251999855041504
step 900,train_accuracy 0.8999999761581421
step 900,test_accuracy 0.9323999881744385
final_accuracy 0.9399999976158142
 

详细代码贴出来如下：

import numpy as np
import tensorflow as tf
from TensorflowTest.mnist import input_data

#1.transform mnist from 28*28 to 32*32
def mnist_reshape_32(_batch):
    batch=np.reshape(_batch,[-1,28,28])
    num=batch.shape[0]
    batch_32=np.array(np.random.rand(num,32,32),dtype=np.float32)
    for i in range(num):
        batch_32[i]=np.pad(batch[i],2,'constant',constant_values=0)
    return batch_32

# def weight_variable(shape,name):
#     return tf.Variable(tf.truncated_normal(shape,stddev=0.1),nam=name)
# def bias_variable(shape,name):
#     return tf.Variable(tf.constant(0.1,shape=shape),name=name)
# def conv2d(x,w,padding):
#     return tf.nn.conv2d(x,w,strides=[1,1,1,1],padding=padding)
# def relu_bias(x,bias,name):
#     return tf.nn.relu(tf.nn.bias_add(x,bias),name=name)
# def max_pool_2x2(x):
#     return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

keep_prob=tf.placeholder(tf.float32)

def LeNetModel(x,regular):
    x_data=tf.reshape(x,[-1,32,32,1])
    #C1层：卷积层，卷积核为5*5，通道数/深度为6，不适用全0补充，步长为1
    #尺寸变化：32*32*2 to 28*28*6
    with tf.variable_scope('LayerC1'):
        c1weight=tf.Variable(tf.truncated_normal([5,5,1,6],stddev=0.1))
        tf.summary.histogram('c1/weight',c1weight)
        c1bias=tf.Variable(tf.constant(0.1,shape=[6]))
        tf.summary.histogram('c1/bias',c1bias)
        c1conv=tf.nn.conv2d(x_data,c1weight,strides=[1,1,1,1],padding='VALID')
        c1relu=tf.nn.relu(tf.nn.bias_add(c1conv,c1bias))
        tf.summary.histogram('c1/output',c1relu)
    #S2层：池化层，下采样为2*2，使用全0补充，步长为2
    #尺寸变化:28*28*6 to 14*14*6
    with tf.name_scope('LayerS2'):
        s2pool=tf.nn.max_pool(c1relu,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        tf.summary.histogram('s2/output',s2pool)
    #C3层：卷积层，卷积核为5*5，通道数/深度为16，不使用全0补充，步长为1
    #尺寸变化：14*14*6 to 10*10*6
    with tf.variable_scope('LayerC3'):
        c3weight=tf.Variable(tf.truncated_normal([5,5,6,16],stddev=0.1))
        tf.summary.histogram('c3/weight',c3weight)
        c3bias=tf.Variable(tf.constant(0.1,shape=[16]))
        tf.summary.histogram('c3/bias',c3bias)
        c3conv=tf.nn.conv2d(s2pool,c3weight,strides=[1,1,1,1],padding='VALID')
        c3relu=tf.nn.relu(tf.nn.bias_add(c3conv,c3bias))
        tf.summary.histogram('c3/output',c3relu)
    #S4层：池化层，下采样为2*2，使用全0补充，步长为2
    #尺寸变化:10*10*6 to 5*5*16
    with tf.variable_scope('LayerS4'):
        s4pool=tf.nn.max_pool(c3relu,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        tf.summary.histogram('s4/output',s4pool)
    #C5层：卷积层，卷积核为5*5，因为输入为5*5*16的map，所以也可视为全连接层
    #尺寸变化：5*5*16=1*400 to 1*120
    #训练时引入dropout随机将部分节点输出改为0，dropout可以避免过拟合，模型越简单越不容易过拟合
    #训练时引入正则化限制权重的大小，使得模型不能任意拟合训练数据中的随机早上，从而避免过拟合
    s4pool_shape=s4pool.get_shape().as_list()
    size=s4pool_shape[1]*s4pool_shape[2]*s4pool_shape[3]
    s4pool_reshape=tf.reshape(s4pool,[-1,size])
    with tf.variable_scope('LayerC5'):
        c5weight=tf.Variable(tf.truncated_normal([size,120],stddev=0.1))
        tf.summary.histogram('c5/weight',c5weight)
        c5bias=tf.Variable(tf.constant(0.1,shape=[120]))
        tf.summary.histogram('c5/bias',c5bias)
        if regular!=None:
            tf.add_to_collection('loss',regular(c5weight))
        c5=tf.matmul(s4pool_reshape,c5weight)
        c5relu=tf.nn.relu(tf.nn.bias_add(c5,c5bias))
        c5relu=tf.nn.dropout(c5relu,keep_prob)
        tf.summary.histogram('c5/output',c5relu)
    #F6层：全连接层
    #尺寸变化：1*120 to 1*84
    with tf.variable_scope('LayerF6'):
        f6weight=tf.Variable(tf.truncated_normal([120,84],stddev=0.1))
        tf.summary.histogram('f6/weight',f6weight)
        f6bias=tf.Variable(tf.constant(0.1,shape=[84]))
        tf.summary.histogram('f6/bias',f6bias)
        if regular!=None:
            tf.add_to_collection('loss',regular(f6weight))
        f6=tf.matmul(c5relu,f6weight)
        f6relu=tf.nn.relu(tf.nn.bias_add(f6,f6bias))
        f6relu=tf.nn.dropout(f6relu,keep_prob)
        tf.summary.histogram('f6/output',f6relu)
    #OUTPUT层：输出层，基于径向基，近似为全连接层,经过softmax得到分类结果
    #尺寸变化：1*84 to 1*10
    with tf.variable_scope('LayerF7'):
        f7weight=tf.Variable(tf.truncated_normal([84,10],stddev=0.1))
        tf.summary.histogram('f7/weight',f7weight)
        f7bias=tf.Variable(tf.constant(0.1,shape=[10]))
        tf.summary.histogram('f7/bias',f7bias)
        if regular!=None:
            tf.add_to_collection('loss',regular(f7weight))
        f7=tf.matmul(f6relu,f7weight)+f7bias
        tf.summary.histogram('f7/output',f7)
    return f7

mnist=input_data.read_data_sets('../../MNIST_data',one_hot=True)
xs=tf.placeholder(tf.float32,[None,32,32])
yLabels=tf.placeholder(tf.float32,[None,10])
regularizer = tf.contrib.layers.l2_regularizer(0.001)
ys=LeNetModel(xs,regularizer)

cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=ys,labels=tf.argmax(yLabels,1))
with tf.name_scope('lossValue'):
    loss=tf.reduce_mean(cross_entropy)+tf.add_n(tf.get_collection('loss'))
    tf.summary.scalar('lossValue',loss)
#with tf.name_scope('lossValue'):
    train_step=tf.train.GradientDescentOptimizer(0.01).minimize(loss)
correct_prediction=tf.equal(tf.argmax(ys,1),tf.argmax(yLabels,1))
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

xs_test32=mnist_reshape_32(mnist.test.images)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    merged=tf.summary.merge_all()
    writer=tf.summary.FileWriter('logs/',sess.graph)
    for i in range(1000):
        batch_xs,batch_ys=mnist.train.next_batch(100)
        batch_xs32=mnist_reshape_32(batch_xs)
        sess.run(train_step,feed_dict={xs:batch_xs32,yLabels:batch_ys,keep_prob:1.0})
        if i%100==0:
            train_accuracy=sess.run(accuracy,feed_dict={xs:batch_xs32,yLabels:batch_ys,keep_prob:1.0})
            print("step {0},train_accuracy {1}".format(i,train_accuracy))
            rs=sess.run(merged,feed_dict={xs:batch_xs32,yLabels:batch_ys,keep_prob:1.0})
            writer.add_summary(rs,i)
        if i%100==0:
            test_accuracy=sess.run(accuracy,feed_dict={xs:xs_test32,yLabels:mnist.test.labels,keep_prob:1.0})
            print("step {0},test_accuracy {1}".format(i,test_accuracy))
    final_accuracy=sess.run(accuracy,feed_dict={xs:batch_xs32,yLabels:batch_ys,keep_prob:1.0})
    print("final_accuracy {0}".format(final_accuracy))