tensorflow2.0定义InstanceNormalization,BatchRenormalization,GroupNormalization,SwitchableNormalization

最新推荐文章于 2022-03-04 11:39:22 发布
最新推荐文章于 2022-03-04 11:39:22 发布
阅读量3.2k 收藏 15
点赞数 3
文章标签： tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27039891/article/details/104439563
版权

使用tensorflow2.0定义InstanceNormalization(论文地址)，BatchRenormalization(论文地址),GroupNormalization(论文地址),SwitchableNormalization(论文地址)。由于没有具体测试过这些代码，如果有错误，请原谅。

class InstanceNormalization(tf.keras.layers.Layer):
    def __init__(self,beta_initializer='zeros',gamma_initializer='ones',
                 beta_regularizer=None,gamma_regularizer=None,
                 beta_constraint=None,gamma_constraint=None,epsilon=1e-5,
                 **kwargs):
        super(InstanceNormalization, self).__init__(**kwargs)
        self.epsilon = epsilon
        self.beta_initializer = tf.keras.initializers.get(beta_initializer)
        self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)
        self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)
        self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)
        self.beta_constraint = tf.keras.constraints.get(beta_constraint)
        self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)
        
    def build(self, input_shape):  
        assert len(input_shape)==4
        shape = (input_shape[-1],)
        self.gamma = self.add_weight(shape=shape,name='gamma',initializer=self.gamma_initializer,
                                regularizer=self.gamma_regularizer,constraint=self.gamma_constraint)
        self.beta = self.add_weight(shape=shape,name='beta',initializer=self.beta_initializer,
                                regularizer=self.beta_regularizer,constraint=self.beta_constraint)
        self.built = True
        
    def call(self,inputs):
        mean,variance = tf.nn.moments(inputs,axes=[1,2])
        mean = tf.reshape(mean,shape=[inputs.shape[0],1,1,inputs.shape[-1]])
        variance = tf.reshape(variance,shape=[inputs.shape[0],1,1,inputs.shape[-1]])
        outputs = (inputs - mean) / tf.sqrt(variance + self.epsilon)
        return outputs*self.gamma + self.beta
    
    def get_config(self):
        config = {
            'epsilon': self.epsilon,
            'beta_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'gamma_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'beta_regularizer': tf.keras.regularizers.serialize(self.beta_regularizer),
            'gamma_regularizer': tf.keras.regularizers.serialize(self.gamma_regularizer),
            'beta_constraint': tf.keras.constraints.serialize(self.beta_constraint),
            'gamma_constraint': tf.keras.constraints.serialize(self.gamma_constraint)
        }
        base_config = super(InstanceNormalization, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

    def compute_output_shape(self, input_shape):
        return input_shape

class BatchRenormalization(tf.keras.layers.Layer):
    def __init__(self,momentum=0.99,rmax=3,damx=5,t_delta=1e-3,axis=-1,beta_initializer='zeros',
                 gamma_initializer='ones',beta_regularizer=None,gamma_regularizer=None,
                 beta_constraint=None,gamma_constraint=None,moving_mean_initializer='zeros',
                 moving_variance_initializer='ones',epsilon=1e-3,
                 **kwargs):
        super(BatchRenormalization, self).__init__(**kwargs)
        self.momentum = momentum
        self.rmax = rmax
        self.dmax = dmax
        self.t_delta=t_delta,
        self.axis = axis
        self.epsilon = epsilon
        self.beta_initializer = tf.keras.initializers.get(beta_initializer)
        self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)
        self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)
        self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)
        self.beta_constraint = tf.keras.constraints.get(beta_constraint)
        self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)
        self.moving_mean_initializer = tf.keras.initializers.get(moving_mean_initializer)
        self.moving_variance_initializer = tf.keras.initializers.get(moving_variance_initializer)
        
    def build(self, input_shape):  
        assert len(input_shape)==4
        shape = (input_shape[self.axis],)
        self.gamma = self.add_weight(shape=shape,name='gamma',initializer=self.gamma_initializer,
                                regularizer=self.gamma_regularizer,constraint=self.gamma_constraint)
        self.beta = self.add_weight(shape=shape,name='beta',initializer=self.beta_initializer,
                                regularizer=self.beta_regularizer,constraint=self.beta_constraint)
        self.moving_mean = self.add_weight(shape=shape,name='moving_mean',
                        initializer=self.moving_mean_initializer,trainable=False)
        self.moving_variance = self.add_weight(shape=shape,name='moving_variance',
                        initializer=self.moving_variance_initializer,trainable=False)
        self.t = self.add_weight(shape=(1,),name='iteration',
            initializer=tf.keras.initializers.Zeros(),trainable=False)
        self.r_value = self.add_weight(shape=(1,),name='r_value',
            initializer=tf.keras.initializers.Ones(),trainable=False)
        self.d_value = self.add_weight(shape=(1,),name='d_value',
            initializer=tf.keras.initializers.Zeros(),trainable=False)
        self.built = True
        
    def call(self,inputs):
        if tf.keras.backend.learning_phase() in [0,False]:
            return tf.keras.backend.batch_normalization(
                    inputs,
                    self.moving_mean,
                    self.moving_variance,
                    self.beta,
                    self.gamma,
                    axis=self.axis,
                    epsilon=self.epsilon)
            
        mean,variance = tf.nn.moments(inputs,axes=[0,1,2])
        r = tf.sqrt(variance + self.epsilon) / tf.sqrt(self.moving_variance + self.epsilon)
        r = tf.stop_gradient(tf.clip_by_value(r,1/self.r_value,self.r_value))
        d = (mean - self.moving_variance) / tf.sqrt(self.moving_variance + self.epsilon)
        d = tf.stop_gradient(tf.clip_by_value(d,-self.d_value,self.d_value))
        outputs = (inputs - mean) * r / tf.sqrt(variance + self.epsilon) + d
        self.add_update([tf.keras.backend.moving_average_update(self.moving_mean,mean,self.momentum),
                      tf.keras.backend.moving_average_update(self.moving_variance,variance,self.momentum),
                      tf.keras.backend.update_add(self.t,self.t_delta),
                      tf.keras.backend.update(self.r_value, self.rmax/(1+(self.rmax-1)*
                                                                       tf.exp(-self.t)) ),
                      tf.keras.backend.update(self.d_value, self.dmax/(1+ ( self.dmax/1e-3 -1)
                                                                       * tf.exp(-(2*self.t))) )],
                      inputs)
        return outputs*self.gamma + self.beta
    
    def get_config(self):
        config = {
            'momentum':self.momentum,
            'axis':self.axis,
            't_delta':self.t_delta,
            'rmax':self.rmax,
            'dmax':self.dmax,
            'epsilon': self.epsilon,
            'beta_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'gamma_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'beta_regularizer': tf.keras.regularizers.serialize(self.beta_regularizer),
            'gamma_regularizer': tf.keras.regularizers.serialize(self.gamma_regularizer),
            'beta_constraint': tf.keras.constraints.serialize(self.beta_constraint),
            'gamma_constraint':tf.keras. constraints.serialize(self.gamma_constraint),
            'moving_mean_initializer':
                tf.keras.initializers.serialize(self.moving_mean_initializer),
            'moving_variance_initializer':
                tf.keras.initializers.serialize(self.moving_variance_initializer),
        }
        base_config = super(BatchRenormalization, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

    def compute_output_shape(self, input_shape):
        return input_shape

class GroupNormalization(tf.keras.layers.Layer):
    def __init__(self,group=32,beta_initializer='zeros',gamma_initializer='ones',
                 beta_regularizer=None,gamma_regularizer=None,
                 beta_constraint=None,gamma_constraint=None,epsilon=1e-5,
                 **kwargs):
        super(GroupNormalization, self).__init__(**kwargs)
        self.group = group
        self.epsilon = epsilon
        self.beta_initializer = tf.keras.initializers.get(beta_initializer)
        self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)
        self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)
        self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)
        self.beta_constraint = tf.keras.constraints.get(beta_constraint)
        self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)
        
    def build(self, input_shape):  
        assert len(input_shape) == 4
        assert input_shape[-1] >= self.group
        assert input_shape[-1] % self.group == 0
        
        shape = (input_shape[-1],)
        self.gamma = self.add_weight(shape=shape,name='gamma',initializer=self.gamma_initializer,
                                regularizer=self.gamma_regularizer,constraint=self.gamma_constraint)
        self.beta = self.add_weight(shape=shape,name='beta',initializer=self.beta_initializer,
                                regularizer=self.beta_regularizer,constraint=self.beta_constraint)
        self.built = True
        
    def call(self,inputs):
        shape = inputs.shape
        inputs = tf.reshape(inputs, shape=[shape[0], shape[1], shape[2],
                                           self.group, shape[-1]//self.group])
        mean,variance = tf.nn.moments(inputs,axes=[1,2,3],keepdims=True)
        outputs = (inputs - mean) / tf.sqrt(variance + self.epsilon)
        outputs = tf.reshape(outputs,shape=shape)
        return outputs*self.gamma + self.beta
    
    def get_config(self):
        config = {
            'epsilon': self.epsilon,
            'beta_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'gamma_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'beta_regularizer': tf.keras.regularizers.serialize(self.beta_regularizer),
            'gamma_regularizer': tf.keras.regularizers.serialize(self.gamma_regularizer),
            'beta_constraint': tf.keras.constraints.serialize(self.beta_constraint),
            'gamma_constraint': tf.keras.constraints.serialize(self.gamma_constraint)
        }
        base_config = super(GroupNormalization, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

    def compute_output_shape(self, input_shape):
        return input_shape        

class SwitchableNormalization(tf.keras.layers.Layer):
    def __init__(self,beta_initializer='zeros',gamma_initializer='ones',
                 mean_weights_initializer='ones',variance_weights_initializer='ones',
                 beta_regularizer=None,gamma_regularizer=None, 
                 mean_weights_regularizer=None,variance_weights_regularizer=None,
                 moving_mean_initializer='zeros',moving_variance_initializer='ones',
                 beta_constraint=None,gamma_constraint=None,epsilon=1e-5,
                 mean_weights_constraint=None,variance_weights_constraint=None,
                 **kwargs):
        super(SwitchableNormalization, self).__init__(**kwargs)
        self.epsilon = epsilon
        self.moving_mean_initializer = tf.keras.initializers.get(moving_mean_initializer)
        self.moving_variance_initializer = tf.keras.initializers.get( moving_variance_initializer)
        self.beta_initializer = tf.keras.initializers.get(beta_initializer)
        self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)
        self.mean_weights_initializer = tf.keras.initializers.get(mean_weights_initializer)
        self.variance_weights_initializer = tf.keras.initializers.get(variance_weights_initializer)
        self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)
        self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)
        self.mean_weights_regularizer = tf.keras.initializers.get(mean_weights_regularizer)
        self.variance_weights_regularizer = tf.keras.initializers.get(variance_weights_regularizer)
        self.beta_constraint = tf.keras.constraints.get(beta_constraint)
        self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)
        self.mean_weights_constraint = tf.keras.initializers.get(mean_weights_constraint)
        self.variance_weights_constraint = tf.keras.initializers.get(variance_weights_constraint)
        
    def build(self, input_shape):  
        assert len(input_shape)==4
        shape = (input_shape[-1],)
        self.gamma = self.add_weight(shape=shape,name='gamma',initializer=self.gamma_initializer,
                                regularizer=self.gamma_regularizer,constraint=self.gamma_constraint)
        self.beta = self.add_weight(shape=shape,name='beta',initializer=self.beta_initializer,
                                regularizer=self.beta_regularizer,constraint=self.beta_constraint)
        
        self.moving_mean = self.add_weight(
            shape=shape,
            name='moving_mean',
            initializer=self.moving_mean_initializer,
            trainable=False)
        self.moving_variance = self.add_weight(
            shape=shape,
            name='moving_variance',
            initializer=self.moving_variance_initializer,
            trainable=False)
        
        self.mean_weights = self.add_weight(
            shape=(3,),
            name='mean_weights',
            initializer=self.mean_weights_initializer,
            regularizer=self.mean_weights_regularizer,constraint=self.mean_weights_constraint)
        self.variance_weights = self.add_weight(
            shape=(3,),
            name='variance_weights',
            initializer=self.moving_variance_initializer,
            regularizer=self.variance_weights_regularizer,
            constraint=self.variance_weights_constraint)
        
        self.built = True
        
    def call(self,inputs):
        if tf.keras.backend.learning_phase() in [0,False]:
            batch_normolization_mean,batch_normolization_variance = self.moving_mean, self.moving_variance
        else:
            batch_normolization_mean,batch_normolization_variance = tf.nn.moments(inputs,axes=[0,1,2],
                                                                             keepdims=True)
        layer_normolization_mean,layer_normolization_variance = tf.nn.moments(inputs,axes=[1,2,3],
                                                                             keepdims=True)
        instance_normolization_mean,instance_normolization_variance = tf.nn.moments(inputs,axes=[1,2],
                                                                             keepdims=True)     
        weight1 = tf.keras.backend.softmax(self.mean_weights)
        weight2 = tf.keras.backend.softmax(self.variance_weights)
        mean = weight1[0] * batch_normolization_mean + weight1[1] * layer_normolization_mean + weight1[2] * instance_normolization_mean
        variance =  weight2[0] * batch_normolization_variance + weight2[1] * layer_normolization_variance + weight2[2] * instance_normolization_variance
        outputs = (inputs - mean) / tf.sqrt(variance + self.epsilon)
        if tf.keras.backend.learning_phase() in [1,True]:
            self.add_update([K.moving_average_update(self.moving_mean,
                                                     batch_normolization_mean,
                                                     self.momentum),
                        K.moving_average_update(self.moving_variance,
                                                     batch_normolization_variance,
                                                     self.momentum)],
                        inputs)
        return outputs*self.gamma + self.beta
    
    def get_config(self):
        config = {
            'epsilon': self.epsilon,
            'beta_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'gamma_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'beta_regularizer': tf.keras.regularizers.serialize(self.beta_regularizer),
            'gamma_regularizer': tf.keras.regularizers.serialize(self.gamma_regularizer),
            'beta_constraint': tf.keras.constraints.serialize(self.beta_constraint),
            'gamma_constraint': tf.keras.constraints.serialize(self.gamma_constraint),
            'moving_mean_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'moving_variance_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'mean_weights_initializer': tf.keras.initializers.serialize(self.beta_initializer),
            'mean_variance_initializer': tf.keras.initializers.serialize(self.gamma_initializer),
            'mean_weights_regularizer': tf.keras.regularizers.serialize(self.beta_regularizer),
            'mean_variance_regularizer': tf.keras.regularizers.serialize(self.gamma_regularizer),
            'mean_weights_constraint': tf.keras.constraints.serialize(self.beta_constraint),
            'mean_variance_constraint': tf.keras.constraints.serialize(self.gamma_constraint),
        }
        base_config = super(SwitchableNormalization, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

    def compute_output_shape(self, input_shape):
        return input_shape
愤怒的勇
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
GroupNormalizationTF:使用ImageNet上的预训练权重在Tensorflow中进行组归一化ResNet
04-28
使用ImageNet上的预训练权重在Tensorflow中进行组归一化ResNet 该存储库包含使用非正式重新实现ResNet的代码。 组归一化（GN）作为BN的一种简单替代方案。 GN的计算不受批次大小的影响，并且其精度在各种批次大小中都稳定，这使其在COCO中的对象检测和分割方面优于基于BN的同类方法。 为了加速基于组归一化的进一步研究，我想在ImageNet上共享针对它们的预先训练的权重，您可以从下载。 使用和其他后期处理，将预训练的权重从重转换而来。 使用转换后的权重的所有网络的输出与原始Caffe2网络的输出几乎相同（错误<1e-5）。 与预训练权重相关的所有权利均属于的的原始作者。 此代码和预先训练的权重仅可用于研究目的。 此ResNet的规范输入图像大小为224x224，每个像素值应在[-128,128]（BGR阶）范围内，并且输入预处理例程非常简单，仅使用通过均值
tensorflow中batch normalization的用法
weixin_34405925的博客
07-27 887
网上找了下tensorflow中使用batch normalization的博客，发现写的都不是很好，在此总结下： 1.原理 公式如下： y=γ(x-μ)/σ+β 其中x是输入，y是输出，μ是均值，σ是方差，γ和β是缩放（scale）、偏移（offset）系数。 一般来讲，这些参数都是基于channel来做的，比如输入x是一个16*32*32*128(NWHC格式)的feature ma...
Switchable-Normalization:从“通过可切换归一化的不同学习到归一化”的可切换归一化代码，https
04-13
可切换归一化 可切换规范化是一种规范化技术，它能够以端到端的方式为深度神经网络中的不同规范化层学习不同的规范化操作。 更新 2019/3/21：发布分布式培训框架和面部识别框架。 我们还发布SyncBN和SyncSN的pytorch实现小批量任务，如分割和检测。 有关SyncBN和SyncSN的更多详细信息，可以参考。 2018/7/27：已发布ResNet50 + SN（8,1）和SN（8,4）的预训练模型。 当目标任务的批处理大小被限制为较小时，这些模型可能会在微调阶段有所帮助。 我们还发布了ResNet101v2 + SN的预训练模型，该模型在ImageNet上达到了78.81％/ 94.16％的top-1 / top-5精度。 更多预训练模型即将发布！ 2018/7/26：用于对象检测的代码已在的存储库中。 2018/7/9：我们想解释SN背后的优点。 请参阅或 。 201
keras 的InstanceNormalization的使用
CodeWorld
01-23 5585
1.instanceNormalization在keras_contrib中，而keras_contrib不能以常规pip方式导入，而是 pip install git+https://www.github.com/keras-team/keras-contrib.git 但是这样还需要下载git工具，我先去官网下载，翻墙后下载速度还是接近10k的高速，然后我去github下载，然并卵，依旧...
【小白学PyTorch】扩展之Tensorflow2.0 | 21 Keras的API详解（下）池化、Normalization
fengdu78的博客
10-16 437
<<小白学PyTorch>>扩展之Tensorflow2.0 | 21 Keras的API详解（上）卷积、激活、初始化、正则扩展之Tensorflow2.0 | ...
tensorflow2.0与tensorflow1.0的性能区别介绍
09-18
TensorFlow 是一个广泛使用的深度学习框架，自发布以来经历了多次重大更新，其中TensorFlow 2.0 是一个显著的里程碑。本文将详细探讨TensorFlow 2.0与1.0在性能上的主要区别。 首先，TensorFlow 1.0采用的是静态图...
tensorflow2-docs-zh:TF2.0 TensorFlow 2.0 TensorFlow2.0 官方文档中文版
05-29
TensorFlow 2 / 2.0 官方文档中文版相关链接，，，目录(持续更新)基础 - 机器学习基础 ML basics过拟合与欠拟合 Overfitting and underfitting保存和恢复模型 Save and restore models基础 - 图像分类卷积神经网络 ...
ranknet-tensorflow2.0:TensorFlow 2.0中RankNet到LambdaRank的实现
05-23
TensorFlow2.0中Ranknet到LambdaRank的实现 **此存储库在Tensorflow 2.0中具有从RankNet到LambdaRank的实现，** 要求 tqdm == 4.32.1 numpy == 1.16.4 点击== 7.0 tensorflow_gpu == 2.1.0 设置 $ git clone ...
tensorflow2.0-unet:tensorflow2.0，resnet，unet
03-12
**TensorFlow 2.0与ResNet-UNet结合应用** 在深度学习领域，TensorFlow 2.0是一个广泛使用的开源框架，它提供了强大的工具来构建和训练神经网络模型。相较于TensorFlow 1.x，2.0版本引入了Eager Execution（即时...
日月光华TensorFlow2.0个人收集整理的数据集和代码
06-11
在本资源包中，日月光华收集整理了一系列与TensorFlow 2.0相关的学习资料，包括数据集和代码示例。这些资料旨在帮助初学者和进阶者深入理解和实践机器学习模型，尤其是使用TensorFlow这一强大的深度学习库。下面我们...
batch normalization 和 layer normalization 在RNN（LSTM、GRU）上的TensorFlow实现
04-19
batch normalization 和 layer normalization 在RNN（LSTM、GRU）上的TensorFlow实现;运行无误，示例为mnist手写体识别
对于深度学习中 Batch Normallization (BN) 和 Batch Renormalization 的理解
XindaBlack的博客
01-19 1401
Batch Normalization Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 由上图可知，Batch Normalization（BN）算法总共有四行，分两步。第一步是前三行，将激活值（论文中进行BN的是激活函数的输入值，也可以是激活函数的输出值，不...
DIFFERENTIABLE LEARNING-TO-NORMALIZE VIA SWITCHABLE NORMALIZATION（SN 可微分学习的自适配归一化）
qq_33266320的博客
10-28 927
DIFFERENTIABLE LEARNING-TO-NORMALIZE VIA SWITCHABLE NORMALIZATION（SN 可微分学习的自适配归一化） 可交换的归一化方法 这是根据不同作者写的以及我个人的理解做出的总结，只是方便我个人下次阅读，如有侵权，请联系我删除。   论文参考：https://zhuanlan.zhihu.com/p/39296570 论文参考：htt...
深入理解TensorFlow之基础概念：数据流图、张量、操作、会话、优化器
huwenxing0801的博客
12-14 1488
前言 本文梳理了TensorFlow的基本概念：数据流图、Tensor、Operation、Variable、Placeholder、Session、Optimizer、minimize。并对每个概念进行了详细的讲解和扩展。 阅读本文需要对深度学习有一定了解，知道tensorflow是什么。 一. 编程范式：数据流图 声明式编程和命令式编程： 声明式编程：做什么 命令式编程：怎么做 Tenso...
各种归一化层（BatchNorm、LayerNorm、InstanceNorm、GroupNorm、Weight Standardization）及其Pytorch实现
热门推荐
David's Tweet
06-05 1万+
BN，LN，IN，GN从学术化上解释差异：BatchNorm：batch方向做归一化，算NHW的均值，对小batchsize效果不好；BN主要缺点是对batchsize的大小比较敏感，由于每次计算均值和方差是在一个batch上，所以如果batchsize太小，则计算的均值、方差不足以代表整个数据分布LayerNorm：channel方向做归一化，算CHW的均值，主要对RNN作用明显；InstanceNorm：一个channel内做归一化，算H*W的均值，用在风格化迁移；因为在图像风格化中，生成结果主要依赖.
一文理解深度学习框架中的InstanceNorm
OneFlow深度学习框架
03-04 6482
本文主要推导 InstanceNorm 关于输入和参数的梯度公式，同时还会结合 PyTorch 和 MXNet 里的 InstanceNorm 代码来分析。
Batch Normalization、Layer Normalization、Instance Normalization、Group Normalization、Switchable Normal...
凌逆战的博客
09-22 972
深度神经网络难训练一个重要的原因就是深度神经网络涉及很多层的叠加，每一层的参数变化都会导致下一层输入数据分布的变化，随着层数的增加，高层输入数据分布变化会非常剧烈，这就使得高层需要不断适应低层的参数更新。为了训练好模型，我们需要谨慎初始化网络权重，调整学习率等。 本篇博客总结几种归一化办法，并给出相应计算公式和代码。 归一化层，目前主要有这几个方法，Batch Normalization...
深度剖析 | SN 可微分学习的自适配归一化 (Switchable Normalization)
Snoopy_Dream
07-12 6019
补充：NIPS 2018 | MIT新研究参透批归一化原理 根据最新的研究，BN层的成功和协方差什么的没有关联！证明这种层输入分布稳定性与 BatchNorm 的成功几乎没有关系。相反，我们发现 BatchNorm 会对训练过程产生更重要的影响：它使优化解空间更加平滑了。这种平滑使梯度更具可预测性和稳定性，从而使训练过程更快。 而且BatchNorm 并不是最好（唯一）的平滑解空间的方法，有时...
Instance Normalization(实列正则化）
写了 = 会了.gif
08-26 1万+
对一个批次中单个图片进行归一化，而不是像batch normaliztion一样对整个批次的所有图片进行归一化，提取出平均值等。 更多 Instance Normalization的提出源于论文“实例规范化：快速程式化的缺失成分” Github：https：//github.com/DmitryUlyanov/texture_nets  https://www.zhihu.com/qu...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值