Tensorflow—基于TensorFlow实现手写数字的模型训练预测

import os
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 加几个随机数种子，让多次运行的时候，随机数列一致
np.random.seed(28)
tf.set_random_seed(28)

if __name__ == '__main__':
    with tf.Graph().as_default():
        # 一、执行图的构建
        unit_size1 = 32
        unit_size2 = 64
        with tf.variable_scope('network',
                               initializer=tf.random_normal_initializer(mean=0.0, stddev=0.01)):
            with tf.variable_scope("InputLayer"):
                # a. 定义占位符
                input_x = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='image')
                input_y = tf.placeholder(dtype=tf.float32, shape=[None, 10], name='label')
				
				tf.summary.image(name='mnist',  # 给定可视化的字符串名称
                 				tensor=tf.reshape(input_x, shape=[-1, 28, 28, 1]),
                             # 给定可视化的tensor对象，要求形状必须为[batch_size, height, width, channels]， 也就是[样本数目，一张图形的高度，一张图形的宽度，一张图形的通道数<灰度图形为1，RGB图形为3>]
                 				max_outputs=10  # 每次训练可视化batch_size个样本中的前多少个图形
                             )
            with tf.variable_scope("Hidden_Layer_1"):
                # 1. 定义参数
                w = tf.get_variable(name='w', shape=[784, unit_size1])
                b = tf.get_variable(name='b', shape=[unit_size1])
                # 2. 计算
                n1 = tf.matmul(input_x, w) + b
                # 3. 激活
                o1 = tf.nn.sigmoid(n1)

            with tf.variable_scope("Hidden_Layer_2"):
                # 1. 定义参数
                w = tf.get_variable(name='w', shape=[unit_size1, unit_size2])
                b = tf.get_variable(name='b', shape=[unit_size2])
                # 2. 计算
                n2 = tf.matmul(o1, w) + b
                # 3. 激活
                o2 = tf.nn.sigmoid(n2)

            with tf.variable_scope("Output_Layer"):
                # 1. 定义参数
                w = tf.get_variable(name='w', shape=[unit_size2, 10])
                b = tf.get_variable(name='b', shape=[10])
                # 2. 计算
                z = tf.matmul(o2, w) + b
                p = tf.nn.softmax(z)
                y_ = tf.argmax(p, axis=1)

        with tf.name_scope('loss'):
            # d. 损失函数构建（交叉熵损失函数）
            loss = tf.reduce_mean(-tf.log(tf.reduce_sum(input_y * p, axis=1)), name='loss')
            tf.summary.scalar('loss', loss)

        with tf.name_scope('train'):
            # e. 定义优化器(优化器的意思：求解让损失函数最小的模型参数<变量>的方式)
            # optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
            optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
            # f. 定义一个训练操作对象
            train_op = optimizer.minimize(loss=loss)

        with tf.name_scope('accuracy'):
            # 将实际值转换为和预测值一样的形式
            label_ = tf.argmax(input_y, axis=1)
            # 比较预测值和实际值，并且将相等的位置设置为1，不相等的位置设置为0
            tmp = tf.cast(tf.equal(y_, label_), tf.float32)
            # 直接计算均值作为准确率
            accuracy = tf.reduce_mean(tmp)
            tf.summary.scalar('acc', accuracy)

        # 二、执行图的训练运行
        with tf.Session() as sess:
            # a. 创建一个持久化对象
            saver = tf.train.Saver()

            # a. 变量的初始化操作
            sess.run(tf.global_variables_initializer())
            # saver.restore(sess, './models/25/model/model.ckpt')

            # 获取一个日志输出对象
            writer = tf.summary.FileWriter(logdir='./models/01/graph', graph=sess.graph)
            # 获取所有的summary输出操作
            summary = tf.summary.merge_all()

            # b. 训练数据的产生/获取（基于numpy随机产生<可以先考虑一个固定的数据集>）
            mnist = input_data.read_data_sets(
                train_dir='../datas/mnist',  # 给定本地磁盘的数据存储路径
                one_hot=True,  # 给定返回的数据中是否对Y做哑编码
                validation_size=5000  # 给定验证数据集的大小
            )
            x_train, y_train = mnist.train.images, mnist.train.labels
            x_test, y_test = mnist.test.images, mnist.test.labels

            # c. 模型训练
            for step in range(10):
                # 1. 触发模型训练操作
                _, loss_, accuracy_, summary_ = sess.run([train_op, loss, accuracy, summary], feed_dict={
                    input_x: x_train,
                    input_y: y_train
                })
                print("第{}次训练后模型的损失函数为:{}, 准确率:{}".format(step, loss_, accuracy_))
                writer.add_summary(summary_, global_step=step)
                # 触发模型持久化
                save_path = './models/01/model/model.ckpt'
                dirpath = os.path.dirname(save_path)
                if not os.path.exists(dirpath):
                    os.makedirs(dirpath)
                saver.save(sess, save_path=save_path)

            # 1. 触发模型训练操作
            loss_, accuracy_ = sess.run([loss, accuracy], feed_dict={
                input_x: x_test,
                input_y: y_test
            })
            print("最终模型在测试数据上的损失函数:{}, 准确率:{}".format(loss_, accuracy_))

            # 关闭输出流
            writer.close()

注：
一、

'''
tensorflow执行的一般流程：
'''
with tf.Graph().as_default():
	# 零、 获取全局step变量对象
    global_step = tf.Variable(0, dtype=tf.int64)
    
    # 一、执行图的构建
    with tf.variable_scope('network'):
    	# a. 定义占位符
    	# b. 定义模型参数
    	# c. 模型预测的构建（获取预测值）
    	
    # 二、 损失函数构建
    with tf.name_scope('loss'):
    
    # 三、 计算准确率
    with tf.name_scope('accuracy'):
    
	#四、执行图的训练运行
	with tf.Session() as sess:

二、

tf.summary.image(name='mnist',  # 给定可视化的字符串名称
                 tensor=tf.reshape(input_x, shape=[-1, 28, 28, 1]),
                             # 给定可视化的tensor对象，要求形状必须为[batch_size, height, width, channels]， 也就是[样本数目，一张图形的高度，一张图形的宽度，一张图形的通道数<灰度图形为1，RGB图形为3>]
                 max_outputs=10  # 每次训练可视化batch_size个样本中的前多少个图形
                             )