05_MNIST数字识别问题

最新推荐文章于 2024-09-21 14:42:22 发布

原创最新推荐文章于 2024-09-21 14:42:22 发布 · 2.4k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#学习笔记

TensorFlow 专栏收录该内容

3 篇文章

订阅专栏

5.1 MNIST数据处理

MNIST是一个非常有名的手写体数字识别数据集，常被用于深度学习的入门样例。
MNIST数据集是NIST数据集的一个子集（6000张图片作为训练数据，10000张图片作为测试数据，大小为28$\times$28 pix）
MNIST数据集介绍
为了方便使用，TensorFlow提供了一个类来处理MNIST数据（见下面的代码段）
- 自动下载并转化为MNIST数据格式
- 将数据从原始数据包中解析成训练(55000)、验证(5000)和测试(10000)神经网络时使用的格式
- 训练数据集指训练+验证

# 导入处理MNIST数据的类
from tensorflow.examples.tutorials.mnist import input_data

# 载入MNIST数据集，如果指定地址下没有，则自动下载
mnist = input_data.read_data_sets('./MNIST_data/', one_hot=True)

# 输出数据集大小（训练集、验证集和测试集）
print('Training data size: ', mnist.train.num_examples)
# 输出Validating data size
print('Validing data size: ', mnist.validation.num_examples)
# 输出 Testing data size
print('Testing data size: ', mnist.test.num_examples)
# 输出 example training data 长度为784的一维数组, 方便tf使用
print('Example training data: ', mnist.train.images[0])
# 输出 example training label
print('Example training data label:', mnist.train.labels[0])

# 调用mnist.train.next_batch函数，从所有的训练数据中读取一小部分作为一个训练batch
batch_size = 100
# 从样本中读取一小部分作为一个训练batch
xs, ys = mnist.train.next_batch(batch_size)
# sample
print('X shape: {}'.format(xs.shape))
# label
print('Y shape: {}'.format(ys.shape))
# 输出结果为
# X shape: (100, 784)
# Y shape: (100, 10)

5.2 神经网络模型训练及不同模型结果对比

完成的TensorFlow程序解决MNIST问题
验证数据集在训练神经网络过程中的作用
验证第4章提出的各种优化方法——这些优化方法都可以或多或少地提高神经网络的分类正确率

5.2.1 TensorFlow 训练神经网络

功能完整的TensorFlow程序–依然有问题–解决

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

# 解决系统出现的问题1
# import os
# os.environ['KMP_DUPLICATE_LIB_OK']='TRUE'

# MNIST数据集相关的常数
INPUT_NODE = 784  # 输入层的节点数 x (图片像素点个数)
OUTPUT_NODE = 10  # 输出层的节点数 y 对应0-9

# 配置神经网络的参数
LAYER1_NODE = 500  # 隐藏层节点数，这里使用只有一个隐藏层的网络结构作为样例
BATCH_SIZE = 100  # 一个训练batch中的训练数据个数。数字越小，越接近随机梯度下降；数字越大，越接近梯度下降
LEARNING_RATE_BASE = 0.8  # 基础的学习率
LEARNING_RATE_DECAY = 0.99  # 学习率的衰减率
REGULARIZATION_RATE = 0.0001  # 描述模型复杂度的正则化项在损失函数中的系数 lambda R(w)
TRAINING_STEPS = 30000  # 训练轮数
MOVING_AVERAGE_DECAY = 0.99  # 滑动平均衰减率 decay * shadow_var + (1-decay) * var

# 前向传播模型
# 一个辅助函数，给定神经网络的输入和所有参数，计算神经网络的前向传播结果
# 这里并没有使用 collection
def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # avg_class: 计算参数平均值的类，方便在测试时使用滑动平均值
    # 当没有提供滑动平均类时，直接使用参数作为当前的取值
    if avg_class == None:
        # 计算隐藏层的前向传播结果，这里使用ReLU激活函数
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
        # output 输出层的前向传播结果
        # 由于计算损失函数时会一并计算softmax函数，所以这里不需要加入激活函数。而且不加入softmax不会影响结果。
        # 因为预测时使用的是不同类别对应节点输出值的相对大小，有没有softmax层对最后分类结果的计算没有影响。
        # 于是在计算整个神经网络的前向传播时可以不加入最后的softmax层。
        return tf.matmul(layer1, weights2) + biases2
    else:
        # 首先使用avg_class.average函数来计算得出变量的滑动平均值，然后再计算相应的神经网络前向传播结果。
        layer1 = tf.nn.relu(
            tf.matmul(input_tensor, avg_class.average(weights1)) + avg_class.average(biases1))
        return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)
    
# 训练模型的过程
def train(mnist):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')  # label
    
    # 生成隐藏层的参数 INPUT_NODE * LAYER1_NODE(weights1) + biases1 trainable
    weights1 = tf.Variable(
        tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))
    # 生成输出层的参数 LAYER1_NODE * OUTPUT_NODE + biases2
    weights2 = tf.Variable(
        tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))
    
    # 计算在当前参数下神经网络前向传播的结果。用于计算滑动平均的类为None，所以函数不会使用参数的滑动平均值
    y = inference(x, None, weights1, biases1, weights2, biases2)  # 预测值
    
    # 定义存储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里指定这个变量为不可训练的变量，在使用TensorFlow训练神经网络时，
    # 一般会将代表训练轮数的变量指定为不可训练的参数
    global_step = tf.Variable(0, trainable=False)
    
    # 给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类。
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    
    # 在所有代表神经网络参数的变量上使用滑动平均。其他辅助变量则不需要。 tf.trainable_variables()返回的就是图上集合
    # GraphKeys.TRAINABLE_VARIABLES中的元素。这个集合的元素就是所有没有指定trainable=False的参数
    variables_average_op = variable_averages.apply(tf.trainable_variables())
    
    # 计算使用了滑动平均之后的前向传播结果。第4章中介绍过滑动平均不会改变变量本身的取值，而是会维护一个影子变量来记录其滑动平均值。
    # 所以当需要使用这个滑动平均值时，需要明确调用average函数。
    # average_output
    average_y = inference(
        x, variable_averages, weights1, biases1, weights2, biases2)
    
    # 计算交叉熵
    # 这里使用TensorFlow中提供的sparse_softmax_cross_entropy_with_logits函数来计算交叉熵。
    # 当分类问题只有一个正确答案时，可以使用这个函数来加速交叉熵计算。
    # 函数的第一个参数为不包括softmax层的前向传播结果，第二个参数为正确答案。
    # 标准答案为一维数组，使用tf.argmax()来得到正确答案对应的类别编号。
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.argmax(y_, 1), logits=y)
    # 计算在当前batch中所有样例的交叉熵平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    
    # 计算L2正则化损失函数 lambda * R(w)
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)  # lambda * R()
    
    # 计算模型的正则化损失。一般只计算神经网络边上权重的正则化损失，而不使用偏置项。
    regularization = regularizer(weights1) + regularizer(weights2)
    # 总损失等于交叉熵和正则化损失的和
    loss = cross_entropy_mean + regularization
    # 设置指数衰减的学习率
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,  # 基础的学习率，随着迭代的进行，更新变量时使用的学习率在这个基础上递减
        global_step,  # 当前迭代的轮数
        mnist.train.num_examples / BATCH_SIZE,   # 过完所有训练数据需要的迭代次数
        LEARNING_RATE_DECAY)  # 学习率衰减速度
    
    # 优化损失函数
    # 使用tf.train.GradientDescentOptimizer优化算法来优化损失函数。
    # 注意这里的损失函数包含了交叉熵损失和L2正则化损失。
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
    
    # 在训练神经网络模型时，每过一遍数据既需要通过反向传播来更新神经网络中的参数，
    # 又要更新每一个参数的滑动平均值。为了一次完成多个操作，TensorFlow提供了
    # tf.control_dependencies和tf.group两种机制，下面两行程序和
    # train_op = tf.group(train_step, variables_averages_op)是等价的。
    with tf.control_dependencies([train_step, variables_average_op]):
        train_op = tf.no_op(name='train')
        
    # 检验使用了滑动平均模型的神经网络前向传播结果是否正确。tf.argmax(average_y, 1)
    # 计算每一个样例的预测答案。其中average_y是一个batch_size*10的二维数组，每一行
    # 表示一个样例的前向传播结果。tf.argmax的第二个参数'1'表示选取最大值的操作仅在第一个
    # 维度中进行，也就是说，只在每一行选取最大值对应的下标。于是得到的结果是一个长度为
    # batch的一维数组， 这个一维数组中的值就表示了每一个样例对应的数字识别的结果。
    # tf.equal判断两个张量的每一维是否相等，如果相等返回True，否则返回False。
    correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))
    
    # 这个运算首先将一个布尔型的数值转换为实数型，然后计算平均值。
    # 这个平均值就是模型在这一组数据上的正确率。
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        
    # 初始化会话并开始训练过程
    with tf.Session() as sess:
        # tf.initialize_all_variables().run() # 新版本中用以面的命令
        tf.global_variables_initializer().run()
        # 准备验证数据。一般在神经网络的训练中会通过验证数据来大致判断停止的条件和评判训练的效果
        validate_feed = {x: mnist.validation.images,
                         y_: mnist.validation.labels}
        
        # 准备测试数据。在真实的应用中，这部分数据在训练时是不可见的，这个数据只是作为模型优劣的最后评价标准。
        test_feed = {x: mnist.test.images, y_: mnist.test.labels}
        
        # 迭代地训练神经网络
        for i in range(TRAINING_STEPS):
            # 每1000轮输出一次在验证数据集上的测试结果
            if i % 1000 == 0:
                # 计算滑动平均模型在验证数据上的结果。因为MNIST数据集比较小，所以一次可以处理所有的验证数据。
                # 为了计算方便，本样例程序没有将验证数据划分为更小的batch。
                # 当神经网络模型比较复杂或者验证数据比较大时，太大的batch会导致计算时间过长甚至发生内存溢出错误。
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print('After %d training steps, valiation accuracy '
                      'using average model is %g ' % (i, validate_acc))
            
            # 产生这一轮使用的一个batch训练数据，并运行训练过程
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={x: xs, y_: ys})
        
        # 在训练结束之后，在测试数据上检测神经网络模型的最终正确率
        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print('After %d trainning steps, test accuracy using average '
            'model is %g' % (TRAINING_STEPS, test_acc))
        
# 主程序入口
def main(argv=None):
    # 屏蔽告警信息
    old_v = tf.logging.get_verbosity()
    tf.logging.set_verbosity(tf.logging.ERROR)
    mnist = input_data.read_data_sets('./MNIST_data/', one_hot=True)
    # 恢复显示告警信息
    tf.logging.set_verbosity(old_v)
    train(mnist)
        
if __name__ == '__main__':
    tf.app.run()  # 调用 main 或 _sys.modules['__main__'].main

Extracting ./MNIST_data/train-images-idx3-ubyte.gz
Extracting ./MNIST_data/train-labels-idx1-ubyte.gz
Extracting ./MNIST_data/t10k-images-idx3-ubyte.gz
Extracting ./MNIST_data/t10k-labels-idx1-ubyte.gz
After 0 training steps, valiation accuracy using average model is 0.0578 
After 1000 training steps, valiation accuracy using average model is 0.9776 
After 2000 training steps, valiation accuracy using average model is 0.9804 
After 3000 training steps, valiation accuracy using average model is 0.9838 
After 4000 training steps, valiation accuracy using average model is 0.983 
After 5000 training steps, valiation accuracy using average model is 0.9844 
After 6000 training steps, valiation accuracy using average model is 0.985 
After 7000 training steps, valiation accuracy using average model is 0.9846 
After 8000 training steps, valiation accuracy using average model is 0.9852 
After 9000 training steps, valiation accuracy using average model is 0.9854 
After 10000 training steps, valiation accuracy using average model is 0.9848 
After 11000 training steps, valiation accuracy using average model is 0.9852 
After 12000 training steps, valiation accuracy using average model is 0.985 
After 13000 training steps, valiation accuracy using average model is 0.9846 
After 14000 training steps, valiation accuracy using average model is 0.986 
After 15000 training steps, valiation accuracy using average model is 0.986 
After 16000 training steps, valiation accuracy using average model is 0.986 
After 17000 training steps, valiation accuracy using average model is 0.985 
After 18000 training steps, valiation accuracy using average model is 0.985 
After 19000 training steps, valiation accuracy using average model is 0.9858 
After 20000 training steps, valiation accuracy using average model is 0.985 
After 21000 training steps, valiation accuracy using average model is 0.9854 
After 22000 training steps, valiation accuracy using average model is 0.9852 
After 23000 training steps, valiation accuracy using average model is 0.985 
After 24000 training steps, valiation accuracy using average model is 0.9854 
After 25000 training steps, valiation accuracy using average model is 0.9854 
After 26000 training steps, valiation accuracy using average model is 0.9856 
After 27000 training steps, valiation accuracy using average model is 0.985 
After 28000 training steps, valiation accuracy using average model is 0.9848 
After 29000 training steps, valiation accuracy using average model is 0.9854 
After 30000 trainning steps, test accuracy using average model is 0.9848



An exception has occurred, use %tb to see the full traceback.


SystemExit



/Users/XXX/anaconda3/envs/tflow/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3275: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

程序似乎挂掉了，但是会立刻重启的。

2019-01-02 23:05:46.980834: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
2019-01-02 23:05:46.984528: I tensorflow/core/common_runtime/process_util.cc:69] Creating new thread pool with default inter op setting: 4. Tune using inter_op_parallelism_threads for best performance.
OMP: Hint: This means that multiple copies of the OpenMP runtime have been linked into the program. That is dangerous, since it can degrade performance or cause incorrect results. The best thing to do is to ensure that only a single OpenMP runtime is linked into the process, e.g. by avoiding static linking of the OpenMP runtime in any library. As an unsafe, unsupported, undocumented workaround you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE to allow the program to continue to execute, but that may cause crashes or silently produce incorrect results. For more information, please see http://www.intel.com/software/products/support/.

解决上面问题的3种方法

在代码中添加

import os
os.environ['KMP_DUPLICATE_LIB_OK']='TRUE'

在运行环境中 conda install nomkl
删除运行环境中对应的文件 anaconda/lib/libiomp5.dylib–未验证

出现新的问题

An exception has occurred, use %tb to see the full traceback.

    SystemExit

    /Users/XXX/anaconda3/envs/tflow/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3275: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
      warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

针对上面问题

运行%tb

SystemExit                                Traceback (most recent call last)
<ipython-input-1-cdbd9989e817> in <module>
    162 
    163 if __name__ == '__main__':
--> 164     tf.app.run()  # 调用 main 或 _sys.modules['__main__'].main

~/anaconda3/envs/tflow/lib/python3.6/site-packages/tensorflow/python/platform/app.py in run(main, argv)
    123   # Call the main function, passing through any arguments
    124   # to the final program.
--> 125   _sys.exit(main(argv))
    126 

SystemExit: