一文读懂经典卷积网络模型——LeNet-5模型（附代码详解、MNIST数据集）

欢迎关注微信公众号【计算机视觉联盟】 获取更多前沿AI、CV资讯

---

LeNet-5模型是Yann LeCun教授与1998年在论文Gradient-based learning applied to document recognition中提出的，它是第一个成功应用于数字识别问题的卷积神经网络。在MNIST数据集上，LeNet-5模型可以达到大约99.2%的正确率。

LeNet-5模型总共有7层，下图展示了LeNet-5模型的架构。

LeNet-5模型结构图

下边详细介绍LeNet-5模型每一层的结构。

第一层，卷积层（C1）

这一层的输入就是原始的图像像素，LeNet-5模型接受的输入层大小为32x32x1。第一个卷积层过滤器的尺寸为5x5，深度为6不使用全0填充，步长为1。因为没有使用全0填充，所以这 一 层的输出的尺寸为32-5+1=28，深度为6。这 一 个卷积层总共有5x5x1x6+6=156 个参数，其中6个为偏置项参数。因为下一层的节点矩阵有28x28x6=4704个节点，每个节点和5x5=25个当前层节点相连，所以本层卷积层总共有4704x(25+1)= 122304个连接 。

---

第二层，池化层（S2）

这一层的输入为第一层的输出，是一个28x28x6的节点矩阵。本层采用的过滤器大小为2x2，长和宽的步长均为2，所以本层的输出矩阵大小为14x14x6。

---

第三层，卷积层（C3）

本层的输入矩阵大小为14x14x6，使用的过滤器大小为5x5，深度为16。本层不使用全0填充，步长为1。本层的输出矩阵大小为 10x10x16。按照标准的卷积层 ，本层应该有5x5x6x16+16=2416个参数，10x10x16(25+1)=41600个连接 。

---

第四层，池化层（S4）

本层的输入矩阵大小为10x10x16，采用的过滤器大小为2×2，步长为2。本层的输出矩阵大小为5x5x16。

---

第五次，卷积层（C5）

本层的输入矩阵大小为5x5x16，使用的过滤器的大小为5×5，深度为120,。本层不使用全0填充，步长为1.本层的输出矩阵大小为1x1x120。总共有5x5x16x120+120=48120个参数。

本层也可以作如下理解：

（本层的输入矩阵大小为5x5x16，因为过滤器的大小就是5×5，所以和全连接层没有区别，在之后的 TensorFlow 程序实现中也会将这一层看成全连接层。如果将5x5x16矩阵中的节点拉成一个向量，那么这一层和全连接层输入就一样了。）

---

第六层，全连接层（F6）

本层的输入节点个数为120个，输出节点个数为84个，总共参数为120x84+84=10164个。

---

第七层，全连接层（Output）

本层的输入节点个数为84个，输出节点个数为10 个，分别代表数字0到9，总共参数为84x10+10=850个。LeNet-5模型论文中最后一层输出层的结构和全连接层有区别，但我们这用全连接层近似的表示 。

---

下边是用TensorFlow实现的LeNet-5模型：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

# ---------------------------------------【导入模块和数据】------------------------------------------------------
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

# --------------------------------------【配置神经网络结构相关的参数】-------------------------------------------
# MNIST数据集相关的常数
INPUT_NODE = 784  # 输入层节点数，因为图片是28*28*1的格式，每个像素点对应一个节点就是784
OUTPUT_NODE = 10  # 输出层节点数，0-9十个数字

# 图片相关参数
IMAGE_SIZE = 28   # 图片大小
NUM_CHANNELS = 1  # 通道数
NUM_LABELS = 10   # 标签数量


# 第一层卷积神经网络配置（深度和尺寸）
CONV1_DEEP = 32
CONV1_SIZE = 5
# 第二层卷积神经网络配置（深度和尺寸）
CONV2_DEEP = 64
CONV2_SIZE = 5
# 全连接层的节点个数
FC_SIZE = 512

BATCH_SIZE = 100  # Batch的大小
LEARNING_RATE_BASE = 0.8  # 基础学习率
LEARNING_RATE_DECAY = 0.99  # 学习率衰减速率
REGULARIZATION_RATE = 0.0001  # L2正则化参数（描述模型复杂度的正则化项在损失函数中的系数(lambda）
TRAINING_STEPS = 3000  # 训练轮数
MOVING_AVERAGE_DECAY = 0.99  # 滑动平均衰减率，decay


# ---------------------------------------------定义前向传播过程--------------------------------------------
def inference(input_tensor, train, regularizer):
    # 第一层，卷积层
    # 声明第一层卷积层的变量并实现前向传播过程，
    # 通过使用不同的命名空间来隔离不同层的变量，这可以让每一层中的变量命名只需要考虑在当前层的作用，不用担心重名的问题
    # 和标准的LeNet-5模型不大一样，这定义的卷积层输入为28*28*1的原始MNIST图片像素。
    # 卷积核大小5*5，深度为16，步长为1，,使用全0填充，输出为28*28*32的矩阵
    with tf.variable_scope('layer1-conv1'):
        # conv1_weights的大小为5*5*1*32
        conv1_weights = tf.get_variable("weight", [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEEP],
                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
        # conv1_biases的大小为32
        conv1_biases = tf.get_variable("bias", [CONV1_DEEP],
                                       initializer=tf.constant_initializer(0.0))
        # 计算卷积层：边长为5，深度为32，步长为1，且用全0填充
        conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1], padding="SAME")
        # 注意这里tf.nn.bias_add函数，函数给每一个节点加上偏置项
        relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))

    # 第二层，池化层
    # 实现第二层的前向传播。这里选用最大池化层，池化层的过滤器边长为2，步长为2，且使用全0补充
    # 这一层的输入是上一层的输出，即28*28*32的矩阵，输出为14*14*32的矩阵
    with tf.variable_scope('layer2-pool1'):
        pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    # 第三层，卷积层
    # 这一层的输入为14*14*32的矩阵
    # # 卷积核大小5*5，深度为64，步长为1，,使用全0填充，输出为14*14*64的矩阵
    with tf.variable_scope('layer3-conv2'):
        # conv2_weights的大小为5*5*32*64
        conv2_weights = tf.get_variable("weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],
                                        initializer=tf.truncated_normal_initializer(stddev=0.1))
        # conv2_biases的大小为64
        conv2_biases = tf.get_variable("bias", [CONV2_DEEP], initializer=tf.constant_initializer(0.0))
        # 卷积运算
        conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding="SAME")
        relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))

    # 第四层，池化层
    # 这里选用最大池化层，池化层的过滤器边长为2，步长为2，且使用全0补充
    # 输入为14*14*64，输出为7*7*64
    with tf.variable_scope('layer4-pool2'):
        pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    # 将第四层的输出转化为第五层全连接层的输入格式。第四层的输出7*7*64的矩阵，然而第五层全连接层需要的输入格式为向量，
    # 所以在这里需要将这个7*7*64的矩阵拉直成一个向量。
    with tf.variable_scope('flatten'):
        fla = tf.contrib.layers.flatten(pool2)
        nodes = fla.shape[1]

    # 第五层，全连接层
    # 输入是拉直后的一组向量，长度为3136，输出时一组长度为512的向量
    # 这里引入了dropout，dropout在训练时会随机将部分节点的输出改为0.dropout可以避免过拟合问题，
    # 从而使得模型在测试数据上的效果更好
    # dropout一般只在全连接层使用，卷积层或者池化层不使用
    with tf.variable_scope('layer5-fc1'):
        fc1_weights = tf.get_variable("weight", [nodes, FC_SIZE],
                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
        # 只有全连接层的权重需要加入正则化
        if regularizer is not None:
            tf.add_to_collection('losses', regularizer(fc1_weights))

        fc1_biases = tf.get_variable('bias', [FC_SIZE], initializer=tf.constant_initializer(0.1))
        fc1 = tf.nn.relu(tf.matmul(fla, fc1_weights) + fc1_biases)
        if train:
            fc1 = tf.nn.dropout(fc1, 0.5)

    # 第六岑，输出层
    # 输入为长度为512的向量，输出为一组长度为10的向量，这一层的输出通过Softmax之后就得到了最后的分类结果
    with tf.variable_scope('layer6-fc2'):
        fc2_weights = tf.get_variable("weight", [FC_SIZE, NUM_LABELS],
                                      initializer=tf.truncated_normal_initializer(stddev=0.1))
        if regularizer is not None:
            tf.add_to_collection('losses', regularizer(fc2_weights))
        fc2_biases = tf.get_variable("bias", [NUM_LABELS], initializer=tf.constant_initializer(0.1))
        logit = tf.matmul(fc1, fc2_weights) + fc2_biases

    # 返回第六层输出
    return logit


# -------------------------定义向后传播和训练过程（包括损失函数的计算，最终预测）-------------------------------
def train(mnist):
    """训练模型"""
    # 定义额输入输出placeholder
    x = tf.placeholder(tf.float32, shape=[None, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS], name="x-input")
    y_ = tf.placeholder(tf.float32, shape=[None, OUTPUT_NODE], name="y-input")

    # 定义正则化的方法
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    # 向前传播求出y
    y = inference(x, False, regularizer)

    # 定义存储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里指定这个变量为不可训练的变量（trainable=False）
    # 在使用TensorFlow训练神经网络时，一般会将代表训练轮数的变量指定为不可训练的参数
    global_step = tf.Variable(0, trainable=False)

    # 给定滑动平均衰减速率和训练轮数，初始化滑动平均类
    # 定训练轮数的变量可以加快训练前期的迭代速度
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

    # 用tf.trainable_variable()获取所有可以训练的变量列表，全部使用滑动平均
    variables_averages_op = variable_averages.apply(tf.trainable_variables())

    # 定义损失函数
    # 因为标准答案是一个长度为10的一维数组，argmax可以从这个矩阵（y_）的轴为1的部分取最大值的序号
    # 注意前面已经热点化答案了，所以最大值为1，其他值为0
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    # 获取总损失平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    # 给损失加上正则化的损失
    # 使用get_collection获取losses集合的全部值的列表，然后用add_n求列表的所有值的和
    loss = cross_entropy_mean + tf.add_n(tf.get_collection("losses"))

    # 求加上指数衰减的学习率
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True
    )

    # 优化损失函数
    # global_step初始值为0，在loss更新后会+1，用来记录更新的次数
    # 返回值是训练之后的梯度，会随着global_step递增
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    # 反向传播更新参数之后需要更新每一个参数的滑动平均值，用下面的代码可以一次完成这两个操作
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name="train")

    # y是计算得出的预测答案，而y_是正确答案，用argmax获取答案的序号（也即是数字的值）
    # equal()判断两个答案是否相等，是就返回True，否就返回False
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    # cast()把一个布尔类型的数转换为实数，然后用reduce_mean计算平均值，获取准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 开启会话，计算
    with tf.Session() as sess:
        # 初始化全局变量
        tf.global_variables_initializer().run()
        for i in range(TRAINING_STEPS):
            # tensorflow的数据集特有的一种batch_size获取方法
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            xs = np.reshape(xs, (BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
            if i % 1000 == 0:
                print("After %d training step(s), loss on training batch is %g" % (step, loss_value))
                test_x, test_y = mnist.test.next_batch(1000)
                test_x = test_x.reshape(-1, 28, 28, 1)
                train_acc = accuracy.eval(feed_dict={x: test_x, y_: test_y})
                print(train_acc)


def main(argv=None):
    # tf.reset_default_graph()
    mnist = input_data.read_data_sets('../datasets/MNIST_data/', one_hot=True)
    train(mnist)


if __name__ == "__main__":
    main()