tensorflow实践-mnist数字识别（2）

最新推荐文章于 2024-05-21 14:45:00 发布

JustMo_

最新推荐文章于 2024-05-21 14:45:00 发布

阅读量102

点赞数

分类专栏： Tensorflow 文章标签： tensorflow实践

本文链接：https://blog.csdn.net/sinat_35456607/article/details/102463868

版权

Tensorflow 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

tensorflow实践-mnist数字识别（2）

版本改进

之前的版本，在选择运行之后，在训练模型的之后也同时对测试集进行预测，在模型训练完之后给出最后一轮模型的预测结果。这样有个缺陷，模型训练过程会由最开始的欠拟合逐渐变成过拟合，这个时候不好选择最优迭代轮数的模型进行数据的预测。所以需要一个能保存模型的机制，即tensorflow的模型持久化。

改进结构

分为3部分脚本进行整个数字识别的模型：模型网络结构的搭建、训练过程、验证过程

tf_minist_inter.py：用于对前向神经网络结构的搭建
tf_mnist_train.py：用来训练模型
tf_mnist_val.py：用来选择模型，并利用选择的模型对测试数据进行测试

注意的点

为了更好的对变量控制，不用多次对同一类型的变量进行多个命名，使用了变量命名空间，在不同的空间中可以使用相同名字的变量，也可以调用其他空间的变量。
在使用正则损失时，当参数过多时，写起来会很繁琐，故采用集合形式，可以把每个需要计算正则损失的变量加入到集合中，最后从集合中拿出所有的正则损失。
因为要对模型进行持久化，这里会涉及到模型的保存，以及模型的读取。

tf_minist_inter.py

使用 tf.add_to_collection(‘losses’ , 正则)，将每个计算好的正则加入到名称为losses的集合中
同前面一样，定义了两层网络。
在初始化网络的时候，调用正则损失函数的计算定义，并加入到集合中，方便计算。

# -*- coding: utf-8 -*-
"""
Created on Thu Sep 19 10:39:00 2019

@author: JustMo
"""

'''
  DO: 该脚本用于mnist前向传播网络结构的固定
'''

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


##接下来进行节点参数的设置
INPUT_NODE = 784
LAYER1_NODE = 500
OUTPUT_NODE = 10

##声明权重变量以及增加正则损失，利用集合，方便获取
def get_weight_variable(shape, regularizer):
    '''
    tips: regularizer接收的是正则项函数，当为None时代表不需要正则化，在验证或测试时为None；
    '''
    ##利用get_variable获取变量是方便直接获取已存在变量的值
    weights = tf.get_variable(name='weights', shape=shape, initializer=tf.truncated_normal_initializer(stddev=0.1))
    
    if regularizer != None:
        tf.add_to_collection('losses', regularizer(weights))
    
    return weights

##接下来定义整个前向传播初始化网络
def inference(input_tensor, regularizer):
    '''
    tips: 用到变量控制空间，方便重用以及控制变量
    '''
    with tf.variable_scope('layer1'):
        ##layer1的相关参数
        weights = get_weight_variable([INPUT_NODE, LAYER1_NODE], regularizer)
        biases = tf.get_variable('biases', shape=[LAYER1_NODE], initializer=tf.constant_initializer(0.0))
        
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)
    
    with tf.variable_scope('layer2'):
        ##layer2相关参数
        weights = get_weight_variable([LAYER1_NODE, OUTPUT_NODE], regularizer)
        biases = tf.get_variable('biases', shape=[OUTPUT_NODE], initializer=tf.constant_initializer(0.0))
        
        layer2 = tf.matmul(layer1, weights) + biases
    
    return layer2

tf_mnist_train.py

注意的点

模型的训练过程，模型持久化，设置模型的保存路径
这里引用到前面定义的模型前向传播网络tf_minist_inter
前面在模型结构定义中，将正则项损失加入到了集合losses中，这里取出的时候使用 tf.add_n(tf.get_collection(‘losses’)) 来将losses中的所有正则项损失相加，作为最终的正则项损失。

模型持久化

tf中提供了模型持久化的api：tf.train.Saver类
通过 saver.save 函数，可以将tf模型保存在model.ckpt文件中，在保存目录下会出现4个文件，模型持久化
- checkpoint: tf.train.Saver自动生成且自动维护，保存了一个目录下所有模型文件列表
- model.ckpt.data: 通过SSTable格式存储，也就是一个(key, value)列表
- model.ckpt.index: 与 model.ckpt.data 保存所有文件的取值
- model.ckpt.meta: 保存了tf的计算图结构即网络结构
当要使用模型的时候，使用 saver.restore 进行恢复指定的模型

# -*- coding: utf-8 -*-
"""
Created on Thu Sep 19 13:13:17 2019

@author: JustMo
"""

'''
DO: 用来训练mnist数据集
'''

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

##加载在tf_minist_inter中定义的前向网络结构
import tf_minist_inter

##定义训练需要的各种参数
BATCH_SIZE = 100
TRAINING_STRP = 30000

##定义各种率
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99##一般设置比较大
REGULARAZTION_RATE = 0.0001
MOVING_AVERAGE_DECAY = 0.99##一般初始较大，可以保证较为稳定的滑动

##定义模型保存路径以及文件名;tf保存模型会3个文件分别是model.ckpt\model.ckpt.meta\checkpoint
'''
checkpoint: tf.train.Saver自动生成且自动维护，保存了一个目录下所有模型文件列表
model.ckpt: 保存了tf程序中每一个变量的取值
model.ckpt.meta: 保存了tf的图结构即网络结构
'''
MODEL_SAVE_PATH = '/path/to/model/'
MODEL_NAME = 'model.ckpt'

##定义模型的训练函数
def train(mnist):
    '''
    tips: 用作模型的训练，其中含有bp反向传播、以及参数的更新
    '''    
    
    ##定义模型的输入
    x = tf.placeholder(dtype=tf.float32, shape=[None, tf_minist_inter.INPUT_NODE], name='x-input')
    y_ = tf.placeholder(dtype=tf.float32, shape=[None, tf_minist_inter.OUTPUT_NODE], name='y-input')
    
    ##定义正则函数
    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    
    ##调用前向神经网络预测输出
    y = tf_minist_inter.inference(x, 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'))
    
    ##定义学习率函数以及bp神经网络优化
    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')
    
    ##初始化持久类，用来保存模型以及测试验证的时候调用模型
    saver = tf.train.Saver()
    
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        
        for i in range(TRAINING_STRP):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x:xs, y_:ys})
            
            #没训练1000轮保存一次模型
            if i % 1000 == 0:
                print('在训练 %d 轮时，模型此时的损失为 %g .' % (step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)

def main(avgv=None):
    mnist = input_data.read_data_sets('/path/to/mnist_data', one_hot=True)
    train(mnist)
    
if __name__ == '__main__':
    tf.app.run()

tf_mnist_val.py

注意的点

这里是验证部分，所以在模型的框架上，不需要计算损失，所以不需要交叉损失以及正则项损失部分。
这里的设计是，在训练的过程中，调用最新的模型进行预测，可以根据个人的需求来设计。
为了完全共用定义的前向传播网络的各种变量，所以使用变量重命名的方式来加载滑动平均模型，可参考：复用滑动平均模型变量

# -*- coding: utf-8 -*-
"""
Created on Thu Sep 19 15:56:09 2019

@author: JustMo
"""

'''
DO： 用来从保存的模型中，选择模型进行数据测试与验证
'''

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

##加载在tf_minist_inter中定义的前向网络结构；以及训练部分
import tf_minist_inter
import tf_mnist_train

import time

##定义调取模型间隔
EVAL_INTERVAL_SECS = 10

def evaluate(mnist):
    '''
    tips：用来调取保存的模型进行数据测试或者预测
    '''
    with tf.Graph().as_default() as g:##实例化一个类，并将这个类作为整个tf运行环境的默认图
        ##定义输入以及输出
        x = tf.placeholder(dtype=tf.float32, shape=[None, tf_minist_inter.INPUT_NODE], name='x-input')
        y_ = tf.placeholder(dtype=tf.float32, shape=[None,tf_minist_inter.OUTPUT_NODE], name='y-input')
        
        ##定义feed数据
        validata_feed = {x:mnist.validation.images, y_:mnist.validation.labels}
        
        ##用前向网络定义输出网络，注意因为在验证以及测试时，不需要计算损失，所以不用传regularizer
        y = tf_minist_inter.inference(x, None)
        
        ##计算预测数据的准确率
        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        
        ##为了完全共用定义的前向传播网络的各种变量，所以使用变量重命名的方式来加载滑动平均模型
        variable_averages = tf.train.ExponentialMovingAverage(tf_mnist_train.MOVING_AVERAGE_DECAY)
        variable_to_restore = variable_averages.variables_to_restore()
        saver = tf.train.Saver(variable_to_restore)
        
        
        ##一下每隔EVAL_INTERVAL_SECS时间，选择最新的模型来进行预测以及计算准确率
        while True:
            with tf.Session() as sess:
                ##在会话中通过checkpoint文件中的列表获取最新的模型文件名
                ckpt = tf.train.get_checkpoint_state(tf_mnist_train.MODEL_SAVE_PATH)
                
                if ckpt and ckpt.model_checkpoint_path:
                    ##如果ckpt存在以及模型中的路径存在
                    ##加载模型
                    saver.restore(sess, ckpt.model_checkpoint_path)
                    ##通过模型文件名，获取训练的轮数
                    global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
                    
                    accuracy_score = sess.run(accuracy, validata_feed)
                    
                    print('在训练了 %s 轮后，验证集的准确率为 %g'%(global_step, accuracy_score))
                else:
                    print('没有找到 checkpoint文件')
                    return
            time.sleep(EVAL_INTERVAL_SECS)##间隔EVAL_INTERVAL_SECS时间运行验证会话

def main(argv=None):
    mnist = input_data.read_data_sets('/path/to/mnist_data', one_hot=True)
    evaluate(mnist)

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