深度学习 手写字体识别_手写字体识别转正

数据集介绍：

mnist数据集使用tensorflow封装好的数据（包含6000张训练数据，1000张测试数据），图片大小为28x28。

在神经网络的结构上，一方面需要使用激活函数去线性化。另一方面需要增加网络的层数以解决更加复杂的问题。

关于tensorflow中的几个函数：
1. tf.Variable()和 tf.get_variable()中的区别：

tf.Variable()： 创建一个变量,

tf.get_variable():  创建或者获取一个变量,在用来创建变量时，和 tf.Variable()功能基本相同。

这两个函数不同的地方是，tf.Variable()函数，变量名称时可选的参数。tf.get_variable()变量名称是必填的参数，它会根据这个名称去创建或者获取变量。

（引用自：https://blog.csdn.net/weixin_38698649/article/details/80099822）

变量共享主要涉及两个函数：tf.variable() 和tf.get_variable()；即就是必须要在tf.variable_scope的作用域下使用tf.get_variable()函数。这里用tf.get_variable( ) 而不用tf.Variable( )，是因为tf.get_variable( ) 拥有一个变量检查机制，会检测已经存在的变量是否设置为共享变量，如果已经存在的变量没有设置为共享变量，TensorFlow 运行到第二个拥有相同名字的变量的时候，就会报错。

两个创建变量的方式。如果使用tf.Variable() 的话每次都会新建变量。但是大多数时候我们是希望重用一些变量，所以就用到了get_variable()，它会去搜索变量名，有就直接用，没有再新建。

既然用到变量名了，就涉及到了名字域的概念。通过不同的域来区别变量名，毕竟让我们给所有变量都取不同名字还是很辛苦。这就是为什么会有scope 的概念。name_scope 作用于操作，variable_scope 可以通过设置reuse 标志以及初始化方式来影响域下的变量，因为想要达到变量共享的效果, 就要在 tf.variable_scope()的作用域下使用 tf.get_variable() 这种方式产生和提取变量. 不像 tf.Variable() 每次都会产生新的变量, tf.get_variable() 如果遇到了已经存在名字的变量时, 它会单纯的提取这个同样名字的变量，如果不存在名字的变量再创建.。

2. name_scope和variable_scope的区别

TF中有两种作用域类型
命名域 (name scope)，通过tf.name_scope 或 tf.op_scope创建；
变量域 (variable scope)，通过tf.variable_scope 或 tf.variable_op_scope创建；
这两种作用域，对于使用tf.Variable()方式创建的变量，具有相同的效果，都会在变量名称前面，加上域名称。

对于通过tf.get_variable()方式创建的变量，只有variable scope名称会加到变量名称前面，而name scope不会作为前缀。例如 print(v1.name) # var1:0

网络的结构如图所示：

tensorflow实现：

# encoding: utf-8
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
 
 
class TrainData:
    def __init__(self, data_path, batch_size=100):
        """
        :param data_path: 训练数据路径
        """
        self.batch_size = batch_size
        self.mnist = input_data.read_data_sets(train_dir=data_path, one_hot=True)
 
    def display_data_info(self):
        """
        输出数据集的信息
        :return:
        """
        print("-"*40)
        print("training data size: {}".format(self.mnist.train.num_examples))
        print("test data size: {}".format(self.mnist.test.num_examples))
        print("validation data size: {}".format(self.mnist.validation.num_examples))
        print("-"*40)
 
    def next_batch(self):
        """
        获取下一个batch的数据  经过处理后的图片为（28x28=784）的一维数组
        :return:
        """
        xs, ys = self.mnist.train.next_batch(self.batch_size)    # 返回训练数据和标签  xs: [batch_size, 784]
        return xs, ys
 
    def validation_data(self):
        """
        返回验证集
        :return:
        """
        images, labels = self.mnist.validation.images, self.mnist.validation.labels
        return images, labels
 
    def test_data(self):
        """
        返回测试集
        :return:
        """
        images, labels = self.mnist.test.images, self.mnist.test.labels
        return images, labels
 
 
class Model:
    def __init__(self, input_node, output_node, layer1_node, layer2_node, regularizer=False, moving_average=False):
        """
        :param input_node:      输入数据的维度
        :param output_node:     输出数据的维度
        :param layer1_node:     隐藏层
        :param layer2_node:     隐藏层
        :param regularizer:     L2正则化
        :param moving_average:    滑动平均模型
        """
        self.input_node = input_node
        self.output_node = output_node
        self.layer1_node = layer1_node
        self.layer2_node = layer2_node
        # self.train_step = train_step
        self.regularizer = regularizer
        self.moving_average = moving_average
        self.moving_average_decay = 0.99    # 滑动平均衰减率
        # self.batch_size = batch_size
 
        """
            关于滑动平均模型：
            实际的原理是对参数的更新进行一阶之后滤波
            对每一个参数会维护一个影子变量shadow_variable
            shadow_variable = shadow_variable * decay + (1 - decay) * variable
            decay 决定了模型的更心速度
            num_updates参数来动态设置参数的大小
            decay = min{decay, (1+num_updates)/(10+num_up_dates)}
            """
 
        self.learning_rate_base = 0.0001     # 初始学习率
        self.learning_rate_decay = 0.98   # 学习率的衰减速度
        self.regularizer_rate = 0.001     # 正则化lambda
 
        with tf.name_scope("placeholder"):   # 变量名
            self.x = tf.placeholder(dtype=tf.float32, shape=[None, self.input_node], name='x-input')
            self.y_ = tf.placeholder(dtype=tf.float32, shape=[None, self.output_node], name='y-input')
 
        with tf.name_scope("weights"):
            # 网络第一层
            self.weight1 = tf.get_variable(initializer=tf.random_normal(dtype=tf.float32,
                                                                        shape=[self.input_node, self.layer1_node],
                                                                        mean=0, stddev=1),
                                           name='weight1')
            self.biases1 = tf.get_variable(initializer=tf.constant_initializer(0.0), shape=[self.layer1_node],
                                           dtype=tf.float32, name='biases1')
            self.layer1 = tf.nn.relu(tf.matmul(self.x, self.weight1) + self.biases1)    # 第一层
            # 正则化
            if self.regularizer:
                tf.add_to_collection(name='loss', value=tf.contrib.layers.l2_regularizer(self.regularizer_rate)(self.weight1))
 
            # 网络第二层
            self.weight2 = tf.get_variable(initializer=tf.random_normal(dtype=tf.float32,
                                                                        shape=[self.layer1_node, self.layer2_node],
                                                                        mean=0, stddev=1),
                                           name='weight2')
            self.biases2 = tf.get_variable(initializer=tf.constant_initializer(0.0), shape=[self.layer2_node],
                                           dtype=tf.float32, name='biases2')
            self.layer2 = tf.nn.relu(tf.matmul(self.layer1, self.weight2) + self.biases2)
            # 正则化
            if self.regularizer:
                tf.add_to_collection(name='loss', value=tf.contrib.layers.l2_regularizer(self.regularizer_rate)(self.weight2))
 
            # 网络第三层  全连接层
            self.weight3 = tf.get_variable(initializer=tf.random_normal(dtype=tf.float32, shape=[self.layer2_node, self.output_node],
                                                                        mean=0, stddev=1),
                                           name='weight3')
            self.biases3 = tf.get_variable(initializer=tf.constant_initializer(0.0), shape=[self.output_node],
                                           dtype=tf.float32, name='biases3')
            self.y = tf.matmul(self.layer2, self.weight3) + self.biases3   # 网络输出
 
        # 定义损失函数
        with tf.name_scope('create_loss'):
            # 计算交叉熵损失函数
            # 问题只有一个正确答案的时候，可以使用sparse_softmax_cross_entropy_with_logits来计算交叉熵
            # 这个函数可以加速交叉熵的计算
            # 但是这个函数需要提供的正确答案是一个数字，而不是one-hot向量
            self.cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=self.y, labels=tf.argmax(self.y_, 1))
            self.cross_entropy_mean = tf.reduce_mean(self.cross_entropy)
            tf.add_to_collection(name='loss', value=self.cross_entropy_mean)
            self.loss = tf.add_n(tf.get_collection('loss'))     # 总的loss
        with tf.name_scope("optimizer"):
            self.optimizer = tf.train.AdamOptimizer(self.learning_rate_base).minimize(self.loss)
 
        with tf.name_scope("evaluate"):    # 验证集
            self.correct_prediction = tf.equal(tf.argmax(self.y, 1), tf.argmax(self.y_, 1))
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, dtype=tf.float32), name="accuracy")
 
        # tensorboard显示数据
        with tf.name_scope("summary"):
            tf.summary.scalar("loss", self.loss)
            tf.summary.scalar("accuracy", self.accuracy)
            self.summary_op = tf.summary.merge_all()
 
    def train(self, train_data, train_step=300):
        """
         训练数据
        :param train_data:
        :param train_step:
        :return:
        """
        with tf.Session() as sess:
            init_op = tf.group(tf.local_variables_initializer(), tf.global_variables_initializer())
            sess.run(init_op)
            # train_data = TrainData(data_path=train_data_path, batch_size=self.batch_size)
            board_data = r"E:\back_up\code\112\tensorflow_project\newbook\chapter3\model\tensorboard"  # tensorboard数据保存路径
            model_save = r'E:\back_up\code\112\tensorflow_project\newbook\chapter3\model\garph\graph'
            writer = tf.summary.FileWriter(logdir=board_data, graph=sess.graph)     # 保存tensorboard中的数据
            saver = tf.train.Saver(tf.global_variables(), max_to_keep=2)    # 保存模型
            for step in range(train_step):           # 开始训练
                xs, ys = train_data.next_batch()
                feed_dict = {self.x: xs, self.y_: ys}
                _, loss, summary = sess.run([self.optimizer, self.loss, self.summary_op], feed_dict=feed_dict)
                # print("loss after {} steps is {}".format(step, loss))
                if step % 200 == 0:
                    feed_dict = {self.x: train_data.validation_data()[0], self.y_: train_data.validation_data()[1]}
                    accuracy = sess.run(self.accuracy, feed_dict=feed_dict)
                    print("After {} step accuracy is {}".format(step, accuracy))
 
                    # 保存模型
                    saver.save(sess=sess, save_path=model_save)
                    # 保存tensorboard数据
                    writer.add_summary(summary=summary, global_step=step)
 
 
def predict(train_data):
    """
    对输入的值进行预测
    :param train_data:   输入数据
    :return:
    """
    # 加载训练好的模型
    model_load = r"E:\back_up\code\112\tensorflow_project\newbook\chapter3\model\garph"
    sess = tf.Session()
    check_point_file = tf.train.latest_checkpoint(model_load)
    saver = tf.train.import_meta_graph("{}.meta".format(check_point_file), clear_devices=True)
    saver.restore(sess=sess, save_path=check_point_file)
    graph = sess.graph
    test_data = graph.get_operation_by_name("placeholder/x-input").outputs[0]
    test_label = graph.get_operation_by_name("placeholder/y-input").outputs[0]
    test_accuracy = graph.get_operation_by_name("evaluate/accuracy").outputs[0]
    feed_dict = {test_data: train_data.test_data()[0], test_label: train_data.test_data()[1]}
    accuracy = sess.run(test_accuracy, feed_dict=feed_dict)
    print("The test accuracy is {}".format(accuracy))
 
 
if __name__ == '__main__':
    data_path = r'E:\code\112\tensorflow_project\chapter5\data\tensorflow_data'
    train_data = TrainData(data_path=data_path, batch_size=200)
    model = Model(input_node=784, output_node=10, layer1_node=500, layer2_node=400, regularizer=True)
    model.train(train_data=train_data, train_step=30000)
    print("---------test-----------")
    predict(train_data=train_data)
 
 

运行程序开始训练：

在cmd中输入如下命令：

tensorboard -logdir="E:\back_up\code\112\tensorflow_project\newbook\chapter3\model\garph"

如下图所示：

将后面的地址复制到浏览器：

可以看到训练的loss和验证集的accuracy：

最后，通过predict()函数加载训练好的模型，求出测试集在模型上的精度：

神经网络模型最终的目标是对未知数据提供判断，所以为了对模型未知数据上的表现进行判断，需要保证测试数据在训练过程中不可见，为了评估模型在不同参数下的效果，通常会从训练数据中抽取一部分数据作为验证集。如果验证数据集不能很好的代表测试数据集的分布，则模型在这两个数据集上的表现很可能是不一样的。