当前位置:   article > 正文

PyTorch 标准化操作层 (BatchNorm, LayerNorm, InstanceNorm))_torch三维标准化

torch三维标准化

PyTorch 正则化层

1. BatchNorm标准化

1.1 BatchNorm1d一维标准化

输入:(N, C, L)
N:batch的样本数量
C: 样本的通道数
L: 样本单通道的尺寸大小

对于小批量数据中的每一个特征维度执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class BatchNorml1d(_BatchNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个维度的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 训练时,该层计算每次输入的均值和方差,并进行移动平均,
       移动平均默认的动量值为0.1。
    4. 在验证时,使用训练求得的均值/方差标准化验证数据。
       
    Method resolution order:
        BatchNorm1d
        _BatchNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的特征数,
            	如果输入是(N, L), 那么num_features=L, 将计算N组均值和方差;
            	如果输入是(N, C,L), 那么num_features=C,将计算C组均值和方差,每组计算N*L个数值;
            eps: 为保证数值的稳定性,给分母加上的值。
            momentum: 动态均值和动态方差使用的动量
            	计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数。
            track_running_stats: bool, 是否统计全局的均值和方差
      		
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, L) or size(N, C, L)
            output: size(N, L) or size(N, C, L)
        """
        pass

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

1.2 BatchNorm2d二维标准化

输入:(N, C, H, W)
N:batch的样本数量
C: 样本的通道数
H: 输入样本的高
W: 输入样本的宽

对于小批量数据中的每一个特征维度执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class BatchNorml2d(_BatchNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个维度的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 训练时,该层计算每次输入的均值和方差,并进行移动平均,
       移动平均默认的动量值为0.1。
    4. 在验证时,使用训练求得的均值/方差标准化验证数据。。
       
    Method resolution order:
        BatchNorm1d
        _BatchNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的特征数,
                输入是(N, C,H, W), 那么num_features=C,将计算C组均值和方差,每组计算N*H*W个数值;
            eps: 为保证数值的稳定性,给分母加上的值。
            momentum: 动态均值和动态方差使用的动量
                计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数。
            track_running_stats: bool, 是否统计全局的均值和方差
        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C, H, W)
            output: size(N, C, H, W)
        """
        pass
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

1.3 BatchNorm3d 三维标准化

输入:(N, C, D, H, W)
N:batch的样本数量
C: 样本的通道数
D: 输入样本的深度
H: 输入样本的高
W: 输入样本的宽

对于小批量数据中的每一个特征维度执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class BatchNorml3d(_BatchNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个维度的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 训练时,该层计算每次输入的均值和方差,并进行移动平均,
       移动平均默认的动量值为0.1。
    4. 在验证时,使用训练求得的均值/方差标准化验证数据。。
       
    Method resolution order:
        BatchNorm1d
        _BatchNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的特征数,
                输入是(N, C,D, H, W), 那么num_features=C,将计算C组均值和方差,每组计算N*D*H*W个数值;
            eps: 为保证数值的稳定性,给分母加上的值。
            momentum: 动态均值和动态方差使用的动量
                计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数。
            track_running_stats: bool, 是否统计全局的均值和方差
        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C, H, W)
            output: size(N, C, H, W)
        """
        pass
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

2. 层标准化LayerNorm

输入:(N, D)
N:batch的样本数量
D: 输入的最后维度,与normalized_shape参数有关

对于小批量数据中的每一个样本执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class LayerNorm(nn.Module):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个样本的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 同时在训练和验证模式下,都是使用输入计算的均值和方差
       
    Method resolution order:
        LayerNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, normalized_shape, eps=1e-05, elementwise_affine=True):
        r"""
        parameters:
            normalized_shape: 来自期望输入的尺寸,用于计算均值和方差的维度
                输入是(N, C,D, H, W),
                    normalized_shape=W,每组计算W个数值的均值和方差;
                    normalized_shape=(H, W),每组计算H*W个数值的均值和方差;
                    normalized_shape=(D, H, W),每组计算D*H*W个数值的均值和方差;
                    normalized_shape=(C, D, H, W),每组计算C*D*H*W个数值的均值和方差;
            eps: 为保证数值的稳定性,给分母加上的值。
            elementwise_affine: bool, 当设为True,给该层添加可学习的仿射变换参数。        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, *)
            output: size(N, *) same shape as input
        """
        pass
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

3. InstanceNorm实例标准化

3.1 InstanceNorm1d一维实例标准化

输入:(N, C, L)
N:batch的样本数量
C: 通道数
L: 单通道尺寸

对于小批量数据中的每一个样本的一个channel内做归一化,执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class InstanceNorm1d(_InstanceNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个样本的每个通道的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 使用训练计算的均值和方差用于评估模式。
       
    Method resolution order:
        InstanceNorm1d
        _InstanceNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的尺寸
                输入是(N, C,L)时, num_features=C, 计算L个数值的均值和方差;
                输入是(N, L)时,num_features=L,计算单个数值的均值和方差;
            eps: 为保证数值的稳定性,给分母加上的值
            momentum: 动态均值和动态方差使用的动量
                计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数
            track_running_stats: bool, 是否统计全局的均值和方差        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C, L)
            output: size(N, C, L) same shape as input
        """
        pass

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

3.2 InstanceNorm2d二维实例标准化

输入:(N, C, H, W)
N: batch的样本数量
C: 通道数
H: 样本尺寸高(像素)
D: 样本尺寸宽(像素)

对于小批量数据中的每一个样本的一个channel内做归一化,执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class InstanceNorm2d(_InstanceNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个样本的每个通道的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 使用训练计算的均值和方差用于评估模式。
       
    Method resolution order:
        InstanceNorm1d
        _InstanceNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的尺寸
                输入是(N, C, H, W)时, num_features=C, 计算H*W个数值的均值和方差;
            eps: 为保证数值的稳定性,给分母加上的值
            momentum: 动态均值和动态方差使用的动量
                计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数
            track_running_stats: bool, 是否统计全局的均值和方差        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C, H, W)
            output: size(N, C, H, W) same shape as input
        """
        pass

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

3.3 InstanceNorm3d三维实例标准化

输入:(N, C, H, W)
N: batch的样本数量
C: 通道数
D: 样本尺寸宽(像素)
H: 样本尺寸高(像素)
D: 样本尺寸宽(像素)

对于小批量数据中的每一个样本的一个channel内做归一化,执行如下的标准化操作:
y = x − E [ x ] V a r [ x ] + ϵ ∗ γ + β y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta y=Var[x]+ϵ xE[x]γ+β

class InstanceNorm3d(_InstanceNorm):
    r"""
    对小批量(mini_batch)的2d或3d输入进行批标准化(Batch_Normalization)操作:
    1. 计算每个小批量数据中,计算输入的各个样本的每个通道的均值和标准差。
    2. gamma 和 beta 是可学习的大小为C的参数向量, 默认值gamma=1,beta=0。
    3. 使用训练计算的均值和方差用于评估模式。
       
    Method resolution order:
        InstanceNorm1d
        _InstanceNorm
        _NormBase
        torch.nn.modules.module.Module
        builtins.object
    """
    def __init__(self, num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True):
        r"""
        parameters:
            num_features: 来自期望输入的尺寸
                输入是(N, C, D, H, W)时, num_features=C, 计算H*W个数值的均值和方差;
            eps: 为保证数值的稳定性,给分母加上的值
            momentum: 动态均值和动态方差使用的动量
                计算全局的均值和方差: x_new=(1−momentum)×x_cur+momentum×x_batch
            affine: bool, 当设为True,给该层添加可学习的仿射变换参数
            track_running_stats: bool, 是否统计全局的均值和方差        
        """
        pass
    
    def __call__(self, input, output):
        r"""
        parameters:
            input: size(N, C, D, H, W)
            output: size(N, C, D, H, W) same shape as input
        """
        pass
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/weixin_40725706/article/detail/606327
推荐阅读
相关标签
  

闽ICP备14008679号