tensorflow 基础学习九：mnist卷积神经网络

mnist_inference.py：

# -*- coding:utf-8 -*-
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

def inference(input_tensor,train,regularizer):

    # 输入：28×28×1，输出：28×28×32
    with tf.variable_scope(‘layer1-conv1‘):
        conv1_weights=tf.get_variable(‘weights‘,[CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_DEEP],
                                     initializer=tf.truncated_normal_initializer(stddev=0.1))
        conv1_biases=tf.get_variable(‘biases‘,[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))

    # 输入：28×28×32，输出：14×14×32
    with tf.name_scope(‘layer2-pool1‘):
        pool1=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(‘weights‘,[CONV2_SIZE,CONV2_SIZE,CONV1_DEEP,CONV2_DEEP],
                                     initializer=tf.truncated_normal_initializer(stddev=0.1))
        conv2_biases=tf.get_variable(‘biases‘,[CONV2_DEEP],initializer=tf.constant_initializer(0.0))

         # 使用尺寸为5，深度为64的过滤器，步长为1，使用全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))

    # 输入：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的矩阵转换成一个向量，因为每一层神经网络的输入输出都为一个batch矩阵，所以这里得到的维度
        # 也包含了一个batch中数据的个数（batch×7×7×64 --> batch×vector)
        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])

    with tf.variable_scope(‘layer5-fc1‘):
        fc1_weights=tf.get_variable(‘weights‘,[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(‘biases‘,[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)

    with tf.variable_scope(‘layer6-fc2‘):
        fc2_weights=tf.get_variable(‘weights‘,[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(‘biases‘,[NUM_LABELS],initializer=tf.constant_initializer(0.1))
        logit=tf.matmul(fc1,fc2_weights)+fc2_biases

    return logit

mnist_train.py：

# -*- coding:utf-8 -*-
import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
import mnist_inference

# 配置神经网络的参数
BATCH_SIZE=100
LEARNING_RATE_BASE=0.01
LEARNING_RATE_DECAY=0.99
REGULARAZTION_RATE=0.0001
TRAINING_STEPS=6000
MOVING_AVERAGE_DECAY=0.99

# 模型保存的路径和文件名
MODEL_SAVE_PATH=‘log/‘
MODEL_NAME=‘model.ckpt‘

def train(mnist):
    # 定义输入输出placeholder
    x=tf.placeholder(tf.float32,[BATCH_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS],name=‘x-input‘)
    y_=tf.placeholder(tf.float32,[None,mnist_inference.OUTPUT_NODE],name=‘y-input‘)

    regularizer=tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    # 直接使用mnist_inference.py 中定义的前向传播过程。
    y=mnist_inference.inference(x,False,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())

    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,staircase=True)
    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:
        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,mnist_inference.IMAGE_SIZE,mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS))
            _,loss_value,step=sess.run([train_op,loss,global_step],feed_dict={x:reshaped_xs,y_:ys})

            # 每1000轮保存一次模型
            if i % 1000 == 0:
                print(‘After {} training step(s), loss on training batch is {}.‘.format(step,loss_value))
                # 这里给出了global_step参数，可以在每个被保存模型的文件名末尾加上训练的轮数
                saver.save(sess,os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)

def main(argv=None):
    mnist=input_data.read_data_sets(‘.‘,one_hot=True)
    train(mnist)

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

原文地址：https://www.cnblogs.com/hypnus-ly/p/8322671.html