功能接口。
导入
导入库
导入
数学
导入
警告
from 打字
导入
可调用,
可选,
类型检查,
联合
导入
火炬
from 火炬
导入 _VF, sym_int
是 _sym_int,
张量
from torch._C 导入
_添加文档字符串,
推断大小
from torch._jit_internal 导入 (
超载_,
布尔分发,
广播列表 1,
广播列表 2,
广播列表 3,
)
from torch._torch_docs 导入
可复现性说明,
稀疏支撑说明,
tf32 说明
from torch.nn 导入
_减少
是
_减少,
梯度 # noqa: F401
from torch.nn 模块.utils
导入
带默认值的列表, _pair, _single, _triple
from torch.overrides 导入 (
handle_torch_function,
有 torch 功能,
has_torch_function_unary,
has_torch_function_variadic,
)
如果
类型检查:
from torch.types 导入 _dtype
是
数据类型
else:
# JIT 编译器不理解 Union，也不理解这里的 torch.dtype
数据类型 =
整型
尝试:
导入 numpy
是 np
除了
模块未找到错误:
np = 无
conv1d = _添加文档字符串(
torch.卷积 1D,
r""
conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> 索引
对由多个输入平面组成的输入信号应用 1D 卷积。
请参阅 :class:`~torch.nn.Conv1d` 获取详细信息及输出形状。
{tf32_note}
详细信息和输出形状请参阅 :class:`~torch.nn.Conv1d`。
注意：
{cudnn_可复现性说明}
注意：
此运算符支持复杂数据类型，即 ``complex32, complex64, complex128``。
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch}
， \text{in\_channels} ， iW}`
权重：形状为 :math:`(\text{out\_channels} ， \frac{\text{in\_channels}}{\text`
{分组}} , kW)`
偏置：可选偏置，形状为 :math:`(out\_channels)`。默认：``None``
步长：卷积核的步长。可以是单个数字或
一个元素的元组 `(sW,)`。默认值：1
填充：输入两侧的隐式填充。可以是字符串 {'valid', 'same'}
单个数字或一个元素的元组 `(padW,)`。默认值：0
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入以保持输出与输入相同的形状。然而，此模式
不支持除 1 以外的任何步长值。
.. 警告::
对于`padding='same'`，如果`weight`长度为偶数且
任何维度上的`dilation`为奇数，则执行完整的 :func:`pad` 操作
可能需要内部使用。降低性能。
扩展：卷积核元素之间的间隔。可以是单个数字或
一个单元素元组 `(dW,)`。默认：1
分组：将输入分割成组，:math:`\text{in\_channels}` 应该是组数的倍数。
默认：1
示例::
>>> inputs = torch.randn(33, 16, 30)
>>> filters = torch.randn(20, 16, 5)
>>> F.conv1d(inputs, filters)
""",
)
conv2d = _添加文档字符串(
torch.卷积 2D,
r""
conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
在输入图像上应用 2D 卷积，输入图像由多个输入组成
请参阅 :class:`~torch.nn.Conv1d` 获取详细信息及输出形状。
{tf32_note}
详细信息和输出形状请参阅 :class:`~torch.nn.Conv2d`
注意：
{cudnn_可复现性说明}
注意：
此运算符支持复杂数据类型，即 ``complex32, complex64, complex128``。
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch}
（\text{in\_channels} ， iH ， iW））
权重：形状为 :math:`(\text{out\_channels} ， \frac{\text{in\_channels}}{\text`
{分组}} , kH , kW)`
偏置：可选的偏置张量，形状为 :math:`(out\_channels)`。默认：`None`
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sH, sW)`。默认：1
填充：输入两侧的隐式填充。可以是字符串 {'valid', 'same'}
单个数字或一个元组 `(padH, padW)`。默认：0
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入以保持输出与输入相同的形状。然而，此模式
不支持除 1 以外的任何步长值。
.. 警告::
对于`padding='same'`，如果`weight`长度为偶数且
任何维度上的`dilation`为奇数，则执行完整的 :func:`pad` 操作
可能需要内部使用。降低性能。
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组 `(dH, dW)`。默认：1
组：将输入分割成组，包括 :math:`\text{in\_channels}` 和 :math:`\text{out\_channels}`
应该可以被组数整除。默认：1
示例::
>>> # 使用方形核和相等步长
>>> filters = torch.randn(8, 4, 3, 3)
>>> 输入 = torch.randn(1, 4, 5, 5)
>>> F.conv2d(inputs, filters, padding=1)
""",
) # noqa: E501
conv3d = _添加文档字符串(
torch.卷积 3D,
r""
conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
在由多个输入图像组成的输入上应用 3D 卷积
请参阅 :class:`~torch.nn.Conv1d` 获取详细信息及输出形状。
{tf32_note}
请参阅 :class:`~torch.nn.Conv3d` 以获取详细信息及输出形状。
注意：
{cudnn_可复现性说明}
注意：
此运算符支持复杂数据类型，即 ``complex32, complex64, complex128``。
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch} , \text{in\_channels} , iT , iH , iW)`
权重：形状为 :math:`(\text{out\_channels} ， \frac{\text{in\_channels}}{\text`
{分组}} , kT , kH , kW)`
bias: 可选的形状为 :math:`(\text{out\_channels})` 的偏置张量。默认：None
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sT, sH, sW)`。默认：1
填充：输入两侧的隐式填充。可以是字符串 {'valid', 'same'}
单个数字或一个元组 `(padT, padH, padW)`。默认：0
``padding='valid'`` 与无填充相同。``padding='same'`` 进行填充
输入以保持输出与输入相同的形状。然而，此模式
不支持除 1 以外的任何步长值。
.. 警告::
对于`padding='same'`，如果`weight`长度为偶数且
任何维度上的`dilation`为奇数，则执行完整的 :func:`pad` 操作
可能需要内部使用。降低性能。
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组 `(dT, dH, dW)`。默认：1
分组：将输入分割成组，:math:`\text{in\_channels}` 应该是组数的倍数。
默认：1
示例::
>>> filters = torch.randn(33, 16, 3, 3, 3)
>>> inputs = torch.randn(20, 16, 50, 10, 20)
>>> F.conv3d(inputs, filters)
""",
) # noqa: E501
conv_transpose1d = _添加文档字符串(
torch.卷积转置 1D,
r""
conv_transpose1d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor
在输入信号上应用 1D 转置卷积算子
由几个输入平面组成，有时也称为“反卷积”。
{tf32_note}
请参阅 :class:`~torch.nn.ConvTranspose1d` 以获取详细信息及输出形状。
注意：
{cudnn_可复现性说明}
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch}
， \text{in\_channels} ， iW}`
weight: 形状为 :math:`(\text{in\_channels} , \frac{\text{out\_channels}}{\text
{分组}} , kW)`
bias: 可选偏置，形状为 :math:`(\text{out\_channels})`. 默认: None
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sW,)`。默认：1
扩展：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
填充：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
（padW，）。默认：0
输出填充：在每个维度的一侧添加的额外大小
输出形状。可以是单个数字或元组（out_padW）。默认：0
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。
组数。默认：1
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组（dW，）。默认值：1
示例::
>>> 输入 = torch.randn(20, 16, 50)
>>> 权重 = torch.randn(16, 33, 5)
>>> F.conv_transpose1d(inputs, weights)
""",
)
conv_transpose2d = _添加文档字符串(
torch.转置卷积 2D,
r""
conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor
在输入图像上应用二维转置卷积算子
由几个输入平面组成，有时也称为“反卷积”。
{tf32_note}
详细信息和输出形状请参阅 :class:`~torch.nn.ConvTranspose2d`。
注意：
{cudnn_可复现性说明}
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch}
（\text{in\_channels} ， iH ， iW））
weight: 形状为 :math:`(\text{in\_channels} , \frac{\text{out\_channels}}{\text
{分组}} , kH , kW)`
bias: 可选偏置，形状为 :math:`(\text{out\_channels})`. 默认: None
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
元组 `(sH, sW)`。默认：1
扩展：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
填充：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
`(padH, padW)`。默认值：0
输出填充：在每个维度的一侧添加的额外大小
输出形状。可以是单个数字或一个元组（out_padH, out_padW）。
默认：0
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。
组数。默认：1
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组（dH，dW）。默认：1
示例::
>>> # 使用方形核和相等步长
>>> 输入 = torch.randn(1, 4, 5, 5)
>>> weights = torch.randn(4, 8, 3, 3)
>>> F.conv_transpose2d(inputs, weights, padding=1)
""",
) # noqa: E501
conv_transpose3d = _添加文档字符串(
torch.3D 转置卷积,
r""
conv_transpose3d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1) -> Tensor
在输入图像上应用 3D 转置卷积算子
由多个输入平面组成，有时也称为“反卷积”
{tf32_note}
详细信息和输出形状请参阅 :class:`~torch.nn.ConvTranspose3d`。
注意：
{cudnn_可复现性说明}
""".格式(
**可复现性说明, **
tf32 说明
)
+ r""
参数：
输入：输入张量，形状为 :math:`(\text`{minibatch} , \text{in\_channels} , iT , iH , iW)`
weight: 形状为 :math:`(\text{in\_channels} , \frac{\text{out\_channels}}{\text
{分组}} , kT , kH , kW)`
bias: 可选偏置，形状为 :math:`(\text{out\_channels})`. 默认: None
步长：卷积核的步长。可以是单个数字或一个元组（sT, sH, sW）。默认：1
填充：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
扩展：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
填充：``dilation * (kernel_size - 1) - padding``。在输入的每个维度两侧将添加零填充。可以是单个数字或一个元组
``（padT, padH, padW）``。默认值：0
输出填充：在每个维度的一侧添加的额外大小
输出形状。可以是单个数字或一个元组
``（out_padT, out_padH, out_padW）``。默认值：0
分组：将输入拆分为组，:math:`\text{in\_channels}` 应该是组数的倍数。
组数。默认：1
扩展：卷积核元素之间的间隔。可以是单个数字或
一个元组 `(dT, dH, dW)`。默认：1
示例::
>>> inputs = torch.randn(20, 16, 50, 10, 20)
>>> weights = torch.randn(16, 33, 3, 3, 3)
>>> F.conv_transpose3d(inputs, weights)
""",
) # noqa: E501
conv_tbc = _添加文档字符串(
torch.卷积转置块,
r""
对输入序列应用一维序列卷积。
输入和输出维度为（时间，批，通道）- 因此为 TBC。
参数：
输入：形状为 :math:`(\text{序列长度} \times 批 \times \text{输入通道})` 的输入张量
重量：形状为(:math:`\text{kernel width} \times \text{in\_channels} \times \text{out\_channels}`)的滤波器
偏置：形状为(:math:`\text{out\_channels}`)的偏置
填充：需要填充的时间步数。默认：0
""",
)
# 池化
avg_pool1d = _添加文档字符串(
torch.avg_pool1d,
r""
avg_pool1d(input, kernel_size, 步长=None, 填充=0, 向上取整模式=False, 计数包含填充=True) -> Tensor
应用一维平均池化到由多个输入信号组成的输入信号上
输入平面。
查看 :class:`~torch.nn.AvgPool1d` 获取详细信息及输出形状。
参数：
输入张量形状为：(:math:`(minibatch, in\_channels, iW)`）
kernel_size：窗口大小。可以是单个数字或一个元组。
元组 `(kW,)`
步长：窗口的步长。可以是单个数字或一个元组
`(sW,)`. 默认: :attr:`核大小`
填充：输入两侧的隐式零填充。可以是
单个数字或一个元组 `(padW,)`。默认：0
ceil_mode: 当为 True 时，将使用`ceil`而不是`floor`进行计算
输出形状。默认：``False``
to compute the output shape. Default: ``False``
平均计算。默认：``True``
示例::
>>> # 正方形窗口池化大小=3，步长=2
>>> input = torch.tensor([[[1, 2, 3, 4, 5, 6, 7]]], dtype=torch.float32)
>>> F.avg_pool1d(input, kernel_size=3, stride=2)
tensor([[[ 2., 4., 6.]]])
""",
)
avg_pool2d = _添加文档字符串(
torch._C._nn.avg_pool2d,
r""
avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) -> 张量
在`:math:`kH \times kW`区域通过步长应用 2D 平均池化操作
`sH × sW` 步。输出特征的数量等于
输入平面。
详细信息和输出形状请参阅 :class:`~torch.nn.AvgPool2d`。
参数：
输入：输入张量 :math:`(\text{minibatch} , \text{in\_channels} , iH , iW)`。
核大小：池化区域的大小。可以是单个数字或一个序列。
元组 `(kH, kW)`
步长：池化操作的步长。可以是单个数字或一个
元组 `(sH, sW)`。默认值：:attr:`kernel_size`
填充：输入两侧的隐式零填充。可以是
单个数字或一个元组 `(padH, padW)`。默认：0
ceil_mode：当为 True 时，将使用 `ceil` 而不是 `floor` 在计算输出形状的公式中。默认：``False``
count_include_pad：当为 True 时，将包括零填充。默认：``False``
to compute the output shape. Default: ``False``
平均计算。默认：``True``
divisor_override：如果指定，则用作除数，否则
将使用池化区域的大小。默认：None
""",
)
avg_pool3d = _添加文档字符串(
torch._C._nn.avg_pool3d,
r""
avg_pool3d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) -> Tensor
在 :math:`kT \times kH \times kW` 区域内应用 3D 平均池化操作，步进
尺寸：`sT × sH × sW` 步。输出特征的数量等于
`⌊input planes / sT⌋`。
详细信息和输出形状请参阅：:class:`~torch.nn.AvgPool3d`。
参数：
输入：输入张量 :math:`(minibatch, in\_channels, iT × iH, iW)`。
核大小：池化区域的大小。可以是单个数字或一个序列。
元组 `(kT, kH, kW)`。
步长：池化操作的步长。可以是单个数字或一个
元组 `(sT, sH, sW)`。默认值：:attr:`kernel_size`。
填充：输入两侧的隐式零填充。可以是
单个数字或一个元组（padT, padH, padW），默认：0
ceil_mode：当为 True 时，将使用 `ceil` 而不是 `floor` 在计算输出形状的公式中。默认：``False``
的公式
to compute the output shape. Default: ``False``
平均值计算
divisor_override：如果指定，则用作除数，否则
将使用池化区域的大小。默认：None
""",
)
定义
分数最大池化 2d 带索引(
输入:
张量,
核心大小:
广播列表 2[
整数
]
output_size: 可选[
广播列表 2[
整数]] =
无,
输出比例:
可选[
广播列表 2[float]] =
无,
返回索引:
布尔 =
错误,
_随机样本:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
fractional_max_pool2d(input, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)
对由多个输入平面组成的输入信号应用二维分数最大池化。
分数最大池化在 Ben Graham 的论文《Fractional MaxPooling》中详细描述
最大池化操作在`:math:`kH \times kW`区域通过随机方式应用
步长由目标输出大小确定。
输出特征的数量等于输入平面的数量。
参数：
kernel_size：取最大值操作的窗口大小。
可以是一个单个数字 :math:`k`（表示 :math:`k \times k` 的正方形核）
或者是一个元组 `(kH, kW)`
output_size：图像的目标输出大小，形式为 :math:`oH \times oW`
可以是一个元组 `(oH, oW)` 或者一个单个数字 :math:`oH`，用于表示正方形图像 :math:`oH \times oH`
输出比例：如果想要将输出大小设置为输入大小的比例，则可以提供此选项。
这必须是一个在范围（0，1）内的数字或元组。
return_indices：如果为 True，则将返回索引和输出。
可用于传递给:func:`~torch.nn.functional.max_unpool2d`。
示例：
>>> input = torch.randn(20, 16, 50, 32)
>>> # 使用大小为 3 的正方形窗口池化，目标输出大小为 13x12
>>> F.fractional_max_pool2d(input, 3, output_size=(13, 12))
>>> # 正方形窗口池和目标输出大小为输入图像大小的一半
>>> F.fractional_max_pool2d(input, 3, output_ratio=(0.5, 0.5))
.. _Fractional MaxPooling:
http://arxiv.org/abs/1412.6071
"文档"
如果 has_torch_function_variadic(
输入,
_随机样本):
返回 handle_torch_function(
分数最大池化 2d 带索引,
(输入,
_随机样本),
输入,
核心大小,
output_size=output_size,
输出比例=
输出比例,
返回索引=
返回索引,
_随机样本=
_随机样本,
)
如果
输出大小
是
无
和
输出比率
是
无:
raise ValueError(
"fractional_max_pool2d 函数需要指定输出大小或输出比例"
)
如果
输出大小
是
无:
断言
输出比率
是
不
无
如果
长度(
输出比例) > 2:
raise ValueError(
"fractional_max_pool2d 函数要求 output_ratio 必须是单个整数或整数元组。"
)
_输出比率_ = _pair(
输出比例)
输出大小 = [
整数(
输入.
尺寸(-2) *
输出比率[0
)]
整数(
输入.
尺寸(-1) *
输出比率[1
)]
]
如果
随机样本
是
无:
批次大小 = 1
如果
输入.
暗() == 3
否则
输入.
尺寸(0)
随机样本 = torch.
随机(
批次大小,
输入.
尺寸(-3), 2,
数据类型=
输入.
数据类型,
设备=
输入.
设备
)
返回 torch._C._nn.
分数最大池化 2d(
输入,
核心大小, output_size,
随机样本
)
定义
分数最大池化 2D(
输入:
张量,
核心大小:
广播列表 2[
整数
]
output_size: 可选[
广播列表 2[
整数]] =
无,
输出比例:
可选[
广播列表 2[float]] =
无,
返回索引:
布尔 =
错误,
_随机样本:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_variadic(
输入,
_随机样本):
返回 handle_torch_function(
分数最大池化 2d,
(输入,
_随机样本),
输入,
核心大小,
output_size=output_size,
输出比例=
输出比例,
返回索引=
返回索引,
_随机样本=
_随机样本,
)
返回
分数最大池化 2d 带索引(
输入,
核心大小, output_size,
输出比例,
返回索引,
随机样本
)0]
分数最大池化 2D =
布尔分发(
参数名称=
"返回索引",
索引参数=4,
默认=
错误,
if_true=分数最大池化 2d 带索引,
如果为假=
分数最大池化 2D,
模块名称=__name__,
函数名=
"分数最大池化 2D",
)
定义
分数最大池化 3d 带索引(
输入:
张量,
核心大小:
广播列表 3[
整数
]
output_size: 可选[
广播列表 3[
整数]] =
无,
输出比例:
可选[
广播列表 3[float]] =
无,
返回索引:
布尔 =
错误,
_随机样本:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
fractional_max_pool3d(input, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)
对由多个输入平面组成的输入信号应用 3D 分数最大池化。
分数最大池化在 Ben Graham 的论文《Fractional MaxPooling》中详细描述
最大池化操作通过随机方式应用于 :math:`kT \times kH \times kW` 区域
步长由目标输出大小确定。
输出特征的数量等于输入平面的数量。
参数：
kernel_size：取最大值操作的窗口大小。
可以是一个单个数字：数学公式`k`（表示一个：数学公式`k \times k \times k`的立方核）
或者是一个元组（kT，kH，kW）
输出大小：目标输出尺寸，形式为 :math:`oT \times oH \times oW`。
可以是一个元组 `(oT, oH, oW)`，或者是一个单独的数字 :math:`oH` 用于立方体输出。
\(oH \times oH \times oH\)
输出比例：如果想要将输出大小设置为输入大小的比例，则可以提供此选项。
这必须是一个在范围（0，1）内的数字或元组。
return_indices：如果为 True，则将返回索引和输出。
可用于传递给 :func:`~torch.nn.functional.max_unpool3d`。
形状：
- 输入：:math:`(N, C, T_{in}, H_{in}, W_{in})` 或 :math:`(C, T_{in}, H_{in}, W_{in})`。
输出：:math:`(N, C, T_{out}, H_{out}, W_{out})` 或 :math:`(C, T_{out}, H_{out}, W_{out})`，其中
math:`(T_{out}, H_{out}, W_{out})=\text{output\_size}` 或
math:`(T_{out}, H_{out}, W_{out})=\text{output\_ratio} \times (T_{in}, H_{in}, W_{in})`
示例：
>>> input = torch.randn(20, 16, 50, 32, 16)
>>> # 立方体窗口大小为 3 的池化，目标输出大小为 13x12x11
>>> F.fractional_max_pool3d(input, 3, output_size=(13, 12, 11))
>>> # 立方体窗口池化，目标输出大小为输入大小的一半
>>> F.fractional_max_pool3d(input, 3, output_ratio=(0.5, 0.5, 0.5))
.. _Fractional MaxPooling:
http://arxiv.org/abs/1412.6071
"文档"
如果 has_torch_function_variadic(
输入,
_随机样本):
返回 handle_torch_function(
分数最大池化 3d 带索引,
(输入,
_随机样本),
输入,
核心大小,
output_size=output_size,
输出比例=
输出比例,
返回索引=
返回索引,
_随机样本=
_随机样本,
)
如果
输出大小
是
无
和
输出比率
是
无:
raise ValueError(
"fractional_max_pool3d 函数需要指定输出大小或输出比例"
)
如果
输出大小
是
无:
断言
输出比率
是
不
无
_输出比率_ =
_三倍_(
输出比例)
输出大小 = [
整数(
输入.
尺寸(-3) *
输出比率[0
)]
整数(
输入.
尺寸(-2) *
输出比率[1
)]
整数(
输入.
尺寸(-1) *
输出比率[2
)]
]
如果
随机样本
是
无:
批次大小 = 1
如果
输入.
暗() == 4
否则
输入.
尺寸(0)
随机样本 = torch.
随机(
批次大小,
输入.
尺寸(-4), 3,
数据类型=
输入.
数据类型,
设备=
输入.
设备
)
返回 torch._C._nn.
分数最大池化 3d(
输入,
核心大小, output_size,
随机样本
)
定义
分数最大池化 3D(
输入:
张量,
核心大小:
广播列表 3[
整数
]
output_size: 可选[
广播列表 3[
整数]] =
无,
输出比例:
可选[
广播列表 3[float]] =
无,
返回索引:
布尔 =
错误,
_随机样本:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_variadic(
输入,
_随机样本):
返回 handle_torch_function(
分数最大池化 3d,
(输入,
_随机样本),
输入,
核心大小,
output_size=output_size,
输出比例=
输出比例,
返回索引=
返回索引,
_随机样本=
_随机样本,
)
返回
分数最大池化 3d 带索引(
输入,
核心大小, output_size,
输出比例,
返回索引,
随机样本
)0]
分数最大池化 3D =
布尔分发(
参数名称=
"返回索引",
索引参数=4,
默认=
错误,
if_true=分数最大池化 3d 带索引,
如果为假=
分数最大池化 3D,
模块名称=__name__,
函数名=
"分数最大池化 3D",
)
定义 max_pool1d_with_indices(
输入:
张量,
核心大小:
广播列表 1[
整数
]
步长:
可选[
广播列表 1[
整数]] =
无,
填充:
广播列表 1[
整数] = 0,
扩展率:
广播列表 1[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
max_pool1d(input, 核大小, 步长=None, 填充=0, 扩展率=1, 向上取整模式=False, 返回索引=False)
应用在由多个输入组成的输入信号上的 1D 最大池化
飞机。
.. 注意::
`:attr:`ceil_mode` 和 :attr:`return_indices` 的顺序不同`
在 `:class:`~torch.nn.MaxPool1d` 中可见，未来版本中将会更改。
查看 :class:`~torch.nn.MaxPool1d` 以获取详细信息。
参数：
输入：形状为：math:`(\text{minibatch} , \text{in\_channels} , iW)` 的输入张量，minibatch 维可选。
kernel_size：窗口大小。可以是单个数字或一个元组。
元组 `(kW,)`
步长：窗口的步长。可以是单个数字或一个元组
`(sW,)`. 默认: :attr:`核大小`
填充：在两侧添加隐式负无穷填充，必须大于等于 0 且小于等于核大小的一半。
扩展率：滑动窗口内元素之间的步长，必须大于 0。
ceil_mode: 如果为 ``True``，将使用 `ceil` 而不是 `floor` 来计算输出形状。
确保输入张量中的每个元素都被滑动窗口覆盖。
如果为 ``True``，将返回 argmax 沿着最大值。
对后续的 :class:`torch.nn.functional.max_unpool1d` 有用。
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
max_pool1d_with_indices,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch.max_pool1d_with_indices(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式
)
定义
_池化 1d(
输入:
张量,
核心大小:
广播列表 1[
整数
]
步长:
可选[
广播列表 1[
整数]] =
无,
填充:
广播列表 1[
整数] = 0,
扩展率:
广播列表 1[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
最大池化 1D,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch.
最大池化 1D(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式)
max_pool1d = 布尔分发(
参数名称=
"返回索引",
索引参数=6,
默认=
错误,
if_true=max_pool1d_with_indices,
如果为假=
_池化 1d,
模块名称=__name__,
函数名=
池化 1d,
)
定义 max_pool2d_with_indices(
输入:
张量,
核心大小:
广播列表 2[
整数
]
步长:
可选[
广播列表 2[
整数]] =
无,
填充:
广播列表 2[
整数] = 0,
扩展率:
广播列表 2[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
max_pool2d(input, 核大小, 步长=None, 填充=0, 扩展率=1, 向上取整模式=False, 返回索引=False)
应用在由多个输入组成的输入信号上的 2D 最大池化
飞机。
.. 注意::
`:attr:`ceil_mode` 和 :attr:`return_indices` 的顺序不同`
在 `:class:`~torch.nn.MaxPool2d` 中可见，未来版本中将会更改。
查看 :class:`~torch.nn.MaxPool2d` 以获取详细信息。
参数：
输入张量：数学公式（批大小，输入通道，iH，iW），批大小维度可选。
核大小：池化区域的大小。可以是单个数字或一个序列。
元组 `(kH, kW)`
步长：池化操作的步长。可以是单个数字或一个
元组 `(sH, sW)`。默认值：:attr:`kernel_size`
填充：在两侧添加隐式负无穷填充，必须大于等于 0 且小于等于核大小的一半。
扩展率：滑动窗口内元素之间的步长，必须大于 0。
ceil_mode: 如果为 ``True``，将使用 `ceil` 而不是 `floor` 来计算输出形状。
确保输入张量中的每个元素都被滑动窗口覆盖。
如果为 ``True``，将返回 argmax 沿着最大值。
对 :class:`torch.nn.functional.max_unpool2d` 后很有用
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
max_pool2d_with_indices,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch._C._nn.max_pool2d_with_indices(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式
)
定义 _max_pool2d(
输入:
张量,
核心大小:
广播列表 2[
整数
]
步长:
可选[
广播列表 2[
整数]] =
无,
填充:
广播列表 2[
整数] = 0,
扩展率:
广播列表 2[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
max_pool2d,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch.max_pool2d(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式)
max_pool2d = 布尔分发(
参数名称=
"返回索引",
索引参数=6,
默认=
错误,
if_true=max_pool2d_with_indices,
如果为假=_max_pool2d,
模块名称=__name__,
函数名=
最大池化 2d,
)
定义 max_pool3d_with_indices(
输入:
张量,
核心大小:
广播列表 3[
整数
]
步长:
可选[
广播列表 3[
整数]] =
无,
填充:
广播列表 3[
整数] = 0,
扩展率:
广播列表 3[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
max_pool3d(input, 核大小, 步长=None, 填充=0, 扩展率=1, 向上取整模式=False, 返回索引=False)
应用在由多个输入组成的输入信号上的 3D 最大池化
飞机。
.. 注意::
`:attr:`ceil_mode` 和 :attr:`return_indices` 的顺序不同`
在 `:class:`~torch.nn.MaxPool3d` 中可见，未来版本中将会更改。
查看 :class:`~torch.nn.MaxPool3d` 以获取详细信息。
参数：
输入张量：数学公式（批大小，输入通道，iD，iH，iW），批大小维度可选。
核大小：池化区域的大小。可以是单个数字或一个序列。
元组 `(kT, kH, kW)`。
步长：池化操作的步长。可以是单个数字或一个
元组 `(sT, sH, sW)`。默认值：:attr:`kernel_size`。
填充：在两侧添加隐式负无穷填充，必须大于等于 0 且小于等于核大小的一半。
扩展率：滑动窗口内元素之间的步长，必须大于 0。
ceil_mode: 如果为 ``True``，将使用 `ceil` 而不是 `floor` 来计算输出形状。
确保输入张量中的每个元素都被滑动窗口覆盖。
如果为 ``True``，将返回 argmax 沿着最大值。
对后续的 :class:`torch.nn.functional.max_unpool3d` 有用。
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
max_pool3d_with_indices,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch._C._nn.max_pool3d_with_indices(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式
)
定义 _max_pool3d(
输入:
张量,
核心大小:
广播列表 3[
整数
]
步长:
可选[
广播列表 3[
整数]] =
无,
填充:
广播列表 3[
整数] = 0,
扩展率:
广播列表 3[
整数] = 1,
向上取整模式:
布尔 =
错误,
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
最大池化 3D,
(输入,),
输入,
核心大小,
步长=
步长,
填充=
填充,
扩展率=
扩展率,
向上取整模式=
向上取整模式,
返回索引=
返回索引,
)
如果
步长
是
无:
步长 = torch.
算子.
标注(
列表[
整数
]
[]
返回 torch.
最大池化 3D(
输入,
核心大小,
步长,
填充,
扩展率,
向上取整模式)
max_pool3d = 布尔分发(
参数名称=
"返回索引",
索引参数=6,
默认=
错误,
if_true=max_pool3d_with_indices,
如果为假=_max_pool3d,
模块名称=__name__,
函数名="max_pool3d",
)
定义 _unpool_output_size(
输入:
张量,
核心大小:
列表[
整数
]
步长:
列表[
整数
]
填充:
列表[
整数
]
output_size: 可选[
列表[
整数]],
)
输入文本:
->
翻译:
-> 列表[
整数]:
输入大小 =
输入.
尺寸()
默认大小 = torch.
算子.
标注(
列表[
整数
]
[]
for d 在
范围(
长度(
核心大小)):
默认大小.append(
(输入大小[-
长度(
核心大小) + d] - 1) *
步长[d]
+ 核心大小[d]
- 2 * 填充[d]
)
如果
输出大小
是
无:
返回 =
默认大小
else:
如果
长度(output_size) ==
长度(
核心大小) + 2:
输出大小 = output_size[2
]
如果
长度(output_size) !=
长度(
核心大小):
raise ValueError(
输出大小应为包含 " 的序列
f"{长度(
核心大小)}
或者{
长度(
核心大小) + 2}
元素，但它长度为 '{
长度(output_size)}
)
for d 在
范围(
长度(
核心大小)):
最小尺寸 =
默认大小[d] -
步长[d]
max_size = 默认大小[d] +
步长[d]
如果
不 (
最小尺寸 < output_size[d] <
最大大小):
raise ValueError(
f'无效的输出尺寸'{output_size}
'（维度'{d}
必须介于{
最小大小}
和{
最大大小})'
)
返回 =
输出大小
返回
返回
[文档]def max_unpool1d(
输入: Tensor,
索引: Tensor,
核大小: BroadcastingList1[int],
stride: 可选的[BroadcastingList1[int]] = None,
padding: BroadcastingList1[int] = 0,
output_size: Optional[BroadcastingList1[int]] = None,
) -> Tensor:
计算一个 :class:`MaxPool1d` 的部分逆运算。
详细信息请参阅 :class:`~torch.nn.MaxUnpool1d`。
"""
如果存在 torch 函数一元运算符(input):
return handle_torch_function(
max_unpool1d,
(input,),
input,
索引,
核心大小,
步长=stride,
填充=padding,
output_size=output_size,
)
kernel_size = _single(kernel_size)
如果 stride 不为 None:
`_stride = _single(stride)`
`else:`
`_stride = kernel_size`
`padding = _single(padding)`
output_size = _unpool_output_size(input, kernel_size, _stride, padding, output_size)
if isinstance(output_size, list):
output_size = output_size + [1]
else:
output_size = output_size + (1,)
return torch._C._nn.max_unpool2d(
input.unsqueeze(-1), indices.unsqueeze(-1), output_size
).squeeze(-1)
[文档]def max_unpool2d(
输入: Tensor,
索引: Tensor,
核大小: BroadcastingList2[int],
stride: 可选的[BroadcastingList2[int]] = None,
padding: BroadcastingList2[int] = 0,
output_size: Optional[BroadcastingList2[int]] = None,
) -> Tensor:
计算一个 `MaxPool2d` 类的部分逆运算。
详细信息请参阅 :class:`~torch.nn.MaxUnpool2d`。
"""
如果存在 torch 函数一元运算符 `input`：
return handle_torch_function(
max_unpool2d,
(input,),
input,
索引,
核心大小,
步长=stride,
填充=padding,
output_size=output_size,
)
kernel_size = _pair(kernel_size)
if stride is not None:
`_stride = _pair(stride)`
`else:`
`_stride = kernel_size`
`padding = _pair(padding)`
output_size = _unpool_output_size(input, kernel_size, _stride, padding, output_size)
return torch._C._nn.max_unpool2d(input, indices, output_size)
[文档]def max_unpool3d(
输入: Tensor,
索引: Tensor,
核大小: BroadcastingList3[int],
stride: 可选的[BroadcastingList3[int]] = None,
padding: BroadcastingList3[int] = 0,
output_size: Optional[BroadcastingList3[int]] = None,
) -> Tensor:
计算一个 `MaxPool3d` 的部分逆运算。
详细信息请参阅 :class:`~torch.nn.MaxUnpool3d`。
"""
如果存在 torch 函数一元运算符 `input`：
return handle_torch_function(
max_unpool3d,
(input,),
input,
索引,
核心大小,
步长=stride,
填充=padding,
output_size=output_size,
)
kernel_size = _triple(kernel_size)
if stride is not None:
`_stride = _triple(stride)`
`else:`
`_stride = kernel_size`
`padding = _triple(padding)`
output_size = _unpool_output_size(input, kernel_size, _stride, padding, output_size)
return torch._C._nn.max_unpool3d(input, indices, output_size, _stride, padding)
[文档]def lp_pool3d(
输入: Tensor,
规范类型: Union[int, float],
核大小: BroadcastingList3[int],
stride: 可选的[BroadcastingList3[int]] = None,
ceil_mode: 布尔型 = False,
) -> Tensor:
r"""
对由多个输入平面组成的输入信号应用 3D 功率平均池化。
如果所有输入的`p`次幂之和为零，
则梯度也设置为 0。
详细信息请参阅：:class:`~torch.nn.LPPool3d`。
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(
lp_pool3d,
输入,
输入,
规范类型,
核心大小,
stride=stride,
ceil_mode=ceil_mode,
)
kd, kw, kh = _triple(kernel_size)
如果步长不为空：
out = avg_pool3d(input.pow(norm_type), kernel_size, stride, 0, ceil_mode)
else:
out = avg_pool3d(
input.pow(norm_type), kernel_size, padding=0, ceil_mode=ceil_mode
)
return (
(torch.sign(out) * relu(torch.abs(out))).mul(kd * kw * kh).pow(1.0 / norm_type)
)
[文档]def lp_pool2d(
输入: Tensor,
规范类型: int 或 float 的联合类型,
核大小: BroadcastingList2[int],
stride: 可选[广播列表 2[int]] = None,
ceil_mode: 布尔型 = False,
) -> Tensor:
r"""
对由多个输入平面组成的输入信号应用 2D 功率平均池化。
如果所有输入的`p`次幂之和为零，
则梯度也设置为 0。
详细信息请参阅：:class:`~torch.nn.LPPool2d`。
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(
lp_pool2d,
输入,
输入,
规范类型,
核心大小,
stride=stride,
ceil_mode=ceil_mode,
)
kw, kh = _pair(kernel_size)
如果步长不为空：
out = avg_pool2d(input.pow(norm_type), kernel_size, stride, 0, ceil_mode)
else:
out = avg_pool2d(
input.pow(norm_type), kernel_size, padding=0, ceil_mode=ceil_mode
)
return (torch.sign(out) * relu(torch.abs(out))).mul(kw * kh).pow(1.0 / norm_type)
[文档]def lp_pool1d(
输入: Tensor,
规范类型: int 或 float,
核大小: int,
stride: 可选的[BroadcastingList1[int]] = None,
ceil_mode: bool = False,
) -> Tensor:
r"""对由多个输入平面组成的输入信号应用 1D 幂平均池化。
所有输入求和的 `p` 次幂为零时
梯度也将设置为零。
详细信息请参阅 :class:`~torch.nn.LPPool1d`。
"""
if has_torch_function_unary(input):
return handle_torch_function(
lp_pool1d,
(input,)
输入,
规范类型,
核大小,
步长=stride,
ceil_mode=ceil_mode,
)
如果 stride 不为 None：
out = avg_pool1d(input.pow(norm_type), kernel_size, stride, 0, ceil_mode)
else:
out = avg_pool1d(
input.pow(norm_type), kernel_size, padding=0, ceil_mode=ceil_mode
)
return (
(torch.sign(out) * relu(torch.abs(out))).mul(kernel_size).pow(1.0 / norm_type)
)
定义 adaptive_max_pool1d_with_indices(
输入:
张量,
output_size: 广播列表 1[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
adaptive_max_pool1d(input, output_size, return_indices=False)
在由多个输入平面组成的输入信号上应用 1D 自适应最大池化。
几个输入平面。
请参阅 :class:`~torch.nn.AdaptiveMaxPool1d` 了解详细信息及输出形状。
参数：
输出大小：目标输出大小（单个整数）
返回索引：是否返回池化索引。默认：``False``
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool1d_with_indices,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
返回 torch.adaptive_max_pool1d(
输入, output_size)
定义
_自适应最大池化 1d(
输入:
张量,
output_size: 广播列表 1[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool1d,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
返回 adaptive_max_pool1d_with_indices(
输入, output_size
)0]
adaptive_max_pool1d 自适应池化 1d =
布尔分发(
参数名称=
"返回索引",
索引参数=2,
默认=
错误,
if_true=adaptive_max_pool1d_with_indices,
如果为假=
_自适应最大池化 1d,
模块名称=__name__,
函数名="adaptive_max_pool1d",
)
定义 adaptive_max_pool2d_with_indices(
输入:
张量,
output_size: 广播列表 2[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
radaptive_max_pool2d(input, output_size, return_indices=False) 自适应池化 2d(input, 输出大小, 返回索引=False)
应用在由输入信号组成的二维自适应最大池化
几个输入平面。
查看 :class:`~torch.nn.AdaptiveMaxPool2d` 获取详细信息及输出形状。
参数：
输出大小：目标输出大小（单个整数或）
双精度整数元组)
返回索引：是否返回池化索引。默认：``False``
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool2d_with_indices,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
输出大小 =
带默认值的列表(output_size,
输入.
尺寸())
返回 torch._C._nn.adaptive_max_pool2d(
输入, output_size)
定义 _adaptive_max_pool2d(
输入:
张量,
output_size: 广播列表 2[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool2d,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
返回 adaptive_max_pool2d_with_indices(
输入, output_size
)0]
adaptive_max_pool2d = 布尔分发(
参数名称=
"返回索引",
索引参数=2,
默认=
错误,
if_true=adaptive_max_pool2d_with_indices,
如果为假=_adaptive_max_pool2d,
模块名称=__name__,
函数名="adaptive_max_pool2d",
)
定义 adaptive_max_pool3d_with_indices(
输入:
张量,
output_size: 广播列表 3[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
# 无需注意：D400
r""
adaptive_max_pool3d(input, output_size, return_indices=False)
应用在由输入信号组成的 3D 自适应最大池化
几个输入平面。
查看 :class:`~torch.nn.AdaptiveMaxPool3d` 获取详细信息及输出形状。
参数：
输出大小：目标输出大小（单个整数或）
三元整数元组)
返回索引：是否返回池化索引。默认：``False``
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool3d_with_indices,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
输出大小 =
带默认值的列表(output_size,
输入.
尺寸())
返回 torch._C._nn.adaptive_max_pool3d(
输入, output_size)
定义 _adaptive_max_pool3d(
输入:
张量,
output_size: 广播列表 3[
整数
]
返回索引:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
adaptive_max_pool3d,
(输入,),
输入,
output_size,
返回索引=
返回索引,
)
返回 adaptive_max_pool3d_with_indices(
输入, output_size
)0]
adaptive_max_pool3d = 布尔分发(
参数名称=
"返回索引",
索引参数=2,
默认=
错误,
if_true=adaptive_max_pool3d_with_indices,
如果为假=_adaptive_max_pool3d,
模块名称=__name__,
函数名="adaptive_max_pool3d",
)
adaptive_avg_pool1d = _添加文档字符串(
torch.adaptive_avg_pool1d,
r""
adaptive_avg_pool1d(input, output_size) -> Tensor
对由多个输入平面组成的输入信号应用 1D 自适应平均池化。
请参阅 :class:`~torch.nn.AdaptiveAvgPool1d` 获取详细信息及输出形状。
详细信息和输出形状请参阅 :class:`~torch.nn.AdaptiveAvgPool1d`。
参数：
输出大小：目标输出大小（单个整数）
""",
)
[文档]def adaptive_avg_pool2d(input: Tensor, output_size: BroadcastingList2[int]) -> Tensor:
r"""在由多个输入平面组成的输入信号上应用 2D 自适应平均池化。
详细信息和输出形状请参阅 :class:`~torch.nn.AdaptiveAvgPool2d`。
Args:
输出大小：目标输出大小（单个整数或
双整数元组）
"""
if has_torch_function_unary(input):
return handle_torch_function(adaptive_avg_pool2d, (input,), input, output_size)
_output_size = _list_with_default(output_size, input.size())
return torch._C._nn.adaptive_avg_pool2d(input, _output_size)
[docs]def adaptive_avg_pool3d(input: Tensor, output_size: BroadcastingList3[int]) -> Tensor:
应用在由多个输入平面组成的输入信号上的 3D 自适应平均池化。
详细信息和输出形状请参阅 :class:`~torch.nn.AdaptiveAvgPool3d`。
参数：
输出大小：目标输出大小（单个整数或
三整数元组）
"""
如果有 torch_function_unary(input):
return handle_torch_function(adaptive_avg_pool3d, (input,), input, output_size)
_output_size = _list_with_default(output_size, input.size())
return torch._C._nn.adaptive_avg_pool3d(input, _output_size)
# 激活函数
[文档]def dropout(
输入: Tensor,
p: float = 0.5,
training: bool = True,
inplace: 布尔值 = False,
) -> 张量:
在训练过程中，以概率 :attr:`p` 随机将输入张量的一些元素置为零。
使用伯努利分布的样本。
查看 :class:`~torch.nn.Dropout` 以获取详细信息。
参数：
p: 将元素置零的概率。默认值：0.5
training: 如果为 ``True`` 则应用 dropout。默认值：``True``
inplace: 如果设置为 ``True``，将在此处执行此操作。默认：``False``
"""
if has_torch_function_unary(input):
return handle_torch_function(
dropout, (输入,), 输入, p=p, 训练=training, 内置=inplace
)
如果 p < 0.0 或者 p > 1.0:
抛出 ValueError 异常(f"dropout 概率必须在 0 和 1 之间，但得到了 {p}")
return (
_VF.dropout_(input, p, training) if inplace else _VF.dropout(input, p, training)
)
[文档]def alpha_dropout(
输入: Tensor,
p: float = 0.5,
training: bool = False,
inplace: 布尔值 = False,
) -> 张量:
应用 alpha dropout 到输入。
详细信息请参阅 :class:`~torch.nn.AlphaDropout`。
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(
alpha_dropout, (input,), input, p=p, training=training, inplace=inplace
)
如果 p < 0.0 或者 p > 1.0:
抛出 ValueError 异常(f"dropout 概率必须在 0 和 1 之间，但得到了 {p}")
return (
_VF.alpha_dropout_(输入, p, 是否训练)
如果就地
否则 _VF.alpha_dropout(输入, p, 是否训练)
)
[文档]def dropout1d(
输入：张量，
p: float = 0.5,
training: bool = True,
inplace: 布尔值 = False,
) -> 张量:
随机将整个通道置零（通道是一维特征图）。
例如，第 :math:`j` 个样本的第 :math:`i` 个通道的
批量输入是一个 1D 张量：math:`\text{input}[i, j]`，它是输入张量。
每个通道将在每次前向调用时独立地使用概率：attr:`p`，从伯努利分布中抽取样本置零。
请参阅：class:`~torch.nn.Dropout1d` 以获取详细信息。
请参阅：class:`~torch.nn.Dropout1d` 以获取详细信息。
Args:
p: 频道归零的概率。默认值：0.5
training: 如果设置为 ``True``，则应用 dropout。默认值：``True``
inplace: 如果设置为 ``True``，将在此处执行此操作。默认值：``False``
"""
如果存在 torch 函数单例(input):
返回 handle_torch_function(
dropout1d, (input,), input, p=p, training=training, inplace=inplace
)
如果 p < 0.0 或者 p > 1.0:
抛出 ValueError 异常(f"dropout 概率必须在 0 和 1 之间，但得到了 {p} ")
inp_dim = input.dim()
如果 inp_dim 不在 (2, 3) 的范围内：
raise RuntimeError(
f"dropout1d: 预期 2D 或 3D 输入，但收到一个 {inp_dim}D 输入。 "
"请注意，dropout1d 存在是为了在具有 1 "
空间维度、通道维度以及可选的批次维度
（即 2D 或 3D 输入）。
)
is_batched = inp_dim == 3
如果不是批量处理：
input = input.unsqueeze_(0) if inplace else input.unsqueeze(0)
result = (
_VF.feature_dropout_(input, p, training)
如果就地
否则 _VF.feature_dropout(input, p, training)
)
如果不是批处理
result = result.squeeze_(0) if inplace else result.squeeze(0)
return result
[文档]
定义 dropout2d(
输入:
张量,
p: 浮点数 = 0.5,
训练:
布尔 =
是,
内置:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r随机将整个通道置零（通道是指二维特征图）。
例如，第 :math:`j` 个通道的第 :math:`i` 个样本在批处理输入中是一个 3D 张量 :math:`\text{input}[i, j]`。
每个通道将在每次前向调用时独立置零。
每个通道将在每次前向调用中独立地以概率 :attr:`p` 使用伯努利分布的样本置零。
使用伯努利分布的样本以概率 :attr:`p` 独立地置零每个通道。
详细信息请参阅：class:`~torch.nn.Dropout2d`
参数：
p：将通道置零的概率。默认：0.5
training：如果为 ``True`` 则应用 dropout。默认：``True``
inplace：如果设置为 ``True``，则将在此处进行原地操作。默认：``False``
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
dropout2d, (输入,),
输入, p=p,
训练=
训练,
内置=
内置
)
如果 p < 0.0
或者 p > 1.0:
raise ValueError(f"dropout 概率必须在 0 和 1 之间，但得到了"{p}")
输入维度 =
输入.
暗()
如果
输入维度
不
在 (3, 4):
警告信息 = (
fdropout2d: 收到{
输入维度}
-D 输入到 dropout2d，已弃用
并且将在未来的版本中导致错误。为了保留行为
"请使用 dropout 来静默此警告。请注意，dropout2d"
"存在是为了在具有 2 个空间维度的输入上提供通道丢弃，"
"一个通道维度和一个可选的批次维度（即 3D 或 4D 输入）。"
)
警告.
警告(warn_msg)
目前不支持无批处理维度输入。现在这些输入不被支持；传递
# 一个 3D 输入将执行 dropout1d 行为。这曾经是历史行为，现在这种行为仍然保持。
# 目前保持这种行为。
# 请参阅 https://github.com/pytorch/pytorch/issues/77081
如果
输入维度 == 3:
警告.
警告(
"dropout2d: 接收到 3D 输入并假设需要 1D dropout 行为 - 输入被解释为形状(N, C, L)，其中 C "
"是通道维度。此行为将在未来的版本中更改，以解释为形状(N, C, L)，其中 C "
"是通道维度。此行为将在未来的版本中更改，以解释为形状(N, C, L)，其中 C "
"输入没有批处理维度，即形状为（C，H，W）。为了保持 1D "
"通道级 dropout 行为，请切换到使用 dropout1d。"
)
结果 = (
_VF.feature_dropout_(输入, p,
训练)
如果
内置
否则 _VF.feature_dropout(
输入, p,
训练)
)
返回
结果
[文档]
定义 dropout3d(
输入:
张量,
p: 浮点数 = 0.5,
训练:
布尔 =
是,
内置:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r"""随机将整个通道置零（通道是一个 3D 特征图）。"""
例如，第 :math:`j` 个通道的第 :math:`i` 个样本在批处理输入中是一个 3D 张量 :math:`\text{input}[i, j]`。
批处理输入是一个输入张量的 3D 张量 :math:`\text{input}[i, j]`。
每个通道将在每次前向调用中独立地以概率 :attr:`p` 使用伯努利分布的样本置零。
使用伯努利分布的样本以概率 :attr:`p` 独立地置零每个通道。
请参阅：class:`~torch.nn.Dropout3d` 以获取详细信息。
参数：
p：将通道置零的概率。默认：0.5
training：如果为 ``True`` 则应用 dropout。默认：``True``
inplace：如果设置为 ``True``，则将在此处进行原地操作。默认：``False``
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
dropout3d, (输入,),
输入, p=p,
训练=
训练,
内置=
内置
)
如果 p < 0.0
或者 p > 1.0:
raise ValueError(f"dropout 概率必须在 0 和 1 之间，但得到了"{p}")
输入维度 =
输入.
暗()
如果
输入维度
不
在 (4, 5):
警告信息 = (
fdropout3d：收到一个{
输入维度}
-D dropout3d 的输入，已弃用
并且将在未来的版本中导致错误。为了保留行为
"请禁用此警告，建议使用 dropout。注意 dropout3d "
"用于在具有 3 个空间维度的输入上提供通道级 dropout，"
"一个通道维度，以及可选的批次维度（即 4D 或 5D 输入）。"
)
警告.
警告(warn_msg)
批处理 =
输入维度 == 5
如果
不
批处理:
输入 =
输入.
unsqueeze_ (未翻译，因为这不是一个完整的英文单词或短语)(0)
如果
内置
否则
输入.
展平(0)
结果 = (
_VF.feature_dropout_(输入, p,
训练)
如果
内置
否则 _VF.feature_dropout(
输入, p,
训练)
)
如果
不
批处理:
结果 =
结果.
挤压_(0)
如果
内置
否则
结果.
挤压(0)
返回
结果
[文档]def feature_alpha_dropout(
输入: Tensor,
p: float = 0.5,
training: bool = False,
inplace: 布尔值 = False,
) -> 张量:
随机屏蔽整个通道（通道是指特征图）。
例如，批输入中第 :math:`i` 个样本的第 :math:`j` 个通道
这是一个输入张量 :math:`\text{input}[i, j]` 的张量。与常规 Dropout 不同，激活值被设置为 SELU 激活函数的负饱和值。
每个元素将在每次前向调用时独立进行掩码，而不是将激活值设为零。
将激活值设置为 SELU 激活函数的负饱和值。
每个元素将在每次前向调用时独立进行掩码。
使用来自伯努利分布的样本计算概率：attr:`p`。
在每次前向调用时，要屏蔽的元素都会随机化，并按比例缩放和移动，以保持零均值和单位方差。
详细信息请参阅：class:`~torch.nn.FeatureAlphaDropout`。
请参阅：class:`~torch.nn.FeatureAlphaDropout`以获取详细信息。
Args:
p: 零化通道的 dropout 概率。默认：0.5
training: 如果为 ``True`` 则应用 dropout。默认：``True``
inplace: 如果设置为 ``True``，则将此操作就地执行。默认：``False``
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(
feature_alpha_dropout,
输入,
输入,
p=等式，
训练=训练，
inplace=inplace,
)
如果 p 小于 0.0 或大于 1.0：
抛出 ValueError 异常(f"dropout 概率必须在 0 和 1 之间，但得到了 {p} ")
return (
_VF.feature_alpha_dropout_(input, p, training)
if inplace
else _VF.feature_alpha_dropout(input, p, training)
)
定义
_阈值(
输入:
张量,
阈值: float,
值: float,
内置:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r将阈值应用于输入张量的每个元素。
更多详情请参阅 :class:`~torch.nn.Threshold`。
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
_阈值, (
输入,),
输入,
阈值,
值,
内置=
内置
)
如果
内置:
结果 = _VF.
阈值_(
输入,
阈值,
值)
else:
结果 = _VF.
阈值(
输入,
阈值,
值)
返回
结果
我们将此函数定义为_threshold，因为它接受一个参数
命名参数 threshold，它覆盖了递归引用函数所需的__
__torch_function__支持
阈值 = _threshold
阈值_ =
_添加文档字符串(
_VF.阈值_,
r""
threshold_(input, threshold, value) -> Tensor
func:`~threshold` 的就地版本。
""",
)
[文档]def relu(input: Tensor, inplace: bool = False) -> Tensor: # noqa: D400,D402
r"""relu(input, inplace=False) -> Tensor"""
线性整流单元函数逐元素应用。详见
class:`~torch.nn.ReLU` 以获取更多详细信息。
"""
if has_torch_function_unary(input):
return handle_torch_function(relu, (input,), input, inplace=inplace)
if inplace:
result = torch.relu_(input)
else:
result = torch.relu(input)
return result
relu_ = _添加文档字符串(
torch.relu_,
r""
relu_(输入) -> 张量
func:`~relu` 的就地版本。
""",
)
[文档]def glu(input: Tensor, dim: int = -1) -> Tensor: # noqa: D400,D402
r"""
glu(input, dim=-1) -> Tensor
门控线性单元。计算：
数学公式
\text{GLU}(a, b) = a \otimes \sigma(b)
其中 `input` 沿 `dim` 分成两半形成 `a` 和 `b`，:math:`\sigma`
是 sigmoid 函数，:math:`\otimes` 是矩阵之间的逐元素乘积。
查看 `基于门控卷积网络的语料库建模 `_。
Args:
输入 (Tensor)：输入张量
dim (int)：分割输入的维度。默认：-1
"""
如果存在 torch 函数单例(input):
返回 handle_torch_function(glu, (input,), input, dim=dim)
如果 input 的维度为 0:
raise RuntimeError(
"glu 不支持标量，因为减半大小必须是偶数"
)
return torch._C._nn.glu(input, dim)
[文档]def hardtanh(
输入: Tensor,
最小值: float = -1.0,
最大值: float = 1.0,
inplace: 布尔值 = False,
) -> Tensor: # noqa: D400,D402
r"""
hardtanh(input, min_val=-1., max_val=1., inplace=False) -> Tensor
应用 HardTanh 函数逐元素。请参阅 :class:`~torch.nn.Hardtanh` 获取更多详情。
详细信息。
"""
如果 has_torch_function_unary(input):
return handle_torch_function(
hardtanh, (input,), input, min_val=min_val, max_val=max_val, inplace=inplace
)
if min_val > max_val:
无法将 min_val 的值设置得大于 max_val
如果 inplace:
result = torch._C._nn.hardtanh_(input, min_val, max_val)
否则：
result = torch._C._nn.hardtanh(input, min_val, max_val)
return result
hardtanh_ = _添加文档字符串(
torch._C._nn.hardtanh_,
r""
hardtanh_(input, min_val=-1., max_val=1.) -> Tensor
func:`~hardtanh` 的就地版本。
""",
)
[docs]def relu6(input: Tensor, inplace: bool = False) -> Tensor: # noqa: D400,D402
r"""relu6(input, inplace=False) -> Tensor
应用逐元素函数 :math:`\text{ReLU6}(x) = \min(\max(0,x), 6)`.
更多详情请参阅 :class:`~torch.nn.ReLU6`。
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(relu6, (input,), input, inplace=inplace)
如果 inplace:
result = torch._C._nn.relu6_(input)
else:
result = torch._C._nn.relu6(input)
return result
[文档]def elu(input: Tensor, alpha: float = 1.0, inplace: bool = False) -> Tensor:
应用逐元素的指数线性单元（ELU）函数。
更多详情请参阅 :class:`~torch.nn.ELU`。
"""
if has_torch_function_unary(input):
return handle_torch_function(elu, (input,), input, alpha=alpha, inplace=inplace)
if inplace:
result = torch._C._nn.elu_(input, alpha)
else:
result = torch._C._nn.elu(input, alpha)
return result
elu_ = _添加文档字符串(
torch._C._nn.elu_,
r""
elu_(输入, alpha=1.) -> 张量
func:`~elu` 的就地版本。
""",
)
[文档]def selu(输入: 张量, inplace: bool = False) -> 张量: # noqa: D400,D402
r"""selu(输入, inplace=False) -> 张量
元素级应用，
math:`\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)))`，
其中 :math:`\alpha=1.6732632423543772848170429916717` 和
math:`scale=1.0507009873554804934193349852946`。
查看更多详情，请参阅：:class:`~torch.nn.SELU`
"""
如果有 torch_function_unary(input)：
返回 handle_torch_function(selu, (input,), input, inplace=inplace)
if inplace:
result = torch.selu_(input)
else:
result = torch.selu(input)
返回结果
selu_ = _添加文档字符串(
torch.selu_,
r""
selu_(输入) -> 张量
func:`~selu` 的就地版本。
""",
)
[文档]def celu(
输入: Tensor,
alpha: float = 1.0,
inplace: bool = False,
) -> 张量: # noqa: D400,D402
r"""celu(input, alpha=1., inplace=False) -> 张量
逐元素应用，
math:`\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))`。
查看更多详情，请参阅：:class:`~torch.nn.CELU`。
"""
如果有_torch_function_unary(input)：
返回 handle_torch_function(
celu, (输入,), 输入, alpha=alpha, inplace=inplace
)
if inplace:
result = torch.celu_(输入, alpha)
else:
result = torch.celu(input, alpha)
return result
celu_ = _添加文档字符串(
torch.celu_,
r""
celu_(input, alpha=1.) -> 张量
func:`~celu` 的就地版本。
""",
)
[文档]def leaky_relu(
输入：Tensor,
负斜率：float = 0.01,
内置：bool = False,
) -> Tensor: # noqa: D400,D402
r"""
leaky_relu(input, negative_slope=0.01, inplace=False) -> Tensor
逐元素应用，
math:`\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)`
查看更多详情，请参阅：:class:`~torch.nn.LeakyReLU`。
"""
如果有 torch_function_unary(input)：
返回 handle_torch_function(
leaky_relu, (输入,), 输入, 负斜率=negative_slope, 放置 inplace
)
if inplace:
result = torch._C._nn.leaky_relu_(输入, 负斜率)
else:
result = torch._C._nn.leaky_relu(input, negative_slope)
return result
leaky_relu_ = _添加文档字符串(
torch._C._nn.leaky_relu_,
r""
leaky_relu_(输入，负斜率=0.01) -> 张量
func:`~leaky_relu` 的就地版本。
""",
)
prelu = _添加文档字符串(
torch.预激活函数,
rprelu(input, weight) -> Tensor
对元素执行函数
math:`\text{PReLU}(x) = \max(0,x) + \text{weight} * \min(0,x)` 其中 weight 是一个
可学习的参数。
.. 注意：
`weight` 预期为一个标量或一维张量。如果 `weight` 是一维的，
其大小必须与输入通道数匹配，该数由
当 `input.dim() >= 2` 时，`input.size(1)` 为 1，否则为 1。
在一维情况下，请注意当`input`的维度大于 2 时，`weight`可以展开
以一种使用常规方法不可能的方式调整 `input` 的形状
参考：:ref:`广播语义`.
更多详情请参阅 :class:`~torch.nn.PReLU`。
""",
)
[文档]def rrelu(
输入：张量，
下限：浮点数 = 1.0 / 8，
上限：浮点数 = 1.0 / 3，
训练：布尔值 = False，
inplace: 布尔值 = False,
) -> Tensor: # noqa: D400,D402
r"""rrelu(input, lower=1./8, upper=1./3, training=False, inplace=False) -> Tensor
随机化泄漏 ReLU.
查看更多详情，请参阅：:class:`~torch.nn.RReLU`。
"""
如果有 torch_function_unary(input)：
返回 handle_torch_function(
rrelu,
(输入,),
输入,
lower=lower,
upper=大写,
training=训练,
inplace=原地,
)
if inplace:
result = torch.rrelu_(input, lower, upper, training)
else:
result = torch.rrelu(input, lower, upper, training)
返回结果
rrelu_ = _添加文档字符串(
torch.rrelu_,
r""
rrelu_(input, lower=1./8, upper=1./3, training=False) -> Tensor
func:`~rrelu` 的就地版本。
""",
)
logsigmoid = _添加文档字符串(
torch._C._nn.log_sigmoid,
r""
logsigmoid(input) -> 张量
逐元素应用 :math:`\text{LogSigmoid}(x_i) = \log \left(\frac{1}{1 + \exp(-x_i)}\right)`
更多详情请参阅 :class:`~torch.nn.LogSigmoid`
""",
)
gelu = _添加文档字符串(
torch._C._nn.gelu,
r""
gelu(input, approximate = 'none') -> 张量
当 approximate 参数为'none'时，它将函数逐元素应用
math:`\text{GELU}(x) = x * \Phi(x)` 的中文翻译为：GELU(x) = x * Φ(x)
其中 :math:`\Phi(x)` 是高斯分布的累积分布函数。
当近似参数为 'tanh' 时，Gelu 的估计为
.. 数学表达式
\text{GELU}(x) = 0.5 * x * (1 + \text{Tanh}(\sqrt{2 / \pi} * (x + 0.044715 * x^3)))
查看 `高斯误差线性单元 (GELUs) `_。
""",
)
hardshrink = _添加文档字符串(
torch.硬收缩,
r""
hardshrink(input, lambd=0.5) -> 张量
应用逐元素硬收缩函数
详细信息请参阅 :class:`~torch.nn.Hardshrink`。
""",
)
[文档]def tanhshrink(input): # noqa: D400,D402
tanhshrink(input) -> 张量
对元素应用，:math:`\text{Tanhshrink}(x) = x - \text{Tanh}(x)`
更多详情请参阅 :class:`~torch.nn.Tanhshrink`
"""
if has_torch_function_unary(input):
return handle_torch_function(tanhshrink, (input,), input)
return input - input.tanh()
[文档]def softsign(input): # noqa: D400,D402
softsign(input) -> 张量
对元素执行逐个应用，函数 :math:`\text{SoftSign}(x) = \frac{x}{1 + |x|}`
更多详情请参阅 :class:`~torch.nn.Softsign`
"""
if has_torch_function_unary(input):
return handle_torch_function(softsign, (input,), input)
return input / (input.abs() + 1)
softplus = _添加文档字符串(
torch._C._nn.软性加,
r""
softplus(input, beta=1, threshold=20) -> Tensor
逐元素应用函数：:math:`\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))`。
为了数值稳定性，实现会回退到线性函数。
当:math:`input \times \beta > threshold`时。
更多详情请参阅：:class:`~torch.nn.Softplus`。
""",
)
定义 _get_softmax_dim(
名称:
字符串,
维数:
整数,
栈级别:
整数)
输入文本:
->
翻译:
-> 整数:
警告.
警告(
f隐式维度选择已被弃用。{
名称}
"请将调用方式修改为包含 dim=X 作为参数。",
栈级别=
栈级别,
)
如果
维数 == 0
或者
维数 == 1
或者
维数 == 3:
返回 = 0
else:
返回 = 1
返回
返回
[文档]def softmin(
输入: Tensor,
dim: Optional[int] = None,
_stacklevel: int = 3,
dtype: Optional[DType] = None,
) -> Tensor:
r"""应用软归一化函数。
注意：:math:`\text{Softmin}(x) = \text{Softmax}(-x)`。请参阅软归一化定义中的数学公式。
查看更多详情，请参阅：:class:`~torch.nn.Softmin`
参数：
输入 (Tensor): 输入
dim (int): softmin 将要计算的维度（因此每个切片
沿着 dim 求和将等于 1)。
dtype (:class:`torch.dtype`, optional): 返回张量的期望数据类型。
如果指定，则在执行操作之前将输入张量转换为 :attr:`dtype`。这有助于防止数据类型溢出。默认：None。
如果指定，则在执行操作之前将输入张量转换为 :attr:`dtype`。这有助于防止数据类型溢出。默认：None。
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(
softmin, (input,), input, dim=dim, _stacklevel=_stacklevel, dtype=dtype
)
如果 dim 为 None：
dim = _get_softmax_dim("softmin", input.dim(), _stacklevel)
如果 dtype 为 None：
ret = (-input).softmax(dim)
else:
ret = (-input).softmax(dim, dtype=dtype)
return ret
[文档]def softmax(
输入: Tensor,
dim: Optional[int] = None,
_stacklevel: int = 3,
dtype: Optional[DType] = None,
) -> Tensor:
r"""应用 softmax 函数。
Softmax 定义为：
\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}
它应用于沿 dim 的所有切片，并将它们重新缩放，使得元素
落在范围 `[0, 1]` 内，并且总和为 1。
更多详情请参阅 :class:`~torch.nn.Softmax`。
Args:
输入 (Tensor): 输入
dim (int): 软 max 将被计算的维度。
dtype (:class:`torch.dtype`, optional): 返回张量的期望数据类型。
如果指定，则在操作之前将输入张量转换为 :attr:`dtype`。这有助于防止数据类型溢出。默认值：None。
执行操作。这有助于防止数据类型溢出。默认：None。
.. 注意::
此函数不能直接与 NLLLoss 一起使用，
预期在 Softmax 和自身之间计算 Log。
使用 log_softmax 代替（它更快，并且具有更好的数值特性）。
"""
如果有 torch_function_unary(input)：
return handle_torch_function(
softmax, (input,), input, dim=dim, _stacklevel=_stacklevel, dtype=dtype
)
if dim is None:
dim = _get_softmax_dim("softmax", input.dim(), _stacklevel)
if dtype is None:
ret = input.softmax(dim)
else:
ret = input.softmax(dim, dtype=dtype)
return ret
[文档]
定义
Gumbel 软最大化(
logits: 张量,
淘:
浮点数 = 1,
硬:
布尔 =
错误,
eps: 浮点数 = 1e-10,
暗:
整型 = -1,
)
输入文本:
->
翻译:
-> 张量:
r""
Gumbel-Softmax 分布的样本（`链接 1`_ `链接 2`_）以及可选的离散化。
参数：
logits: `[..., num_features]` 未归一化的对数概率
tau: 非负标量温度
hard: 如果为 ``True``，则返回的样本将被离散化为 one-hot 向量，
但将被区分，仿佛它是 autograd 中的软样本
dim（int）：softmax 将计算的维度。默认值：-1。
返回：
从 Gumbel-Softmax 分布中采样的与`logits`形状相同的张量。
如果`hard=True`，则返回的样本将是一维热编码，否则不是。
在 `dim` 上求和为 1 的概率分布。
.. 注意::
此函数出于历史原因存在，未来可能从 nn.Functional 中移除。
.. 注意::
`hard` 的主要技巧是执行 `y_hard - y_soft.detach() + y_soft`。
它实现了两个目标：
- 使输出值正好为 one-hot
- 由于我们添加然后减去 y_soft 值
- 使梯度等于 y_soft 梯度
- 由于我们移除所有其他梯度
示例：
>>> logits = torch.randn(20, 32)
>>> # Sample soft categorical using reparametrization trick:
>>> F.gumbel_softmax(logits, tau=1, hard=False)
>>> # Sample hard categorical using "Straight-through" trick:
>>> F.gumbel_softmax(logits, tau=1, hard=True)
.. _链接 1:
https://arxiv.org/abs/1611.00712
.. _链接 2:
https://arxiv.org/abs/1611.01144
"文档"
如果 has_torch_function_unary(logits):
返回 handle_torch_function(
Gumbel 软最大化, (logits,), logits,
淘=
淘,
硬=
硬, eps=eps,
暗=
维度
)
如果 eps != 1e-10:
警告.
警告(
"`eps`参数已弃用，无任何效果。")
古姆贝尔斯 = (
-torch.空值类似(logits,
内存格式=torch.
遗产连续格式)
.指数()
.日志()
) # ~Gumbel(0,1)
古姆贝尔斯 = (logits +
古姆贝尔斯) /
塔乌 # ~Gumbel(logits,tau)
y_soft = 古姆贝尔斯.
软式最大化(
暗)
如果
硬:
# 直通。
索引 =
软 y.
最大值(
暗,
保持维度=
是
)1]
难 y = torch.
等于零的(
logits, 内存格式=torch.
旧连续格式
).散射_(
暗,
索引, 1.0)
返回 =
难 y -
软 y.detach() + y_soft
else:
重参数化技巧。
返回 = y_soft
返回
返回
[文档]def log_softmax(
输入：张量，
dim: 可选[int] = None,
_stacklevel: int = 3,
dtype: 可选[DType] = None,
) -> Tensor:
应用 softmax 后跟对数。
虽然数学上等同于 log(softmax(x))，但分别执行这两个操作会更慢且数值上不稳定。此函数使用一种替代公式来正确计算输出和梯度。
这些操作分别进行会更慢且数值上不稳定。此函数使用一种替代公式来正确计算输出和梯度。
此函数使用一种替代公式来正确计算输出和梯度。
查看更多详情，请参阅：:class:`~torch.nn.LogSoftmax`。
参数：
输入（Tensor）：输入
dim（int）：log_softmax 将被计算的一个维度。
dtype (:class:`torch.dtype`, optional): 返回张量的期望数据类型。
如果指定，则在执行操作之前将输入张量转换为 :attr:`dtype`。这有助于防止数据类型溢出。默认值：None。
执行操作前，如果指定，则将输入张量转换为 :attr:`dtype`。这有助于防止数据类型溢出。默认：None。
"""
if has_torch_function_unary(input):
return handle_torch_function(
log_softmax, (input,), input, dim=dim, _stacklevel=_stacklevel, dtype=dtype
)
如果 dim 为 None：
dim = _get_softmax_dim("log_softmax", input.dim(), _stacklevel)
如果 dtype 为 None：
ret = input.log_softmax(dim)
else:
ret = input.log_softmax(dim, dtype=dtype)
return ret
softshrink = _添加文档字符串(
torch._C._nn.软性收缩,
r""
softshrink(input, lambd=0.5) -> 张量
应用逐元素软收缩函数
更多详情请参阅 :class:`~torch.nn.Softshrink`。
""",
)
[文档]def tanh(input): # noqa: D400,D402
r"""tanh(input) -> 张量
元素级应用，
\tanh(x) = \tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}
更多详情请参阅 :class:`~torch.nn.Tanh`。
"""
return input.tanh()
[文档]def sigmoid(input): # noqa: D400,D402
r"""sigmoid(input) -> Tensor
应用逐元素函数 :math:`\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}`
查看更多详情，请参阅：:class:`~torch.nn.Sigmoid`
"""
返回 input 的 sigmoid()
[文档]def hardsigmoid(input: Tensor, inplace: bool = False) -> Tensor:
应用元素-wise 的 Hardsigmoid 函数。
.. math::
\text{Hardsigmoid}(x) = \begin{cases}
0 & \text{if~} x \le -3, \\
1 & \text{如果} x \ge +3, \\
x / 6 + 1 / 2 & \text{否则}
\end{cases}
参数:
如果设置为 ``True``，将在此处执行此操作。默认：``False``
更多详情请参阅 :class:`~torch.nn.Hardsigmoid`
"""
如果 has_torch_function_unary(input):
return handle_torch_function(hardsigmoid, (input,), input, inplace=inplace)
if inplace:
return torch._C._nn.hardsigmoid_(input)
return torch._C._nn.hardsigmoid(input)
线性 =
_添加文档字符串(
torch._C._nn.线性,
r""
linear(input, weight, bias=None) -> Tensor
对传入数据进行线性变换：:math:`y = xA^T + b`
此操作支持 2-D :attr:`weight` 使用 :ref:`稀疏布局`
{sparse_beta_warning}
此操作符支持：ref:`TensorFloat32`.
形状：
输入：:math:`(*, in\_features)` 其中 `*` 表示任意数量的维度，包括零维度
附加维度
权重：:math:`(out\_features, in\_features)` 或 :math:`(in\_features)`
- 偏差: :math:`(out\_features)` 或 :math:`()`
- 输出: :math:`(*, out\_features)` 或 :math:`(*)`，根据权重的形状
""".格式(
**稀疏支持注释
),
)
双线性 =
_添加文档字符串(
torch.双线性,
r""
bilinear(input1, input2, weight, bias=None) -> Tensor
对传入数据进行双线性变换：
\( y = x_1^T A x_2 + b \)
形状：
- input1: \( (N, *, H_{in1}) \) 其中 \( H_{in1}=\text{in1\_features} \)
并且 :math:`*` 表示任意数量的额外维度。
除了输入的最后维度外，所有维度都应该相同。
- input2: :math:`(N, *, H_{in2})` 其中 :math:`H_{in2}=\text{in2\_features}`
- weight: :math:`(\text{out\_features}, \text{in1\_features},`
`in2\_features)`
- 偏置: :math:`(\text{out\_features})`
- 输出: :math:`(N, *, H_{out})` 其中 :math:`H_{out}=\text{out\_features}`
并且除了最后一个维度外，其余维度都与输入相同。
""",
)
[文档]def silu(input: Tensor, inplace: bool = False) -> Tensor:
r"""应用逐元素的 Sigmoid 线性单元（SiLU）函数。
SiLU 函数也称为 swish 函数。
.. math::
\text{silu}(x) = x * \sigma(x)，其中 \sigma(x) 是逻辑 Sigmoid 函数。
.. 注意：
查看《高斯误差线性单元（GELUs）`_
SiLU（Sigmoid 线性单元）最初被提出的地方，并查看
sigmoid 加权线性单元用于神经网络函数逼近
强化学习 和 `Swish:
自门控激活函数
该处后来进行了 SiLU 的实验。
查看更多详情，请参阅：:class:`~torch.nn.SiLU`
"""
如果有 torch_function_unary(input)：
返回 handle_torch_function(silu, (input,), input, inplace=inplace)
if inplace:
return torch._C._nn.silu_(input)
return torch._C._nn.silu(input)
[文档]def mish(input: Tensor, inplace: bool = False) -> Tensor:
r"""应用元素级的 Mish 函数。
Mish：一种自正则化的非单调神经网络激活函数。
.. math::
Mish(x) = x * Tanh(Softplus(x))
.. 注意::
查看 `Mish: 一种自正则化的非单调神经网络激活函数 `
更多详情请参阅 :class:`~torch.nn.Mish`
"""
如果存在 torch_function_unary(input):
返回 handle_torch_function(mish, (input,), input, inplace=inplace)
如果 inplace:
return torch._C._nn.mish_(input)
return torch._C._nn.mish(input)
[文档]def hardswish(input: Tensor, inplace: bool = False) -> Tensor:
r"""应用元素级 hardswish 函数。"""
遵循论文中描述的实现：
《搜索 MobileNetV3》_。
.. math::
\text{Hardswish}(x) = \begin{cases}
0 & \text{如果} x \le -3, \\
x & \text{如果} x \ge +3, \\
x \cdot (x + 3) /6 & \text{否则}
\end{cases}
查看更多详情，请参阅：:class:`~torch.nn.Hardswish`
.. _`搜索 MobileNetV3`:
https://arxiv.org/abs/1905.02244
"""
if has_torch_function_unary(input):
return handle_torch_function(hardswish, (input,), input, inplace=inplace)
if inplace:
return torch._C._nn.hardswish_(input)
return torch._C._nn.hardswish(input)
定义 _no_grad_embedding_renorm_(
重量:
张量,
输入:
张量,
最大范数: float,
归一化类型: float,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量]:
torch.embedding_renorm_(重量.detach(),
输入,
最大范数,
归一化类型)
[文档]
定义
嵌入(
输入:
张量,
重量:
张量,
填充索引:
可选[
整数] =
无,
最大范数:
可选[float] =
无,
归一化类型:
浮点数 = 2.0,
按频率缩放梯度:
布尔 =
错误,
稀疏:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r生成一个简单的查找表，用于在固定字典和大小中查找嵌入。
此模块常用于通过索引检索词嵌入。
模块的输入是一个索引列表和嵌入矩阵
输出对应词嵌入。
请参阅 :class:`torch.nn.Embedding` 获取更多详细信息。
.. 注意::
注意，此函数关于 :attr:`weight` 中指定行 :attr:`padding_idx` 的分析梯度与数值梯度可能不同。
预期此函数关于 :attr:`weight` 中指定行 :attr:`padding_idx` 的分析梯度与数值梯度可能不同。
分析梯度与数值梯度可能不同。
.. 注意::
注意 `:class:`torch.nn.Embedding` 与此函数不同，
它在构造时将 :attr:`weight` 的指定行 `:attr:`padding_idx` 初始化为零。
输入 (LongTensor)：包含嵌入矩阵索引的 Tensor。
参数：
输入 (LongTensor)：包含嵌入矩阵索引的 Tensor。
权重（张量）：行数等于最大可能索引 + 1 的嵌入矩阵
并且列数等于嵌入大小
padding_idx（int，可选）：如果指定，则：attr:`padding_idx`处的条目不参与梯度计算；
因此，在训练过程中，:attr:`padding_idx`处的嵌入向量不会被更新
即保持为固定的“填充”。
the starting index position of each bag (sequence) in :attr:`input`。
如果给定，则将范数大于 :attr:`max_norm` 的每个嵌入向量重新归一化，使其范数为 :attr:`max_norm`。
注意：这将就地修改：attr:`weight`。
norm_type (浮点数，可选): 用于计算 :attr:`max_norm` 选项的 p-norm 的 p 值。默认 ``2``。
scale_grad_by_freq (布尔值，可选): 如果提供，则将梯度按 mini-batch 中单词的频率的倒数进行缩放。默认 ``False``。
the words in the mini-batch. Default ``False``.
sparse (布尔值，可选): 如果 ``True``，则相对于 :attr:`weight` 的梯度将是一个稀疏张量。参见下方的注释。
`torch.nn.Embedding` 用于更多关于稀疏梯度的细节。
形状：
输入：任意形状的 LongTensor，包含要提取的索引。
权重：形状为 `(V, embedding_dim)` 的浮点数嵌入矩阵，
其中 V = 最大索引 + 1 且 embedding_dim = 嵌入大小。
输出：`(*, embedding_dim)`，其中 `*` 是输入形状
示例：
>>> # 两个样本的 4 个索引批次
>>> input = torch.tensor([[1, 2, 4, 5], [4, 3, 2, 9]])
>>> # 包含 10 个大小为 3 的张量的嵌入矩阵
>>> embedding_matrix = torch.rand(10, 3)
>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> F.embedding(input, embedding_matrix)
tensor([[[ 0.8490, 0.9625, 0.6753],
[ 0.9666, 0.7761, 0.6108],
[0.6246, 0.9751, 0.3618]
[0.4161, 0.2419, 0.7383]
[[0.6246, 0.9751, 0.3618]]
[0.0237, 0.7794, 0.0528]
[ 0.9666, 0.7761, 0.6108],
[[0.3385, 0.8612, 0.1867]]]
>>> 示例中使用 padding_idx
>>> 权重 = torch.rand(10, 3)
>>> weights[0, :].zero_()
>>> 嵌入矩阵 = 权重
>>> input = torch.tensor([[0, 2, 0, 5]])
>>> F.embedding(input, embedding_matrix, padding_idx=0)
tensor([[[ 0.0000, 0.0000, 0.0000],
[ 0.5609, 0.5384, 0.8720],
[0.0000, 0.0000, 0.0000]
[0.6262, 0.2438, 0.7471]
"文档"
如果 has_torch_function_variadic(
输入,
重量):
返回 handle_torch_function(
嵌入,
(输入,
重量),
输入,
重量,
填充索引=
填充索引,
最大范数=
最大范数,
归一化类型=
归一化类型,
按频率缩放梯度=
按频率缩放梯度,
稀疏=
稀疏,
)
如果 padding_idx
是
不
无:
如果 padding_idx > 0:
断言 padding_idx <
重量.
尺寸(
0
), "Padding_idx 必须在 num_embeddings 范围内"
elif padding_idx < 0:
断言 padding_idx >= -
重量.
尺寸(
0
), "Padding_idx 必须在 num_embeddings 范围内"
padding_idx = 重量.
尺寸(0) + padding_idx
else:
padding_idx = -1
如果 max_norm
是
不
无:
# Note [embedding_renorm contiguous]
`embedding_renorm_` 将无论如何在输入上调用 .contiguous()。
在这里调用它并利用改进的局部性
以下代码行中包含的 `embedding` 调用也适用。
输入 =
输入.
连续()
# 注意 [embedding_renorm 设置梯度启用]
# XXX: 相当于
# 使用 torch.no_grad():
# torch.embedding_renorm_
# 移除一旦脚本支持 set_grad_enabled
_no_grad_embedding_renorm_(重量,
输入,
最大范数,
归一化类型)
返回 torch.
嵌入(
重量,
输入,
填充索引,
按频率缩放梯度,
稀疏)
[文档]
定义
嵌入包(
输入:
张量,
重量:
张量,
偏移量:
可选[
张量] =
无,
最大范数:
可选[float] =
无,
归一化类型:
浮点数 = 2,
按频率缩放梯度:
布尔 =
错误,
模式:
字符串 =
平均值,
稀疏:
布尔 =
错误,
每样本权重:
可选[
张量] =
无,
include_last_offset: 布尔 =
错误,
填充索引:
可选[
整数] =
无,
)
输入文本:
->
翻译:
-> 张量:
r计算嵌入体的总和、平均值或最大值。
计算过程中不实例化中间嵌入体。
更多详情请参阅 :class:`torch.nn.EmbeddingBag`。
注意：
{backward_reproducibility_note}
参数：
输入（长张量）：包含嵌入矩阵索引袋的张量
权重（张量）：行数等于最大可能索引 + 1 的嵌入矩阵
并且列数等于嵌入大小
offsets (LongTensor，可选）：仅当 :attr:`input` 为 1D 时使用。:attr:`offsets` 确定每个包（序列）在 :attr:`input` 中的起始索引位置。
max_norm (浮点数，可选）：如果提供，则将范数大于 :attr:`max_norm` 的每个嵌入向量重新归一化，使其范数为 :attr:`max_norm`。
the starting index position of each bag (sequence) in :attr:`input`。
如果给定，则将范数大于 :attr:`max_norm` 的每个嵌入向量重新归一化，使其范数为 :attr:`max_norm`。
注意：这将就地修改：attr:`weight`。
norm_type (浮点数，可选): 用于计算 :attr:`max_norm` 选项的 ``p``-范数中的 ``p``。
默认 ``2``。
scale_grad_by_freq (布尔值，可选): 如果提供，这将通过梯度的频率的倒数来缩放梯度。
the words in the mini-batch. Default ``False``.
注意：当 ``mode="max"`` 时，此选项不受支持。
mode (str, 可选): ``"sum"``, ``"mean"`` 或 ``"max"``。指定减少袋的方式。
默认: ``"mean"``
sparse (bool, 可选): 如果 ``True``，则相对于 :attr:`weight` 的梯度将是一个稀疏张量。参见注意事项。
`torch.nn.Embedding` 用于更多关于稀疏梯度的细节。
注意：当 ``mode="max"`` 时，此选项不受支持。
per_sample_weights（张量，可选）：一个浮点/双精度浮点权重张量，或 None
以指示所有权重都应取为 1。如果指定，:attr:`per_sample_weights`
必须与输入具有完全相同的形状，如果:attr:`offsets`不是 None，则被视为具有相同的
attr:`偏移量`
include_last_offset (bool, 可选): 如果为 ``True``，偏移量的大小等于包的数量 + 1。
最后一个元素是输入的大小，或者最后一个包（序列）的结束索引位置。
padding_idx (int, 可选): 如果指定，则 :attr:`padding_idx` 位置的条目不贡献梯度；因此，:attr:`padding_idx` 的嵌入向量不会更新。
padding_idx (int, 可选): 如果指定，则 :attr:`padding_idx` 位置的条目不贡献梯度；因此，:attr:`padding_idx` 的嵌入向量不会更新。
在训练过程中，即保持为固定的“填充”。请注意，在：attr:`padding_idx`处的嵌入向量被排除在缩减之外。
- :attr:`input`（长张量）和：attr:`offsets`（长张量，可选）
形状：
- 如果：attr:`input`是形状为`(B, N)`的 2D 张量，它将被视为`B`个袋子（序列）
- 如果：attr:`input`是形状为`(B, N)`的 2D 张量，它将被视为`B`个袋子（序列）
每个长度为“N”，这将返回以某种方式聚合的“B”个值
根据`:attr:`模式`. 在这种情况下，`:attr:`偏移量`被忽略，必须为`None`。
如果 :attr:`input` 是形状为 `(N)` 的 1D，它将被视为形状为 `(N)` 的连接
多个袋子（序列）。:attr:`offsets` 必须是一个包含 1D 张量的
每个包在 :attr:`input` 中的起始索引位置。因此，对于 :attr:`offsets`
的形状为 `(B)`，:attr:`input` 将被视为有 ``B`` 个包。
空包（即长度为 0 的包）将返回由零填充的向量。
- :attr:`weight`（张量）：该模块的可学习权重，形状为 `(num_embeddings, embedding_dim)`
- :attr:`per_sample_weights`（张量，可选）。与:attr:`input`具有相同的形状。
- :attr:`output`：形状为`(B, embedding_dim)`的聚合嵌入值。
示例：
>>> # 包含 10 个大小为 3 的张量的嵌入模块
>>> embedding_matrix = torch.rand(10, 3)
>>> # 两个样本的 4 个索引批次
>>> input = torch.tensor([1, 2, 4, 5, 4, 3, 2, 9])
>>> offsets = torch.tensor([0, 4])
>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> F.embedding_bag(input, embedding_matrix, offsets)
tensor([[ 0.3397, 0.3552, 0.5545],
[[0.5893, 0.4386, 0.5882]])
>>> 示例中使用 padding_idx
>>> embedding_matrix = torch.rand(10, 3)
>>> input = torch.tensor([2, 2, 2, 2, 4, 3, 2, 9])
>>> offsets = torch.tensor([0, 4])
>>> F.embedding_bag(input, embedding_matrix, offsets, padding_idx=2, mode='sum')
tensor([[ 0.0000, 0.0000, 0.0000],
[-0.7082, 3.2145, -2.6251]])
"文档"
如果 has_torch_function_variadic(
输入,
重量,
偏移量,
每样本权重):
返回 handle_torch_function(
嵌入包,
(输入,
重量,
偏移量,
每样本权重),
输入,
重量,
偏移量=
偏移量,
最大范数=
最大范数,
归一化类型=
归一化类型,
按频率缩放梯度=
按频率缩放梯度,
模式=
模式,
稀疏=
稀疏,
每样本权重=
每样本权重,
include_last_offset=include_last_offset,
填充索引=
填充索引,
)
检查向后兼容性。
之前是 embedding_bag(weight, input, ...)。
现在是 embedding_bag(input, weight, ...)。
如果
重量.dtype == torch.
长的
和
输入.is_floating_point():
警告.
警告(
nn.functional.embedding_bag 的参数顺序已更改。
"使用 `embedding_bag(weight, input, ...)` 已弃用，"
"现在应使用 `embedding_bag(input, weight, ...)`。"
)
重量,
输入 =
输入,
权重
如果
每样本权重
是
不
无
和
输入.
尺寸() !=
每样本权重.
尺寸():
raise ValueError(
f嵌入包：如果 per_sample_weights （{
每样本权重.
形状}
) 不为空，"
f然后它必须与输入具有相同的形状（{
输入.
形状})"
)
如果
不
重量.
暗() == 2:
raise ValueError(
f权重必须是一个二维张量，但得到的是维度{
重量.
暗()}"
)
如果
不 torch.
算子.
是否正在脚本化()
和
输入.
暗() == 2
和
输入.
是嵌套的:
包含最后一个偏移量 =
真实
偏移量 =
输入.
偏移量()
输入 =
输入.
值().
重塑(-1)
如果
每样本权重
是
不
无:
如果
不
每样本权重.
是嵌套的:
raise ValueError(
"如果输入是嵌套的，则指定的每样本权重必须是嵌套的"
)
每样本权重 =
每样本权重.
值().
重塑(-1)
elif 输入.
暗() == 2:
如果
偏移量
是
不
无:
类型字符串 =
"<未知>"
# TODO: 一旦脚本支持 type()调用，请删除此行
如果
不 torch.
算子.
是否正在脚本化():
类型字符串 =
字符串(
类型(
偏移量))
raise ValueError(
如果输入是二维的，那么偏移量必须为 None
", 作为输入被处理为一个迷你批次"
固定长度序列。然而，发现
f类型偏移量{
类型字符串}"
)
偏移量 = torch.arange(
0, 输入.
元素数量(),
输入.
尺寸(1),
数据类型=
输入.
数据类型,
设备=
输入.
设备
)
输入 =
输入.
重塑(-1)
如果
每样本权重
是
不
无:
每样本权重 =
每样本权重.
重塑(-1)
elif 输入.
暗() == 1:
如果
偏移量
是
无:
raise ValueError(偏移量必须是一个一维张量，但得到了 None)
如果
偏移量.
暗() != 1:
raise ValueError("偏移量必须是一个一维张量")
else:
raise ValueError(
f"输入必须是一维或二维张量，但得到了维度为的张量"{
输入.
暗()}"
)
如果
模式 ==
"求和":
模式枚举 = 0
elif 模式 ==
平均值:
模式枚举 = 1
elif 模式 ==
最大:
模式枚举 = 2
如果
按频率缩放梯度:
raise ValueError(
"最大模式不支持按频率缩放梯度"
)
如果
稀疏:
raise ValueError("最大模式不支持稀疏权重")
else:
raise ValueError("模式必须是 sum、mean 或 max 之一")
如果 max_norm
是
不
无:
# XXX: 相当于
# 使用 torch.no_grad():
# torch.nembedding_renorm_
# 移除一旦脚本支持 set_grad_enabled
_no_grad_embedding_renorm_(重量,
输入,
最大范数,
归一化类型)
如果
每样本权重
是
不
无
和
模式 !=
"求和":
raise 不支持的操作异常(
"embedding_bag: per_sample_weights 不为 None。"
"仅支持 mode='sum' 模式。"
f"(获取 mode='"{
模式}
'). 请在 GitHub 上提交功能请求。'
)
返回, _, _, _ = torch.
嵌入包(
重量,
输入,
偏移量,
按频率缩放梯度,
模式枚举,
稀疏,
每样本权重,
include_last_offset,
填充索引,
)
返回
返回
如果
嵌入包.__doc__:
嵌入包.__doc__ =
嵌入包.__doc__.
格式(**
可复现性说明)
定义
_验证批次大小(
尺寸:
列表[
整数])
输入文本:
->
翻译:
-> 无:
# XXX：JIT 脚本不支持 functools 中的 reduce 操作，并且 mul 操作是
# 内置的，目前还不能用作函数的值，所以需要重写这个大小
# 检查一个简单的等效循环
#
# TODO：当即时编译（JIT）准备好并具备缺失的功能时，像下面这样使用 reduce
# 从运算符导入乘法
导入 functools
#
如果 reduce(mul, size[2:], size[0]) 等于 1
产品尺寸 =
尺寸[0]
for i 在
范围(
长度(
尺寸) - 2):
产品尺寸 *=
尺寸[i + 2]
如果
产品尺寸 == 1:
raise ValueError(
f"训练时每个通道预期超过 1 个值，但得到了输入大小"{
尺寸}"
)
[文档]def 批标准化(
输入: Tensor,
运行均值: Optional[Tensor],
运行方差: Optional[Tensor],
weight: 可选[Tensor] = None,
bias: 可选[Tensor] = None,
training: 布尔型 = False,
momentum: 浮点数 = 0.1,
eps: float = 1e-5,
) -> Tensor:
应用批量归一化对数据批次中的每个通道进行处理。
查看 :class:`~torch.nn.BatchNorm1d`, :class:`~torch.nn.BatchNorm2d`,
`torch.nn.BatchNorm3d` 的详细信息请参阅。
"""
如果 has_torch_function_variadic(input, running_mean, running_var, weight, bias) 为真：
返回 handle_torch_function(
批标准化
(输入，运行均值，运行方差，权重，偏置)
输入
运行均值
运行变量,
weight=weight,
bias=bias,
training=training,
momentum=动量,
eps=epsilon,
)
如果训练：
_verify_batch_size(input.size())
return torch.batch_norm(
input,
weight,
偏差,
运行均值,
运行方差,
训练,
动量,
eps,
torch.backends.cudnn.enabled,
)
定义
验证空间大小(
尺寸:
列表[
整数])
输入文本:
->
翻译:
-> 无:
# 验证实例归一化计算时是否存在大于 1 的空间元素。
产品尺寸 = 1
for i 在
范围(2,
长度(
尺寸)):
产品尺寸 *=
尺寸[i]
如果
产品尺寸 == 1:
raise ValueError(
f"在训练时预期有超过 1 个空间元素，但得到了输入大小 "{
尺寸}"
)
[文档]def instance_norm(
输入: Tensor,
running_mean: Optional[Tensor] = None,
running_var: Optional[Tensor] = None,
weight: 可选[Tensor] = None,
bias: 可选[Tensor] = None,
use_input_stats: 布尔 = True,
momentum: 浮点数 = 0.1,
eps: float = 1e-5,
) -> Tensor:
独立地对每个数据样本中的每个通道应用实例归一化。
查看 :class:`~torch.nn.InstanceNorm1d`, :class:`~torch.nn.InstanceNorm2d`,
`torch.nn.InstanceNorm3d` 的详细信息请参阅。
"""
如果 has_torch_function_variadic(input, running_mean, running_var, weight, bias) 为真：
返回 handle_torch_function(
instance_norm,
(输入，运行均值，运行方差，权重，偏置),
输入,
running_mean=running_mean,
running_var=running_var,
weight=weight,
bias=bias,
use_input_stats=use_input_stats,
momentum=动量,
eps=eps,
)
如果使用输入统计:
_验证输入大小(input.size())
return torch.instance_norm(
input,
weight,
偏差,
运行均值,
运行方差,
使用输入统计信息,
动量,
eps,
torch.backends.cudnn.enabled,
)
[文档]def layer_norm(
输入: Tensor,
标准化形状: list[int],
weight: Optional[Tensor] = None,
bias: Optional[Tensor] = None,
eps: float = 1e-5,
) -> Tensor:
r"""应用层归一化于最后若干维度。
查看 :class:`~torch.nn.LayerNorm` 获取详细信息。
"""
如果 has_torch_function_variadic(input, weight, bias) 为真：
返回 handle_torch_function(
层归一化
(输入，权重，偏置)
输入
归一化形状
weight=权重,
bias=偏置,
eps=epsilon,
)
return torch.layer_norm(
输入，归一化形状，权重，偏置，eps，torch.backends.cudnn.enabled
)
[文档]def rms_norm(
输入: Tensor,
标准化形状: list[int],
weight: Optional[Tensor] = None,
eps: 可选的浮点数 = None,
) -> 张量:
应用均方根层归一化。
详细信息请参阅 :class:`~torch.nn.RMSNorm`。
"""
如果具有 torch_function_variadic(input, weight):
返回 handle_torch_function(
rms_norm, (input, weight), input, normalized_shape, weight=weight, eps=eps
)
返回 torch.rms_norm(input, normalized_shape, weight, eps)
[文档]def group_norm(
输入: Tensor,
num_groups: int,
weight: Optional[Tensor] = None,
bias: Optional[Tensor] = None,
eps: float = 1e-5,
) -> Tensor:
r"""应用组归一化于最后若干维度。
查看 :class:`~torch.nn.GroupNorm` 获取详细信息。
"""
如果 has_torch_function_variadic(input, weight, bias) 为真：
返回 handle_torch_function(
group_norm,
(
input,
weight,
偏差,
),
输入,
组数,
weight=权重,
bias=偏置,
eps=epsilon,
)
if input.dim() < 2:
raise RuntimeError(
f"期望输入张量至少有 2 个维度，但实际接收到 {input.dim()}"
)
_verify_batch_size(
[input.size(0) * input.size(1) // num_groups, num_groups]
+ list(input.size()[2:])
)
return torch.group_norm(
input, num_groups, weight, bias, eps, torch.backends.cudnn.enabled
)
[文档]def local_response_norm(
输入: Tensor,
大小: int,
alpha: float = 1e-4,
beta: 浮点数 = 0.75,
k: 浮点数 = 1.0,
) -> 张量:
r"""在输入信号上应用局部响应归一化。
输入信号由多个输入平面组成，其中通道占据第二维。
在通道间应用归一化。
详细信息请参阅 :class:`~torch.nn.LocalResponseNorm`。
"""
if has_torch_function_unary(input):
return handle_torch_function(
local_response_norm, (input,), input, size, alpha=alpha, beta=beta, k=k
)
dim = input.dim()
if dim < 3:
raise ValueError(
f"期望 3D 或更高维度的输入（实际维度为{dim}）"
)
if input.numel() == 0:
return input
div = input.mul(input)
if dim == 3:
div = div.unsqueeze(1)
div = pad(div, (0, 0, size // 2, (size - 1) // 2))
div = avg_pool2d(div, (size, 1), stride=1).squeeze(1)
else:
sizes = input.size()
div = div.view(sizes[0], 1, sizes[1], sizes[2], -1)
div = pad(div, (0, 0, 0, 0, size // 2, (size - 1) // 2))
div = avg_pool3d(div, (size, 1, 1), stride=1).squeeze(1)
div = div.view(sizes)
div = div.mul(alpha).add(k).pow(beta)
return input / div
# 损失
[文档]
定义 ctc_loss(
log_probs: 张量,
targets: 张量,
input_lengths: 张量,
目标长度:
张量,
空白:
整型 = 0,
缩减:
字符串 =
平均值,
零无穷:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r应用连接主义时序分类损失。
详细信息请参阅 :class:`~torch.nn.CTCLoss`。
注意：
{cudnn_可复现性说明}
注意：
{backward_reproducibility_note}
参数：
log_probs: (T, N, C) 或 (T, C) 其中 C = 字母表中的字符数（包括空格）
`T = 输入长度`，和 `N = 批处理大小`。
输出对数概率
例如，通过:func:`torch.nn.functional.log_softmax`获得。
目标：:math:`(N, S)` 或 `(sum(target_lengths))`
目标不能为空。在第二种形式中，假设目标已连接。
input_lengths: :math:`(N)` 或 :math:`()`
输入长度（必须每个都 ≤ T）
目标长度：:math:`(N)` 或 :math:`()`.
目标长度
空白（int，可选）：
空白标签。默认 :math:`0`.
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``: 输出的损失将除以目标长度，然后取批次的平均值，
``'sum'``: 输出将直接相加，
求和。默认值：``'mean'``
zero_infinity (bool, optional):
是否将无穷大的损失及其关联的梯度置零。
默认：``False``
无穷大的损失主要发生在输入太短时。
与目标对齐。
示例::
>>> log_probs = torch.randn(50, 16, 20).log_softmax(2).detach().requires_grad_()
>>> targets = torch.randint(1, 20, (16, 30), dtype=torch.long)
>>> input_lengths = torch.full((16,), 50, dtype=torch.long)
>>> target_lengths = torch.randint(10, 30, (16,), dtype=torch.long)
>>> 损失 = F.ctc_loss(log_probs, targets, input_lengths, target_lengths)
>>> loss.backward()
"文档"
如果 has_torch_function_variadic(log_probs, targets, input_lengths,
目标长度):
返回 handle_torch_function(
ctc_loss,
(log_probs, targets, input_lengths, 目标长度),
log_probs,
targets,
input_lengths,
目标长度,
空白=
空白,
缩减=
缩减,
零无穷=
零无穷,
)
返回 torch.ctc_loss(
log_probs,
targets,
input_lengths,
目标长度,
空白,
_减少.
获取枚举(
缩减),
零无穷,
)
如果 ctc_loss.__doc__:
ctc_loss.__doc__ = ctc_loss.__doc__.格式(**
可复现性说明)
[文档]
定义 nll_loss(
输入:
张量,
目标:
张量,
重量:
可选[
张量] =
无,
平均大小:
可选[
布尔] =
无,
忽略索引:
整型 = -100,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
)
输入文本:
->
翻译:
-> 张量:
r计算负对数似然损失。
查看 :class:`~torch.nn.NLLLoss` 获取详细信息。
参数：
输入: :math:`(N, C)` 其中 `C = 类别数量` 或 :math:`(N, C, H, W)`
在 2D 损失的情况下，或：数学公式`(N, C, d_1, d_2, ..., d_K)`其中`K ≥ 1`
在 K 维损失的情况下。`input` 应为对数概率。
目标：:math:`(N)` 其中每个值是 :math:`0 \leq \text{targets}[i] \leq C-1`，
或者 :math:`(N, d_1, d_2, ..., d_K)` 其中 :math:`K \geq 1`，
K 维损失。
权重（Tensor，可选）：为每个类别提供的手动缩放权重。如果提供，必须是一个大小为 `C` 的 Tensor。
类。如果提供，必须是大小为 `C` 的张量
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
忽略索引（int，可选）：指定一个要忽略的目标值
并且不贡献于输入梯度。当 :attr:`size_average` 为 ``True`` 时，
损失将在非忽略的目标上进行平均。默认：-100
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
``'sum'``：输出将进行求和。注意：:attr:`size_average`
和 :attr:`reduce` 正在弃用，在此期间，
指定这两个参数中的任何一个将覆盖 :attr:`reduction`。默认：``'mean'``
示例::
>>> # 输入大小为 N x C = 3 x 5
>>> input = torch.randn(3, 5, requires_grad=True)
>>> # 目标中的每个元素都必须满足 0 <= value < C
>>> target = torch.tensor([1, 0, 4])
>>> output = F.nll_loss(F.log_softmax(input, dim=1), target)
>>> output.backward()
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量):
返回 handle_torch_function(
nll_loss,
(输入,
目标,
重量),
输入,
目标,
重量=
重量,
平均大小=
平均大小,
忽略索引=
忽略索引,
减少=
减少,
缩减=
缩减,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减少 =
_减少.
旧版获取字符串(
平均大小,
减少)
返回 torch._C._nn.nll_loss_nd(
输入,
目标,
重量,
_减少.
获取枚举(
缩减), ignore_index
)
[文档]
定义
泊松 NLL 损失(
输入:
张量,
目标:
张量,
日志输入:
布尔 =
是,
full: 布尔 =
错误,
平均大小:
可选[
布尔] =
无,
eps: 浮点数 = 1e-8,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
)
输入文本:
->
翻译:
-> 张量:
r泊松负对数似然损失。
详细信息请参阅 :class:`~torch.nn.PoissonNLLLoss`。
参数：
输入：底层泊松分布的期望。
目标：随机样本 :math:`target \sim \text{Poisson}(input)`。
log_input: 如果为 ``True``，则损失计算为
math:`\exp(\text{input}) - \text{target} * \text{input}`，如果为 ``False``，则损失为
math:`\text{input} - \text{target} * \log(\text{input}+\text{eps})`。默认：``True``
full: 是否计算完整损失，即添加 Stirling
近似项。默认值：``False``
math:`\text{目标} * \log(\text{目标}) - \text{目标} + 0.5 * \log(2 * \pi * \text{目标})`
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
eps (float, 可选): 避免评估 :math:`\log(0)` 的小值
`log_input` = ``False``. 默认：1e-8
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
``'sum'``：输出将进行求和。注意：:attr:`size_average`
和 :attr:`reduce` 正在弃用，在此期间，
指定这两个参数中的任何一个将覆盖 :attr:`reduction`。默认：``'mean'``
"文档"
如果 has_torch_function_variadic(
输入,
目标):
返回 handle_torch_function(
泊松 NLL 损失,
(输入,
目标),
输入,
目标,
日志输入=
日志输入,
full=full,
平均大小=
平均大小,
eps=eps,
减少=
减少,
缩减=
缩减,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减少 =
_减少.
旧版获取字符串(
平均大小,
减少)
如果
减少 !=
无
和
减少 !=
平均值
和
减少 !=
"求和":
返回 =
输入
raise ValueError(减少 +
"不是有效的缩减值")
返回 = torch.
泊松 NLL 损失(
输入,
目标,
日志输入, full, eps,
_减少.
获取枚举(
缩减)
)
返回
返回
[文档]
定义
高斯负对数似然损失(
输入:
张量,
目标:
张量,
变量:
联盟[
张量, float
]
full: 布尔 =
错误,
eps: 浮点数 = 1e-6,
缩减:
字符串 =
平均值,
)
输入文本:
->
翻译:
-> 张量:
r高斯负对数似然损失。
详细信息请参阅 :class:`~torch.nn.GaussianNLLLoss`。
参数：
输入：高斯分布的期望
目标：从高斯分布中抽取样本
var：正方差（s）的张量，每个期望一个（异方差），或一个（同方差）
在输入中（异方差），或一个（同方差）
或为所有期望使用的正标量值。
full (bool, 可选): 是否在损失计算中包含常数项。默认：``False``。
eps (float, 可选): 添加到 var 中的值，以增加稳定性。默认：1e-6。
reduction (str, 可选): 指定应用于输出的缩减方式：
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出为所有批次成员损失的均值，
``'sum'``：输出为所有批次成员损失的总和。
默认：``'mean'``。
"文档"
如果 has_torch_function_variadic(
输入,
目标,
变量):
返回 handle_torch_function(
高斯负对数似然损失,
(输入,
目标,
变量),
输入,
目标,
变量,
full=full,
eps=eps,
缩减=
缩减,
)
# var 的条目必须为非负
如果 isinstance(
变量, float):
如果
变量 < 0:
raise ValueError("变量包含负数项")
变量 =
变量 * torch.
喜欢的(
输入)
elif torch.任何(
变量 < 0):
raise ValueError("变量包含负数项")
# 检查变量大小
# 如果 var.size 等于 input.size，则情况为异方差性，无需进一步检查。
否则：
如果
变量.
尺寸() !=
输入.
尺寸():
如果变量比输入少一个维度，但其他维度大小匹配，则这是一个同方差情况。
例如：输入.size = (10, 2, 3)，变量.size = (10, 2)
-> 将变量扩展，使变量.shape = (10, 2, 1)
这样做是为了在损失计算中实现广播
如果
输入.
尺寸()[:-1] ==
变量.
尺寸():
变量 = torch.
展平(
变量, -1)
这检查是否与最终维度匹配，并且 var 的最终维度大小为 1。
这也是一个同方差的情况。
例如，input.size = (10, 2, 3)，var.size = (10, 2, 1)
elif (
输入.
尺寸()[:-1] ==
变量.
尺寸()[:-1]
和
变量.
尺寸(-1) == 1
): 异方差情况
通过
# 如果以上都不符合，则变量 var 的大小不正确。
else:
raise ValueError("变量 var 的大小不正确")
# 检查缩减模式的有效性
如果
减少 !=
无
和
减少 !=
平均值
和
减少 !=
"求和":
raise ValueError(减少 +
"无效")
# 稳定性夹具
变量 =
变量.
克隆()
与 torch.
不梯度():
变量.clamp_(
最小=eps)
计算损失
损失 = 0.5 * (torch.
日志(
变量) + (
输入 -
目标) ** 2 /
变量)
如果 full:
损失 += 0.5 *
数学.
日志(2 *
数学.
π)
如果
减少 ==
平均值:
返回
损失.
均值()
elif 减少 ==
"求和":
返回
损失.
总和()
else:
返回
损失
[文档]
定义 kl_div(
输入:
张量,
目标:
张量,
平均大小:
可选[
布尔] =
无,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
日志目标:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
r计算 KL 散度损失。
参考 - `Kullback-Leibler 散度损失`
[https://en.wikipedia.org/wiki/Kullback-Leibler_divergence](https://en.wikipedia.org/wiki/Kullback-Leibler_divergence)
详细信息请参阅 :class:`~torch.nn.KLDivLoss`。
参数：
输入：任意形状的对数概率张量。
目标：与输入形状相同的张量。有关目标的解释，请参阅：attr:`log_target`。
目标的解释。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'`` | ``'batchmean'`` | ``'sum'`` | ``'mean'``。
``'none'``：不应用降维
``'batchmean'``：输出之和将被除以批大小
``'sum'``: 输出将被求和
``'mean'``: 输出将被除以输出中的元素数量
默认: ``'mean'``
log_target (布尔值): 一个标志，表示是否在对数空间中传递 ``target``。
建议传递某些分布（如 `softmax`）
在对数空间中，以避免由显式 `log` 引起的数值问题。
默认：``False``
.. 注意::
`size_average` 和 `reduce` 正在弃用中，
同时，指定这两个参数中的任何一个都将覆盖 `reduction`。
.. 警告::
`:attr:`reduction` = ``'mean'`` 不返回真正的 KL 散度值，请使用
`:attr:`reduction` = ``'batchmean'`` 这与 KL 数学定义一致。
"文档"
如果 has_torch_function_variadic(
输入,
目标):
返回 handle_torch_function(
kl_div,
(输入,
目标),
输入,
目标,
平均大小=
平均大小,
减少=
减少,
缩减=
缩减,
日志目标=
日志目标,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减法枚举 =
_减少.
旧版获取枚举(
平均大小,
减少)
else:
如果
减少 ==
平均值:
警告.
警告(
"reduction: 'mean' 将总损失除以批大小和支持大小。"
"'batchmean' 只除以批大小，并与 KL 除法数学定义一致。"
"在下一个主要版本中，'mean' 将改为与 'batchmean' 的行为相同。"
)
# 批 mean 的特殊情况
如果
减少 ==
批量均值:
减法枚举 =
_减少.
获取枚举(
"求和")
else:
减法枚举 =
_减少.
获取枚举(
缩减)
减少 = torch.kl_div(
输入,
目标,
减少枚举,
日志目标=
日志目标)
如果
减少 ==
批均值
和
输入.
暗() != 0:
减少 =
减少 /
输入.
尺寸()[0]
返回
减少
[文档]
定义
交叉熵(
输入:
张量,
目标:
张量,
重量:
可选[
张量] =
无,
平均大小:
可选[
布尔] =
无,
忽略索引:
整型 = -100,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
标签平滑:
浮点数 = 0.0,
)
输入文本:
->
翻译:
-> 张量:
r计算输入对数几率和目标之间的交叉熵损失。
详细信息请参阅 :class:`~torch.nn.CrossEntropyLoss`。
参数：
输入 (Tensor) : 预测的非规范化对数几率；
查看下方的形状部分以了解支持的形状。
目标（张量）：真实类索引或类概率
查看下方的形状部分以了解支持的形状。
权重（Tensor，可选）：为每个类别提供的手动缩放权重。如果提供，必须是一个大小为 `C` 的 Tensor。
类。如果提供，必须是大小为 `C` 的张量
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
忽略索引（int，可选）：指定一个要忽略的目标值
并且不贡献于输入梯度。当 :attr:`size_average` 为 ``True`` 时，
“True”，损失是针对非忽略目标平均的。注意，
attr:`ignore_index` 仅在目标包含类别索引时适用。
默认：-100
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
``'sum'``：输出将进行求和。注意：:attr:`size_average`
和 :attr:`reduce` 正在弃用，在此期间，
指定这两个参数中的任何一个将覆盖 :attr:`reduction`。默认：``'mean'``
标签平滑（浮点数，可选）：一个位于[0.0, 1.0]之间的浮点数。指定平滑量
在计算损失时的平滑度，其中 0.0 表示无平滑。目标
原始真实值和如描述的均匀分布混合在一起
《重新思考计算机视觉的 Inception 架构 》。默认值：:math:`0.0`。
形状：
- 输入：形状 :math:`(C)`，:math:`(N, C)` 或 :math:`(N, C, d_1, d_2, ..., d_K)`，其中 :math:`K \geq 1`
在 `K` 维度损失的情况下。
- 目标：如果包含类别索引，形状为 :math:`()`, :math:`(N)` 或 :math:`(N, d_1, d_2, ..., d_K)`，其中
math:`K \geq 1` 在 K 维损失的情况下，每个值应在 :math:`[0, C)` 范围内。
如果包含类别概率，形状与输入相同，每个值应在 :math:`[0, 1]` 范围内。
其中：
.. math::
\begin{aligned}
C ={} & \text{类别数量} \\
N ={} & \text{批量大小} \\
\end{aligned}
示例：
>>> # 示例：带有类别索引的目标
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randint(5, (3,), dtype=torch.int64)
>>> loss = F.cross_entropy(input, target)
>>> loss.backward()
...
>>> # 示例：带有概率类的目标
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5).softmax(dim=1)
>>> loss = F.cross_entropy(input, target)
>>> loss.backward()
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量):
返回 handle_torch_function(
交叉熵,
(输入,
目标,
重量),
输入,
目标,
重量=
重量,
平均大小=
平均大小,
忽略索引=
忽略索引,
减少=
减少,
缩减=
缩减,
标签平滑=
标签平滑,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减少 =
_减少.
旧版获取字符串(
平均大小,
减少)
返回 torch._C._nn.
交叉熵损失(
输入,
目标,
重量,
_减少.
获取枚举(
缩减),
忽略索引,
标签平滑,
)
[文档]
定义
二元交叉熵(
输入:
张量,
目标:
张量,
重量:
可选[
张量] =
无,
平均大小:
可选[
布尔] =
无,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
)
输入文本:
->
翻译:
-> 张量:
r测量目标概率与输入概率之间的二进制交叉熵。
请参阅：class:`~torch.nn.BCELoss` 以获取详细信息。
参数：
输入：任意形状的张量作为概率。
目标：与输入形状相同的张量，其值介于 0 和 1 之间。
权重（张量，可选）：一个手动缩放权重
如果提供，则重复以匹配输入张量形状
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
``'sum'``：输出将进行求和。注意：:attr:`size_average`
和 :attr:`reduce` 正在弃用，在此期间，
指定这两个参数中的任何一个将覆盖 :attr:`reduction`。默认：``'mean'``
示例：
>>> input = torch.randn(3, 2, requires_grad=True)
>>> target = torch.rand(3, 2, requires_grad=False)
>>> loss = F.binary_cross_entropy(torch.sigmoid(input), target)
>>> loss.backward()
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量):
返回 handle_torch_function(
二元交叉熵,
(输入,
目标,
重量),
输入,
目标,
重量=
重量,
平均大小=
平均大小,
减少=
减少,
缩减=
缩减,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减法枚举 =
_减少.
旧版获取枚举(
平均大小,
减少)
else:
减法枚举 =
_减少.
获取枚举(
缩减)
如果
目标.
尺寸() !=
输入.
尺寸():
raise ValueError(
f使用一个与输入大小不同的目标大小（{
目标.
尺寸()}
）{
输入.
尺寸()}
）是 deprecated。
"请确保它们具有相同的大小。"
)
如果
权重
是
不
无:
新尺寸 =
_推断大小(
目标.
尺寸(),
重量.
尺寸())
权重 =
重量.
展开(
新尺寸)
返回 torch._C._nn.
二元交叉熵(
输入,
目标,
重量,
减少枚举)
[文档]
定义
二元交叉熵（对数）(
输入:
张量,
目标:
张量,
重量:
可选[
张量] =
无,
平均大小:
可选[
布尔] =
无,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
正向权重:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量:
r计算目标与输入 logits 之间的二元交叉熵。
详细信息请参阅 :class:`~torch.nn.BCEWithLogitsLoss`。
参数：
输入：任意形状的张量，作为未归一化的分数（通常称为 logits）。
目标：与输入形状相同的张量，其值介于 0 和 1 之间。
权重（张量，可选）：一个手动缩放权重
如果提供，则重复以匹配输入张量形状
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失，每个样本有多个元素。如果字段：attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 reduce 为``False``。默认：``True``
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
``'sum'``：输出将进行求和。注意：:attr:`size_average`
和 :attr:`reduce` 正在弃用，在此期间，
指定这两个参数中的任何一个将覆盖 :attr:`reduction`。默认：``'mean'``
pos_weight (Tensor，可选): 正例的权重，将广播与目标一起使用。
必须是一个与类别维度的类别数量相等的张量。
请密切关注 PyTorch 的广播语义，以实现所需的效果。
操作。对于大小为[B, C, H, W]的目标（其中 B 是批量大小），将根据大小[B, C, H, W]应用不同的 pos_weight 到批量的每个元素或
[C, H, W]在整个批次中应用相同的 pos_weight。对于 2D 多类目标[C, H, W]，要沿所有空间维度应用相同的正权重，请使用：[C, 1, 1]。
沿所有空间维度应用相同的正权重。对于 2D 多类目标[C, H, W]，要沿所有空间维度应用相同的正权重，请使用：[C, 1, 1]。
[C, 1, 1]。对于 2D 多类目标[C, H, W]，要沿所有空间维度应用相同的正权重，请使用：[C, 1, 1]。
默认：`None`
示例：
>>> input = torch.randn(3, requires_grad=True)
>>> target = torch.empty(3).random_(2)
>>> loss = F.binary_cross_entropy_with_logits(input, target)
>>> loss.backward()
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量,
正向权重):
返回 handle_torch_function(
二元交叉熵（对数）,
(输入,
目标,
重量,
正向权重),
输入,
目标,
重量=
重量,
平均大小=
平均大小,
减少=
减少,
缩减=
缩减,
正向权重=
正向权重,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减法枚举 =
_减少.
旧版获取枚举(
平均大小,
减少)
else:
减法枚举 =
_减少.
获取枚举(
缩减)
如果
不 (
目标.
尺寸() ==
输入.
尺寸()):
raise ValueError(
f"目标大小（"{
目标.
尺寸()}
）必须与输入大小（"{
输入.
尺寸()})"
)
返回 torch.
二元交叉熵（对数）(
输入,
目标,
重量,
正向权重,
减法枚举
)
[文档]def smooth_l1_loss(
输入: Tensor,
目标: Tensor,
size_average: Optional[bool] = None,
reduce: Optional[bool] = None,
reduction: str = "mean",
beta: float = 1.0,
) -> Tensor:
计算平滑 L1 损失。
函数在元素级误差低于 beta 时使用平方项，否则使用 L1 项。
详细信息请参阅 :class:`~torch.nn.SmoothL1Loss`。
有关详细信息，请参阅 :class:`~torch.nn.SmoothL1Loss`。
"""
如果具有 torch_function_variadic(input, target):
返回 handle_torch_function(
smooth_l1_loss,
输入，目标
输入
目标
size_average=size_average
reduce=reduce,
reduction=reduction,
beta=beta,
)
如果目标大小（target.size()）不等于输入大小（input.size()）
警告：
f"使用目标大小 ({target.size()}) 与输入大小 ({input.size()}) 不一致。 "
这可能会由于广播导致结果不正确。
请确保它们具有相同的大小。
stacklevel=2,
)
如果 size_average 不为 None 或 reduce 不为 None：
reduction = _Reduction.legacy_get_string(size_average, reduce)
expanded_input, expanded_target = torch.broadcast_tensors(input, target)
if beta == 0.0:
return torch._C._nn.l1_loss(
expanded_input, expanded_target, _Reduction.get_enum(reduction)
)
else:
return torch._C._nn.smooth_l1_loss(
expanded_input, expanded_target, _Reduction.get_enum(reduction), beta
)
[文档]
定义
胡伯损失(
输入:
张量,
目标:
张量,
缩减:
字符串 =
平均值,
Δ:
浮点数 = 1.0,
重量:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量:
rhuber_loss(input, target, reduction='mean', delta=1.0, weight=None) -> Tensor
计算 Huber 损失，可选加权。
函数在元素级误差低于 delta 时使用平方项，否则使用 delta 缩放的 L1 项。
函数使用平方项如果元素级误差低于 delta，否则使用 delta 缩放的 L1 项。
当 delta 等于 1 时，此损失函数等同于 SmoothL1Loss。
通常情况下，Huber 损失与 SmoothL1Loss 的差别是一个 delta（也称为 Smooth L1 中的 beta）的系数。
参数：
input (Tensor): 预测值。
target (Tensor): 真实值。
reduction（字符串，可选）：指定应用于输出的缩减
'none' | 'mean' | 'sum'。'mean'：取输出平均值。
'求和：输出将被求和。无：不应用任何缩减。'
默认：'平均'。
delta (浮点数，可选): 在 delta-scaled L1 和 L2 损失之间切换的阈值。默认：1.0。
权重（张量，可选）：每个样本的权重。默认：None。
返回：
张量：Huber 损失（可选加权）。
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量):
返回 handle_torch_function(
胡伯损失,
(输入,
目标,
重量),
输入,
目标,
缩减=
缩减,
Δ=
Δ,
重量=
重量,
)
如果
不 (
目标.
尺寸() ==
输入.
尺寸()):
警告.
警告(
f使用一个与输入大小不同的目标大小（{
目标.
尺寸()}
）{
输入.
尺寸()}
)。"
"这可能会因为广播而导致结果不正确。"
"请确保它们具有相同的大小。",
栈级别=2,
)
扩展输入,
扩展目标 = torch.
广播张量(
输入,
目标)
如果
权重
是
无:
使用优化的 C++后端进行标准 Huber 损失
返回 torch._C._nn.
胡伯损失(
扩展输入,
扩展目标,
_减少.
获取枚举(
缩减), delta
)
else:
如果
重量.
尺寸() !=
输入.
尺寸():
raise ValueError(权重和输入必须具有相同的大小。)
首先计算未加权的损失
未加权损失 = torch._C._nn.
胡伯损失(
扩展输入,
扩展目标,
_减少.
获取枚举(
无), delta
)
# 将权重应用于未加权的损失
加权损失 =
未加权损失 *
权重
如果
减少 ==
无:
返回
加权损失
elif 减少 ==
"求和":
返回 torch.
总和(
加权损失)
elif 减少 ==
平均值:
返回
加权损失.
均值()
else:
raise ValueError(
f"无效的减少模式："{
缩减}
. 预期的是 'none'、'mean' 或 'sum' 之一。
)
[文档]
定义
l1_loss：L1 损失(
输入:
张量,
目标:
张量,
平均大小:
可选[
布尔] =
无,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
重量:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量: # noqa: D400,D402
rl1_loss(input, target, size_average=None, reduce=None, reduction='mean') -> Tensor
函数用于计算元素间平均的绝对值差。
详细信息请参阅 :class:`~torch.nn.L1Loss`。
"文档"
如果 has_torch_function_variadic(
输入,
目标):
返回 handle_torch_function(
l1_loss：L1 损失,
(输入,
目标,
重量),
输入,
目标,
平均大小=
平均大小,
减少=
减少,
缩减=
缩减,
)
如果
不 (
目标.
尺寸() ==
输入.
尺寸()):
警告.
警告(
f使用一个与输入大小不同的目标大小（{
目标.
尺寸()}
）{
输入.
尺寸()}
)。"
"这可能会因为广播而导致结果不正确。"
"请确保它们具有相同的大小。",
栈级别=2,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减少 =
_减少.
旧版获取字符串(
平均大小,
减少)
扩展输入,
扩展目标 = torch.
广播张量(
输入,
目标)
如果
权重
是
不
无:
如果
重量.
尺寸() !=
输入.
尺寸():
raise ValueError(权重和输入必须具有相同的大小。)
绝对误差 = torch.
绝对值(
扩展输入 -
扩展目标)
加权绝对误差 =
绝对误差 *
权重
如果
减少 ==
无:
返回
加权绝对误差
elif 减少 ==
"求和":
返回 torch.
总和(
加权绝对误差)
elif 减少 ==
平均值:
返回 torch.
总和(
加权绝对误差) / torch.
总和(
重量)
else:
raise ValueError(
f"无效的减少模式："{
缩减}
. 预期的是 'none'、'mean' 或 'sum' 之一。
)
else:
返回 torch._C._nn.
l1_loss：L1 损失(
扩展输入,
扩展目标,
_减少.
获取枚举(
缩减)
)
[文档]
定义 mse_loss(
输入:
张量,
目标:
张量,
平均大小:
可选[
布尔] =
无,
减少:
可选[
布尔] =
无,
缩减:
字符串 =
平均值,
重量:
可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 张量:
rmse_loss(input, target, size_average=None, reduce=None, reduction='mean', weight=None) -> Tensor
测量元素级的均方误差，可选加权。
参数：
input (Tensor): 预测值。
target (Tensor): 真实值。
size_average (bool, 可选): 已废弃（使用 reduction）。
reduce (bool, 可选): 已废弃（使用 reduction）。
reduction（字符串，可选）：指定应用于输出的缩减
'none' | 'mean' | 'sum'。'mean'：取输出平均值。
'求和：输出将被求和。无：不应用任何缩减。'
默认：'平均'。
权重（张量，可选）：每个样本的权重。默认：None。
返回：
张量：均方误差损失（可选加权）。'
"文档"
如果 has_torch_function_variadic(
输入,
目标,
重量):
返回 handle_torch_function(
mse_loss,
(输入,
目标,
重量),
输入,
目标,
平均大小=
平均大小,
减少=
减少,
缩减=
缩减,
重量=
重量,
)
如果
不 (
目标.
尺寸() ==
输入.
尺寸()):
警告.
警告(
f使用一个与输入大小不同的目标大小（{
目标.
尺寸()}
）{
输入.
尺寸()}
)。"
"这可能会因为广播而导致结果不正确。"
"请确保它们具有相同的大小。",
栈级别=2,
)
如果 size_average
是
不
无
或者 reduce
是
不
无:
减少 =
_减少.
旧版获取字符串(
平均大小,
减少)
扩展输入,
扩展目标 = torch.
广播张量(
输入,
目标)
如果
权重
是
不
无:
如果
重量.
尺寸() !=
输入.
尺寸():
raise ValueError(权重和输入必须具有相同的大小。)
手动执行加权均方误差损失
平方误差 = torch.pow(
扩展输入 -
扩展目标, 2)
加权平方误差 =
平方误差 *
权重
如果
减少 ==
无:
返回
加权平方误差
elif 减少 ==
"求和":
返回 torch.
总和(
加权平方误差)
elif 减少 ==
平均值:
返回 torch.
总和(
加权平方误差) / torch.
总和(
重量)
else:
raise ValueError(
f"无效的减少模式："{
缩减}
. 预期的是 'none'、'mean' 或 'sum' 之一。
)
else:
返回 torch._C._nn.mse_loss(
扩展输入,
扩展目标,
_减少.
获取枚举(
缩减)
)
[文档]def margin_ranking_loss(
输入 1: Tensor,
输入 2: Tensor,
目标: Tensor,
margin: 浮点数 = 0,
size_average: 可选[布尔] = None,
reduce: 可选[布尔] = None,
reduction: 字符串 = "mean",
) -> 张量: # noqa: D400,D402
r"""边缘排序损失(input1, input2, 目标, margin=0, size_average=None, reduce=None, reduction='mean') -> 张量
详细信息请参阅 :class:`~torch.nn.MarginRankingLoss`
"""
if has_torch_function_variadic(input1, input2, target):
return handle_torch_function(
margin_ranking_loss,
(input1, input2, target),
输入 1,
输入 2,
目标，
边距=边距，
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为 None 或 reduce 不为 None：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
如果 input1 的维度不等于 input2 的维度，或者 input1 的维度不等于 target 的维度：
raise RuntimeError(
f"margin_ranking_loss : 所有输入张量应具有相同的维度，但得到了以下大小："
f"input1: {input1.size()}, input2: {input2.size()}, target: {target.size()} "
)
返回 torch.margin_ranking_loss(input1, input2, target, margin, reduction_enum)
[文档]def hinge_embedding_loss(
输入: Tensor,
目标: Tensor,
边距: float = 1.0,
size_average: 可选[bool] = None,
reduce: 可选[bool] = None,
reduction: str = "mean",
) -> Tensor: # noqa: D400,D402
r"""hinge_embedding_loss(input, target, margin=1.0, size_average=None, reduce=None, reduction='mean') -> Tensor
查看详细信息请参阅 :class:`~torch.nn.HingeEmbeddingLoss`。
"""
if has_torch_function_variadic(input, target):
return handle_torch_function(
hinge_embedding_loss,
(input, target),
input,
target,
margin=margin,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为空或 reduce 不为空：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
return torch.hinge_embedding_loss(input, target, margin, reduction_enum)
[文档]def multilabel_margin_loss(
输入: Tensor,
目标: Tensor,
size_average: Optional[bool] = None,
reduce: Optional[bool] = None,
reduction: str = "mean",
) -> Tensor: # noqa: D400,D402
r"""多标签边缘损失(input, target, size_average=None, reduce=None, reduction='mean') -> Tensor
查看详细信息请参阅：:class:`~torch.nn.MultiLabelMarginLoss`
"""
如果 has_torch_function_variadic(input, target) 为真：
返回 handle_torch_function(
多标签边缘损失,
(输入，目标),
输入,
目标,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为 None 或 reduce 不为 None：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
return torch._C._nn.multilabel_margin_loss(input, target, reduction_enum)
[文档]def soft_margin_loss(
输入: Tensor,
目标: Tensor,
size_average: Optional[bool] = None,
reduce: Optional[bool] = None,
reduction: str = "mean",
) -> Tensor: # noqa: D400,D402
r"""
soft_margin_loss(input, target, size_average=None, reduce=None, reduction='mean') -> Tensor
详细信息请参阅 :class:`~torch.nn.SoftMarginLoss`。
"""
if has_torch_function_variadic(input, target):
return handle_torch_function(
soft_margin_loss,
(input, target),
input,
target,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为 None 或者 reduce 不为 None：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
否则：
reduction_enum = _Reduction.get_enum(reduction)
return torch._C._nn.soft_margin_loss(input, target, reduction_enum)
[文档]def multilabel_soft_margin_loss(
输入: Tensor,
目标: Tensor,
权重: Optional[Tensor] = None,
size_average: 可选[bool] = None,
reduce: 可选[bool] = None,
reduction: str = "mean",
) -> Tensor: # noqa: D400,D402
r"""多标签软边界损失(input, target, weight=None, size_average=None, reduce=None, reduction='mean') -> Tensor"""
查看文档 :class:`~torch.nn.MultiLabelSoftMarginLoss` 获取详细信息。
"""
if has_torch_function_variadic(input, target, weight):
return handle_torch_function(
multilabel_soft_margin_loss,
(input, target, weight),
input,
target,
weight=weight,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为空或 reduce 不为空：
reduction = _Reduction.legacy_get_string(size_average, reduce)
loss = -(target * logsigmoid(input) + (1 - target) * logsigmoid(-input))
if weight is not None:
loss = loss * weight
class_dim = input.dim() - 1
C = 输入的大小(class_dim)
loss = loss.sum(dim=class_dim) / C # 仅返回 N 个 loss 值
if reduction == "none":
ret = loss
elif reduction == "mean":
ret = loss.mean()
elif reduction == "sum":
ret = loss.sum()
else:
ret = input
raise ValueError(减少 + " 无效")
return ret
[文档]def 余弦嵌入损失(
输入 1: 张量,
输入 2: 张量,
目标: 张量,
margin: 浮点数 = 0,
size_average: 可选[布尔] = None,
reduce: 可选[布尔] = None,
reduction: 字符串 = "mean",
) -> 张量: # noqa: D400,D402
r"""余弦嵌入损失(input1, input2, 目标, margin=0, size_average=None, reduce=None, reduction='mean') -> 张量
详细信息请参阅 :class:`~torch.nn.CosineEmbeddingLoss`。
"""
if has_torch_function_variadic(input1, input2, target):
return handle_torch_function(
余弦嵌入损失,
(input1, input2, target),
输入 1,
输入 2,
目标，
边距=边距，
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为 None 或 reduce 不为 None：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
返回 torch.cosine_embedding_loss(input1, input2, target, margin, reduction_enum)
[文档]def 多边损失(
输入: Tensor,
目标: Tensor,
p: int = 1,
margin: 浮点数 = 1.0,
weight: 可选[Tensor] = None,
size_average: 可选[布尔] = None,
reduce: 可选[布尔] = None,
reduction: str = "mean",
) -> Tensor: # noqa: D400,D402
r"""多边损失(input, target, p=1, margin=1, weight=None, size_average=None, reduce=None, reduction='mean') -> Tensor
查看详情请见 :class:`~torch.nn.MultiMarginLoss`。
"""
如果具有 torch_function_variadic(input, target, weight):
返回 handle_torch_function(
multi_margin_loss,
(输入，目标，权重)
输入
目标
p=p
margin=margin,
weight=weight,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为空或 reduce 不为空：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
if p != 1 and p != 2:
raise ValueError("only p == 1 and p == 2 supported")
如果 weight 不为 None：
如果 weight.dim()不等于 1：
抛出 ValueError 异常("weight 必须是一维的")
return torch._C._nn.multi_margin_loss(
输入，目标，p，边距，权重，减少枚举
)
像素混淆 =
_添加文档字符串(
torch.pixel_shuffle,
r""
像素混淆(input, upscale_factor) -> 张量
重新排列形状为 :math:`(*, C \times r^2, H, W)` 的张量中的元素
张量形状为 :math:`(*, C, H \times r, W \times r)`，其中 r 是 :attr:`upscale_factor`。
查看 :class:`~torch.nn.PixelShuffle` 以获取详细信息。
参数：
输入（张量）：输入张量
upscale_factor (int): 用于增加空间分辨率的因子
示例::
>>> input = torch.randn(1, 9, 4, 4)
>>> output = torch.nn.functional.pixel_shuffle(input, 3)
>>> 打印(output.size())
torch.Size([1, 1, 12, 12])
""",
)
pixel_unshuffle = _添加文档字符串(
torch.像素重排,
r""
pixel_unshuffle(input, downscale_factor) -> Tensor
通过重新排列元素来反转 :class:`~torch.nn.PixelShuffle` 操作
将形状为 :math:`(*, C, H \times r, W \times r)` 的张量转换为形状为
math:`(*, C \times r^2, H, W)` 的张量，其中 r 是 :attr:`downscale_factor`
请参阅：class:`~torch.nn.PixelUnshuffle` 以获取详细信息。
参数：
输入（张量）：输入张量
downscale_factor（整数）：通过该因子增加空间分辨率
示例::
>>> input = torch.randn(1, 1, 12, 12)
>>> output = torch.nn.functional.pixel_unshuffle(input, 3)
>>> 打印(output.size())
torch.Size([1, 9, 4, 4])
""",
)
channel_shuffle = _添加文档字符串(
torch.频道洗牌,
r""
channel_shuffle(input, groups) -> 索引张量
将形状为 :math:`(*, C , H, W)` 的张量中的通道进行划分
将文本分组为 g 组，并重新排列为：(*, C(g), g, H, W)
保持原始张量形状。
请参阅：class:`~torch.nn.ChannelShuffle` 以获取详细信息。
参数：
输入（张量）：输入张量
groups（整数）：将通道划分成多少组以及重新排列的数目。
示例::
>>> input = torch.randn(1, 4, 2, 2)
>>> print(input)
[[[[1, 2],
[3, 4]
[[5, 6]]
[7, 8]
[[9, 10]]
[11, 12]
[[13, 14]]
[15, 16]
]]
>>> output = torch.nn.functional.channel_shuffle(input, 2)
>>> print(output)
[[[[1, 2],
[3, 4]
[[9, 10]]
[11, 12]
[[5, 6]]
[7, 8]
[[13, 14]]
[15, 16]
]]
""",
)
原生通道随机 =
_添加文档字符串(
torch.本地频道随机打乱,
r""
native_channel_shuffle(input, groups) -> 张量
`channel_shuffle`的原生内核级实现。
此函数可能在未来的版本中变为私有，请谨慎使用。
将形状为 :math:`(*, C , H, W)` 的张量中的通道进行划分
将文本分组为 g 组，并重新排列为：(*, C(g), g, H, W)
保持原始张量形状。
请参阅：class:`~torch.nn.ChannelShuffle` 以获取详细信息。
参数：
输入（张量）：输入张量
groups（整数）：将通道划分成多少组以及重新排列的数目。
示例::
>>> input = torch.randn(1, 4, 2, 2)
>>> print(input)
[[[[1, 2],
[3, 4]
[[5, 6]]
[7, 8]
[[9, 10]]
[11, 12]
[[13, 14]]
[15, 16]
]]
>>> output = torch.nn.functional.native_channel_shuffle(input, 2)
>>> print(output)
[[[[1, 2],
[3, 4]
[[9, 10]]
[11, 12]
[[5, 6]]
[7, 8]
[[13, 14]]
[15, 16]
]]
""",
)
@_overload
定义
上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[float] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
通过
@_overload
定义
上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[float] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
通过
[文档]
定义
上采样( # noqa: F811
输入,
尺寸=
无,
缩放因子=
无,
模式=
最近邻,
align_corners=无,
):
r上采样输入。
提供的张量被上采样到给定的 :attr:`size` 或给定的
使用哪种插值算法由 :attr:`mode` 决定。
.. 警告::
此函数已被弃用，推荐使用 :func:`torch.nn.functional.interpolate`。
这与 ``nn.functional.interpolate(...)`` 等效。
注意：
{backward_reproducibility_note}
上采样所使用的算法由 :attr:`mode` 决定。
目前支持时间、空间和体积上采样，即
预期输入形状为 3-D、4-D 或 5-D。
输入维度以以下形式解释：
`批大小 x 通道 x [可选深度] x [可选高度] x 宽度`。
可用的上采样模式有：`最近邻`、`线性`（仅 3D）、
`双线性`、`双三次`（仅 4D）、`三线性`（仅 5D）
参数：
输入（张量）：输入张量
大小（int 或 Tuple[int]或 Tuple[int, int]或 Tuple[int, int, int]）：
输出空间大小。
scale_factor (浮点数或浮点数元组): 空间大小的乘数。如果是一个元组，必须与输入大小匹配。
mode (字符串): 用于上采样的算法：
``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
``'trilinear'``。默认值：``'nearest'``
align_corners (bool, 可选): 几何上，我们将输入和输出的像素视为正方形而不是点。
input and output as squares rather than points.
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
对于超出边界值，使此操作与输入大小无关
当保持 :attr:`scale_factor` 不变时。这仅在 :attr:`mode`
是 ``'线性'``、``'双线性'``、``'双三次'`` 或 ``'三线性'``。
默认：``False``
.. 注意::
使用 ``mode='双三次'`` 可能会导致溢出，换句话说，它可能会产生
负值或大于 255 的值，对于图像。
如果您想减少溢出，请显式调用 ``result.clamp(min=0, max=255)``。
。
.. 警告::
使用 `align_corners = True` 时，线性插值模式（`linear`、`bilinear` 和 `trilinear`）不会按比例对齐输出和输入像素，因此输出值可能取决于输入大小。这些模式在此版本之前默认就是这样。
这意味着输出和输入像素的比例关系不匹配，因此输出值可能取决于输入大小。
这意味着输出和输入像素的比例关系不匹配，因此输出值可能取决于输入大小。
这意味着输出和输入像素的比例关系不匹配，因此输出值可能取决于输入大小。
0.3.1. 从那时起，默认行为是 `align_corners = False`。
请参阅 :class:`~torch.nn.Upsample` 以获取具体示例。
这会影响输出。
"文档"
警告.
警告(
"`nn.functional.upsample` 已弃用。"
"请使用 `nn.functional.interpolate` 代替。",
栈级别=2,
)
返回 interpolate(
输入,
尺寸,
缩放因子,
模式, align_corners)
如果
上采样.__doc__:
上采样.__doc__ =
上采样.__doc__.
格式(**
可复现性说明)
定义
_是整数(x)
输入文本:
->
翻译:
-> 布尔:
r检查输入数字是否为整数。
对于 int、SymInt、Numpy 整数和具有整数元素的 Tensors，将返回 True。
"文档"
如果 isinstance(x, (
整数, torch.SymInt)):
返回
真实
如果 np
是
不
无
和 isinstance(x,
numpy.
整数):
返回
真实
返回 isinstance(x,
张量)
和
不 x.is_floating_point()
@_overload
定义 interpolate( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[
列表[float]] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
重新计算缩放因子:
可选[
布尔] =
无,
抗锯齿:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
通过
@_overload
定义 interpolate( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[
列表[float]] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
重新计算缩放因子:
可选[
布尔] =
无,
抗锯齿:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
通过
@_overload
定义 interpolate( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[float] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
重新计算缩放因子:
可选[
布尔] =
无,
抗锯齿:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
通过
@_overload
定义 interpolate( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[float] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
重新计算缩放因子:
可选[
布尔] =
无,
抗锯齿:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
通过
[文档]
定义 interpolate( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[
列表[float]] =
无,
模式:
字符串 =
最近邻,
align_corners: 可选[
布尔] =
无,
重新计算缩放因子:
可选[
布尔] =
无,
抗锯齿:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 张量:
# 无需注意：B950
r对输入进行下/上采样。
张量插值到给定的 :attr:`size` 或给定的 :attr:`scale_factor`。
使用哪种插值算法由 :attr:`mode` 决定。
算法用于插值的算法由 :attr:`mode` 决定。
目前支持时间、空间和体积采样，即
预期输入形状为 3-D、4-D 或 5-D。
输入维度以以下形式解释：
`批大小 x 通道 x [可选深度] x [可选高度] x 宽度`。
可用的缩放模式有：`最近邻`、`线性`（仅 3D）、
`双线性`、`双三次`（仅 4D）、`三线性`（仅 5D）、`区域`、`最近邻精确`
参数：
输入（张量）：输入张量
大小（int 或 Tuple[int]或 Tuple[int, int]或 Tuple[int, int, int]）：
输出空间大小。
scale_factor (浮点数或浮点数元组): 空间大小的乘数。如果 `scale_factor` 是元组，其长度必须与空间维度数匹配；`input.dim() - 2`。
其长度必须与空间维度数匹配；`input.dim() - 2`。
mode (字符串): 用于上采样的算法：
``'nearest'`` | ``'linear'`` | ``'bilinear'`` | ``'bicubic'`` |
``'trilinear'`` | ``'area'`` | ``'nearest-exact'``. 默认: ``'nearest'``
align_corners (bool, 可选): 几何上，我们将输入和输出的像素视为正方形而不是点。
input and output as squares rather than points.
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``True``，输入和输出张量将根据其角落像素的中心点对齐，保留角落像素的值。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
如果设置为 ``False``，输入和输出张量将根据其角像素的角点对齐，并且插值使用边缘值填充。
对于超出边界值，使此操作与输入大小无关
当保持 :attr:`scale_factor` 不变时。这仅在 :attr:`mode`
是 ``'线性'``、``'双线性'``、``'双三次'`` 或 ``'三线性'``。
默认：``False``
recompute_scale_factor (布尔值，可选)：重新计算 scale_factor 以用于
插值计算。如果 `recompute_scale_factor` 为 `True`，则
`scale_factor` 必须传入，并使用 `scale_factor` 来计算
输出 `size`。计算得到的输出 `size` 将用于推断插值的新尺度
注意，当 `scale_factor` 为浮点数时，它可能不同
由于四舍五入和精度问题，重新计算的 `scale_factor`。
如果 `recompute_scale_factor` 为 ``False``，则直接使用 `size` 或 `scale_factor` 进行插值。默认：``None``。
抗锯齿（bool，可选）：应用抗锯齿的标志。默认：``False``。使用抗锯齿
(bool, 可选): 应用抗锯齿的标志。默认：``False``。使用抗锯齿
与 `align_corners=False` 选项一起，插值结果将与 Pillow 相匹配
下采样操作的输出结果。支持的模式：`'bilinear'`、`'bicubic'`
.. 注意::
使用 ``mode='双三次'`` 可能会导致溢出，换句话说，它可能会产生
负值或大于 255 的值，对于图像。
如果您想减少溢出，请显式调用 ``result.clamp(min=0, max=255)``。
。
.. 注意::
模式 `mode='nearest-exact'` 与 Scikit-Image 和 PIL 的最近邻插值算法相匹配
并修复了 `mode='nearest'` 的已知问题。此模式被引入以保持
向后兼容。
模式 `mode='nearest'` 与有缺陷的 OpenCV 的 `INTER_NEAREST` 插值算法匹配。
.. 注意::
在 CUDA 上，对于 `float16` 数据类型的梯度在上采样操作中可能不准确。
当使用模式 `['linear', 'bilinear', 'bicubic', 'trilinear', 'area']` 时。
更多详情，请参阅讨论内容
issue#104157 _.
注意：
{backward_reproducibility_note}
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
interpolate,
(输入,),
输入,
尺寸=
尺寸,
缩放因子=
缩放因子,
模式=
模式,
align_corners=align_corners,
重新计算缩放因子=
重新计算缩放因子,
抗锯齿=
抗锯齿,
)
如果
模式
在 (
最近邻,
面积,
"最近邻精确"):
如果
对齐角落
是
不
无:
raise ValueError(
"“对齐角点”选项只能与以下内容一起设置"
"插值模式：线性 | 双线性 | 双三次 | 三线性"
)
else:
如果
对齐角落
是
无:
对齐角落 =
假
维度 =
输入.
暗() - 2
# 空间维度数量。
处理大小和 scale_factor。验证是否恰好设置了一个。
如果它是列表，则验证其长度；如果是标量，则扩展它。
在此块之后，output_size 和 scale_factors 中恰好有一个非 None，并且它将是一个列表（或元组）。
将非 None 值设为列表（或元组）。
如果
大小
是
不
无
和
缩放系数
是
不
无:
raise ValueError("仅应定义大小或缩放因子之一")
elif 大小
是
不
无:
断言
缩放系数
是
无
缩放系数 =
无
如果 isinstance(
尺寸, (
列表,
元组)):
如果
长度(
尺寸) !=
暗:
raise ValueError(
"输入和输出必须具有相同的空间维度，但得到了 "
f"具有空间维度的输入 "{
列表(
输入.
形状[2:])}
并且输出大小为{
尺寸}
.
"请提供输入张量，格式为 (N, C, d1, d2, ...,dK) "
"以(o1, o2, ...,oK)格式输出大小。"
)
如果
不 torch.
算子.
是否正在脚本化():
如果
不
所有(
_是整数(x) for x
在
尺寸):
raise 类型错误(
"期望大小为 int 或 Tuple[int] 或 Tuple[int, int] 或 Tuple[int, int, int]，但得到的大小类型为"
f"但得到的大小类型为"{[
类型(x) for x
在
尺寸]}"
)
输出大小 =
大小
else:
输出大小 = [
大小 for _
在
范围(
暗)]
elif 缩放系数
是
不
无:
断言
大小
是
无
输出大小 =
无
如果 isinstance(
缩放因子, (
列表,
元组)):
如果
长度(
缩放因子) !=
暗:
raise ValueError(
"输入和 scale_factor 必须具有相同的空间维度，但"
f"得到了具有以下空间维度的输入"{
列表(
输入.
形状[2:])}
和
f形状的 scale_factor{
缩放因子}
.
"请提供输入张量，格式为 (N, C, d1, d2, ...,dK) "
"尺度因子格式为 (s1, s2, ...,sK) 。"
)
缩放系数 =
缩放系数
else:
缩放系数 = [
缩放系数 for _
在
范围(
暗)]
else:
raise ValueError("大小或 scale_factor 必须定义")
如果 (
recompute_scale_factor 是
不
无
和 recompute_scale_factor
和
大小
是
不
无
):
raise ValueError(
"在显式大小的情况下，重新计算 scale_factor 没有意义。"
)
"区域"模式始终需要显式的大小而不是缩放因子。
重新使用 recompute_scale_factor 代码路径。
如果
模式 ==
面积
和
输出大小
是
无:
recompute_scale_factor = 真实
如果 recompute_scale_factor
是
不
无
和
重新计算缩放因子:
我们在这里计算输出大小，然后取消设置缩放因子。
C++代码将根据（整数）输出大小重新计算它。
断言
缩放系数
是
不
无
如果
不 torch.
算子.
是否正在脚本化()
和 torch._C.
_获取追踪状态():
在跟踪时将 scale_factor 转换为张量，以便常量不会烘焙进去
输出大小 = [
(
torch.向下取整(
(
输入.
尺寸(i + 2).float()
* torch.张量(
缩放因子[i
]
数据类型=torch.float32)
).float()
)
)
for i 在
范围(
暗)
]
elif torch.算子.
是否正在脚本化():
输出大小 = [
整数(
数学.
向下取整(float(
输入.
尺寸(i + 2)) *
缩放因子[i]))
for i 在
范围(
暗)
]
else:
输出大小 = [
_sym_int(输入.
尺寸(i + 2) *
缩放因子[i]) for i
在
范围(
暗)
]
缩放系数 =
无
如果
抗锯齿
和
不 (
模式
在 (
双线性,
双三次)
和
输入.
维数 == 4):
raise ValueError(
抗锯齿选项仅限于双线性双三次模式，并需要 4 维张量作为输入
)
如果
输入.
暗() == 3
和
模式 ==
最近邻:
返回 torch._C._nn.
上采样最近邻 1D(
输入, output_size,
缩放因子)
如果
输入.
暗() == 4
和
模式 ==
最近邻:
返回 torch._C._nn.upsample_nearest2d(
输入, output_size,
缩放因子)
如果
输入.
暗() == 5
和
模式 ==
最近邻:
返回 torch._C._nn.
最近邻上采样 3D(
输入, output_size,
缩放因子)
如果
输入.
暗() == 3
和
模式 ==
"最近邻精确":
返回 torch._C._nn._upsample_nearest_exact1d(
输入, output_size,
缩放因子)
如果
输入.
暗() == 4
和
模式 ==
"最近邻精确":
返回 torch._C._nn.
_最近邻精确 2d 上采样(
输入, output_size,
缩放因子)
如果
输入.
暗() == 5
和
模式 ==
"最近邻精确":
返回 torch._C._nn._upsample_nearest_exact3d(
输入, output_size,
缩放因子)
如果
输入.
暗() == 3
和
模式 ==
面积:
断言
输出大小
是
不
无
返回 adaptive_avg_pool1d(
输入, output_size)
如果
输入.
暗() == 4
和
模式 ==
面积:
断言
输出大小
是
不
无
返回 adaptive_avg_pool2d(
输入, output_size)
如果
输入.
暗() == 5
和
模式 ==
面积:
断言
输出大小
是
不
无
返回
自适应平均池化 3D(
输入, output_size)
如果
输入.
暗() == 3
和
模式 ==
线性:
断言
对齐角落
是
不
无
返回 torch._C._nn.
upsample_linear1d（线性 1D 上采样）(
输入, output_size, align_corners,
缩放系数
)
如果
输入.
暗() == 4
和
模式 ==
双线性:
断言
对齐角落
是
不
无
如果
抗锯齿:
返回 torch._C._nn._upsample_bilinear2d_aa(
输入, output_size, align_corners,
缩放系数
)
# 两个级别是必要的，以防止 TorchScript 触及
# are_deterministic_algorithms_enabled.
如果
不 torch.
算子.
是否正在脚本化():
如果 torch.
是否启用了确定性算法()
和 (
输入.is_cuda
或者
输入.
是_xpu
):
# 使用慢速反编译，其反向操作将涉及 index_put
# 需要 importlib，因为导入不能是顶层
# （循环）且不能嵌套（TS 不支持）
返回 importlib.
导入模块(
torch._decomp.分解
)._上采样线性向量(
输入, output_size, align_corners,
缩放因子)
返回 torch._C._nn.upsample_bilinear2d(
输入, output_size, align_corners,
缩放系数
)
如果
输入.
暗() == 5
和
模式 ==
三线性:
断言
对齐角落
是
不
无
返回 torch._C._nn.
三线性上采样 3D(
输入, output_size, align_corners,
缩放系数
)
如果
输入.
暗() == 4
和
模式 ==
双三次:
断言
对齐角落
是
不
无
如果
抗锯齿:
返回 torch._C._nn._upsample_bicubic2d_aa(
输入, output_size, align_corners,
缩放系数
)
返回 torch._C._nn.upsample_bicubic2d(
输入, output_size, align_corners,
缩放系数
)
如果
输入.
暗() == 3
和
模式 ==
双线性:
raise 不支持的操作异常(
"输入为 3D，但双线性模式需要 4D 输入")
如果
输入.
暗() == 3
和
模式 ==
三线性:
raise 不支持的操作异常(
"收到 3D 输入，但三线性模式需要 5D 输入")
如果
输入.
暗() == 4
和
模式 ==
线性:
raise 不支持的操作异常(
"收到 4D 输入，但线性模式需要 3D 输入")
如果
输入.
暗() == 4
和
模式 ==
三线性:
raise 不支持的操作异常(
"输入为 4D，但三线性模式需要 5D 输入")
如果
输入.
暗() == 5
和
模式 ==
线性:
raise 不支持的操作异常(
"输入为 5D，但线性模式需要 3D 输入")
如果
输入.
暗() == 5
和
模式 ==
双线性:
raise 不支持的操作异常(
"输入为 5D，但双线性模式需要 4D 输入")
raise 不支持的操作异常(
"输入错误：仅支持 3D、4D 和 5D 输入张量"
f"（获取了"{
输入.
暗()}
D）对于模式：最近邻 | 线性 | 双线性 | 双三次 | 三线性 | 面积 | 最近邻精确
f"（获取了"{
模式})"
)
如果 interpolate.__doc__:
interpolate.__doc__ = interpolate.__doc__.格式(**
可复现性说明)
@_overload
定义
最近邻上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[float] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
@_overload
定义
最近邻上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[float] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
[文档]def upsample_nearest(input, size=None, scale_factor=None): # noqa: F811
r"""使用最近邻像素值上采样输入。"""
.. 警告::
此函数已被弃用，建议使用 :func:`torch.nn.functional.interpolate`。
这与 `nn.functional.interpolate(..., mode='nearest')` 等价。
目前支持空间和体积上采样（即输入应为 4 或 5 维）。
输入是 4 或 5 维）。
参数：
输入（张量）：输入
大小（int 或 Tuple[int, int] 或 Tuple[int, int, int]）：输出空间
大小。
scale_factor（int）：空间大小的乘数。必须是一个整数。
备注：
{向后可重现性备注}
"""
默认情况下忽略 DeprecationWarning 警告
warnings.warn(
"``nn.functional.upsample_nearest`` 已弃用。"
"请使用 ``nn.functional.interpolate`` 代替。"
stacklevel=2,
)
返回 interpolate(input, size, scale_factor, mode="nearest")
如果
最近邻上采样.__doc__:
最近邻上采样.__doc__ =
最近邻上采样.__doc__.
格式(**
可复现性说明)
@_overload
定义
双线性上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[float] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
@_overload
定义
双线性上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[float] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
@_overload
定义
双线性上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
整数] =
无,
缩放因子:
可选[
列表[float]] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
@_overload
定义
双线性上采样( # noqa: F811
输入:
张量,
尺寸:
可选[
列表[
整数]] =
无,
缩放因子:
可选[
列表[float]] =
无,
)
输入文本:
->
翻译:
-> 张量:
通过
[文档]def upsample_bilinear(input, size=None, scale_factor=None): # noqa: F811
r"""对输入进行上采样，使用双线性上采样。
.. 警告::
该函数已被弃用，建议使用 :func:`torch.nn.functional.interpolate`。
这与等效
``nn.functional.interpolate(..., mode='bilinear', align_corners=True)``.
预期输入是空间（4 维）。使用 `upsample_trilinear` 对
体积（5 维）输入。
Args:
输入 (Tensor): 输入
大小 (int 或 Tuple[int, int]): 输出空间大小。
scale_factor (int 或 Tuple[int, int]): 空间大小的乘数
备注：
{向后可重现性备注}
"""
默认情况下忽略 DeprecationWarning 警告
warnings.warn(
"``nn.functional.upsample_bilinear`` 已弃用。"
"请使用 ``nn.functional.interpolate`` 代替。"
stacklevel=2,
)
return interpolate(input, size, scale_factor, mode="bilinear", align_corners=True)
如果
双线性上采样.__doc__:
双线性上采样.__doc__ =
双线性上采样.__doc__.
格式(
**可复现性说明
)
网格采样插值模式 = {
双线性: 0,
最近邻: 1,
双三次: 2,
}
网格样本填充模式 = {
零: 0,
边界: 1,
反射: 2,
}
[文档]
定义
网格采样(
输入:
张量,
网格:
张量,
模式:
字符串 =
双线性,
填充模式:
字符串 =
零,
align_corners: 可选[
布尔] =
无,
)
输入文本:
->
翻译:
-> 张量:
r计算网格样本。
给定一个 :attr:`输入` 和一个流场 :attr:`网格`，使用 :attr:`输入` 值和 :attr:`网格` 中的像素位置计算 ``输出``。
目前，仅支持空间（4-D）和体积（5-D）:attr:`输入`。
目前，仅支持空间（4-D）和体积（5-D）:attr:`输入`。
不支持。
在空间（4-D）情况下，对于形状为 :attr:`input` 的 :math:`(N, C, H_\text{in}, W_\text{in})` 和形状为 :attr:`grid` 的 :math:`(N, H_\text{out}, W_\text{out}, 2)`，输出将具有形状
math:`(N, H_\text{out}, W_\text{out})`。
math:`(N, C, H_\text{out}, W_\text{out})`。
math:`(N, C, H_\text{out}, W_\text{out})`。
对于每个输出位置 `output[n, :, h, w]`，大小为 2 的向量
`grid[n, h, w]` 指定了 :attr:`input` 像素位置 `x` 和 `y`，
这些位置用于插值输出值 `output[n, :, h, w]`。
对于 5D 输入，`grid[n, d, h, w]` 指定了
``x``、``y``、``z`` 像素位置用于插值
``output[n, :, d, h, w]``。:attr:`mode` 参数指定 ``nearest`` 或
``bilinear`` 插值方法来采样输入像素。
attr:`grid` 指定采样像素位置，按归一化处理
输入的：attr:`input` 空间维度。因此，它应该具有大多数值在
范围 ``[-1, 1]`` 内。例如，值 ``x = -1, y = -1`` 是：attr:`input` 的
左上像素，而值 ``x = 1, y = 1`` 是：attr:`input` 的
右下像素。
如果 :attr:`grid` 的值超出 ``[-1, 1]`` 范围
输出处理方式由 :attr:`padding_mode` 定义。选项有
* ``padding_mode="zeros"``: 使用 ``0`` 对越界网格位置进行填充
* ``padding_mode="border"``: 使用边界值处理超出网格范围的网格位置，
* ``padding_mode="reflection"``: 使用边界反射的值
边界外的网格位置。对于远离边界的位置，
它将不断反射，直到变为边界内，例如，（归一化）像素位置 ``x = -3.5`` 通过边界 ``-1`` 反射
，例如，（归一化）像素位置 ``x = -3.5`` 通过边界 ``-1`` 反射
然后通过边界“1”反射变为“x' = 1.5”
“x'' = -0.5”
注意：
此函数通常与：func:`affine_grid`一起使用
构建空间变换网络_。
注意：
使用 CUDA 后端时，此操作可能引起非确定性
行为在其反向传播中不易关闭。
请参阅：doc:`/notes/randomness` 中的笔记以获取背景信息。
注意：
在 :attr:`grid` 中的 NaN 值将被解释为 ``-1``。
参数：
输入 (Tensor)：形状为 :math:`(N, C, H_\text{in}, W_\text{in})` 的输入 (4-D 情况)
或 :math:`(N, C, D_\text{in}, H_\text{in}, W_\text{in})` (5-D 情况)
grid (Tensor)：形状为 :math:`(N, H_\text{out}, W_\text{out}, 2)` 的流场 (4-D 情况)
或 :math:`(N, D_\text{out}, H_\text{out}, W_\text{out}, 3)` (5-D 情况)
模式 (str)：计算输出值的插值模式
``'bilinear'`` | ``'nearest'`` | ``'bicubic'``. 默认: ``'bilinear'`
注意：``mode='bicubic'`` 只支持 4-D 输入。
当`mode='bilinear'`且输入为 5-D 时，插值模式
实际上在内部使用将是三线性。然而，当输入是 4-D 时，
插值模式将合法地是双线性。
padding_mode (str): 用于外部网格值的填充模式
``'zeros'`` | ``'border'`` | ``'reflection'``. 默认: ``'zeros'``
align_corners (bool, 可选): 几何上，我们将输入和输出的像素视为正方形而不是点。
input 作为正方形而不是点。
如果设置为 ``True``，则极值（``-1`` 和 ``1``）被视为引用
将其设置为 ``False`` 时，则被视为指向输入的角像素的角点。
否则，它们被视为指向输入的角像素的角点。
这样可以使采样更加分辨率无关。
此选项与 ``align_corners`` 选项相对应。
func:`interpolate`，因此这里使用哪个选项
应该在那里也使用它来在网格采样之前调整输入图像的大小。
默认：``False``
返回：
输出（张量）：输出张量
.. _`空间变换网络`:
https://arxiv.org/abs/1506.02025
.. 警告::
当 ``align_corners = True`` 时，网格位置取决于像素
输入图像大小的相对大小，因此在不同分辨率下（即放大或缩小后）采样的位置将不同
func:`grid_sample` 的结果将因输入分辨率的不同而不同
（即，在放大或缩小后）。版本 1.2.0 之前的默认行为是 ``align_corners = True``。
版本 1.2.0 之前的默认行为是 ``align_corners = True``。
自那时起，默认行为已更改为 `align_corners = False`，
以使其与 :func:`interpolate` 的默认值保持一致。
.. 注意::
``mode='bicubic'`` 使用 `三次卷积算法`_，其中 :math:`\alpha=-0.75`。
常数 :math:`\alpha` 在不同的包中可能会有所不同。
例如，`PIL`_ 和 `OpenCV`_ 分别使用 -0.5 和 -0.75。
此算法可能会“超出”其插值值范围的限制。
例如，当对输入值[0, 255]进行插值时，可能会产生负值或大于 255 的值。
使用 :func:`torch.clamp` 函数对结果进行钳位，以确保它们在有效范围内。
.. _`三次卷积算法`: https://zh.wikipedia.org/wiki/Bicubic_interpolation
.. _`PIL`: https://github.com/python-pillow/Pillow/blob/4634eafe3c695a014267eefdce830b4a825beed7/src/libImaging/Resample.c#L51
.. _`OpenCV`: https://github.com/opencv/opencv/blob/f345ed564a06178670750bad59526cfa4033be55/modules/imgproc/src/resize.cpp#L908
"文档"
如果 has_torch_function_variadic(
输入,
网格):
返回 handle_torch_function(
网格采样,
(输入,
网格),
输入,
网格,
模式=
模式,
填充模式=
填充模式,
align_corners=align_corners,
)
如果
模式 !=
双线性
和
模式 !=
最近邻
和
模式 !=
双三次:
raise ValueError(
fnn.functional.grid_sample()：期望模式为 'bilinear'、'nearest' 或 'bicubic'，但得到：'{
模式}
)
如果 (
填充模式 !=
"零"
和
填充模式 !=
"边界"
和
填充模式 !=
反射
):
raise ValueError(
"nn.functional.grid_sample(): 预期填充模式 "
"应为 'zeros'、'border' 或 'reflection'，"
f但是得到了: '{
填充模式}
)
如果
模式 ==
双线性:
模式枚举 = 0
elif 模式 ==
最近邻:
模式枚举 = 1
else: # mode == 'bicubic'
模式枚举 = 2
如果
填充模式 ==
零:
填充模式枚举 = 0
elif 填充模式 ==
边界:
填充模式枚举 = 1
else: # 填充模式 == '反射'
填充模式枚举 = 2
如果
对齐角落
是
无:
警告.
警告(
"默认的 grid_sample 和 affine_grid 行为已更改"
"自 1.3.0 版本起更改为 align_corners=False。请指定"
"如果需要旧的行为，请指定 align_corners=True。"
"查看 grid_sample 的文档以获取详细信息。"
)
对齐角落 =
假
返回 torch.
网格采样器(
输入,
网格,
模式枚举, padding_mode_enum, align_corners)
[文档]
定义 affine_grid(
西塔:
张量,
尺寸:
列表[
整数
]
align_corners: 可选[
布尔] =
无,
)
输入文本:
->
翻译:
-> 张量:
r根据给定的仿射矩阵批处理：attr:`theta`，生成 2D 或 3D 流场（采样网格）。
.. 注意::
此函数通常与：func:`grid_sample`一起使用。
构建空间变换网络_。
参数：
theta (张量)：输入的仿射矩阵批次，形状为
(:math:`N \times 2 \times 3`) 用于 2D 或
(:math:`N \times 3 \times 4`) 用于 3D
size (torch.Size)：目标输出图像大小。
(:math:`N \times C \times H \times W` 对于 2D 或
math:`N \times C \times D \times H \times W` 对于 3D)
示例：torch.Size((32, 3, 24, 24))
align_corners (bool, 可选): 如果为 ``True``，则将 ``-1`` 和 ``1``
解释为角落像素的中心，而不是图像的角落。
请参阅 :func:`grid_sample` 获取更完整的描述。
由 :func:`affine_grid` 生成的网格应传递给 :func:`grid_sample`
使用相同的设置选项。
默认：``False``
返回：
输出（张量）：大小为 (:math:`N \times H \times W \times 2`) 的输出张量
.. _`空间变换网络`:
https://arxiv.org/abs/1506.02025
.. 警告::
当 ``align_corners = True`` 时，网格位置取决于像素
输入图像大小的相对大小，因此在不同分辨率下（即放大或缩小后）采样的位置将不同
func:`grid_sample` 的结果将因输入分辨率的不同而不同
（即，在放大或缩小后）。版本 1.2.0 之前的默认行为是 ``align_corners = True``。
版本 1.2.0 之前的默认行为是 ``align_corners = True``。
自那时起，默认行为已更改为 `align_corners = False`，
以使其与 :func:`interpolate` 的默认值保持一致。
.. 警告::
当 `align_corners = True` 时，对 1D 数据进行 2D 仿射变换以及
对 2D 数据进行 3D 仿射变换（即当其中一个空间维度
维度具有单位大小）是不明确的，也不是预期的用例。
当 `align_corners = False` 时，这不是问题。
在版本 1.2.0 之前，单位维度上的所有网格点都被任意地认为是 `-1`。
被任意地认为是 `-1`。
从版本 1.3.0 开始，在`align_corners = True`的情况下，所有网格点
沿着单位维度被认为是“0”
(输入图像的中心)。
"文档"
如果 has_torch_function_unary(
西塔):
返回 handle_torch_function(
affine_grid, (西塔,),
西塔,
尺寸, align_corners=
对齐角落
)
如果
对齐角落
是
无:
警告.
警告(
"默认的 grid_sample 和 affine_grid 行为已更改"
"自 1.3.0 版本起更改为 align_corners=False。请指定"
"如果需要旧的行为，请指定 align_corners=True。"
"查看 grid_sample 的文档以获取详细信息。"
)
对齐角落 =
假
# 在 theta 上强制使用浮点数据类型
如果
不
西塔.is_floating_point():
raise ValueError(
f预期 theta 为浮点类型，但得到了{
西塔.
数据类型}"
)
# 检查形状和大小是否匹配
如果
长度(
尺寸) == 4:
如果
西塔.
暗() != 3
或者
西塔.
形状[-2] != 2
或者
西塔.
形状[-1] != 3:
raise ValueError(
f预期一个形状为 Nx2x3 的 2D 仿射矩阵的批次大小{
尺寸}
.得到了{
西塔.
形状}
。
)
空间大小 =
尺寸[-2
]
# 空间维度大小
elif 长度(
尺寸) == 5:
如果
西塔.
暗() != 3
或者
西塔.
形状[-2] != 3
或者
西塔.
形状[-1] != 4:
raise ValueError(
f预期一个形状为 Nx3x4 的 3D 仿射矩阵批次{
尺寸}
.得到了{
西塔.
形状}
。
)
空间大小 =
尺寸[-3
]
# 空间维度大小
else:
raise 不支持的操作异常(
"仿射网格仅支持 4D 和 5D 大小，"
"分别对应 2D 和 3D 仿射变换。"
f"获取大小"{
尺寸}
。
)
# 检查空跨度
如果
对齐角落
和
最小(spatial_size) == 1:
警告.
警告(
"自版本 1.3.0 起，affine_grid 的行为已更改"
"当 align_corners=True 时，对于单位大小的网格。"
"这不是 affine_grid 的预期用途。"
"请参阅 affine_grid 的文档以获取详细信息。"
)
elif 最小(
尺寸)
≤ 0:
raise ValueError(f"期望输出大小非零且为正。得到"{
尺寸}")
返回 torch.
线性网格生成器(
西塔,
尺寸, align_corners)
[文档]
定义
填充(
输入:
张量,
填充:
列表[
整数
]
模式:
字符串 =
常数,
值:
可选[float] =
无,
)
输入文本:
->
翻译:
-> 张量:
r""
pad(input, pad, mode="constant", value=None) -> Tensor
填充张量。
填充大小：
通过填充大小来填充：attr:`input`的一些维度
从最后一个维度开始描述，向前移动。
math:`\left\lfloor\frac{\text{len(pad)}}{2}\right\rfloor` 维度
的 `input` 将会被填充。
例如，如果要只填充输入张量的最后一个维度，那么
`:attr:`pad` 的形式是`
`(:math:`(\text{padding\_left}, \text{padding\_right})`)`;`
为了填充输入张量的最后两个维度，然后使用`
`padding_left`, `padding_right`,`
`padding_top`, `padding_bottom`)`;
要填充最后三个维度，请使用
`padding_left`, `padding_right`,`
`padding_top`, `padding_bottom`
`padding_front, padding_back)`。
填充模式：
请参阅 :class:`torch.nn.CircularPad2d`, :class:`torch.nn.ConstantPad2d`,
class:`torch.nn.ReflectionPad2d`, 以及 :class:`torch.nn.ReplicationPad2d`
关于如何使用每种填充模式的具体示例。
填充适用于任意维度。环形、复制和反射填充用于填充最后三个维度。
反射填充被实现用于填充一个张量的最后三个维度。
4D 或 5D 输入张量，3D 或 4D 输入张量的最后 2 个维度
或 2D 或 3D 输入张量的最后一个维度。
注意：
使用 CUDA 后端时，此操作可能引起非确定性
行为在其反向传播中不易关闭。
请参阅：doc:`/notes/randomness` 中的笔记以获取背景信息。
参数：
输入（Tensor）：N 维张量
填充（元组）：m 个元素的元组，其中
$\frac{m}{2} \leq$ 输入维度且$m$为偶数。
模式：``'constant'``、``'reflect'``、``'replicate'`` 或 ``'circular'``。
默认：``'constant'``
value：用于 ``'constant'`` 填充的填充值。默认：``0``
示例：
>>> t4d = torch.empty(3, 3, 4, 2)
>>> p1d = (1, 1) # 在最后一个维度两侧各填充 1
>>> out = F.pad(t4d, p1d, "constant", 0) # 实际上为零填充
>>> print(out.size())
torch.Size([3, 3, 4, 4])
>>> p2d = (1, 1, 2, 2) # 在最后一个维度上填充(1, 1)，在倒数第二个维度上填充(2, 2)
>>> out = F.pad(t4d, p2d, "constant", 0)
>>> print(out.size())
torch.Size([3, 3, 8, 4])
>>> t4d = torch.empty(3, 3, 4, 2)
>>> p3d = (0, 1, 2, 1, 3, 3) # pad by (0, 1), (2, 1), and (3, 3)
>>> out = F.pad(t4d, p3d, "constant", 0)
>>> print(out.size())
torch.Size([3, 9, 7, 3])
"文档"
如果 has_torch_function_unary(
输入):
返回 handle_torch_function(
torch.神经网络.
功能性.
填充, (
输入,),
输入,
填充,
模式=
模式,
值=
值
)
如果
不 torch.
算子.
是否正在脚本化():
如果 torch.
是否启用了确定性算法()
和 (
输入.is_cuda
或者
输入.
是_xpu
):
如果
模式 ==
复制:
使用慢速反编译，其反向操作将以 index_put 为基准。
# 需要 importlib，因为导入不能是顶层
# （循环）且不能嵌套（TS 不支持）
返回 importlib.
导入模块(
torch._decomp.分解
).复制垫(
输入,
填充)
返回 torch._C._nn.
填充(
输入,
填充,
模式,
值)
# TODO: 通过 https://github.com/pytorch/pytorch/issues/75798 修复
填充.__module__ = "torch.nn.functional"
# 距离
对应距离 =
_添加文档字符串(
torch.对距离,
r""
pairwise_distance(x1, x2, p=2.0, eps=1e-6, keepdim=False) -> 张量
详细信息请参阅 :class:`torch.nn.PairwiseDistance`
""",
)
pdist = _添加文档字符串(
torch.pdist,
r""
计算输入之间的 p 范距离，p=2 时表示欧几里得距离。-> 计算输入之间的 p 范距离，p=2 时表示欧几里得距离
计算输入中每一对行向量的 p 范数距离。
这与上三角部分（不包括对角线）相同。
`torch.norm(input[:, None] - input, dim=2, p=p)`。如果行是连续的，这个函数将会更快。
如果行是连续的，将会更快。
如果输入的形状为 :math:`N \times M`，则输出形状将为
1/2 N (N - 1)
此函数等同于 `scipy.spatial.distance.pdist(input,`)
minkowski 距离，p=p)`` 当 :math:`p \in (0, \infty)`。当 :math:`p = 0` 时，它是
等价于 `scipy.spatial.distance.pdist(input, 'hamming') * M`.
当 :math:`p = \infty` 时，最接近的 scipy 函数是
`scipy.spatial.distance.pdist(xn, lambda x, y: np.abs(x - y).max())`.
参数：
输入：形状为 :math:`N \times M` 的输入张量。
p：计算每个向量对之间的 p-范数距离的 p 值
math:`\in [0, \infty]`。
""",
)
余弦相似度 =
_添加文档字符串(
torch.余弦相似度,
r""
cosine_similarity(x1, x2, dim=1, eps=1e-8) -> Tensor
返回 `x1` 和 `x2` 之间的余弦相似度，沿 dim 计算。`x1` 和 `x2` 必须可广播到公共形状。
公共形状。`dim` 指的是这个公共形状中的维度。输出维度的 `dim` 被压缩（参见 :func:`torch.squeeze`），结果为
压缩（参见 :func:`torch.squeeze`），结果为
输出维度减少 1 的张量。
.. math ::
\text{相似度} = \dfrac{x_1 \cdot x_2}{\max(\Vert x_1 \Vert _2, \epsilon) \cdot \max(\Vert x_2 \Vert _2, \epsilon)}
支持 :ref:`类型提升 `.
参数：
x1（张量）：第一个输入。
x2（张量）：第二个输入。
dim（int，可选）：计算余弦相似度的维度。默认：1
eps（float，可选）：避免除以零的小值。
默认：1e-8
示例::
>>> input1 = torch.randn(100, 128)
>>> input2 = torch.randn(100, 128)
>>> output = F.cosine_similarity(input1, input2)
>>> print(output)
""",
)
热编码 =
_添加文档字符串(
torch._C._nn.one_hot,
r""
one_hot(tensor, num_classes=-1) -> LongTensor
接受形状为 ``(*)`` 的 LongTensor 索引值并返回一个张量
形状为 ``(*, num_classes)`` 的张量，除最后一个维度的索引与输入张量中对应的值匹配外，其余位置均为零
其中最后一个维度的索引与输入张量中对应的值匹配
在这种情况下将是 1。
参见维基百科上的`One-hot`_ 。
.. _One-hot 在维基百科上：
https://en.wikipedia.org/wiki/One-hot
参数：
张量（LongTensor）：任何形状的类别值。
num_classes (int, 可选): 总类别数。如果设置为 -1，则表示
类数将被推断为大于最大类数的一个数
输入张量中的值。默认：-1
返回：
长张量，比 1 值多一个维度
输入指示的最后一个维度索引，其他地方为 0
否则。
示例：
>>> F.one_hot(torch.arange(0, 5) % 3)
tensor([[1, 0, 0],
[0, 1, 0]
[0, 0, 1]
[1, 0, 0]
[0, 1, 0]
>>> F.one_hot(torch.arange(0, 5) % 3, num_classes=5)
tensor([[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[1, 0, 0, 0, 0],
[[0, 1, 0, 0, 0]])
>>> F.one_hot(torch.arange(0, 6).view(3,2) % 3)
tensor([[[1, 0, 0],
[0, 1, 0]]
[[0, 0, 1]]
[[1, 0, 0]]
[[0, 1, 0]]
[[0, 0, 1]]]]
""",
)
[文档]def triplet_margin_loss(
锚点: Tensor,
正样本: Tensor,
负样本: Tensor,
margin: 浮点数 = 1.0,
p: 浮点数 = 2,
eps: 浮点数 = 1e-6,
swap: 布尔值 = False,
size_average: 可选[布尔] = None,
reduce: 可选[布尔] = None,
reduction: str = "mean",
) -> Tensor:
计算给定输入张量之间的三元组损失，并设置一个大于 0 的边界。
详细信息请参阅 :class:`~torch.nn.TripletMarginLoss`。
""
如果有_torch_function_variadic(anchor, positive, negative):
return handle_torch_function(
triplet_margin_loss,
(anchor, positive, negative),
anchor,
正面,
负面,
margin=margin,
p=p,
eps=eps,
swap=swap,
size_average=size_average,
reduce=reduce,
reduction=reduction,
)
如果 size_average 不为空或 reduce 不为空：
reduction_enum = _Reduction.legacy_get_enum(size_average, reduce)
else:
reduction_enum = _Reduction.get_enum(reduction)
if 毛利率 <= 0:
raise ValueError(f"毛利率必须大于 0，获取到 {毛利率}")
return torch.triplet_margin_loss(
锚点，正样本，负样本，间隔，p，eps，交换，reduction_enum
)
[文档]
定义
三重边距与距离损失(
锚点:
张量,
正的:
张量,
负面:
张量,
*,
距离函数:
可选[
可调用[[
张量,
张量
]
张量]] =
无,
边距:
浮点数 = 1.0,
交换:
布尔 =
错误,
缩减:
字符串 =
平均值,
)
输入文本:
->
翻译:
-> 张量:
r使用自定义距离函数计算输入张量的三元组损失。
详细信息请参阅 :class:`~torch.nn.TripletMarginWithDistanceLoss`。
"文档"
如果 torch.
算子.
是否正在脚本化():
raise 不支持的操作异常(
"F.triplet_margin_with_distance_loss 不支持 JIT 脚本："
"需要 Callable 的函数无法进行脚本化。"
)
如果 has_torch_function_variadic(
锚点,
正的,
负面):
返回 handle_torch_function(
三重边距与距离损失,
(锚点,
正的,
负面),
锚点,
正的,
负面,
距离函数=
距离函数,
边距=
边距,
交换=
交换,
缩减=
缩减,
)
# 检查缩减模式的有效性
如果
减少
不
在 (
平均值,
"求和",
无):
raise ValueError(f"{缩减}
不是有效的缩减值)
检查边距的有效性
如果
边距
≤ 0:
raise ValueError(f"边距必须大于 0，实际得到"{
边距}")
检查尺寸
一个维度 =
锚点.
维数
p_dim = 正的.
维数
n_维度 =
负面.
维数
如果
不 (
一个维度 == p_dim
和 p_dim == n_dim):
raise 运行时错误(
f"锚点、正张量和负张量应具有相同的维度，但得到的是：锚点"
f"维度数相同，但得到了：anchor"{
一個維度}
D，"
f"積極的{
p 維度}
D，和负{n_dim}
D 输入
)
计算损失
如果
距离函数
是
无:
距离函数 = torch.
对应距离
正距离 =
距离函数(
锚点,
正的)
dist_neg = 距离函数(
锚点,
负面)
# 距离交换在论文《学习浅层卷积特征描述符的三元损失》中进行了描述，作者为 V. Balntas，E. Riba 等。如果为 True，并且正例更接近于
# # 距离交换在论文《学习浅层卷积特征描述符的三元损失》中进行了描述，作者为 V. Balntas，E. Riba 等。如果为 True，并且正例更接近于
# # 距离交换在论文《学习浅层卷积特征描述符的三元损失》中进行了描述，作者为 V. Balntas，E. Riba 等。如果为 True，并且正例更接近于
与锚点相比，负例比正例更差，交换正例和锚点在损失计算中。
锚点在损失计算中。
如果
交换:
距离交换 =
距离函数(
正的,
负的)
dist_neg = torch.最小(
分布式否定,
交换距离)
损失 = torch.
最小限制(
边距 +
正距离 -
分布式否定, 0)
应用缩减
如果
减少 ==
"求和":
返回 torch.
总和(
损失)
elif 减少 ==
平均值:
返回 torch.
均值(
损失)
else: # reduction == "none"
返回
损失
[文档]def normalize(
输入: Tensor,
p: float = 2.0,
dim: int = 1,
eps: float = 1e-12,
out: Optional[Tensor] = None,
) -> Tensor:
r"""执行输入在指定维度上的 :math:`L_p` 归一化。
对于一个大小为 :math:`(n_0, ..., n_{dim}, ..., n_k)` 的张量 :attr:`input`，每个
`n_dim` -元素向量 `v` 沿维度 `dim` 转换为
.. 数学表达式
v = v / max(∥v∥_p, ε)
使用默认参数时，它使用维度 :math:`1` 上的欧几里得范数进行归一化。
Args:
输入：任何形状的输入张量
p (浮点数)：范数公式中的指数值。默认：2
dim (int 或 int 元组的元组)：降维的维度。默认：1
eps (float): 避免除以零的小值。默认：1e-12
输出（Tensor，可选）：输出张量。如果使用：attr:`out`，则
操作不可微。
"""
如果具有 torch_function_variadic(input, out):
返回 handle_torch_function(
normalize, (input, out), input, p=p, dim=dim, eps=eps, out=out
)
if out is None:
denom = input.norm(p, dim, keepdim=True).clamp_min(eps).expand_as(input)
return input / denom
else:
denom = input.norm(p, dim, keepdim=True).clamp_min_(eps).expand_as(input)
return torch.div(input, denom, out=out)
定义
断言整型或对偶(arg:
列表[
整数
]
参数名称:
字符串,
消息:
字符串)
输入文本:
->
翻译:
-> 无:
断言 isinstance(arg,
整数)
或者
长度(arg) == 2,
消息.
格式(
参数名称)
[文档]def 展开(
输入: Tensor,
核大小: BroadcastingList2[int],
扩展率: BroadcastingList2[int] = 1,
padding: BroadcastingList2[int] = 0,
stride: BroadcastingList2[int] = 1,
) -> Tensor:
r"""从批处理的输入张量中提取滑动局部块。"""
..警告::
目前仅支持 4-D 输入张量（批量的图像类张量）。
支持。
..警告::
展开的张量可能包含多个元素指向同一个内存位置。因此，原地操作（尤其是向量化的操作）可能会导致不正确的行为。如果您需要向张量写入，请先对其进行克隆。
作为结果，原地操作（尤其是向量化的操作）可能会导致不正确的行为。如果您需要向张量写入，请先对其进行克隆。
如果您需要向张量写入，请先对其进行克隆。
如果您需要向张量写入，请先对其进行克隆。
查看 :class:`torch.nn.Unfold` 获取详细信息
"""
如果 has_torch_function_unary(input):
返回 handle_torch_function(
展开,
(输入,),
输入,
核心大小,
dilation=dilation,
padding=padding,
stride=stride,
)
return torch._C._nn.im2col(
输入，_pair(kernel_size)，_pair(dilation)，_pair(padding)，_pair(stride)
)
[文档]def fold(
输入: Tensor,
输出大小: BroadcastingList2[int],
核大小: BroadcastingList2[int],
dilation: 广播列表 2[int] = 1,
padding: 广播列表 2[int] = 0,
stride: 广播列表 2[int] = 1,
) -> 张量:
将一系列滑动局部块组合成一个大的包含张量。
.. 警告::
目前仅支持未批处理（3D）或批处理（4D）的图像类似输出张量。
详细信息请参阅 :class:`torch.nn.Fold`
"""
如果存在 torch 函数单例(input):
返回 handle_torch_function(
fold,
输入,
输入,
输出大小,
核大小,
dilation=dilation,
padding=padding,
stride=stride,
)
return torch._C._nn.col2im(
输入
_pair(output_size)
_pair(kernel_size)
_pair(膨胀)
_pair(填充)
_pair(步长)
)
#
多头注意力
#
定义 _in_projection_packed(
q: 张量,
k: 张量,
v: 张量,
w: 张量,
b: 可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 列表[
张量
]：
r执行注意力操作的投影步骤，使用打包的权重。
输出是一个包含查询、键和值投影张量的三元组。
参数：
q, k, v：查询、键和值张量将被投影。对于自注意力机制，
这些通常是相同的张量；对于编码器-解码器注意力机制，
k 和 v 通常是指同一个张量。 (我们利用这些
身份用于性能，如果存在的话。无论如何，q，k 和 v
必须共享一个共同的嵌入维度；否则它们的形状可能不同。
q, k 和 v 的投影权重，打包成一个张量。权重沿维度 0 打包，顺序为 q, k, v。
打包顺序为 q, k, v。
b：q, k 和 v 的可选投影偏置，打包成一个张量
，顺序为 q, k, v。
形状：
输入：
- q：:math:`(..., E)` 其中 E 是嵌入维度
- k：:math:`(..., E)` 其中 E 是嵌入维度
- v：:math:`(..., E)` 其中 E 是嵌入维度
- w: (E * 3, E) 其中 E 是嵌入维度
- b: E * 3 其中 E 是嵌入维度
输出：
- 在输出列表 [q', k', v'] 中，每个输出张量将具有
与相应的输入张量形状相同。
"文档"
E = q.尺寸(-1)
如果 k
是 v:
如果 q
是 k:
# 自注意力
项目 =
线性(q, w, b)
# 调整形状为 3, E 和不是 E，3 是故意为之，以实现更好的内存归约并保持与 chunk()相同的顺序
项目 = (
项目.unflatten(-1, (3, E))
.展平(0)
.转置(0, -2)
.挤压(-2)
.连续()
)
返回
项目[0
]
项目[1
]
项目[2]
else:
编码器-解码器注意力
w_q, w_kv = w.分割
[E, E * 2])
如果 b
是
无:
b_q = b_kv = 无
else:
b_q, b_kv = b.分割
[E, E * 2])
q_proj = 线性(q, w_q, b_q)
kv_proj = 线性(k, w_kv, b_kv)
# 重新塑形为 2，E 和非 E，2 是故意的，为了更好的内存归约并保持与 chunk()相同的顺序
kv_proj = (
kv_proj.unflatten(-1, (2, E))
.展平(0)
.转置(0, -2)
.挤压(-2)
.连续()
)
返回 (q_proj, kv_proj[0
] kv_proj[1])
else:
w_q, w_k, w_v = w.数据块(3)
如果 b
是
无:
b_q = b_k = b_v = 无
else:
b_q, b_k, b_v = b.数据块(3)
返回
线性(q, w_q, b_q),
线性(k, w_k, b_k),
线性(v, w_v, b_v)
定义
投影中(
q: 张量,
k: 张量,
v: 张量,
w_q: 张量,
w_k: 张量,
w_v: 张量,
b_q: 可选[
张量] =
无,
b_k: 可选[
张量] =
无,
b_v: 可选[
张量] =
无,
)
输入文本:
->
翻译:
-> 元组[
张量,
张量,
张量]:
r执行注意力操作的投影步骤。
这只是一个由线性投影组成的 triple，
权重上有形状约束，
确保投影输出中的嵌入维度一致性。
输出是一个包含查询、键和值投影张量的三元组。
参数：
q, k, v：要投影的查询、键和值张量。
w_q, w_k, w_v：q、k 和 v 的权重，分别对应。
b_q, b_k, b_v：q、k 和 v 的可选偏置，分别对应。
形状：
输入：
- q: (Qdims..., Eq) 其中 Eq 是查询嵌入维度，Qdims 是任意维度。
主导维度数量。
- k: (Kdims..., Ek) 其中 Ek 是键嵌入维度，Kdims 是任意维度。
主导维度数量。
- v: :math:`(Vdims..., Ev)` 其中 Ev 是值嵌入维度，Vdims 是任何
主导维度数量。
- w_q: (Eq, Eq)
- w_k: (Eq, Ek)
- w_v: (Eq, Ev)
- b_q: (方程式)
- b_k: (方程式)
- b_v: (方程式)
输出：在输出三元组(q', k', v')中，
- q': :math:`[Qdims..., Eq]`
- k': :math:`[Kdims..., Eq]`
- v': :math:`[Vdims..., Eq]`
"文档"
等式, Ek, Ev = q.
尺寸(-1), k.
尺寸(-1), v.
尺寸(-1)
断言 w_q.
形状 == (
等式,
等式,
), f预期查询权重形状为{(
等式,
等式)}
, 但得到{w_q.
形状}"
断言 w_k.
形状 == (
等式,
Ek,
), f预期键权重形状为{(
等式, Ek)}
, 但得到{w_k.
形状}"
断言 w_v.
形状 == (
等式,
欧文,
), f预期值权重形状为{(
等式,
欧文)}
, 但得到{w_v.
形状}"
断言 b_q
是
无
或者 b_q.
形状 == (
等式,
), f期待查询偏差形状{(
等式,)}
, 但得到{b_q.
形状}"
断言 b_k
是
无
或者 b_k.
形状 == (
等式,
), f期待键偏置形状{(
等式,)}
, 但得到{b_k.
形状}"
断言 b_v
是
无
或者 b_v.
形状 == (
等式,
), f预期值偏差形状的{(
等式,)}
, 但得到{b_v.
形状}"
返回
线性(q, w_q, b_q),
线性(k, w_k, b_k),
线性(v, w_v, b_v)
缩放点积注意力机制 =
_添加文档字符串(
torch._C._nn.扩放点积注意力,
r"""缩放点积注意力机制(query, key, value, attn_mask=None, dropout_p=0.0,
is_causal=False, scale=None, enable_gqa=False) -> Tensor:
计算查询、键和值张量上的缩放点积注意力，如果传递了可选的注意力掩码，
并应用大于 0.0 的概率的 dropout。可选的 scale 参数只能作为关键字参数指定。
。
.. 代码块 :: python
# 高效实现等价于以下代码：
def scaled_dot_product_attention(query, key, value, attn_mask=None, dropout_p=0.0,
is_causal=False, scale=None, enable_gqa=False) -> torch.Tensor:
L, S = query.size(-2), key.size(-2)
scale_factor = 1 / math.sqrt(query.size(-1)) if scale is None else scale
attn_bias = torch.zeros(L, S, dtype=query.dtype, device=query.device)
if is_causal:
assert attn_mask is None
temp_mask = torch.ones(L, S, dtype=torch.bool).tril(diagonal=0)
attn_bias.masked_fill_(temp_mask.logical_not(), float("-inf"))
将 attn_bias 转换为 query 的数据类型
如果 attn_mask 不为空：
如果 attn_mask 的数据类型为 torch.bool：
attn_bias.masked_fill_(attn_mask.logical_not(), float("-inf"))
否则:
attn_bias = attn_mask + attn_bias
if enable_gqa:
key = key.repeat_interleave(query.size(-3)//key.size(-3), -3)
value = value.repeat_interleave(query.size(-3)//value.size(-3), -3)
attn_weight = query @ key.transpose(-2, -1) * scale_factor
attn_weight += attn_bias
attn_weight = torch.softmax(attn_weight, dim=-1)
attn_weight = torch.dropout(attn_weight, dropout_p, train=True)
return attn_weight @ value
.. 警告::
此函数处于测试阶段，可能会发生变化。
.. 警告::
此函数始终根据指定的 `dropout_p` 参数应用 dropout。
要在评估期间禁用 dropout，请确保传递 `0.0` 的值，当模块的函数调用不在训练模式时。
使得函数调用不在训练模式。
例如：
.. 代码块 :: python
类 MyModel(nn.Module):
def __init__(self, p=0.5):
super().__init__()
self.p = p
def forward(self, ...):
return F.scaled_dot_product_attention(...,
dropout_p=(self.p if self.training else 0.0))
注意：
目前支持三种缩放点积注意力机制的实现：
- `FlashAttention-2：更快的注意力机制，更好的并行性和工作分区`
- `内存高效注意力机制`
- 使用 C++定义的与上述公式匹配的 PyTorch 实现
The function may call optimized kernels for improved performance when using the CUDA backend.
对于所有其他后端，将使用 PyTorch 实现。
所有实现默认启用。缩放点积注意力尝试自动选择
基于输入的最优实现。为了提供更多细粒度的控制，以实现
用于启用和禁用实现的功能如下。
上下文管理器是首选机制：
- :func:`torch.nn.attention.sdpa_kernel`：用于启用或禁用任何实现的上下文管理器。
- :func:`torch.backends.cuda.enable_flash_sdp`: 全局启用或禁用 FlashAttention。
- :func:`torch.backends.cuda.enable_mem_efficient_sdp`: 全局启用或禁用内存高效注意力。
- :func:`torch.backends.cuda.enable_math_sdp`: 全局启用或禁用 PyTorch C++ 实现。
每个融合内核都有特定的输入限制。如果用户需要使用特定的融合实现，
使用 :func:`torch.nn.attention.sdpa_kernel` 禁用 PyTorch 的 C++ 实现。
如果没有可用的融合实现，将发出警告，说明融合实现无法运行的原因。
融合实现无法运行的原因。
由于融合浮点运算的特性，此函数的输出可能因所选后端内核而异。
取决于所选后端内核。
C++ 实现支持 torch.float64，当需要更高精度时可以使用。
对于数学后端，如果输入为 torch.half 或 torch.bfloat16，所有中间结果都保持在 torch.float。
欲了解更多信息，请参阅：doc:`/notes/numerical_accuracy`
分组查询注意力（GQA）是一个实验性功能。目前它仅适用于 Flash_attention
和 CUDA 张量上的数学内核，不支持嵌套张量。
GQA 的约束条件：
- 头数查询 % 头数键值 == 0 且，
- 头数键 == 头数值
注意：
{cudnn_可复现性说明}
""".格式(
**可复现性说明
)
+ r""
参数：
查询（张量）：查询张量；形状：math:`(N, ..., Hq, L, E)`。
密钥（张量）：密钥张量；形状：math:`(N, ..., H, S, E)`。
值（张量）：值张量；形状：math:`(N, ..., H, S, Ev)`。
attn_mask（可选张量）：注意力掩码；形状必须可广播到注意力权重形状。
这是一个数学表达式：(N,..., L, S)。支持两种类型的掩码。
这是一个布尔掩码，其中 True 值表示该元素*应该*参与注意力。
这是一个与查询、键、值相同类型的浮点掩码，它被添加到注意力分数中。
dropout_p (浮点数): Dropout 概率；如果大于 0.0，则应用 dropout。
is_causal (布尔值): 如果设置为 true，当掩码是正方形矩阵时，注意力掩码是一个下三角矩阵。
正方形矩阵。当掩码是非正方形矩阵时，注意力掩码具有上左因果偏差的形式（参见 :class:`torch.nn.attention.bias.CausalBias`）。
如果同时设置了 attn_mask 和 is_causal，则会抛出错误。
如果同时设置了 attn_mask 和 is_causal，则会抛出错误。
缩放因子（可选浮点数，关键字参数）：在 softmax 之前应用的缩放因子。如果为 None，则设置默认值
到 :math:`\frac{1}
{E}{E}}`.
enable_gqa (布尔值): 如果设置为 True，则启用分组查询注意力（GQA），默认设置为 False。
返回：
output (张量): 注意力输出；形状 :math:`(N, ..., Hq, L, Ev)`。
形状说明：
- :math:`N: 批处理大小 ... : 其他批处理维度数量（可选）`
- S：源序列长度
- L：目标序列长度
- E：查询和键的嵌入维度
- Ev：值的嵌入维度
- :math:`Hq: \text{查询头数}`
- :math:`H: \text{键和值的头数}`
示例：
>>> # 可选使用上下文管理器以确保运行融合内核之一
>>> query = torch.rand(32, 8, 128, 64, dtype=torch.float16, device="cuda")
>>> key = torch.rand(32, 8, 128, 64, dtype=torch.float16, device="cuda")
>>> value = torch.rand(32, 8, 128, 64, dtype=torch.float16, device="cuda")
>>> with sdpa_kernel(backends=[SDPBackend.FLASH_ATTENTION]):
>>> F.scaled_dot_product_attention(query,key,value)
>>> # GQA 样本用于 llama3
>>> query = torch.rand(32, 32, 128, 64, dtype=torch.float16, device="cuda")
>>> key = torch.rand(32, 8, 128, 64, dtype=torch.float16, device="cuda")
>>> value = torch.rand(32, 8, 128, 64, dtype=torch.float16, device="cuda")
>>> with sdpa_kernel(backends=[SDPBackend.MATH]):
>>> F.scaled_dot_product_attention(query,key,value,enable_gqa=True)
.. _FlashAttention-2: 更快速的注意力机制，具有更好的并行性和工作分区
https://arxiv.org/abs/2307.08691
.. _Memory-Efficient Attention: 内存高效注意力机制
https://github.com/facebookresearch/xformers
.. _Grouped-Query Attention:
https://arxiv.org/pdf/2305.13245
""",
)
定义 _mha_shape_check(
查询:
张量,
键:
张量,
值:
张量,
关键填充掩码:
可选[
张量
]
注意掩码:
可选[
张量
]
头数:
整数,
):
# 验证 `query`、`key`、`value`、`key_padding_mask` 和 `attn_mask` 的预期形状
# 并返回输入是否批处理
如果 `query` 不是二维（非批量）或三维（批量）张量，则会引发错误。
形状检查。
如果
查询.
暗() == 3:
批量输入。
批处理 =
真实
断言
键.
暗() == 3
和
值.
暗() == 3, (
对于批处理（3-D）`查询`，期望`键`和`值`为 3-D
f"但找到了"{
键.
暗()}
-D 和{
值.
暗()}
-D 张量分别"
)
如果 key_padding_mask
是
不
无:
断言
关键填充掩码.
暗() == 2, (
"对于批量（3-D）`查询`，期望`key_padding_mask`为`None`或 2-D"
f"但找到了"{
关键填充掩码.
暗()}
-D 索引张量而不是
)
如果
注意力掩码
是
不
无:
断言
注意掩码.
暗()
在 (2, 3), (
"对于批处理（3-D）`查询`，期望`注意力掩码`为`None`，2-D 或 3-D"
f"但找到了"{
注意掩码.
暗()}
-D 索引张量而不是
)
elif 查询.
暗() == 2:
未分批输入
批处理 =
假
断言
键.
暗() == 2
和
值.
暗() == 2, (
对于未分批（2-D）的`query`，期望`key`和`value`为 2-D
f"但找到了"{
键.
暗()}
-D 和{
值.
暗()}
-D 张量分别"
)
如果 key_padding_mask
是
不
无:
断言
关键填充掩码.
暗() == 1, (
对于未分批（2-D）`query`，期望`key_padding_mask`为`None`或 1-D
f"但找到了"{
关键填充掩码.
暗()}
-D 索引张量而不是
)
如果
注意力掩码
是
不
无:
断言
注意掩码.
暗()
在 (2, 3), (
对于未分批（2-D）的`query`，期望`attn_mask`为`None`，2-D 或 3-D
f但找到{attn_mask.
暗淡()}
“-D 张量而不是”
)
如果 attn_mask.
暗() == 3:
预期形状 = (
头数,
查询.
形状[0
]
键.
形状[0])
断言 (
注意掩码.
形状 ==
预期形状
), f预期 `attn_mask` 的形状为{
预期形状}
但是得到了{
注意掩码.
形状}"
else:
raise 断言错误(
f查询应为未批处理的 2D 或批处理的 3D 张量，但收到{
查询.
暗()}
-D 查询张量
)
返回
批处理
定义
_规范掩码(
面具:
可选[
张量
]
面具名称:
字符串,
其他类型:
可选的[DType
]
其他名称:
字符串,
目标类型:
数据类型,
检查其他:
布尔 =
是,
)
输入文本:
->
翻译:
-> 可选[
张量]:
如果
面具
是
不
无:
_掩码数据类型 =
面具.dtype
_mask 是否为浮点数 = torch.is_floating_point(
面具)
如果
_掩码数据类型 != torch.
布尔
和
不
_mask 是否为浮点数:
raise 断言错误(
f"仅支持布尔型和浮点型"{mask_name}
支持
)
如果
检查其他
并且
其他类型
是
不
无:
如果
_掩码数据类型 !=
其他类型:
警告.
警告(
f支持不匹配{
掩码名称}
和{
其他名称} "
已弃用。请使用相同类型代替。
)
如果
不
_mask 是否为浮点数:
面具 =
火把.
与...相同形状的零(
面具,
数据类型=
目标类型).
遮蔽填充(
遮罩, float(
-无穷大)
)
返回
面具
定义
_无或数据类型(
输入:
可选[
张量]) ->
可选[
数据类型
]
如果
输入
是
无:
返回
无
elif isinstance(输入, torch.
张量):
返回
输入.dtype
raise 运行时错误(
"_none_or_dtype()的输入必须是 None 或 torch.Tensor")
定义
检查键填充掩码(
关键填充掩码: torch.
张量,
源长度:
整数, bsz:
整型
)
输入文本:
->
翻译:
-> 无:
torch._check_with(
断言错误,
关键填充掩码.
形状[0] == bsz,
lambda: f预期 key_padded_mask.shape[0] 的值{bsz}
, 但得到{
关键填充掩码.
形状[0]}",
)
torch._check_with(
断言错误,
关键填充掩码.
形状[1] ==
源长度,
lambda: f"期望 key_padded_mask.shape[1] 的值{
源长度}
, 但得到{key_padding_mask.shape[1]}",
)
定义 multi_head_attention_forward(
查询:
张量,
键:
张量,
值:
张量,
验证嵌入维度:
整数,
头数:
整数,
输入投影权重:
可选[
张量
]
输入投影偏置:
可选[
张量
]
偏置_k:
可选[
张量
]
偏置_v:
可选[
张量
]
添加零注意力:
布尔,
dropout_p: float,
输出投影权重:
张量,
输出投影偏置:
可选[
张量
]
训练:
布尔 =
是,
关键填充掩码:
可选[
张量] =
无,
需要的权重:
布尔 =
是,
注意掩码:
可选[
张量] =
无,
使用独立项目权重:
布尔 =
错误,
q_proj_weight: 可选[
张量] =
无,
k_proj_weight: 可选[
张量] =
无,
v_项目权重:
可选[
张量] =
无,
静态_k:
可选[
张量] =
无,
静态_v:
可选[
张量] =
无,
平均注意力权重:
布尔 =
是,
因果:
布尔 =
错误,
)
输入文本:
->
翻译:
-> 元组[
张量,
可选[
张量
]]
r多头注意力方法的向前方法。
.. 注意::
请参阅此教程 了解 PyTorch 提供的用于构建自己的 Transformer 层的高效构建块深入讨论。
有关 PyTorch 提供的用于构建自己的 Transformer 层的高效构建块的深入讨论，请参阅。
Transformer 层。
请参阅：class:`torch.nn.MultiheadAttention`以获取详细信息。
参数：
查询、键、值：将查询和一组键值对映射到输出。
请参阅“Attention Is All You Need”以获取更多详细信息。
embed_dim_to_check：模型的总维度。
num_heads: 并行注意力头。
in_proj_weight, in_proj_bias: 输入投影权重和偏差。
bias_k, bias_v: 在 dim=0 处添加 key 和 value 序列的偏差。
add_zero_attn: 向 key 添加一个新的全零批次。
dim=1 的值序列。
dropout_p：将元素置零的概率。
out_proj_weight, out_proj_bias：输出投影权重和偏差。
training：如果为 True 则应用 dropout。
key_padding_mask：如果提供，指定键中的填充元素
被注意力忽略。这是一个二进制掩码。当值为真时，
相应的注意力层上的值将被填充为-inf。
需要权重：输出注意力输出权重。
默认：`True`
注意：`needs_weight` 默认为 `True`，但应设置为 `False`
当不需要注意力权重时，为了最佳性能。
*将 `needs_weights` 设置为 `True`
导致性能显著下降。
attn_mask：2D 或 3D 掩码，用于阻止对某些位置的注意力。2D 掩码将广播到所有
批处理时，3D 掩码允许为每个批次的条目指定不同的掩码。
is_causal: 如果指定，则应用因果掩码作为注意力掩码，并忽略
计算缩放点积注意力机制的 attn_mask。
默认：``False``。
.. 警告::
is_causal 提供了 attn_mask 是因果掩码的提示。
提供错误的提示可能导致执行错误，包括前向和反向传播。
包括前向和反向传播在内的执行错误。
兼容性。
use_separate_proj_weight: 该函数接受查询、键、
和值的不同形式的 proj.权重。如果为 false，则使用 in_proj_weight，它是
q_proj_weight、k_proj_weight、v_proj_weight 的组合。
q_proj_weight, k_proj_weight, v_proj_weight, in_proj_bias：输入投影权重和偏差。
static_k, static_v：用于注意力操作器的静态键和值。
average_attn_weights：如果为 true，表示返回的`attn_weights`应在头部之间平均。
否则，`attn_weights`将按头部分别提供。注意，此标志仅在此处有效
当 `need_weights=True`。默认：True
形状：
输入：
- 查询：:math:`(L, E)` 或 :math:`(L, N, E)`，其中 L 是目标序列长度，N 是批大小，E 是
嵌入维度。
- 键：:math:`(S, E)` 或 :math:`(S, N, E)`，其中 S 是源序列长度，N 是批大小，E 是
嵌入维度。
- value: (S, E) 或 (S, N, E) 其中 S 是源序列长度，N 是批量大小，E 是
嵌入维度。
key_padding_mask: :math:`(S)` 或 :math:`(N, S)` 其中 N 是批大小，S 是源序列长度。
如果提供一个 FloatTensor，它将直接添加到值中。
如果提供一个 BoolTensor，则值为 ``True`` 的位置将被忽略，而值为 ``False`` 的位置将保持不变。
值为 ``True`` 的位置将被忽略，而值为 ``False`` 的位置将保持不变。
- attn_mask：2D 掩码：math:`(L, S)`，其中 L 为目标序列长度，S 为源序列长度。
3D 掩码：math:`(N*num_heads, L, S)`，其中 N 为批大小，L 为目标序列长度，
S 为源序列长度。attn_mask 确保位置 i 可以关注未掩码的位置。
如果提供 BoolTensor，则位置与``True``相关。
在此情况下不允许参加，而 ``False`` 值将保持不变。如果提供一个浮点张量，
它将被添加到注意力权重中。
- static_k: :math:`(N*num_heads, S, E/num_heads)`，其中 S 是源序列长度，
N 是批大小，E 是嵌入维度。E/num_heads 是头维度。
- 静态_v: :math:`(N*num_heads, S, E/num_heads)`，其中 S 是源序列长度，
N 是批大小，E 是嵌入维度。E/num_heads 是头维度。
输出：
- attn_output: :math:`(L, E)` 或 :math:`(L, N, E)` 其中 L 是目标序列长度，N 是批大小，
E 是嵌入维度。
- 当`need_weights=True`时返回`attn_output_weights`。如果`average_attn_weights=True`，则返回
在输入未批处理时，头部的注意力权重平均值，形状为:math:`(L, S)`，
math:`(N, L, S)`，其中:N 是批处理大小，:math:`L`是目标序列长度，:math:`S`是序列长度，
`S` 是源序列长度。如果 `average_attn_weights=False`，则返回每个注意力头的注意力权重。
形状为 :math:`(num_heads, L, S)` 的注意力头，当输入未批处理时或形状为 :math:`(N, num_heads, L, S)`。
"文档"
线性代数操作 = (
查询,
键,
值,
输入投影权重,
输入投影偏置,
偏置_k,
偏置_v,
输出投影权重,
输出投影偏置,
)
如果
有 torch 功能(
线性运算):
返回 handle_torch_function(
multi_head_attention_forward,
线性运算,
查询,
键,
值,
验证嵌入维度,
头数,
输入投影权重,
输入投影偏置,
偏置_k,
偏置_v,
添加零注意力,
dropout_p,
输出投影权重,
输出投影偏置,
训练=
训练,
关键填充掩码=
关键填充掩码,
需要的权重=
需要的权重,
注意掩码=
注意掩码,
因果=
因果,
使用独立项目权重=
使用独立项目权重,
q_proj_weight=q_proj_weight,
k_proj_weight=k_proj_weight,
v_项目权重=
v_项目权重,
静态_k=
静态_k,
静态_v=
静态_v,
平均注意力权重=
平均注意力权重,
)
批处理 = _mha_shape_check(
查询,
键,
值,
关键填充掩码,
注意掩码,
头数
)
对于未分批输入，我们在预期的批处理维度上取消展平，以假装输入
# 批量处理，运行计算，然后返回之前挤压
# 挤压批量维度，以便输出不携带这个临时的批量维度。
如果
不
批处理:
# 如果输入未批量处理，则展开
查询 =
查询.
展平(1)
key = 键.
展平(1)
值 =
值.
展平(1)
如果 key_padding_mask
是
不
无:
key_padding_mask = 关键填充掩码.
展平(0)
# 设置形状变量
tgt_len, bsz, 嵌入维度 =
查询.
形状
源长度, _, _ =
键.
形状
key_padding_mask = _规范掩码(
面具=
关键填充掩码,
掩码名称=
"关键填充掩码",
其他类型=
_无或数据类型(
注意掩码),
其他名称=
"注意力掩码",
目标类型=
查询.
数据类型,
)
如果
是因果的
和
注意力掩码
是
无:
raise 运行时错误(
需要指定 is_causal 提示时，需要 attn_mask。
您可以使用 Transformer 模块方法
`generate_square_subsequent_mask` 用于创建此掩码。
)
如果
是因果的
和 key_padding_mask
是
无
和
不
需要的权重:
# 当我们有 kpm 或需要权重时，我们需要 attn_mask
# 否则，我们使用 is_causal 提示直接作为 is_causal
指示 SDPA
注意力掩码 =
无
else:
注意力掩码 =
_规范掩码(
面具=
注意掩码,
掩码名称=
"注意力掩码",
其他类型=
无,
其他名称=
输入文本翻译为简体中文为："",
目标类型=
查询.
数据类型,
检查其他=
错误,
)
如果 key_padding_mask
是
不
无:
我们已经有了 attn_mask，并使用它来合并 kpm。
关闭使用 is_causal 提示，因为合并后的掩码不再具有因果性。
# 更新：由于合并后的掩码不再具有因果性，因此不再使用 is_causal 提示。
是因果的 =
假
断言 (
嵌入维度 ==
嵌入维度检查
), f期待嵌入维度为{
验证嵌入维度}
, 但得到{
嵌入维度}"
如果 isinstance(
嵌入维度,
火把.
张量):
# embed_dim 可以是一个张量，当进行 JIT 追踪时
头维度 =
嵌入维度.
除法(
头数,
四舍五入模式=
截断)
else:
头维度 =
嵌入维度 //
头数
断言 (
头维度 *
头数 ==
嵌入维度
), f嵌入维度{
嵌入维度}
不能被 num_heads 整除{
头数}"
如果
使用独立项目权重:
允许在单独使用投影权重时，MHA 具有不同的嵌入维度
断言 (
键.
形状
[2] ==
值.
形状
[2]
), f"键的序列和批次维度"{
键.
形状
[2]}
与值的维度不匹配{
值.
形状
[2]}"
else:
断言 (
键.
形状 ==
值.
形状
), f"关键形状"{
键.
形状}
值形状不匹配{
值.
形状}"
#
# 在投影中计算
#
如果
不
使用独立项目权重:
断言 (
投影权重
是
不
无
), 使用_separate_proj_weight 为 False 但_in_proj_weight 为 None
q, k, v = _in_projection_packed(查询,
键,
值,
输入投影权重,
输入投影偏置)
else:
断言 (
q_proj_weight 是
不
无
), "use_separate_proj_weight 为 True 但 q_proj_weight 为 None"
断言 (
k_proj_weight 是
不
无
), "use_separate_proj_weight 为 True 但 k_proj_weight 为 None"
断言 (
v_proj_weight 是
不
无
), "use_separate_proj_weight 为 True 但 v_proj_weight 为 None"
如果 in_proj_bias
是
无:
b_q = b_k = b_v = 无
else:
b_q, b_k, b_v = 输入投影偏置.
数据块(3)
q, k, v = 投影中(
查询,
键,
值,
q_proj_weight,
k_proj_weight,
v_项目权重,
b_q,
b_k,
b_v,
)
预处理注意力掩码
如果
注意力掩码
是
不
无:
确保注意力掩码的维度为 3
如果
注意掩码.
暗() == 2:
确保二维尺寸正确 = (tgt_len,
源长度)
如果
注意掩码.
形状 !=
正确的二维尺寸:
raise 运行时错误(
f"2D attn_mask 的形状是{
注意掩码.
形状}
，但应该是{
正确的二维尺寸}
。
)
注意力掩码 =
注意掩码.
展平(0)
elif 注意掩码.
暗() == 3:
正确的 3D 尺寸 = (
批大小 *
头数, tgt_len,
源长度)
如果
注意掩码.
形状 !=
正确的 3D 尺寸:
raise 运行时错误(
f3D 注意力掩码的形状是{
注意掩码.
形状}
，但应该是{
正确的 3D 尺寸}
。
)
else:
raise 运行时错误(
f注意力掩码的维度{
注意掩码.
暗()}
不受支持"
)
# 在批处理维度上添加偏差（目前是第二个）
如果
偏差_k
是
不
无
和
偏置_v
是
不
无:
断言
静态键
是
无,
"偏差不能添加到静态键。"
断言 static_v
是
无,
偏差不能添加到静态值。
k = torch.猫
[k,
偏置_k.
重复(1, bsz, 1
)]])
v = torch.猫
[v,
偏置_v.
重复(1, bsz, 1
)]])
如果
注意力掩码
是
不
无:
注意力掩码 =
填充(
注意掩码, (0, 1))
如果 key_padding_mask
是
不
无:
key_padding_mask = 填充(
关键填充掩码, (0, 1))
else:
断言
偏差_k
是
无
断言
偏置_v
是
无
#
# 重新排列 q、k、v 以进行多头注意力并使它们成为批处理优先
#
q = q.视图(tgt_len,
批大小 *
头数,
头维度).
转置(0, 1)
如果
静态键
是
无:
k = k.视图(k.
形状[0
]
批大小 *
头数,
头维度).
转置(0, 1)
else:
# TODO 完成解耦控制流，这样在传递静态变量时就不会执行内投影
断言 (
静态_k.
尺寸(0) ==
批大小 *
头数
), f预期 static_k.size(0) 的值{
批大小 *
头数}
, 但得到{
静态_k.
尺寸(0)}"
断言 (
静态_k.
尺寸(2) ==
头维度
), f预期 static_k.size() 为 2{
头维度}
, 但得到{
静态_k.
尺寸(2)}"
k = 静态键
如果 static_v
是
无:
v = v.视图(v.
形状[0
]
批大小 *
头数,
头维度).
转置(0, 1)
else:
# TODO 完成解耦控制流，这样在传递静态变量时就不会执行内投影
断言 (
静态_v.
尺寸(0) ==
批大小 *
头数
), f预期 static_v.size(0) 的值{
批大小 *
头数}
, 但得到{
静态_v.
尺寸(0)}"
断言 (
静态_v.
尺寸(2) ==
头维度
), f预期 static_v.size(2) 为{
头维度}
, 但得到{
静态_v.
尺寸(2)}"
v = static_v
在批处理维度上添加零注意力（现在为第一个）
如果
添加零注意力:
零注意力形状 = (
批大小 *
头数, 1,
头维度)
k = 火把.
猫(
[k, 火把.
零值(
zero_attn_shape
零注意力形状, 数据类型=k.
数据类型,
设备=k.
设备
)]，
暗=1
)
v = 火把.
猫(
[v, 火把.
零值(
zero_attn_shape
零注意力形状, 数据类型=v.
数据类型,
设备=v.
设备
)]，
暗=1
)
如果
注意力掩码
是
不
无:
注意力掩码 =
填充(attn_mask, (0, 1))
如果 key_padding_mask
是
不
无:
key_padding_mask = 填充(
关键填充掩码, (0, 1))
# 更新调整后的源序列长度
源长度 = k.
尺寸(1)
合并填充和注意力掩码键
如果 key_padding_mask
是
不
无:
如果
不
火把.
算子.
是否正在脚本化()
和
不
火把.
算子.is_tracing():
检查键填充掩码(
关键填充掩码,
源长度, bsz)
key_padding_mask = (
关键填充掩码.
视图(bsz, 1, 1,
源长度)
.展开(-1,
头数, -1, -1)
.重塑(
批大小 *
头数, 1,
源长度)
)
如果
注意力掩码
是
无:
注意力掩码 = key_padding_mask
else:
注意力掩码 =
注意力掩码 + key_padding_mask
调整 dropout 概率
如果
不
训练:
dropout 概率 = 0.0
#
（深呼吸）计算注意力与输出投影
#
如果
需要的权重:
_B, _Nt, E = q.形状
q_scaled = q * 数学.
平方根(1.0 / float(E))
断言
不 (
是因果的
和
注意力掩码
是
无
), "FIXME：is_causal 对 need_weights 未实现"
如果
注意力掩码
是
不
无:
attn_output_weights = torch.抱歉，您提供的文本 "baddbmm" 似乎没有明确的意义或上下文，因此无法进行准确的翻译。请提供具有明确意义的文本以便翻译(
注意掩码,
q 缩放, k.
转置(-2, -1)
)
else:
attn_output_weights = torch.bmm(q 缩放, k.
转置(-2, -1))
attn_output_weights = 软式最大化(
注意力输出权重,
暗=-1)
如果
dropout 概率 > 0.0:
attn_output_weights = dropout(注意力输出权重, p=dropout_p)
attn_output = torch.bmm(注意力输出权重, v)
attn_output = (
attn_output.转置(0, 1).
连续().
视图(
目标长度 * bsz,
嵌入维度)
)
attn_output = 线性(attn_output,
输出投影权重,
输出投影偏置)
attn_output = attn_output.视图(tgt_len, bsz, attn_output.
尺寸(1))
# 可选地平均头注意力权重
attn_output_weights = 注意力输出权重.
视图(bsz,
头数, tgt_len,
源长度)
如果
平均注意力权重:
attn_output_weights = 注意力输出权重.
均值(
暗=1)
如果
不
批处理:
如果输入未批处理，则压缩输出
attn_output = attn_output.挤压(1)
attn_output_weights = 注意力输出权重.
挤压(0)
返回 attn_output, attn_output_weights
else:
# attn_mask 可以是(L,S)或者(N*num_heads, L, S)
# 如果 attn_mask 的形状是(1, L, S)，我们需要将其展平为(1, 1, L, S)
# 为了与输入的 SDPA 形状(N, num_heads, L, S)相匹配
如果
注意力掩码
是
不
无:
如果
注意掩码.
尺寸(0) == 1
和 attn_mask.
暗() == 3:
注意力掩码 = attn_mask.
展平(0)
else:
注意力掩码 = attn_mask.
视图(bsz,
头数, -1,
源长度)
q = q.视图(bsz,
头数, tgt_len,
头维度)
k = k.视图(bsz,
头数,
源长度,
头维度)
v = v.视图(bsz,
头数,
源长度,
头维度)
attn_output = 扩放点积注意力(
q, k, v, 注意掩码, dropout_p,
是因果的
)
attn_output = (
attn_output.排列(2, 0, 1, 3).
连续().
视图(
批大小 * tgt_len,
嵌入维度)
)
attn_output = 线性(attn_output,
输出投影权重,
输出投影偏置)
attn_output = attn_output.视图(tgt_len, bsz, attn_output.
尺寸(1))
如果
不
批处理:
如果输入未批处理，则压缩输出
attn_output = attn_output.挤压(1)
返回 attn_output,
无
