Tensorflow实现简单的手写数字神经网络模型

1.全连接层直接实现手写数字神经网络

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

#对于使用FLAGS，则在终端上运行的命令python mnistClassify.py --is_train=0
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer("is_train",1,"指定程序是否为训练")

def full_connected():
    #加载MNIST数据
    mnist = input_data.read_data_sets("./MNIST/", one_hot=True)

    #1.建立数据占位符 x[None,784]  y[None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32,[None,784])
        y_true = tf.placeholder(tf.int32,[None,10])

    #2.建立一个全连接层的神经网络模型
    with tf.variable_scope("model"):
        #随机初始化权重和偏置
        weight = tf.Variable(tf.random_normal([784,10],mean=0.0,stddev=1.0),name="w")
        bias = tf.Variable(tf.constant(0.0,shape=[10]))
        y_predict = tf.matmul(x,weight) + bias

    #3.Softmax交叉熵损失函数, 求出所有样本的损失，然后求平均值
    with tf.variable_scope("loss"):
        #求平均交叉损失函数
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_predict))

    #4.梯度下降求出损失函数
    with tf.variable_scope("optimizer"):
        #学习率
        leaning_rate = 0.1
        train_op = tf.train.GradientDescentOptimizer(leaning_rate).minimize(loss)

    #5.计算准确率
    with tf.variable_scope("acc"):
        equal_list = tf.equal(tf.argmax(y_true,1),tf.argmax(y_predict,1))
        # equal_list None个样本    [1 0 0 1 0 1 . . . . ]
        accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))

    #收集变量 单个数字值收集
    tf.summary.scalar("losses",loss)
    tf.summary.scalar("acc",accuracy)
    #高纬度变量收集
    tf.summary.histogram("weight",weight)
    tf.summary.histogram("bias",bias)

    #定义初始化变量op
    init_op = tf.global_variables_initializer()

    #创建一个Serve
    serve = tf.train.Saver()

    #合并Summary
    meger = tf.summary.merge_all()

    #开启会话训练
    with tf.Session() as sess:
        sess.run(init_op)

        #建立事件events文件，然后写入
        filewrites = tf.summary.FileWriter("./MNIST/Events/",graph=sess.graph)

        if FLAGS.is_train == 1:
            # 迭代步数去训练，更新参数去预测
            for i in range(2000):
                # 取出训练集的特征值和目标值
                train_x, train_y = mnist.train.next_batch(50)

                sess.run(train_op, feed_dict={x: train_x, y_true: train_y})
                # 写入每步训练的值
                summary = sess.run(meger, feed_dict={x: train_x, y_true: train_y})
                filewrites.add_summary(summary, i)
                print("训练第%d步，准确率为:%f" % (i, sess.run(accuracy, feed_dict={x: train_x, y_true: train_y})))
            # 保存模型
            serve.save(sess, "./MNIST/model/fc_model")
        else:
            #加载模型
            serve.restore(sess,"./MNIST/model/fc_model")
            #如果是0，做出预测
            for i in range(100):
                #每次预测一张图片
                x_test, y_test = mnist.test.next_batch(1)
                print("第%d张图片，手写数字目标是:%d, 预测的图片结果是：%d"%(
                    i,
                    tf.argmax(y_test,1).eval(),
                    tf.argmax(sess.run(y_predict,feed_dict={x: x_test, y_true: y_test}),1).eval()
                ))

def prdect():
    # 加载MNIST数据
    mnist = input_data.read_data_sets("./MNIST/", one_hot=True)
    # 1.建立数据占位符 x[None,784]  y[None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32, [None, 784])
        y_true = tf.placeholder(tf.int32, [None, 10])

    # 2.建立一个全连接层的神经网络模型
    with tf.variable_scope("model"):
        # 随机初始化权重和偏置
        weight = tf.Variable(tf.random_normal([784, 10], mean=0.0, stddev=1.0), name="w")
        bias = tf.Variable(tf.constant(0.0, shape=[10]))
        y_predict = tf.matmul(x, weight) + bias
    # 创建一个Serve
    serve = tf.train.Saver()
    with tf.Session() as sess:
        # 加载模型
        serve.restore(sess, "./MNIST/model/fc_model")
        # 如果是0，做出预测
        for i in range(100):
            # 每次预测一张图片
            x_test, y_test = mnist.test.next_batch(1)
            print("第%d张图片，手写数字目标是:%d, 预测的图片结果是：%d" % (
                i,
                tf.argmax(y_test, 1).eval(),
                tf.argmax(sess.run(y_predict, feed_dict={x: x_test, y_true: y_test}), 1).eval()
            ))

if __name__ == "__main__":
    full_connected()
    prdect()

2. 卷积神经网络实现手写数字神经网络

def weight_variable(shape):
    """
    定义一个初始化的权重
    :param shape:
    :return:
    """
    weight = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=1.0), "w")
    return weight

def bias_variable(shape):
    """
    定义一个初始化的偏置
    :param shape:
    :return:
    """
    b = tf.Variable(tf.constant(0.0,shape=shape))
    return b

def model():
    """
    自定义卷积模型
    :return:
    """
    # 1.建立数据占位符 x[None,784]  y[None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32, [None, 784])
        y_true = tf.placeholder(tf.int32, [None, 10])

    #2.一层卷积 卷积，激活，池化
    with tf.variable_scope("conv1"):
        #随机初始化偏置和权重
        weight_1 = weight_variable([5, 5, 1, 32])
        bias_1 = bias_variable([32])

        #对输入x进行形状的改变  [None, 28, 28, 1]
        x_reshape = tf.reshape(x, [-1, 28, 28, 1])
        #卷积
        conv1 = tf.nn.conv2d(x_reshape,weight_1,strides=1, padding="SAME") + bias_1
        #激活函数
        x_relu1 = tf.nn.relu(conv1)

        #池化 2*2 , strides2 [None, 28, 28, 2] -----> [None, 14, 14, 32]
        x_pool1 = tf.nn.max_pool(x_relu1,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

    #二层卷积：5*5*32 64个filter , strides=1
    with tf.variable_scope("conv2"):
        # 随机初始化偏置和权重
        weight_2 = weight_variable([5, 5, 32, 64])
        bias_2 = bias_variable([64])

        #卷积，激活，池化
        #[None, 14, 14, 32] ----> [None, 14, 14, 64]
        # 卷积
        conv2 = tf.nn.conv2d(x_pool1, weight_2, strides=1, padding="SAME") + bias_2
        # 激活函数
        x_relu2 = tf.nn.relu(conv2)

        # 池化 2*2 , strides2 [None, 14, 14, 64] -----> [None, 7, 7, 64]
        x_pool2 = tf.nn.max_pool(x_relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    #全连接层   [None, 7, 7, 64] --->  [None, 7, 7, 64]*[7*7*64,10] + [10] = [None, 10]
    with tf.variable_scope("fc"):
        # 随机初始化偏置和权重
        weight_fc = weight_variable([7*7*64, 10])
        bias_fc = bias_variable([10])

        #修改形状  [None, 7, 7, 64] ----> [None,7*7*64]
        x_fc_reshpe = tf.reshape(x_pool2,[-1,7*7*64])

        #进行矩阵运算出每个样本的10个结果
        y_predict = tf.matmul(x_fc_reshpe,weight_fc) + bias_fc

    return x, y_true, y_predict

def conv_fc():
    """
    卷积神经网络训练手写数字
    :return:
    """
    # 加载MNIST数据
    mnist = input_data.read_data_sets("./MNIST/", one_hot=True)

    #定义模型，得出输出
    x, y_true, y_predict = model()

    #进行交叉熵损失计算
    # 3.Softmax交叉熵损失函数, 求出所有样本的损失，然后求平均值
    with tf.variable_scope("loss"):
        # 求平均交叉损失函数
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))

    # 4.梯度下降求出损失函数
    with tf.variable_scope("optimizer"):
        # 学习率
        leaning_rate = 0.001
        train_op = tf.train.GradientDescentOptimizer(leaning_rate).minimize(loss)

    # 5.计算准确率
    with tf.variable_scope("acc"):
        equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
        # equal_list None个样本    [1 0 0 1 0 1 . . . . ]
        accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))

    #初始化变量
    init_op = tf.global_variables_initializer()

    #开启会话
    with tf.Session() as sess:
        sess.run(init_op)

        for i in range(1000):
            # 取出训练集的特征值和目标值
            train_x, train_y = mnist.train.next_batch(50)

            sess.run(train_op, feed_dict={x: train_x, y_true: train_y})
            print("训练第%d步，准确率为:%f" % (i, sess.run(accuracy, feed_dict={x: train_x, y_true: train_y})))


    return None
if __name__ == "__main__":
    # full_connected()
    # prdect()
    conv_fc()