新手深入浅出理解PyTorch归一化层全解析

2024-01-08 21:37:43

目录

torch.nn子模块normal层详解

nn.BatchNorm1d

BatchNorm1d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.BatchNorm2d

BatchNorm2d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

?nn.BatchNorm3d

BatchNorm3d 函数简介

参数详解

使用技巧与注意事项

示例代码

nn.LazyBatchNorm1d

LazyBatchNorm1d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.LazyBatchNorm2d

LazyBatchNorm2d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.LazyBatchNorm3d

LazyBatchNorm3d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.GroupNorm

GroupNorm 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.SyncBatchNorm

SyncBatchNorm 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.InstanceNorm1d

InstanceNorm1d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.InstanceNorm2d

InstanceNorm2d 函数简介

函数工作原理?

参数详解

使用技巧与注意事项

示例代码

nn.InstanceNorm3d

InstanceNorm3d 函数简介

参数详解

使用技巧与注意事项

示例代码

nn.LazyInstanceNorm1d

LazyInstanceNorm1d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.LazyInstanceNorm2d

LazyInstanceNorm2d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.LazyInstanceNorm3d

LazyInstanceNorm3d 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

nn.LayerNorm

LayerNorm 函数简介

参数详解

使用技巧与注意事项

示例代码

nn.LocalResponseNorm

LocalResponseNorm 函数简介

函数工作原理

参数详解

使用技巧与注意事项

示例代码

总结

torch.nn子模块normal层详解

nn.BatchNorm1d

BatchNorm1d 函数简介

  • 用途：BatchNorm1d（批量归一化）主要用于加速深度神经网络的训练，通过减少内部协变量偏移来实现。

函数工作原理

  • 定义：BatchNorm1d 对于每个特征维度计算小批量（mini-batch）的均值和标准差，并使用这些统计量对数据进行归一化。
  • 数学表达式：对于输入 x，BatchNorm1d 计算为y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta?其中 E[x] 是均值，Var[x] 是方差，\gamma 和 \beta 是可学习的参数向量，\epsilon 是为了数值稳定性而加的小值。

参数详解

  • num_features（int）：输入的特征或通道数 C。
  • eps（float）：为了数值稳定性加在分母上的小值，默认为 1e-5。
  • momentum（float）：用于计算 running_mean 和 running_var 的值。默认为 0.1。设为 None 可用于计算累积移动平均（即简单平均）。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，且初始化 running_mean 和 running_var 为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 在训练和评估模式下的不同行为：在训练模式下，该层会计算并更新均值和方差的运行估计。在评估模式下，它会使用这些估计进行归一化。
  • 选择正确的 momentum：momentum 参数对于运行统计量的更新非常重要，需要根据应用场景适当选择。

示例代码

下面是一个使用 BatchNorm1d 的示例代码：

import torch
import torch.nn as nn

# 带有可学习参数的 BatchNorm1d
m = nn.BatchNorm1d(100)

# 不带可学习参数的 BatchNorm1d
m_no_affine = nn.BatchNorm1d(100, affine=False)

# 创建输入张量
input_tensor = torch.randn(20, 100)

# 应用 BatchNorm1d
output = m(input_tensor)

print("Output with Learnable Parameters:", output)

?这段代码展示了如何初始化带有和不带有可学习参数的 BatchNorm1d 层，并对一个随机生成的输入张量应用该层。

nn.BatchNorm2d

BatchNorm2d 函数简介

  • 用途：BatchNorm2d 用于对包含额外通道维度的二维输入的小批量（mini-batch）进行批量归一化。它主要用于加速深度网络训练，并减少内部协变量偏移。

函数工作原理

  • 定义：该函数对每个特征维度计算小批量的均值和标准差，并使用这些统计量对数据进行归一化。
  • 数学表达式：对于输入 x，BatchNorm2d 计算为y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta?其中 E[x] 是均值，Var[x] 是方差，\gamma 和 \beta 是可学习的参数向量，\epsilon 是一个小的常数，用于数值稳定性。

参数详解

  • num_features（int）：期望输入的大小 (N, C, H, W) 中的 C，即通道数。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。设置为 None 时表示使用累积移动平均（即简单平均）。默认为 0.1。
  • affine（bool）：当设置为 True 时，此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：当设置为 True 时，此模块跟踪运行均值和方差；设置为 False 时，不跟踪这些统计量，并且将 running_mean 和 running_var 初始化为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 训练与评估模式的不同：在训练模式下，该层会更新运行均值和方差的估计；在评估模式下，则使用这些估计进行归一化。
  • 适当选择 momentum：选择合适的 momentum 值对于运行统计量的准确性非常重要。

示例代码

下面是一个使用 BatchNorm2d 的示例代码：

import torch
import torch.nn as nn

# 带有可学习参数的 BatchNorm2d
m = nn.BatchNorm2d(100)

# 不带可学习参数的 BatchNorm2d
m_no_affine = nn.BatchNorm2d(100, affine=False)

# 创建输入张量
input_tensor = torch.randn(20, 100, 35, 45)

# 应用 BatchNorm2d
output = m(input_tensor)

print("Output with Learnable Parameters:", output)

这段代码展示了如何初始化带有和不带有可学习参数的 BatchNorm2d 层，并对一个随机生成的四维输入张量应用该层。

?nn.BatchNorm3d

BatchNorm3d 函数简介

  • 用途：BatchNorm3d 主要用于加速深度神经网络的训练，并减少内部协变量偏移。它特别适用于处理具有深度、高度和宽度维度的数据，如视频或医学成像数据。

参数详解

  • num_features（int）：期望输入的大小 (N, C, D, H, W) 中的 C，即通道数。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。设置为 None 时表示使用累积移动平均（即简单平均）。默认为 0.1。
  • affine（bool）：当设置为 True 时，此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：当设置为 True 时，此模块跟踪运行均值和方差；设置为 False 时，不跟踪这些统计量，并且将 running_mean 和 running_var 初始化为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 训练与评估模式的不同：在训练模式下，该层会更新运行均值和方差的估计；在评估模式下，则使用这些估计进行归一化。
  • 适当选择 momentum：选择合适的 momentum 值对于运行统计量的准确性非常重要。

示例代码

下面是一个使用 BatchNorm3d 的示例代码：

import torch
import torch.nn as nn

# 带有可学习参数的 BatchNorm3d
m = nn.BatchNorm3d(100)

# 不带可学习参数的 BatchNorm3d
m_no_affine = nn.BatchNorm3d(100, affine=False)

# 创建输入张量
input_tensor = torch.randn(20, 100, 35, 45, 10)

# 应用 BatchNorm3d
output = m(input_tensor)

print("Output with Learnable Parameters:", output)

这段代码展示了如何初始化带有和不带有可学习参数的 BatchNorm3d 层，并对一个随机生成的五维输入张量应用该层。

nn.LazyBatchNorm1d

LazyBatchNorm1d 函数简介

  • 用途：LazyBatchNorm1d 与标准的 BatchNorm1d 功能相似，但它在模型构建阶段不需要指定 num_features（特征数量）。这一点在处理动态或未知大小的输入特征时非常有用。

函数工作原理

  • 懒初始化：该模块会在接收到第一个输入数据时自动推断 num_features 的大小。在这之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。设置为 None 时表示使用累积移动平均（即简单平均）。默认为 0.1。
  • affine（bool）：当设置为 True 时，此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：当设置为 True 时，此模块跟踪运行均值和方差；设置为 False 时，不跟踪这些统计量，并且将 running_mean 和 running_var 初始化为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 BatchNorm1d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入特征的数量未知或可能发生变化，使用 LazyBatchNorm1d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyBatchNorm1d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyBatchNorm1d 层
m = nn.LazyBatchNorm1d()

# 创建输入张量（特征数量未指定）
input_tensor = torch.randn(20, 100)

# 应用 LazyBatchNorm1d
output = m(input_tensor)

print("Output:", output)

在这个示例中，LazyBatchNorm1d 在接收到输入张量后自动推断特征数量，并初始化相关的参数。

nn.LazyBatchNorm2d

LazyBatchNorm2d 函数简介

  • 用途：LazyBatchNorm2d 类似于标准的 BatchNorm2d，但它可以在模型构建阶段自动推断 num_features 参数（即输入通道数）。这对于处理动态或未知大小的输入特别有用。

函数工作原理

  • 懒初始化：在接收到第一个输入数据时，LazyBatchNorm2d 自动推断 num_features 的大小。在此之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。设置为 None 时表示使用累积移动平均（即简单平均）。默认为 0.1。
  • affine（bool）：当设置为 True 时，此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：当设置为 True 时，此模块跟踪运行均值和方差；设置为 False 时，不跟踪这些统计量，并且将 running_mean 和 running_var 初始化为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 BatchNorm2d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入通道数未知或可能发生变化，使用 LazyBatchNorm2d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyBatchNorm2d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyBatchNorm2d 层
m = nn.LazyBatchNorm2d()

# 创建输入张量（通道数量未指定）
input_tensor = torch.randn(20, 100, 35, 45)

# 应用 LazyBatchNorm2d
output = m(input_tensor)

print("Output:", output)

在这个示例中，LazyBatchNorm2d 在接收到输入张量后自动推断通道数量，并初始化相关的参数。

nn.LazyBatchNorm3d

LazyBatchNorm3d 函数简介

  • 用途：LazyBatchNorm3d 类似于标准的 BatchNorm3d，但它能够在模型构建阶段自动推断 num_features 参数（即输入通道数）。这在处理动态或未知大小的输入时特别有用。

函数工作原理

  • 懒初始化：在接收到第一个输入数据时，LazyBatchNorm3d 自动推断 num_features 的大小。在此之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。设置为 None 时表示使用累积移动平均（即简单平均）。默认为 0.1。
  • affine（bool）：当设置为 True 时，此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：当设置为 True 时，此模块跟踪运行均值和方差；设置为 False 时，不跟踪这些统计量，并且将 running_mean 和 running_var 初始化为 None。在这种情况下，模块总是使用批量统计量。默认为 True。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 BatchNorm3d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入通道数未知或可能发生变化，使用 LazyBatchNorm3d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyBatchNorm3d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyBatchNorm3d 层
m = nn.LazyBatchNorm3d()

# 创建输入张量（通道数量未指定）
input_tensor = torch.randn(20, 100, 10, 35, 45)

# 应用 LazyBatchNorm3d
output = m(input_tensor)

print("Output:", output)

?在这个示例中，LazyBatchNorm3d 在接收到输入张量后自动推断通道数量，并初始化相关的参数。

nn.GroupNorm

GroupNorm 函数简介

  • 用途：GroupNorm 在一批输入数据上应用组归一化，其特别适用于小批量（mini-batch）大小较小的情况。它按照给定的组数将输入通道分组，并在每组内独立计算均值和标准差用于归一化。

函数工作原理

  • 数学表达式：对于输入 x，BatchNorm2d 计算为y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta?其中 E[x] 是均值，Var[x] 是方差，\gamma 和 \beta 是可学习的仿射变换参数，\epsilon 是一个小的常数，用于数值稳定性。
  • 分组：输入通道被分成 num_groups 组，每组包含 num_channels / num_groups 通道。num_channels 必须能被 num_groups 整除。

参数详解

  • num_groups（int）：要将通道分成的组数。
  • num_channels（int）：输入中期望的通道数。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • affine（bool）：若设置为 True，则此模块具有可学习的逐通道仿射参数。默认为 True。

使用技巧与注意事项

  • 应用场景：GroupNorm 在批量大小较小或不定时特别有用，因为它不像批量归一化那样依赖于整个批量的统计数据。
  • 与其他归一化方法的对比：将所有通道分为一个组时，等同于 LayerNorm；将每个通道作为一个单独的组时，等同于 InstanceNorm。

示例代码

下面是一些使用 GroupNorm 的示例代码：

import torch
import torch.nn as nn

# 输入数据
input = torch.randn(20, 6, 10, 10)

# 将 6 个通道分成 3 组
m = nn.GroupNorm(3, 6)

# 将 6 个通道分成 6 组（等同于 InstanceNorm）
m_instance = nn.GroupNorm(6, 6)

# 将所有 6 个通道放入一个组（等同于 LayerNorm）
m_layer = nn.GroupNorm(1, 6)

# 激活模块
output = m(input)

nn.SyncBatchNorm

SyncBatchNorm 函数简介

  • 用途：SyncBatchNorm 将标准的批量归一化操作扩展到多个进程和设备上。它在训练过程中跨不同的进程组同步批量归一化的均值和方差。

函数工作原理

?定义：与传统的批量归一化类似，SyncBatchNorm 对数据进行归一化：y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta?其中 E[x] 和 Var[x] 是在所有进程中计算得到的均值和方差，\gamma 和 \beta 是可学习的参数，\epsilon 是为了数值稳定性添加的小常数。

参数详解

  • num_features（int）：输入的通道数 C。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 True。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 True。
  • process_group（Optional[Any]）：指定进行统计数据同步的进程组。

使用技巧与注意事项

  • 分布式训练：SyncBatchNorm 主要用于分布式训练场景，在这些场景中，需要在多个GPU或节点上同步均值和方差。
  • 转换现有模型：可以使用 torch.nn.SyncBatchNorm.convert_sync_batchnorm 方法将现有的 BatchNorm*D 层转换为 SyncBatchNorm 层。

示例代码

下面是一个使用 SyncBatchNorm 的示例代码：

import torch
import torch.nn as nn
import torch.distributed as dist

# 创建 SyncBatchNorm 层
m = nn.SyncBatchNorm(100)

# 输入数据
input = torch.randn(20, 100, 35, 45)

# 应用 SyncBatchNorm
output = m(input)

# 将现有的 BatchNorm*D 层转换为 SyncBatchNorm 层
module = nn.Sequential(
            nn.Linear(20, 100),
            nn.BatchNorm1d(100),
         )
sync_bn_module = nn.SyncBatchNorm.convert_sync_batchnorm(module)

在分布式训练中，您需要设置适当的进程组，以确保不同GPU或节点间的正确同步。

nn.InstanceNorm1d

InstanceNorm1d 函数简介

  • 用途：InstanceNorm1d 主要用于对一维数据（如多通道时间序列）应用实例归一化，这在风格化变换等应用中非常有用。它按照每个样本和每个通道分别计算归一化统计。

函数工作原理

  • 定义：对于每个样本和通道，InstanceNorm1d 对数据进行归一化：y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta?其中 E[x] 是每个样本和通道的均值，Var[x] 是方差，\gamma 和 \beta 是可学习的参数（如果 affine 设置为 True），\epsilon 是为了数值稳定性添加的小常数。

参数详解

  • num_features（int）：输入中的特征或通道数 C。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 训练和评估模式：默认情况下，无论是在训练还是评估模式，InstanceNorm1d 都使用实例统计量。如果 track_running_stats 设置为 True，则在训练模式下会更新运行统计量，这些统计量在评估模式下用于归一化。
  • 与 LayerNorm 的区别：虽然 InstanceNorm1d 和 LayerNorm 非常相似，但 InstanceNorm1d 是在每个通道上独立应用的，而 LayerNorm 通常应用于整个样本，并且常用于 NLP 任务。

示例代码

下面是一个使用 InstanceNorm1d 的示例代码：

import torch
import torch.nn as nn

# 不带可学习参数的 InstanceNorm1d
m = nn.InstanceNorm1d(100)

# 带有可学习参数的 InstanceNorm1d
m_affine = nn.InstanceNorm1d(100, affine=True)

# 创建输入张量
input_tensor = torch.randn(20, 100, 40)

# 应用 InstanceNorm1d
output = m(input_tensor)

print("Output:", output)

nn.InstanceNorm2d

InstanceNorm2d 函数简介

  • 用途：InstanceNorm2d 主要用于对四维输入（如小批量的二维输入，具有额外的通道维度）应用实例归一化。这在图像处理（例如风格化变换）中特别有用，因为它按照每个样本和每个通道分别计算归一化统计。

函数工作原理?

定义：对于每个样本和通道，InstanceNorm2d 对数据进行归一化：y=\frac{x-E[x]}{\sqrt{Var[x]+\varepsilon }}*\gamma +\beta其中 E[x] 是每个样本和通道的均值，Var[x] 是方差，\gamma 和 \beta 是可学习的参数（如果 affine 设置为 True）， 是为了数值稳定性添加的小常数。

参数详解

  • num_features（int）：输入中的特征或通道数 C。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 训练和评估模式：默认情况下，无论是在训练还是评估模式，InstanceNorm2d 都使用实例统计量。如果 track_running_stats 设置为 True，则在训练模式下会更新运行统计量，这些统计量在评估模式下用于归一化。
  • 与 LayerNorm 的区别：虽然 InstanceNorm2d 和 LayerNorm 非常相似，但 InstanceNorm2d 是在每个通道上独立应用的，适用于如 RGB 图像等通道化数据，而 LayerNorm 通常应用于整个样本，并且常用于 NLP 任务。

示例代码

下面是一个使用 InstanceNorm2d 的示例代码：

import torch
import torch.nn as nn

# 不带可学习参数的 InstanceNorm2d
m = nn.InstanceNorm2d(100)

# 带有可学习参数的 InstanceNorm2d
m_affine = nn.InstanceNorm2d(100, affine=True)

# 创建输入张量
input_tensor = torch.randn(20, 100, 35, 45)

# 应用 InstanceNorm2d
output = m(input_tensor)

print("Output:", output)

nn.InstanceNorm3d

InstanceNorm3d 函数简介

  • 用途：InstanceNorm3d 主要用于对五维输入（如小批量的三维输入，具有额外的通道维度）应用实例归一化。这在处理三维数据，如医学成像或3D模型时特别有用，因为它按照每个样本和每个通道分别计算归一化统计。

参数详解

  • num_features（int）：输入中的特征或通道数 C。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 训练和评估模式：默认情况下，无论是在训练还是评估模式，InstanceNorm3d 都使用实例统计量。如果 track_running_stats 设置为 True，则在训练模式下会更新运行统计量，这些统计量在评估模式下用于归一化。
  • 与 LayerNorm 的区别：虽然 InstanceNorm3d 和 LayerNorm 非常相似，但 InstanceNorm3d 是在每个通道上独立应用的，适用于如3D模型等通道化数据，而 LayerNorm 通常应用于整个样本，并且常用于 NLP 任务。

示例代码

下面是一个使用 InstanceNorm3d 的示例代码：

import torch
import torch.nn as nn

# 不带可学习参数的 InstanceNorm3d
m = nn.InstanceNorm3d(100)

# 带有可学习参数的 InstanceNorm3d
m_affine = nn.InstanceNorm3d(100, affine=True)

# 创建输入张量
input_tensor = torch.randn(20, 100, 35, 45, 10)

# 应用 InstanceNorm3d
output = m(input_tensor)

print("Output:", output)

nn.LazyInstanceNorm1d

LazyInstanceNorm1d 函数简介

  • 用途：LazyInstanceNorm1d 是 InstanceNorm1d 的懒初始化版本。它允许您在模型构建时推迟指定输入特征（通道数）的数量，这在处理动态或未知大小的输入时特别有用。

函数工作原理

  • 懒初始化：在接收到第一个输入数据时，LazyInstanceNorm1d 自动推断 num_features（特征或通道数）的大小。在此之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 InstanceNorm1d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入特征的数量未知或可能发生变化，使用 LazyInstanceNorm1d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyInstanceNorm1d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyInstanceNorm1d 层
m = nn.LazyInstanceNorm1d()

# 创建输入张量（特征数量未指定）
input_tensor = torch.randn(20, 100, 40)

# 应用 LazyInstanceNorm1d
output = m(input_tensor)

print("Output:", output)

?在这个示例中，LazyInstanceNorm1d 在接收到输入张量后自动推断特征数量，并初始化相关的参数。

nn.LazyInstanceNorm2d

LazyInstanceNorm2d 函数简介

  • 用途：LazyInstanceNorm2d 是 InstanceNorm2d 的懒初始化版本。它在模型构建时允许您推迟指定输入特征（即通道数）的数量，这在处理动态或未知大小的输入时特别有用。

函数工作原理

  • 懒初始化：在接收到第一个输入数据时，LazyInstanceNorm2d 自动推断 num_features（特征或通道数）的大小。在此之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 InstanceNorm2d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入通道数未知或可能发生变化，使用 LazyInstanceNorm2d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyInstanceNorm2d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyInstanceNorm2d 层
m = nn.LazyInstanceNorm2d()

# 创建输入张量（通道数量未指定）
input_tensor = torch.randn(20, 100, 35, 45)

# 应用 LazyInstanceNorm2d
output = m(input_tensor)

print("Output:", output)

?在这个示例中，LazyInstanceNorm2d 在接收到输入张量后自动推断通道数量，并初始化相关的参数。

nn.LazyInstanceNorm3d

LazyInstanceNorm3d 函数简介

  • 用途：LazyInstanceNorm3d 是 InstanceNorm3d 的懒初始化版本。它在模型构建时允许您推迟指定输入特征（即通道数）的数量，这在处理动态或未知大小的输入时特别有用。

函数工作原理

  • 懒初始化：在接收到第一个输入数据时，LazyInstanceNorm3d 自动推断 num_features（特征或通道数）的大小。在此之前，权重（weight）、偏差（bias）、运行均值（running_mean）和运行方差（running_var）等属性保持未初始化状态。

参数详解

  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • momentum（float）：用于运行均值和方差计算的值。默认为 0.1。
  • affine（bool）：若设置为 True，则此模块具有可学习的仿射参数。默认为 False。
  • track_running_stats（bool）：若设置为 True，则此模块跟踪运行均值和方差；若为 False，则不跟踪，总是使用批量统计量。默认为 False。

使用技巧与注意事项

  • 懒初始化的限制：懒初始化模块在模型的序列化和复制过程中可能有一些限制。建议在模型的最终版本中使用具体的 InstanceNorm3d 模块，而不是懒初始化版本。
  • 适用场景：在模型构建时，如果输入通道数未知或可能发生变化，使用 LazyInstanceNorm3d 可以提供更大的灵活性。

示例代码

下面是一个使用 LazyInstanceNorm3d 的示例代码：

import torch
import torch.nn as nn

# 创建 LazyInstanceNorm3d 层
m = nn.LazyInstanceNorm3d()

# 创建输入张量（通道数量未指定）
input_tensor = torch.randn(20, 100, 30, 40, 50)

# 应用 LazyInstanceNorm3d
output = m(input_tensor)

print("Output:", output)

在这个示例中，LazyInstanceNorm3d 在接收到输入张量后自动推断通道数量，并初始化相关的参数。

nn.LayerNorm

LayerNorm 函数简介

  • 用途：LayerNorm 主要用于对小批量输入数据应用层归一化，这在自然语言处理（NLP）和某些图像处理任务中非常有用。它在输入的最后几个维度上计算归一化统计。

参数详解

  • normalized_shape（int 或 list 或 torch.Size）：期望输入的形状。如果使用单个整数，则视为单元素列表，此模块将在最后一个维度上进行归一化。
  • eps（float）：用于数值稳定性的分母小值。默认为 1e-5。
  • elementwise_affine（bool）：若设置为 True，则此模块具有逐元素可学习的仿射参数。默认为 True。
  • bias（bool）：如果设置为 False，则不会学习加性偏置（仅在 elementwise_affine 为 True 时相关）。默认为 True。

使用技巧与注意事项

  • 与 BatchNorm 和 InstanceNorm 的区别：不同于批量归一化和实例归一化，它们对每个通道/平面应用标量缩放和偏置，LayerNorm 对每个元素应用缩放和偏置。
  • 适用场景：LayerNorm 通常用于处理具有固定特征维度的输入，例如自然语言处理中的嵌入层或图像处理中的特定通道。

示例代码

下面是一些使用 LayerNorm 的示例代码：

NLP 示例

import torch
import torch.nn as nn

batch, sentence_length, embedding_dim = 20, 5, 10
embedding = torch.randn(batch, sentence_length, embedding_dim)
layer_norm = nn.LayerNorm(embedding_dim)

# 激活模块
layer_norm_output = layer_norm(embedding)

?图像示例

N, C, H, W = 20, 5, 10, 10
input_tensor = torch.randn(N, C, H, W)

# 在通道和空间维度上归一化
layer_norm = nn.LayerNorm([C, H, W])
output = layer_norm(input_tensor)

nn.LocalResponseNorm

LocalResponseNorm 函数简介

  • 用途：LocalResponseNorm 应用于由多个输入平面组成的输入信号上，主要用于跨通道（占第二维度）进行归一化。这种归一化在早期卷积神经网络中常见，用于增强模型的泛化能力。

函数工作原理

  • 定义：LRN 对每个元素应用局部归一化：

?其中 a_c 是输入在通道 c 上的值，n 是归一化窗口大小，N 是通道总数，k、\alpha 和 \beta 是超参数。

参数详解

  • size（int）：用于归一化的邻近通道数。
  • alpha（float）：乘性因子。默认为 0.0001。
  • beta（float）：指数。默认为 0.75。
  • k（float）：加性因子。默认为 1。

使用技巧与注意事项

  • 应用场景：虽然LRN在现代深度学习模型中使用较少，但它仍在某些特定的架构或任务中有其独特作用。
  • 与 BatchNorm 的区别：与批量归一化（Batch Normalization）不同，LRN 主要关注局部输入区域的归一化，而不是整个小批量的统计。

示例代码

下面是使用 LocalResponseNorm 的示例代码：

import torch
import torch.nn as nn

# 创建 LocalResponseNorm 层
lrn = nn.LocalResponseNorm(2)

# 创建二维和四维信号
signal_2d = torch.randn(32, 5, 24, 24)
signal_4d = torch.randn(16, 5, 7, 7, 7, 7)

# 应用 LocalResponseNorm
output_2d = lrn(signal_2d)
output_4d = lrn(signal_4d)

总结

这篇博客详细解释了 PyTorch 中 torch.nn 子模块下的多种归一化层，包括 BatchNorm (1d, 2d, 3d)、LazyBatchNorm (1d, 2d, 3d)、GroupNorm、SyncBatchNorm、InstanceNorm (1d, 2d, 3d)、LayerNorm 和 LocalResponseNorm。每种归一化层的功能、工作原理、参数详解以及使用技巧都进行了全面的阐述。此外，还提供了每种归一化层的示例代码，帮助理解它们在实际应用中的使用方式。

文章来源:https://blog.csdn.net/qq_42452134/article/details/135386646
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。