# mypy: 允许未类型化定义
导入
数字
来自
打字
导入
可选,
联合
导入
火炬
来自
火炬
导入
尺寸,
张量
来自 torch.nn
导入
功能性
作为 F,
初始化
来自
torch.nn 参数
导入
参数
来自 ._functions
导入 CrossMapLRN2d
作为
_交叉映射学习 2D
来自
.模块
导入
模块
__all__ = [局部响应归一化,
交叉映射 LRN2d,
层归一化, "GroupNorm", "RMSNorm"]
[文档]
类
局部响应归一化(
模块):
r"对输入信号应用局部响应归一化。"
输入信号由多个输入平面组成，其中通道占据第二维。
对通道进行归一化处理。
.. math::
b_{c} = a_{c}(k + \frac{\alpha}{n})
\sum_{c'=\max(0, c-n/2)}^{\min(N-1,c+n/2)}a_{c'}^2\right)^{-\beta}
Args:
邻近通道数量：用于归一化的邻近通道数量
alpha：乘法因子。默认值：0.0001
beta：指数。默认值：0.75
k：加法因子。默认值：1
形状：
- 输入: :math:`(N, C, *)`
- 输出: :math:`(N, C, *)` (与输入形状相同)
示例：
>>> lrn = nn.LocalResponseNorm(2)
>>> signal_2d = torch.randn(32, 5, 24, 24)
>>> signal_4d = torch.randn(16, 5, 7, 7, 7, 7)
>>> output_2d = lrn(signal_2d)
>>> output_4d = lrn(signal_4d)
"源代码"
常量 = [
大小, "alpha",
beta, "k"]
尺寸:
整型
阿尔法:
浮点数
测试版:
浮点数
k: 浮点数
def 初始化(
self, 尺寸: int,
阿尔法:
浮点数 =
0.0001,
测试版:
浮点数 = 0.75, k:
浮点数 = 1.0
) -> 无:
超级().
初始化()
self.大小 =
大小
self.alpha = alpha
self.测试版 =
测试版
self.k = k
def 前向(self,
输入:
张量) ->
张量:
返回 F.
本地响应归一化(
输入, self.
尺寸, self.
阿尔法, self.
测试版, self.k)
def 额外表示(self):
返回 "
{大小}, alpha={alpha}, beta={beta}, k={k}".
格式(**self.
字典)
类 CrossMapLRN2d(
模块):
尺寸:
整型
阿尔法:
浮点数
测试版:
浮点数
k: 浮点数
def 初始化(
self, 尺寸: int,
阿尔法:
浮点数 =
0.0001,
测试版:
浮点数 = 0.75, k:
浮点数 = 1
) -> 无:
超级().
初始化()
self.大小 =
大小
self.alpha = alpha
self.测试版 =
测试版
self.k = k
def 前向(self,
输入:
张量) ->
张量:
返回 _cross_map_lrn2d.
应用(
输入, self.
尺寸, self.
阿尔法, self.
测试版, self.k)
def 额外表示(self) ->
字符串:
返回 "
{大小}, alpha={alpha}, beta={beta}, k={k}".
格式(**self.
字典)
_shape_t = 联盟[int,
列表[int
]
尺寸]
[文档]
类
层归一化(
模块):
r"应用于输入小批次的层归一化。"
本层实现了论文中描述的操作
的《层归一化 `__
.. math::
y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
y = \frac{x - x 的期望}{\sqrt{x 的方差 + \epsilon}} * \gamma + \beta
均值和标准差是在最后 `D` 维度上计算的，其中 `D`
是 `normalized_shape` 的维度。例如，如果 `normalized_shape`
是`(3, 5)`（一个二维形状），均值和标准差是在
输入的最后一个维度（即 `input.mean((-2, -1))`）。
γ 和 β 是可学习的仿射变换参数
:attr:`normalized_shape` 如果 :attr:`elementwise_affine` 为 ``True``。
方差通过有偏估计量计算得出，相当于
`torch.var(input, unbiased=False)`。
.. 注意::
与批量归一化和实例归一化不同，它们为每个整个通道/平面应用标量缩放和偏置
与 `:attr:`affine` 选项应用标量缩放和偏置不同，层归一化使用 `:attr:`elementwise_affine` 对每个元素应用缩放和偏置
attr:`affine` 选项，层归一化通过 `:attr:`elementwise_affine` 对每个元素应用缩放和偏置
偏置
这一层使用从训练和输入数据中计算出的统计数据
评估模式。
Args:
normalized_shape（int 或 list 或 torch.Size）：期望输入的输入形状
大小为
.. math::
[* × normalized_shape[0] × normalized_shape[1]
× ... × normalized_shape[-1]]
如果使用单个整数，则将其视为单元素列表，并且此模块将在最后一个维度上归一化，该维度预期具有特定的大小。
elementwise_affine：一个布尔值，当设置为 True 时，此模块具有可学习的每个元素的仿射参数，初始化为 1（用于权重）。
eps: 为数值稳定性添加到分母的值。默认：1e-5
elementwise_affine：一个布尔值，当设置为 True 时，此模块具有可学习的每个元素的仿射参数，初始化为 1（用于权重）。
elementwise_affine：一个布尔值，当设置为 True 时，此模块具有可学习的每个元素的仿射参数，初始化为 1（用于权重）。
和零（用于偏差）。默认：``True``。
偏差：如果设置为 ``False``，则层将不会学习加性偏差（仅在 :attr:`elementwise_affine` 为 ``True`` 时相关）。默认：``True``。
attr:`elementwise_affine` 设置为 ``True`` 时。默认：``True``。
属性：
weight: 该模块的可学习权重，形状为
math:`\text{normalized\_shape}` 当 :attr:`elementwise_affine` 设置为 ``True`` 时。
值被初始化为 1。
bias: 该模块的可学习偏置，形状为
math:`\text{normalized\_shape}` 当 :attr:`elementwise_affine` 设置为 ``True`` 时。
值被初始化为 0。
形状：
- 输入: :math:`(N, *)`
- 输出: :math:`(N, *)` （与输入相同形状）
示例：
>>> # NLP 示例
>>> batch, sentence_length, embedding_dim = 20, 5, 10
>>> embedding = torch.randn(batch, sentence_length, embedding_dim)
>>> layer_norm = nn.LayerNorm(embedding_dim)
>>> # Activate module
>>> layer_norm(embedding)
...
>>> # 图像示例
>>> N, C, H, W = 20, 5, 10, 10
>>> input = torch.randn(N, C, H, W)
>>> # 在最后三个维度上归一化（即通道和空间维度）
>>> 如下图所示
>>> layer_norm = nn.LayerNorm([C, H, W])
>>> output = layer_norm(input)
.. 图像:: ../_static/img/nn/layer_norm.jpg
缩放比例：50%
"源代码"
常量 = [
标准化形状,
eps,
元素级仿射变换]
归一化形状:
元组[int, ...]
eps: 浮点数
元素级仿射变换:
布尔类型
def 初始化(
self,
归一化形状:
_形状_t,
eps: 浮点数 =
0.00001,
元素间仿射:
布尔类型 = True,
偏差:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
如果 isinstance(
归一化形状,
数字.
积分):
# mypy 错误：赋值中类型不兼容
归一化形状 = (
归一化形状,)
# 类型：忽略[赋值]
self.标准化形状 =
元组(
归一化形状) # type: ignore[arg-type]
self.eps = eps
self.元素间仿射变换 =
元素间仿射变换
如果 self.
元素间仿射变换:
self.权重 =
参数(
火炬.
空的(self.
归一化形状, **
工厂参数)
)
如果
偏差:
self.bias = 参数(
火炬.
空的(self.
归一化形状, **
工厂参数)
)
否则:
self.注册参数(
偏置,
无)
否则:
self.注册参数(
权重,
无)
self.注册参数(
偏置,
无)
self.重置参数()
def 重置参数(self) ->
无:
如果 self.
元素级仿射:
初始化.
全 1 矩阵(self.
重量)
如果 self.bias
是 not
无:
初始化.
全 0 矩阵(self.
偏差)
def 前向(self,
输入:
张量) ->
张量:
返回 F.
层归一化(
输入, self.
归一化形状, self.
重量, self.
偏差, self.eps
)
def 额外表示(self) ->
字符串:
返回 (
"{标准化形状}, eps={eps}
，"
"逐元素仿射=
{元素级仿射}".
格式(**self.
字典)
)
[文档]
类
组归一化(
模块):
r应用组归一化于输入的小批量。
此层实现了如下描述的操作
论文《分组归一化`__
.. math::
y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
y = \frac{x - x 的期望}{\sqrt{x 的方差 + \epsilon}} * \gamma + \beta
输入通道被分为 :attr:`num_groups` 组，每组包含
``num_channels / num_groups`` 个通道。:attr:`num_channels` 必须能被
attr:`num_groups` 整除。计算均值和标准差
分别对每个组进行。:math:`γ` 和 :math:`β` 是可学习的
每个通道的仿射变换参数向量大小为 :attr:`num_channels`
当 :attr:`affine` 为 ``True`` 时。
方差通过有偏估计量计算得出，相当于
`torch.var(input, unbiased=False)`。
此层使用从输入数据中计算出的统计数据，在训练和
评估模式。
Args:
num_groups (int): 将通道分离成组的数量
num_channels (int): 预期输入中的通道数
eps: 为数值稳定性添加到分母的值。默认：1e-5
affine: 当设置为 ``True`` 时，此模块的布尔值
具有可学习的通道相关仿射参数，初始化为 1（权重）和 0（偏置）。默认：``True``。
和 0（偏置）。默认：``True``。
形状：
- 输入：:math:`(N, C, *)` 其中 :math:`C=\text{num\_channels}`
- 输出：:math:`(N, C, *)` （与输入形状相同）
示例：
>>> 输入 = torch.randn(20, 6, 10, 10)
>>> 将 6 个通道分为 3 组
>>> m = nn.GroupNorm(3, 6)
>>> 将 6 个通道分为 6 组（相当于 InstanceNorm）
>>> m = nn.GroupNorm(6, 6)
>>> 将所有 6 个通道放入一个组（相当于 LayerNorm）
>>> m = nn.GroupNorm(1, 6)
>>> # 激活该模块
>>> output = m(input)
"源代码"
常量 = [
num_groups,
"通道数",
eps,
"仿射"]
群组数量:
整型
通道数:
整型
eps: 浮点数
线性:
布尔类型
def 初始化(
self,
群组数量: int,
通道数: int,
eps: 浮点数 =
0.00001,
线性:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
如果
通道数 %
分组数 != 0:
提升 ValueError(
"通道数必须能被分组数整除")
self.分组数 =
群组数量
self.通道数量 =
通道数量
self.eps = eps
self.线性变换 =
类似
如果 self.
线性:
self.权重 =
参数(
火炬.
空的(
通道数, **
工厂参数))
self.bias = 参数(
火炬.
空的(
通道数, **
工厂参数))
否则:
self.注册参数(
权重,
无)
self.注册参数(
偏置,
无)
self.重置参数()
def 重置参数(self) ->
无:
如果 self.
线性:
初始化.ones_(self.
重量)
初始化.zeros_(self.
偏差)
def 前向(self,
输入:
张量) ->
张量:
返回 F.
群组归一化(
输入, self.
群组数量, self.
重量, self.
偏差, self.eps)
def 额外表示(self) ->
字符串:
返回 "
{组数},
{通道数}
, 阶段=
{阶段}
线性变换=
{变换}".
格式(
**self.字典
)
[文档]
类 RMSNorm(
模块):
r应用在输入迷你批次的根均方层归一化。
此层实现了论文《根均方层归一化》中描述的操作。
论文链接：`根均方层归一化 `__
.. math::
y_i = \frac{x_i}{\mathrm{RMS}(x)} * \gamma_i, \quad
\text{其中} \quad \text{RMS}(x) = \sqrt{\epsilon + \frac{1}{n} \sum_{i=1}^{n} x_i^2}
RMS 是在最后“D”个维度上取的，其中“D”
是：attr:`normalized_shape`的维度。例如，如果：attr:`normalized_shape`
是一个二维形状（3, 5），均方根（RMS）是在输入的最后两个维度上计算的。
的基础上进行的。
Args:
normalized_shape（int 或 list 或 torch.Size）：从预期的输入中获取的输入形状。
大小为
.. math::
[* × normalized_shape[0] × normalized_shape[1]]
\times \ldots \times \text{normalized\_shape}[-1]]
如果使用单个整数，则将其视为单元素列表，并且此模块将
在最后一个维度上进行归一化，该维度预期具有该特定大小。
eps：为数值稳定性添加到分母的值。默认：:func:`torch.finfo(x.dtype).eps`
elementwise_affine：一个布尔值，当设置为“True”时，此模块
具有可学习的每个元素仿射参数，初始化为 1（用于权重）。默认：``True``。
形状：
输入：:math:`(N, *)`
翻译：输入：:math:`(N, *)`
输出：:math:`(N, *)`（与输入相同形状）
示例：
>>> rms_norm = nn.RMSNorm([2, 3])
>>> input = torch.randn(2, 2, 3)
>>> rms_norm(input)
"源代码"
常量 = ["normalized_shape",
eps,
元素级仿射]
归一化形状:
元组[int, ...]
eps: 可选[float]
元素级仿射:
布尔类型
def 初始化(
self,
归一化形状: _shape_t,
eps: 可选[float] =
无,
元素级仿射:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
如果 isinstance(
归一化形状,
数字.
积分):
# mypy 错误：赋值中类型不兼容
归一化形状 = (
归一化形状,)
# 类型：忽略[赋值]
self.归一化形状 =
元组(
归一化形状) # type: ignore[arg-type]
self.eps = eps
self.元素级仿射 =
元素级仿射
如果 self.
元素级仿射:
self.权重 =
参数(
火炬.
空的(self.
归一化形状, **
工厂参数)
)
否则:
self.注册参数(
权重,
无)
self.重置参数()
[文档] def 重置参数(self) -> None:
"``"
根据在 __init__ 中使用的初始化参数重置参数。
"``"
如果 self.elementwise_affine:
init.ones_(self.weight)
[文档] def forward(self, x: torch.Tensor) -> torch.Tensor:
"""
执行前向传递。
"""
返回 F.rms_norm(x, self.normalized_shape, self.weight, self.eps)
# TODO: 对比归一化 2D
# TODO: 分割归一化 2D
# TODO: 减法二维范数
