【深度学习】5-3 与学习相关的技巧 - Batch Normalization

这篇具有很好参考价值的文章主要介绍了【深度学习】5-3 与学习相关的技巧 - Batch Normalization。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

如果为了使各层拥有适当的广度,“强制性”地调整激活值的分布会怎样呢?实际上,Batch Normalization 方法就是基于这个想法而产生的

为什么Batch Norm这么惹人注目呢?因为Batch Norm有以下优点:

  • 可以使学习快速进行(可以增大学习率)。
  • 不那么依赖初始值(对于初始值不用那么神经质) 。
  • 抑制过拟合(降低Dropout等的必要性)。

Batch Norm的思路是调整各层的激活值分布使其拥有适当的广度。为此,要向神经网络中插入对数据分布进行正规化的层,即Batch Normalization层(下文简称Batch Norm层)
【深度学习】5-3 与学习相关的技巧 - Batch Normalization
Batch Norm,顾名思义,以进行学习时的mini-batch为单位,按mini-batch进行正规化。具体而言,就是进行使数据分布的均值为0、方差为1的正规化。用数学式表示的话,如下:
【深度学习】5-3 与学习相关的技巧 - Batch Normalization

这里对mini-batch的m个输人数据的集合B求均值方差。然后,对输人数据进行均值为0、方差为1(合适的分布)的正规化。
这个式子所做的是将mini-batch的输人数据变换为均值为0,方差为1的数据。通过将这个处理插入到激活函数的前面(或者后面),可以减少数据分布的偏向
接着,Batch Norm层会对正规化后的数据进行缩放和平移的变换用数学式可以如下表示。
【深度学习】5-3 与学习相关的技巧 - Batch Normalization

这里,γ和β是参数。一开始γ=1,β=0,然后再通过学习调整到合适的值。
上面就是Batch Norm的算法。这个算法是神经网络上的正向传播。

用计算图表示如下:
【深度学习】5-3 与学习相关的技巧 - Batch Normalization

Batch Norm的反向传播
Batch Norm实现类

class BatchNormalization:
    """
    http://arxiv.org/abs/1502.03167
    """
    def __init__(self, gamma, beta, momentum=0.9, running_mean=None, running_var=None):
        self.gamma = gamma
        self.beta = beta
        self.momentum = momentum
        self.input_shape = None # Conv层的情况下为4维,全连接层的情况下为2维  

        # 测试时使用的平均值和方差
        self.running_mean = running_mean
        self.running_var = running_var  
        
        # backward时使用的中间数据
        self.batch_size = None
        self.xc = None
        self.std = None
        self.dgamma = None
        self.dbeta = None

    def forward(self, x, train_flg=True):
        self.input_shape = x.shape
        if x.ndim != 2:
            N, C, H, W = x.shape
            x = x.reshape(N, -1)

        out = self.__forward(x, train_flg)
        
        return out.reshape(*self.input_shape)
            
    def __forward(self, x, train_flg):
        if self.running_mean is None:
            N, D = x.shape
            self.running_mean = np.zeros(D)
            self.running_var = np.zeros(D)
                        
        if train_flg:
            mu = x.mean(axis=0)
            xc = x - mu
            var = np.mean(xc**2, axis=0)
            std = np.sqrt(var + 10e-7)
            xn = xc / std
            
            self.batch_size = x.shape[0]
            self.xc = xc
            self.xn = xn
            self.std = std
            self.running_mean = self.momentum * self.running_mean + (1-self.momentum) * mu
            self.running_var = self.momentum * self.running_var + (1-self.momentum) * var            
        else:
        	# 算法实现
            xc = x - self.running_mean
            xn = xc / ((np.sqrt(self.running_var + 10e-7)))
            
        out = self.gamma * xn + self.beta 
        return out

    def backward(self, dout):
        if dout.ndim != 2:
            N, C, H, W = dout.shape
            dout = dout.reshape(N, -1)

        dx = self.__backward(dout)

        dx = dx.reshape(*self.input_shape)
        return dx

	# 反向传播
    def __backward(self, dout):
        dbeta = dout.sum(axis=0)
        dgamma = np.sum(self.xn * dout, axis=0)
        dxn = self.gamma * dout
        dxc = dxn / self.std
        dstd = -np.sum((dxn * self.xc) / (self.std * self.std), axis=0)
        dvar = 0.5 * dstd / self.std
        dxc += (2.0 / self.batch_size) * self.xc * dvar
        dmu = np.sum(dxc, axis=0)
        dx = dxc - dmu / self.batch_size
        
        self.dgamma = dgamma
        self.dbeta = dbeta
        
        return dx

Batch Normalization的评估

现在我们使用Batch Norm层进行实验。首先,使用MNIST数据集,观察使用Batch Norm层和不使用Batch Norm层时学习的过程会如何变化,
代码如下:

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.multi_layer_net_extend import MultiLayerNetExtend
from common.optimizer import SGD, Adam

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 减少学习数据
x_train = x_train[:1000]
t_train = t_train[:1000]

max_epochs = 20
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01


def __train(weight_init_std):
    bn_network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10, 
                                    weight_init_std=weight_init_std, use_batchnorm=True)
    network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10,
                                weight_init_std=weight_init_std)
    optimizer = SGD(lr=learning_rate)
    
    train_acc_list = []
    bn_train_acc_list = []
    
    iter_per_epoch = max(train_size / batch_size, 1)
    epoch_cnt = 0
    
    for i in range(1000000000):
        batch_mask = np.random.choice(train_size, batch_size)
        x_batch = x_train[batch_mask]
        t_batch = t_train[batch_mask]
    
        for _network in (bn_network, network):
            grads = _network.gradient(x_batch, t_batch)
            optimizer.update(_network.params, grads)
    
        if i % iter_per_epoch == 0:
            train_acc = network.accuracy(x_train, t_train)
            bn_train_acc = bn_network.accuracy(x_train, t_train)
            train_acc_list.append(train_acc)
            bn_train_acc_list.append(bn_train_acc)
    
            print("epoch:" + str(epoch_cnt) + " | " + str(train_acc) + " - " + str(bn_train_acc))
    
            epoch_cnt += 1
            if epoch_cnt >= max_epochs:
                break
                
    return train_acc_list, bn_train_acc_list


# 3.绘制图形==========
weight_scale_list = np.logspace(0, -4, num=16)
x = np.arange(max_epochs)

for i, w in enumerate(weight_scale_list):
    print( "============== " + str(i+1) + "/16" + " ==============")
    train_acc_list, bn_train_acc_list = __train(w)
    
    plt.subplot(4,4,i+1)
    plt.title("W:" + str(w))
    if i == 15:
        plt.plot(x, bn_train_acc_list, label='Batch Normalization', markevery=2)
        plt.plot(x, train_acc_list, linestyle = "--", label='Normal(without BatchNorm)', markevery=2)
    else:
        plt.plot(x, bn_train_acc_list, markevery=2)
        plt.plot(x, train_acc_list, linestyle="--", markevery=2)

    plt.ylim(0, 1.0)
    if i % 4:
        plt.yticks([])
    else:
        plt.ylabel("accuracy")
    if i < 12:
        plt.xticks([])
    else:
        plt.xlabel("epochs")
    plt.legend(loc='lower right')
    
plt.show()

运行结果如下:
【深度学习】5-3 与学习相关的技巧 - Batch Normalization

从运行结果可以看到使用Batch Norm后,学习进行得更快了。
综上,通过使用Batch Norm,可以推动学习的进行。并且,对权重初始值变得健壮(表示不那么依初始值) Batch Norm具备如此优良的性质,一定能应用在更多场合中。文章来源地址https://www.toymoban.com/news/detail-495608.html

到了这里,关于【深度学习】5-3 与学习相关的技巧 - Batch Normalization的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【卷积层、BN层(Batch Normalization)、激活函数理解】

    卷积层的功能:对数据进行特征提取。 卷积层由输出特征面组成,每个特征面有无数个神经元(像素点)组成。其中输出特征面的每个神经元是通过卷积核对输入特征面中的每个神经元进行卷积操作得到的。 一个卷积核产生一张特征图,n个卷积核产生n个特征图。卷积核的设

    2024年02月07日
    浏览(42)
  • 【深度学习】5-2 与学习相关的技巧 - 权重的初始值

    在神经网络的学习中,权重的初始值特别重要。实际上, 设定什么样的权重初始值,经常关系到神经网络的学习能否成功 。本节将介绍权重初始值的推荐值,并通过实验确认神经网络的学习是否会快速进行。 可以将权重初始值设为0吗 后面我们会介绍 抑制过拟合、提高泛化

    2024年02月10日
    浏览(31)
  • DNNGP模型解读-early stopping 和 batch normalization的使用

    一、考虑的因素(仅代表个人观点) 1.首先我们看到他的这篇文章所考虑的不同方面从而做出的不同改进,首先考虑到了对于基因组预测的深度学习方法的设计 ,我们设计出来这个方法就是为了基因组预测而使用,这也是主要目的,所以要抓住事物的主要方面。 2.DNNGP相比于

    2024年02月12日
    浏览(40)
  • pytorch10:正则化(weight_decay、dropout、Batch Normalization)

    往期回顾 pytorch01:概念、张量操作、线性回归与逻辑回归 pytorch02:数据读取DataLoader与Dataset、数据预处理transform pytorch03:transforms常见数据增强操作 pytorch04:网络模型创建 pytorch05:卷积、池化、激活 pytorch06:权重初始化 pytorch07:损失函数与优化器 pytorch08:学习率调整策略

    2024年02月01日
    浏览(58)
  • 深度学习中epoch、batch、batch size和iterations详解

    1.epoch 在训练一个模型时所用到的全部数据; 备注:一般在训练时都要使用多于一个的epoch,因为在神经网络中传递完整的数据集仅仅一次是不够的,只有将完整的数据集在同样的神经网络中传递多次,才会得到比较优秀的训练效果,当然也不行,容易过拟合,所以要根据实

    2023年04月25日
    浏览(35)
  • 深入理解ECAPA-TDNN——兼谈Res2Net、ASP统计池化、SENet、Batch Normalization

    ECAPA-TDNN是说话人识别中基于TDNN的神经网络,是目前最好的单体模型之一 关于TDNN,可以参考深入理解TDNN(Time Delay Neural Network)——兼谈x-vector网络结构 TDNN本质上是1维卷积,而且常常是1维膨胀卷积,这样的一种结构非常注重context,也就是上下文信息,具体而言,是在frame

    2024年02月03日
    浏览(40)
  • 深度学习中Epoch和Batch Size的关系

    在深度学习中,Epoch(周期)和 Batch Size(批大小)是训练神经网络时经常使用的两个重要的超参数。它们之间的关系是通过以下方式连接的: Epoch 表示整个训练数据集被神经网络完整地通过了一次。在一个 Epoch 内,神经网络会看到训练数据集中的所有样本一次,进行前向传

    2024年01月16日
    浏览(42)
  • 深度学习中,什么是batch-size?如何设置?

    batch-size 是深度学习模型在训练过程中一次性输入给模型的样本数量。它在训练过程中具有重要的意义,影响着训练速度、内存使用以及模型的稳定性等方面。 以下是 batch-size 大小的一些影响和意义: 训练速度 :较大的 batch-size 通常可以加快训练速度,因为在每次迭代中处

    2024年02月12日
    浏览(37)
  • 深度学习记录--mini-batch gradient descent

    batch:段,块 与传统的batch梯度下降不同,mini-batch gradient descent将数据分成多个子集,分别进行处理,在 数据量非常巨大 的情况下,这样处理可以及时进行梯度下降,大大加快训练速度 两种方法的梯度下降图如下图所示 batch gradient descent是一条正常的 递减 的曲线 mini-batch

    2024年01月21日
    浏览(45)
  • 深度学习中epoch、batch、step、iteration等神经网络参数是什么意思?

    epoch: 表示将训练数据集中的所有样本都过一遍 (且仅过一遍)的训练过程。在一个epoch中,训练算法会按照设定的顺序将所有样本输入模型进行前向传播、计算损失、反向传播和参数更新。一个epoch通常包含多个step。 batch:一般翻译为“批次”,表示一次性输入模型的一组

    2024年02月10日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包