卷积神经网络样例程序 （LeNet-5模型）（ MNIST作为测试数据）

写在前面：卷积神经网络的计算量很大，使用cpu训练的时间会很长，建议使用Tensorflow-gpu版本

 

 

定义卷积神经网络的相关参数和结构

mnist_inference.py

import tensorflow as tf
#定义神经网络结构相关的参数
INPUT_NODE = 784
OUTPUT_NODE = 10

IMAGE_SIZE = 28
NUM_CHANNELS = 1
NUM_LABELS = 10

#第一层卷积层的尺寸和深度。
CONV1_DEEP = 32
CONV1_SIZE = 5
#第二层卷积层的尺寸和深度
CONV2_DEEP = 64
CONV2_SIZE = 5
#全连接层的节点个数。
FC_SIZE = 512


#定义卷积神经网络的前向传播过程。这里添加一个新的参数train，用于区别训练过程和
# 测试过程。在这个程序中将用到dropout方法，dropout可以进一步提升模型可靠性并防止过拟合，
#dropout过程只在训练时使用。
def inference(input_tensor, train, regularizer):
    #声明第一层卷积层的变量并实现前向传播过程。
    #通过使用不同的命名空间来隔离不同层的变量，这可以让每一层的变量命名只需要
    #考虑当前层的作用，而不需要担心重名的问题。和标准LeNet-5模型不太一样，这里
    #定义的卷积层输入为28*28*1的原始MNIST图片像素。因为卷积层使用了全0填充，
    #所以输出位28*28*32的矩阵
    with tf.variable_scope('layer-conv1'):
        conv1_weights = tf.get_variable(
            "weight", [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEEP],
            initializer=tf.truncated_normal_initializer(stddev=(0.1)))
        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')
        relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))

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

    #声明第三层卷积层的变量并实现前向传播过程。这一层的输入为14*14*32的矩阵。
    #输出为14*14*64的矩阵。
    with tf.variable_scope('layer3-conv2'):
        conv2_weights = tf.get_variable(
            "weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],
            initializer=tf.truncated_normal_initializer(stddev=0.1))
        conv2_biases = tf.get_variable(
            "bias", [CONV2_DEEP], initializer=tf.constant_initializer(0.0))

        #使用边长为5，深度为64的过滤器，过滤器移动的步长为1，且实用全0填充。
        conv2 = tf.nn.conv2d(
            pooll, conv2_weights, strides=[1, 1, 1, 1], padding="SAME")
        relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))

    #实现第四层池化层的前向传播过程。这一层和第一层的结构是一样的。这一层的输入为
    #14*14*64的矩阵，输出为7*7*64的矩阵。
    with tf.name_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的矩阵拉直成一个
    # 向量，pool2.get_shape函数可以得到第四层输出矩阵的维度而不需要手工计算。注意
    # 因为每一层神经网络的输入输出都为一个batch矩阵，所以这里得到的维度也包含一个batch
    # 中数据的个数
    pool_shape = pool2.get_shape().as_list()

    # 计算将矩阵拉直成向量之后的长度，这个长度就是矩阵长宽及深度的乘积。注意这里
    # pool_shape[0]为一个batch中数据的个数。
    nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]

    # 通过tf.reshape函数将第四层的输出变成一个batch的向量。
    reshaped = tf.reshape(pool2, [pool_shape[0], nodes])

    # 声明第五层全连接层的变量并实现前向传播过程。这一层的输入是拉直之后的一组向量，
    # 向量长度为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 != None:
            tf.add_to_collection('losses', regularizer(fc1_weights))
        fc1_biases = tf.get_variable(
            "bisa", [FC_SIZE], initializer=tf.constant_initializer(0.1))
        fc1 = tf.nn.relu(tf.matmul(reshaped, 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 != None:
            tf.add_to_collection('losses', regularizer(fc2_weights))
        fc2_biases = tf.get_variable(
            "bisa", [NUM_LABELS], initializer=tf.constant_initializer(0.1))
        logit = tf.matmul(fc1, fc2_weights) + fc2_biases
    # 返回第六层的输出。
    return logit

 

训练过程：

mnist_train.py

import tensorflow as tf
import os
from tensorflow.examples.tutorials.mnist import input_data

# 加载mnist_inference.py中定义的常量和前向传播函数
import 卷积神经网络.mnist_inference as mnistinfer
import numpy as np

# 配置神经网络的参数。
BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8  # 使用指数衰减法设置学习率时可以将学习率设置的大一点
                          # 这样可以快速得到一个比较优的解，然后随着迭代的继续
                          # 逐步减小学习率，使得模型在后期更加稳定
LEARNING_RATE_DECAY = 0.99
REGULARATION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99
# 模型保存的路径和文件名
MODEL_SAVE_PATH = "path/to/model2"
MODEL_NAME = "model2.ckpt"


def train(mnist):
    print("开始训练！")
    # 定义输入输出placeholder
    x = tf.placeholder(
        tf.float32, [BATCH_SIZE, mnistinfer.IMAGE_SIZE, mnistinfer.IMAGE_SIZE,
                     mnistinfer.NUM_CHANNELS], name='x-inpyt')
    y_ = tf.placeholder(
        tf.float32, [None, mnistinfer.NUM_LABELS], name='y-input')
    #正则化损失函数L2
    regularizer = tf.contrib.layers.l2_regularizer(REGULARATION_RATE)
    # 直接使用mnist_inferense.py中定义的前向传播过程
    is_train = True
    y = mnistinfer.inference(x, is_train, regularizer)
    global_step = tf.Variable(0, trainable=False)

    # 定义损失函数、学习率、滑动平均操作以及训练过程
    variable_averages = tf.train.ExponentialMovingAverage(
        MOVING_AVERAGE_DECAY, global_step)
    variable_averages_op = variable_averages.apply(
        tf.trainable_variables())
    # 交叉熵与softmax函数一起使用
    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)
    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
    )
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name='train')

    # 初始化Tensorflow持久类。

    saver = tf.train.Saver()
    with tf.Session() as sess:
        print("变量初始化！")
        tf.global_variables_initializer().run()

        # 在训练过程中不在测试模型在验证数据上的表现，验证和测试的过程将会有一个独立的程序来完成
        for i in range(TRAINING_STEPS):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            reshaped_xs = np.reshape(xs, (BATCH_SIZE,
                                          mnistinfer.IMAGE_SIZE,
                                          mnistinfer.IMAGE_SIZE,
                                          mnistinfer.NUM_CHANNELS))
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs, y_: ys})

            # 每1000轮保存一次模型。
            if i % 10 == 0:
                print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
                #saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)


def main(argv=None):
    print("进入主函数！")
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
    print("准备训练！")
    train(mnist)


if __name__ == '__main__':
    tf.app.run()