深度学习中batch normalization

目录

  • 1  Batch Normalization笔记

Batch Normalization笔记

我们将会用MNIST数据集来演示这个batch normalization的使用, 以及他所带来的效果:

引包

import tensorflow as tf
import os
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.contrib.layers import flatten
import numpy as np
import tensorflow.contrib.slim as slim

构建模型:

def model1(input, is_training, keep_prob):
    input = tf.reshape(input, shape=[-1, 28, 28, 1])
    batch_norm_params = {
        ‘decay‘: 0.95,
        ‘updates_collections‘: None
    }

    with slim.arg_scope([slim.batch_norm, slim.dropout], is_training=is_training):
        with slim.arg_scope([slim.conv2d, slim.fully_connected],
                            weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
                                normalizer_fn=slim.batch_norm, normalizer_params=batch_norm_params,
                            activation_fn=tf.nn.crelu):
            conv1 = slim.conv2d(input, 16, 5, scope=‘conv1‘)
            pool1 = slim.max_pool2d(conv1, 2, scope=‘pool1‘)
            conv2 = slim.conv2d(pool1, 32, 5, scope=‘conv2‘)
            pool2 = slim.max_pool2d(conv2, 2, scope=‘pool2‘)
            flatten = slim.flatten(pool2)
            fc = slim.fully_connected(flatten, 1024, scope=‘fc1‘)
            print(fc.get_shape())
            drop = slim.dropout(fc, keep_prob=keep_prob)
            logits = slim.fully_connected(drop, 10, activation_fn=None, scope=‘logits‘)

            return logits
def model2(input, is_training, keep_prob):
    input = tf.reshape(input, shape=[-1, 28, 28, 1])
    with slim.arg_scope([slim.conv2d, slim.fully_connected],
                        weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
                            normalizer_fn=None, activation_fn=tf.nn.crelu):
        with slim.arg_scope([slim.dropout], is_training=is_training):
            conv1 = slim.conv2d(input, 16, 5, scope=‘conv1‘)
            pool1 = slim.max_pool2d(conv1, 2, scope=‘pool1‘)
            conv2 = slim.conv2d(pool1, 32, 5, scope=‘conv2‘)
            pool2 = slim.max_pool2d(conv2, 2, scope=‘pool2‘)
            flatten = slim.flatten(pool2)
            fc = slim.fully_connected(flatten, 1024, scope=‘fc1‘)
            print(fc.get_shape())
            drop = slim.dropout(fc, keep_prob=keep_prob)
            logits = slim.fully_connected(drop, 10, activation_fn=None, scope=‘logits‘)

            return logits

构建训练函数

def train(model, model_path, train_log_path, test_log_path):
    # 计算图
    graph = tf.Graph()
    with graph.as_default():
        X = tf.placeholder(dtype=tf.float32, shape=[None, 28 * 28])
        Y = tf.placeholder(dtype=tf.float32, shape=[None, 10])
        is_training = tf.placeholder(dtype=tf.bool)

        logit = model(X, is_training, 0.7)

        loss =tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logit, labels=Y))
        accuray = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(logit, 1), tf.argmax(Y, 1)), tf.float32))

        global_step = tf.Variable(0, trainable=False)
        learning_rate = tf.train.exponential_decay(0.1, global_step, 1000, 0.95, staircase=True)
        optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate)

        update = slim.learning.create_train_op(loss, optimizer, global_step)

        mnist = input_data.read_data_sets("tmp", one_hot=True)

        saver = tf.train.Saver()

        tf.summary.scalar("loss", loss)
        tf.summary.scalar("accuracy", accuray)
        merged_summary_op = tf.summary.merge_all()

        train_summary_writter = tf.summary.FileWriter(train_log_path, graph=tf.get_default_graph())
        test_summary_writter = tf.summary.FileWriter(test_log_path, graph=tf.get_default_graph())

        init = tf.global_variables_initializer()

        iter_num = 10000
        batch_size = 1024

        os.environ["CUDA_VISIBLE_DEVICES"] = ‘2‘  # 选择cuda的设备
        gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.2)  # gpu显存使用

        with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
            sess.run(init)

            if not os.path.exists(os.path.dirname(model_path)):
                os.makedirs(os.path.dirname(model_path))
            else:
                try:
                    saver.restore(sess, model_path)
                except:
                    pass

            for i in range(iter_num):
                x, y = mnist.train.next_batch(batch_size)

                sess.run(update, feed_dict={X:x, Y:y, is_training:True})

                if i  % 100 == 0:
                    x_test, y_test = mnist.test.next_batch(batch_size)

                    print("train:", sess.run(accuray, feed_dict={X: x, Y: y, is_training:False}))
                    print("test:", sess.run(accuray, feed_dict={X: x_test, Y: y_test, is_training:False}))

                    saver.save(sess, model_path)

                    g, summary = sess.run([global_step, merged_summary_op], feed_dict={X: x, Y: y, is_training:False})
                    train_summary_writter.add_summary(summary, g)
                    train_summary_writter.flush()

                    g, summary = sess.run([global_step, merged_summary_op], feed_dict={X: x_test, Y: y_test, is_training:False})
                    test_summary_writter.add_summary(summary, g)
                    test_summary_writter.flush()

        train_summary_writter.close()
        test_summary_writter.close()

下面我们来进行计算:

train(model1, "model1/model", "model1_train_log", "model1_test_log")
train(model2, "model2/model", "model2_train_log", "model2_test_log")

结论

我们发现, 加了batch norm的似乎收敛的更快一些, 这个我们可以从对比上可以很清楚的看到, 所以这个bn是我们一个很好的技术, 前提是你选的参数比较适合.

以下是两个注意点:

The keys to use batch normalization in slim are:

Set proper decay rate for BN layer. Because a BN layer uses EMA (exponential moving average) to approximate the population mean/variance, it takes sometime to warm up, i.e. to get the EMA close to real population mean/variance. The default decay rate is 0.999, which is kind of high for our little cute MNIST dataset and needs ~1000 steps to get a good estimation. In my code, decay is set to 0.95, then it learns the population statistics very quickly. However, a large value of decay does have it own advantage: it gathers information from more mini-batches thus is more stable.

Use slim.learning.create_train_op to create train op instead of tf.train.GradientDescentOptimizer(0.1).minimize(loss) or something else!.

原文地址:https://www.cnblogs.com/songfy/p/8502632.html

时间: 2024-10-09 19:56:46

深度学习中batch normalization的相关文章

深度学习之Batch Normalization

1.Batch Normalization的引入 在机器学习领域有个很重要的假设:IID独立同分布假设,也就是假设训练数据和测试数据是满足相同分布的,这是通过训练数据获得的模型能够在测试集上获得好的效果的一个基本保障.在深度学习网络中,后一层的输入是受前一层的影响的,而为了方便训练网络,我们一般都是采用Mini-Batch SGD来训练网络的(Mini-Batch SGD的两个优点是:梯度更新方向更准确和并行计算速度快). 我们知道在神经网络训练开始前,都要对输入数据做一个归一化处理,那么具体为

浅谈深度学习中潜藏的稀疏表达

浅谈深度学习中潜藏的稀疏表达 “王杨卢骆当时体,轻薄为文哂未休. 尔曹身与名俱灭,不废江河万古流.” — 唐 杜甫<戏为六绝句>(其二) [不要为我为啥放这首在开头,千人千面千理解吧] 深度学习:概述和一孔之见 深度学习(DL),或说深度神经网络(DNN), 作为传统机器学习中神经网络(NN).感知机(perceptron)模型的扩展延伸,正掀起铺天盖地的热潮.DNN火箭般的研究速度,在短短数年内带来了能“读懂”照片内容的图像识别系统,能和人对话到毫无PS痕迹的语音助手,能击败围棋世界冠军.引

深度学习中的常见问题汇总(一)

深度学习中的常见问题汇总(一) 转自 卷积神经网络的复杂度分析 关于感受野的总结 1.CNN复杂度分析 在深度学习基础网络不断进化的过程中,可以发现新的模型不仅性能有极大地提升,网络的复杂度通常也会更低.深度学习网络模型的复杂度直接关系到其实际应用中的速度与可行性,因此这里总结一下 CNN 复杂度的含义与计算方式. 1.1时间复杂度 通常,我们假设计算机运行一行基础代码需要一次运算,那么模型的时间复杂度即为模型的运算次数,用浮点运算次数 FLOPs(FLoating-point OPeratio

深度学习中的Data Augmentation方法(转)基于keras

在深度学习中,当数据量不够大时候,常常采用下面4中方法: 1. 人工增加训练集的大小. 通过平移, 翻转, 加噪声等方法从已有数据中创造出一批"新"的数据.也就是Data Augmentation 2. Regularization. 数据量比较小会导致模型过拟合, 使得训练误差很小而测试误差特别大. 通过在Loss Function 后面加上正则项可以抑制过拟合的产生. 缺点是引入了一个需要手动调整的hyper-parameter. 详见 https://www.wikiwand.c

关于深度学习中的batch_size

5.4.1 关于深度学习中的batch_size batch_size可以理解为批处理参数,它的极限值为训练集样本总数,当数据量比较少时,可以将batch_size值设置为全数据集(Full batch cearning). 实际上,在深度学习中所涉及到的数据都是比较多的,一般都采用小批量数据处理原则. 小批量训练网络的优点: 相对海量的的数据集和内存容量,小批量处理需要更少的内存就可以训练网络. 通常小批量训练网络速度更快,例如我们将一个大样本分成11小样本(每个样本100个数据),采用小批量

深度学习中得数学,高效计算基础与线性分类器

深度学习说到底就是要调节网络中得权重,使网络的分类结果更接近于训练值.这个重复迭代的过程又是一个线性回归的问题.在这种可能会用到高数,线性代数,概率论中的知识. 一.数学基础提一提. 1.高数中得知识. 高数中最重要的就是微积分了,那在深度学习中出现最多的一个概念就是梯度.什么是梯度呢?要说导数,学过高数的肯定都知道.其实梯度就是当把标量x变成向量X时,对X求导就是梯度.那为什么要用梯度呢?因为梯度等于0在凸函数中往往代表着一个极小值点.我们要求得就是损失函数的极小值,这正是我们需要的.梯度是指

深度学习中 --- 解决过拟合问题(dropout, batchnormalization)

过拟合,在Tom M.Mitchell的<Machine Learning>中是如何定义的:给定一个假设空间H,一个假设h属于H,如果存在其他的假设h’属于H,使得在训练样例上h的错误率比h’小,但在整个实例分布上h’比h的错误率小,那么就说假设h过度拟合训练数据. 也就是说,某一假设过度的拟合了训练数据,对于和训练数据的分布稍有不同的数据,错误率就会加大.这一般会出现在训练数据集比较小的情况. 深度学习中避免过拟合的方法: Dropout      2012年ImageNet比赛的获胜模型A

资深程序员带你玩转深度学习中的正则化技术(附Python代码)!

目录 1. 什么是正则化? 2. 正则化如何减少过拟合? 3. 深度学习中的各种正则化技术: L2和L1正则化 Dropout 数据增强(Data augmentation) 提前停止(Early stopping) 4. 案例:在MNIST数据集上使用Keras的案例研究 1. 什么是正则化? 在深入该主题之前,先来看看这几幅图: 之前见过这幅图吗?从左到右看,我们的模型从训练集的噪音数据中学习了过多的细节,最终导致模型在未知数据上的性能不好. 换句话说,从左向右,模型的复杂度在增加以至于训练

卷积在深度学习中的作用(转自http://timdettmers.com/2015/03/26/convolution-deep-learning/)

卷积可能是现在深入学习中最重要的概念.卷积网络和卷积网络将深度学习推向了几乎所有机器学习任务的最前沿.但是,卷积如此强大呢?它是如何工作的?在这篇博客文章中,我将解释卷积并将其与其他概念联系起来,以帮助您彻底理解卷积. 已经有一些关于深度学习卷积的博客文章,但我发现他们都对不必要的数学细节高度混淆,这些细节没有以任何有意义的方式进一步理解.这篇博客文章也会有很多数学细节,但我会从概念的角度来看待他们,在这里我用每个人都应该能够理解的图像表示底层数学.这篇博文的第一部分是针对任何想要了解深度学习中