MNIST神经网络的训练

简介: import tensorflow as tffrom tensorflow.examples.tutorials.mnist import input_data1.设置输入和输出节点的个数,配置神经网络的参数。
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

1.设置输入和输出节点的个数,配置神经网络的参数。

# MNIST数据集相关的常数
INPUT_NODE = 784     # 输入层节点数。对于MNIST数据集便是图片的像素。
OUTPUT_NODE = 10     # 输出层节点数。即类别数目。(0 ~ 9 数字)

# 配置神经网络参数
LAYER1_NODE = 500    # 隐藏层节点数,这里只使用一个隐藏层。       
                              
BATCH_SIZE = 100     # 每次batch打包的样本个数。数字越小,训练过程越接近随机梯度下降;数字越大,越接近梯度下降。        

# 模型相关的参数
LEARNING_RATE_BASE = 0.8    # 基础的学习率    
LEARNING_RATE_DECAY = 0.99    # 学习率的衰减率
REGULARAZTION_RATE = 0.0001   # 描述模型复杂度的正则化项在损失函数中的系数。
TRAINING_STEPS = 5000          # 训练轮数
MOVING_AVERAGE_DECAY = 0.99    # 滑动平均衰减率

2. 定义辅助函数来计算前向传播结果,使用ReLU做为激活函数。

一个辅助函数,给定神经网络的所有输入和所有参数,计算神经网络的前向传播结果,定义了一个使用ReLU激活函数的三层全连接神经网络。

def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # 不使用滑动平均类,直接使用参数当前的取值。
    if avg_class == None:
        # 计算隐藏层的前向传播结果,使用ReLU做为激活函数
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
        
        # 计算输出层的前向传播结果。因为在计算损失函数时会一并计算 `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)  

3. 定义训练过程。

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')
    # 生成隐藏层的参数。
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))
    # 生成输出层的参数。
    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    # 计算不含滑动平均类的前向传播结果
    y = inference(x, None, weights1, biases1, weights2, biases2)
    
    # 定义存储训练轮数的变量。这个变量不需要计算滑动平均值,所以这里指定这个变量为不可训练的变量(`trainable=False`)。
    # 在使用TensorFlow训练神经网络时,一般会将代表训练轮数的变量指定为不可训练的参数。
    global_step = tf.Variable(0, trainable=False)
    
    # 给定滑动平均衰减率和训练轮数的变量,初始化滑动平均类。
    # 给定训练轮数的变量可以加快训练早期变量的更新速度。
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    
    # 在所有代表神经网络参数的变量上使用滑动平均。其他辅助变量(如 `global_step`)就不需要了。
    # `tf.trainable_variables` 返回的是图上集合 `tf.GraphKeys.TRAINABLE_VARIABLES` 中的元素。这个集合中的元素
    # 就是没有指定 `trainable=False` 的参数。
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    
    # 计算使用了滑动平均后的前向传播结果。
    # 因为滑动平均不会改变变量本身的取值,而是维护一个影子来记录其滑动平均值,所以需要明确调用 `average` 函数。
    average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)
    
    # 计算交叉熵及其平均值
    # 当分类问题只有一个正确答案时可使用 `tf.nn.sparse_softmax_cross_entropy_with_logits` 函数来加快交叉熵的计算。
    # 此函数的第一个参数是神经网络不包括 `softmax` 层的前向传播结果,第二个是训练数据的正确答案。
    # 因为标准答案是一个长度为10 的一维数组,而该函数需要提供的是一个正确答案的数字,所以需要使用 `tf.argmax` 函数
    # 来得到正确答案所对应的类别编号。
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    # 计算当前batch中的所有样例的交叉熵平均值。
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    
    # L2 正则化损失函数的计算
    regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
    # 计算模型的正则化损失。一般只计算神经网络边上的权重的损失,而不计算偏置项。
    regularaztion = regularizer(weights1) + regularizer(weights2)
    # 总损失 = 交叉熵损失 + 正则化损失
    loss = cross_entropy_mean + regularaztion
    
    # 设置指数衰减的学习率。
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,     # 基础的学习率,随着迭代的进行,更新变量时使用的学习率在这个基础上递减。
        global_step,            # 当前迭代轮数
        mnist.train.num_examples / BATCH_SIZE,    # 过完所有的训练数据需要的迭代次数。
        LEARNING_RATE_DECAY,                    # 学习率衰减速度。
        staircase=True)           # 阶梯型递减
    
    # 优化损失函数loss
    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_averages_op]):
        train_op = tf.no_op(name='train')

    
    # 计算正确率
    # 检验使用了滑动平均模型的神经网络前向传播结果是否正确。
    # `tf.argmax(average_y, 1)` 计算每个样例的预测答案。其中 `average_y` 是一个 `batch_size * 10` 的二维数组,每一行
    # 表示一个样例的前向传播结果。`tf.argmax` 的第二个参数 `1` 表示选取最大值的操作仅在第1个维度进行,即只在每一行选取
    # 最大值对应的下标。于是得到的结果是一个长度为 `batch_size` 的一维数组,这个数组中的值就表示了每一个样例对应的数字
    # 识别结果。
    # `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.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 step(s), validation 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 training step(s), test accuracy using average model is %g" %(TRAINING_STEPS, test_acc)))
   

4. 主程序入口,这里设定模型训练次数为5000次。

def main(argv=None):
    # 声明处理MNIST数据集的类,这个类在初始化时会自动下载数据。
    mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)
    train(mnist)
    
if __name__ == '__main__':
    main()
Extracting ../../../datasets/MNIST_data\train-images-idx3-ubyte.gz
Extracting ../../../datasets/MNIST_data\train-labels-idx1-ubyte.gz
Extracting ../../../datasets/MNIST_data\t10k-images-idx3-ubyte.gz
Extracting ../../../datasets/MNIST_data\t10k-labels-idx1-ubyte.gz
After 0 training step(s), validation accuracy using average model is 0.1152 
After 1000 training step(s), validation accuracy using average model is 0.9782 
After 2000 training step(s), validation accuracy using average model is 0.9816 
After 3000 training step(s), validation accuracy using average model is 0.9824 
After 4000 training step(s), validation accuracy using average model is 0.9822 
After 5000 training step(s), test accuracy using average model is 0.9827
# 第二种调用方法
def main(argv=None):
    # 声明处理MNIST数据集的类,这个类在初始化时会自动下载数据。
    mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)
    train(mnist)

# TensorFlow 提供的一个主程序入口,`tf.app.run` 也会调用上面定义的 `main` 函数:
if __name__ == '__main__':
    tf.app.run()
Extracting ../../../datasets/MNIST_data\train-images-idx3-ubyte.gz
Extracting ../../../datasets/MNIST_data\train-labels-idx1-ubyte.gz
Extracting ../../../datasets/MNIST_data\t10k-images-idx3-ubyte.gz
Extracting ../../../datasets/MNIST_data\t10k-labels-idx1-ubyte.gz
After 0 training step(s), validation accuracy using average model is 0.0814 
After 1000 training step(s), validation accuracy using average model is 0.9784 
After 2000 training step(s), validation accuracy using average model is 0.9806 
After 3000 training step(s), validation accuracy using average model is 0.9832 
After 4000 training step(s), validation accuracy using average model is 0.9832 
After 5000 training step(s), test accuracy using average model is 0.9827



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


SystemExit



C:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py:2870: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
  warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
探寻有趣之事!
目录
相关文章
|
2月前
|
机器学习/深度学习 PyTorch 算法框架/工具
目标检测实战(一):CIFAR10结合神经网络加载、训练、测试完整步骤
这篇文章介绍了如何使用PyTorch框架,结合CIFAR-10数据集,通过定义神经网络、损失函数和优化器,进行模型的训练和测试。
145 2
目标检测实战(一):CIFAR10结合神经网络加载、训练、测试完整步骤
|
2月前
|
机器学习/深度学习 数据可视化 计算机视觉
目标检测笔记(五):详细介绍并实现可视化深度学习中每层特征层的网络训练情况
这篇文章详细介绍了如何通过可视化深度学习中每层特征层来理解网络的内部运作,并使用ResNet系列网络作为例子,展示了如何在训练过程中加入代码来绘制和保存特征图。
67 1
目标检测笔记(五):详细介绍并实现可视化深度学习中每层特征层的网络训练情况
|
25天前
|
机器学习/深度学习 自然语言处理 语音技术
Python在深度学习领域的应用,重点讲解了神经网络的基础概念、基本结构、训练过程及优化技巧
本文介绍了Python在深度学习领域的应用,重点讲解了神经网络的基础概念、基本结构、训练过程及优化技巧,并通过TensorFlow和PyTorch等库展示了实现神经网络的具体示例,涵盖图像识别、语音识别等多个应用场景。
48 8
|
2月前
|
机器学习/深度学习 数据采集 算法
目标分类笔记(一): 利用包含多个网络多种训练策略的框架来完成多目标分类任务(从数据准备到训练测试部署的完整流程)
这篇博客文章介绍了如何使用包含多个网络和多种训练策略的框架来完成多目标分类任务,涵盖了从数据准备到训练、测试和部署的完整流程,并提供了相关代码和配置文件。
64 0
目标分类笔记(一): 利用包含多个网络多种训练策略的框架来完成多目标分类任务(从数据准备到训练测试部署的完整流程)
|
2月前
|
机器学习/深度学习 算法 TensorFlow
深度学习笔记(五):学习率过大过小对于网络训练有何影响以及如何解决
学习率是深度学习中的关键超参数,它影响模型的训练进度和收敛性,过大或过小的学习率都会对网络训练产生负面影响,需要通过适当的设置和调整策略来优化。
508 0
深度学习笔记(五):学习率过大过小对于网络训练有何影响以及如何解决
|
2月前
|
机器学习/深度学习 算法
【机器学习】揭秘反向传播:深度学习中神经网络训练的奥秘
【机器学习】揭秘反向传播:深度学习中神经网络训练的奥秘
|
3月前
|
机器学习/深度学习 数据采集 数据可视化
深度学习实践:构建并训练卷积神经网络(CNN)对CIFAR-10数据集进行分类
本文详细介绍如何使用PyTorch构建并训练卷积神经网络(CNN)对CIFAR-10数据集进行图像分类。从数据预处理、模型定义到训练过程及结果可视化,文章全面展示了深度学习项目的全流程。通过实际操作,读者可以深入了解CNN在图像分类任务中的应用,并掌握PyTorch的基本使用方法。希望本文为您的深度学习项目提供有价值的参考与启示。
|
4月前
|
安全 Apache 数据安全/隐私保护
你的Wicket应用安全吗?揭秘在Apache Wicket中实现坚不可摧的安全认证策略
【8月更文挑战第31天】在当前的网络环境中,安全性是任何应用程序的关键考量。Apache Wicket 是一个强大的 Java Web 框架,提供了丰富的工具和组件,帮助开发者构建安全的 Web 应用程序。本文介绍了如何在 Wicket 中实现安全认证,
50 0
|
6月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch代码实现神经网络
这段代码示例展示了如何在PyTorch中构建一个基础的卷积神经网络(CNN)。该网络包括两个卷积层,分别用于提取图像特征,每个卷积层后跟一个池化层以降低空间维度;之后是三个全连接层,用于分类输出。此结构适用于图像识别任务,并可根据具体应用调整参数与层数。
下一篇
DataWorks