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

PyTorch 正则化层

1. BatchNorm标准化

1.1 BatchNorm1d一维标准化

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

对于小批量数据中的每一个特征维度执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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 BatchNorm2d二维标准化

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

对于小批量数据中的每一个特征维度执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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.3 BatchNorm3d 三维标准化

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

对于小批量数据中的每一个特征维度执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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

2. 层标准化LayerNorm

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

对于小批量数据中的每一个样本执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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

3. InstanceNorm实例标准化

3.1 InstanceNorm1d一维实例标准化

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

对于小批量数据中的每一个样本的一个channel内做归一化，执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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

3.2 InstanceNorm2d二维实例标准化

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

对于小批量数据中的每一个样本的一个channel内做归一化，执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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

3.3 InstanceNorm3d三维实例标准化

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

对于小批量数据中的每一个样本的一个channel内做归一化，执行如下的标准化操作：
$$y=\frac{x-\mathrm{E}[x]}{\sqrt{\mathrm{V}\mathrm{a}\mathrm{r}[x]+ϵ}}\ast \gamma +\beta$$

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