# mypy: 允许未类型化定义
来自
打字
导入
可调用,
可选,
联合
来自 typing_extensions
导入
已弃用
来自
火炬
导入
张量
来自 torch.nn
导入
_减少
作为
_减少,
功能性
作为 F
来自
.距离
导入
成对距离
来自
.模块
导入
模块
__all__ = [
"L1 损失",
"负对数似然损失",
"NLLLoss2d",
"PoissonNLLLoss",
"GaussianNLLLoss",
"KLDivLoss",
"MSELoss",
"BCELoss",
"BCEWithLogitsLoss",
"HingeEmbeddingLoss",
"MultiLabelMarginLoss",
"SmoothL1Loss",
"HuberLoss",
"SoftMarginLoss",
"交叉熵损失",
"多标签软间隔损失",
"余弦嵌入损失",
"边界排序损失",
"MultiMarginLoss",
"TripletMarginLoss",
"TripletMarginWithDistanceLoss",
"CTCLoss",
]
类 _Loss(
模块):
缩减:
字符串
def 初始化(self,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值) ->
无:
超级().
初始化()
如果 size_average
是 not
无
或 reduce
是 not
无:
self.缩减:
字符串 =
_减少.
旧版获取字符串(
平均大小,
减少)
否则:
self.减少 =
减少
类
_加权 Loss(_Loss):
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.注册缓冲区(
权重,
重量)
self.重量:
可选[
张量]
[文档]
类 L1Loss(_Loss):
r创建一个测量输入 :math:`x` 和目标 :math:`y` 中每个元素之间平均绝对误差 (MAE) 的准则。
未归一化的损失（即 :attr:`reduction` 设置为 ``'none'``）可以描述为：
未归一化（即：将：attr:`reduction` 设置为 ``'none'``）的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = |x_n - y_n|,
其中 :math:`N` 是批大小。如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{如果 reduction} = \text{`sum'.}
\end{cases}
math:`x` 和 :math:`y` 是任意形状的张量，其总形状为
每个元素有 :math:`N` 个。
求和操作仍然对所有元素进行操作，并除以 :math:`N`。
如果设置 `reduction = 'sum'`，则可以避免除以 :math:`N`。
支持实值和复值输入。
Args:
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则
(*), 与输入具有相同形状。
示例：
>>> 损失 = nn.L1Loss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()
"源代码"
常量 = [
"减少"]
def 初始化(self,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值) ->
无:
超级().
初始化(
平均大小,
减少,
缩减)
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
l1_loss：L1 损失(
输入,
目标,
缩减=self.
缩减)
[文档]
类 NLLLoss(
_加权 Loss):
r负对数似然损失。它用于训练分类
`C`类的问题。
如果提供，可选参数 :attr:`weight` 应该是一个分配给每个类别的 1D 张量。
这在训练集不平衡时尤其有用。
不平衡的训练集。
通过正向调用提供的 `input` 应包含每个类别的对数概率。`input` 必须是一个大小为 `(minibatch, C)` 或 `(minibatch, C, d_1, d_2, ..., d_K)` 的张量
其中 :math:`K \geq 1` 对于 `K` 维情况。后者对于具有多个维度的输入很有用
math:`(minibatch, C)` 或 :math:`(minibatch, C, d_1, d_2, ..., d_K)`
的情况。其中 :math:`K \geq 1` 对于 `K` 维情况。后者对于具有多个维度的输入很有用
高维输入，例如为 2D 图像计算每个像素的 NLL 损失。
在神经网络中获取对数概率很容易，只需在网络的最后一层添加一个`LogSoftmax`层。
如果您不想添加额外的层，可以使用`CrossEntropyLoss`。
您可以选择使用`CrossEntropyLoss`，如果您不希望添加额外的层。
层。
此损失函数期望的目标 `target` 应该是一个范围在 :math:`[0, C-1]` 之间的类别索引
其中 `C = 类别数量`; 如果指定了 `ignore_index`，此损失函数也接受
此类别索引（此索引不一定在类别范围内）。
未归一化（即：将：attr:`reduction` 设置为 ``'none'``）的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = - w_{y_n} x_{n,y_n}, \quad
w_{c} = \text{weight}[c] \cdot \mathbb{1}\{c \not= \text{ignore\_index}\},
当 :math:`x` 是输入，:math:`y` 是目标，:math:`w` 是权重时，
math:`N` 是批量大小。如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则
.. math::
\ell(x, y) = \begin{cases}
\sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{y_n}} l_n, &
\text{if reduction} = \text{`mean';}\\
\sum_{n=1}^N l_n, &
\text{if reduction} = \text{`sum'}.
\end{cases}
Args:
权重（Tensor，可选）：为每个类别提供的手动缩放权重。如果提供，必须是一个大小为 `C` 的 Tensor。
类。如果提供，它必须是一个大小为 `C` 的张量。否则，它就是
被视为全为 1。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 `reduce` 属性为 `False`。默认值：`None`
忽略索引（int，可选）：指定一个要忽略的目标值
并且不贡献于输入梯度。
当 :attr:`size_average` 为 ``True`` 时，损失会在非忽略的目标上平均。
非忽略的目标上。
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
而不是批元素，并忽略 :attr:`size_average`。默认：``None``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'`` | ``'mean'`` | ``'sum'``。``'none'``：不进行降维
应用于，``'mean'``：取输出值的加权平均值
'sum'：输出将被求和。注意：:attr:`size_average`
`and :attr:`reduce` 正在弃用中，并且`
同时，指定这两个参数中的任何一个都将覆盖
attr:`reduction`。默认值：``'mean'``
形状::
- 输入：:math:`(N, C)` 或 :math:`(C)`，其中 `C = 类别数量`，`N = 批处理大小`，或
(N, C, d₁, d₂, ..., dₖ) 其中 K ≥ 1
在 `K` 维度损失的情况下。
- 目标：N 或 ( )，其中每个值是
0 ≤ targets[i] ≤ C-1，或者
(N, d₁, d₂, ..., dₖ) 其中 K ≥ 1 的情况下
K 维损失。
- 输出：如果 :attr:`reduction` 是 ``'none'``，形状 :math:`(N)` 或
math:`(N, d_1, d_2, ..., d_K)`，其中 :math:`K \geq 1` 为 K 维损失的情况。
否则，为标量。
示例：
>>> log_softmax = nn.LogSoftmax(dim=1)
>>> loss_fn = nn.NLLLoss()
>>> # 输入到 NLLLoss 的大小为 N x C = 3 x 5
>>> input = torch.randn(3, 5, requires_grad=True)
>>> # 目标中的每个元素值必须满足 0 <= value < C
>>> target = torch.tensor([1, 0, 4])
>>> loss = loss_fn(log_softmax(input), target)
>>> loss.backward()
...
...
>>> # 2D 损失示例（例如，用于图像输入）
>>> N, C = 5, 4
>>> loss_fn = nn.NLLLoss()
>>> data = torch.randn(N, 16, 10, 10)
>>> conv = nn.Conv2d(16, C, (3, 3))
>>> log_softmax = nn.LogSoftmax(dim=1)
>>> # 输出 conv 前向的结果形状为 [N, C, 8, 8]
>>> output = log_softmax(conv(data))
>>> # 目标中的每个元素值必须满足 0 <= value < C
>>> target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
>>> # NLLLoss 的输入大小为 N x C x 高度（8）x 宽度（8）
>>> loss = loss_fn(output, target)
>>> loss.backward()
"源代码"
常量 = [
"忽略索引",
"减少"]
忽略索引:
整型
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
忽略索引:
整型 = -100,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
重量,
平均大小,
减少,
缩减)
self.ignore_index = ignore_index
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.nll_loss(
输入,
目标,
重量=self.
重量,
忽略索引=self.
忽略索引,
缩减=self.
缩减,
)
@deprecated(
"NLLLoss2d 已弃用。"
"请使用 `NLLLoss` 作为直接替换，并查看 "
"https://maskerprc.github.io/docs/main/nn.html#torch.nn.NLLLoss 以获取更多详细信息。",
分类=
未来警告,
)
类 NLLLoss2d(NLLLoss):
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
忽略索引:
整型 = -100,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
重量,
平均大小,
忽略索引,
减少,
缩减)
[文档]
类 PoissonNLLLoss(_Loss):
r带有泊松分布的目标的负对数似然损失。
损失可以描述为：
.. math::
\text{目标} \sim \mathrm{Poisson}(\text{输入})
损失函数（输入，目标）= 输入 - 目标 * log(输入)
+ log(target!)
最后一项可以省略或用斯特林公式近似。
近似用于大于 1 的目标值。对于小于或等于 1 的目标
添加 1 个零到损失中。
Args:
log_input (bool, 可选): 如果为 ``True``，则损失计算为
math:`\exp(\text{input}) - \text{target}*\text{input}`，如果为 ``False``，则损失为
math:`\text{input} - \text{target}*\log(\text{input}+\text{eps})`。
full (bool, 可选): 是否计算完整损失，即添加
斯特林近似项
.. 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”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
示例：
>>> 损失函数 = nn.PoissonNLLLoss()
>>> log_input = torch.randn(5, 2, requires_grad=True)
>>> target = torch.randn(5, 2)
>>> output = loss(log_input, target)
>>> output.backward()
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：默认为标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(*)`，
输入相同的形状。
"源代码"
常量 = ["log_input",
全部,
eps,
"减少"]
日志输入:
布尔类型
full: 布尔类型
eps: 浮点数
def 初始化(
self,
日志输入:
布尔类型 = True,
full: 布尔类型 =
错误,
平均大小=
无,
eps: 浮点数 = 1e-8,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.日志输入 =
日志输入
self.完整 =
完整
self.eps = eps
def 前向(self,
日志输入:
张量,
目标:
张量) ->
张量:
返回 F.
泊松 NLL 损失(
日志输入,
目标,
日志输入=self.
日志输入,
full=self.full,
eps=self.eps,
缩减=self.
缩减,
)
[文档]
类
高斯负对数似然损失(_Loss):
r高斯负对数似然损失。
目标被视为高斯分布的样本处理
神经网络预测的预期和偏差。对于
目标张量建模为具有高斯分布的张量
输入期望 ``input`` 和正方差张量 ``var`` 的损失为：
.. math::
\text{loss} = \frac{1}{2}\left(\log\left(\text{max}\left(\text{var}, \text{eps}\right)\right) + \frac{\left(\text{input} - \text{target}\right)^2}{\text{max}\left(\text{var}, \text{eps}\right)}\right) + \text{const.}
\ \text{eps}用于稳定性。默认情况下，常数项为
{\text{max}\left(\text{var}, \ \text{eps}\right)}\right) + \text{const.}
其中 :attr:`eps` 用于稳定性。默认情况下，常数项为
损失函数被省略，除非 `:attr:`full` 为 `True`。如果 `var` 不相同
大小作为“输入”（由于同方差假设），它必须具有最终维度
1 或具有一个维度更少（其他尺寸相同）以进行正确广播。
Args:
完整（布尔值，可选）：在损失中包含常数项
计算。默认：``False``。
eps（浮点数，可选）：用于限制 ``var`` 的值（见下文说明），
稳定性。默认：1e-6。
reduction（字符串，可选）：指定要应用到的
`none` | `mean` | `sum`。`none`：不进行降维
将被应用，`mean`：输出是所有批次成员损失的均值
，`sum`：输出是所有批次成员损失的总和。
默认：`mean`。
形状：
- 输入：:math:`(N, *)` 或 :math:`(*)`，其中 :math:`*` 表示任意数量的附加
尺寸
- 目标：:math:`(N, *)` 或 :math:`(*)`，与输入形状相同，或与输入形状相同
但其中一个维度等于 1（以允许广播）
- 变量：:math:`(N, *)` 或 :math:`(*)`，与输入形状相同，或与输入形状相同但
维度为 1，或者与输入具有相同形状但少一个维度（以允许广播），或者是一个标量值
- 输出：如果：attr:`reduction` 是 ``'mean'``（默认）或 ``'sum'``，则为标量。如果：attr:`reduction` 是 ``'none'``，则为 (N, *) 形状
- 输出：如果：attr:`reduction` 是 ``'mean'``（默认）或 ``'sum'``，则为标量。如果：attr:`reduction` 是 ``'none'``，则为 (N, *) 形状
- 输出：如果：attr:`reduction` 是 ``'mean'``（默认）或 ``'sum'``，则为标量。如果：attr:`reduction` 是 ``'none'``，则为 (N, *) 形状
输入的形状
示例：
>>> loss = nn.GaussianNLLLoss()
>>> input = torch.randn(5, 2, requires_grad=True)
>>> target = torch.randn(5, 2)
>>> var = torch.ones(5, 2, requires_grad=True) # 异方差性
>>> output = loss(input, target, var)
>>> output.backward()
>>> loss = nn.GaussianNLLLoss()
>>> input = torch.randn(5, 2, requires_grad=True)
>>> target = torch.randn(5, 2)
>>> var = torch.ones(5, 1, requires_grad=True) # 均匀分布
>>> output = loss(input, target, var)
>>> output.backward()
注意：
The clamping of ``var`` is ignored with respect to autograd, and so the
渐变不受其影响。
参考文献：
Nix, D. A. 和 Weigend, A. S.，“估计目标概率分布的均值和方差”，1994 年 IEEE 国际会议论文集
目标概率分布的均值和方差估计，1994 年 IEEE 国际会议论文集
神经网络会议（ICNN'94），奥兰多，佛罗里达州，美国，1994 年，第 55-60 页
第 1 卷，doi: 10.1109/ICNN.1994.374138.
"源代码"
常量 = [
全部,
eps,
"减少"]
full: 布尔类型
eps: 浮点数
def 初始化(
self, *, full: 布尔类型 =
错误, eps:
浮点数 = 1e-6,
缩减:
字符串 =
平均值
) -> 无:
超级().
初始化(
无,
无,
缩减)
self.完整 =
完整
self.eps = eps
def 前向(
self, 输入:
张量,
目标:
张量,
变量:
联盟[
张量, float]
) -> 张量:
返回 F.
高斯负对数似然损失(
输入,
目标,
变量, full=self.full, eps=self.eps,
缩减=self.
减少
)
[文档]
类
Kullback-Leibler 散度损失(_Loss):
r“Kullback-Leibler 散度损失。”
对于形状相同的张量 :math:`y_{\text{pred}},\ y_{\text{true}}`，
其中 :math:`y_{\text{pred}}` 是 :attr:`输入`，:math:`y_{\text{true}}` 是 :attr:`目标`，
我们定义 **点 wise KL 散度** 为
.. math::
L(y_{\text{pred}},\ y_{\text{true}})
= y_{\text{true}} \cdot \log \frac{y_{\text{true}}}{y_{\text{pred}}}
= y_{\text{true}} \cdot (\log y_{\text{true}} - \log y_{\text{pred}})
为了避免在计算此数量时出现下溢问题，此损失函数期望在对数空间中的：attr:`input`。：attr:`target` 参数也可以提供
attr:`input` 在对数空间中。参数：attr:`target` 也可以提供
如果 :attr:`log_target` 等于 True，则记录空间。
总结来说，这个函数大致等同于计算。
.. 代码块 :: python
如果不使用 log_target：# 默认
loss_pointwise = target * (target.log() - input)
否则:
loss_pointwise = target.exp() * (target - input)
然后根据参数 :attr:`reduction` 减少这个结果
.. 代码块 :: python
if reduction == "mean": # 默认
loss = loss_pointwise.mean()
elif reduction == "batchmean": # 数学上正确
loss = loss_pointwise.sum() / input.size(0)
elif reduction == "sum":
loss = loss_pointwise.sum()
else: # reduction == "none"
loss = loss_pointwise
.. 注意::
与 PyTorch 中的其他所有损失函数一样，此函数期望第一个参数，
attr:`input`，为模型的输出（例如神经网络）
并且第二个，:attr:`target`，表示数据集中的观测值。
这与标准数学符号 :math:`KL(P\ ||\ Q)` 不同，
其中 :math:`P` 表示观测值的分布，:math:`Q` 表示模型。
.. 警告::
attr:`reduction`\ `= "mean"` 并不返回真正的 KL 散度值，请使用
`:attr:`reduction` = "batchmean"` 与数学定义一致。
Args:
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为 `False`，则损失将分别对每个小批量求和。当 :attr:`reduce` 为 `False` 时忽略。默认：`True`
当 :attr:`reduce` 为 `False` 时忽略。默认：`True`
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为`False`时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：`True`
减少（str，可选）：指定应用于输出的减少方式。默认："mean"
log_target（布尔值，可选）：指定`target`是否为对数空间。默认：`False`
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 默认情况下为标量输出。如果 :attr:`reduction` 为 `'none'`，则 :math:`(*)`，
- 与输入具有相同的形状。
示例：
- >>> kl_loss = nn.KLDivLoss(reduction="batchmean")
>>> # 输入应为对数空间中的分布
>>> input = F.log_softmax(torch.randn(3, 5, requires_grad=True), dim=1)
>>> # 从数据集中采样一批分布。通常这会来自数据集
>>> target = F.softmax(torch.rand(3, 5), dim=1)
>>> output = kl_loss(input, target)
>>> kl_loss = nn.KLDivLoss(reduction="batchmean", log_target=True)
>>> log_target = F.log_softmax(torch.rand(3, 5), dim=1)
>>> output = kl_loss(input, log_target)
"源代码"
常量 = [
"减少"]
def 初始化(
self,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
日志目标:
布尔类型 =
错误,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.对数目标 =
对数目标
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.kl_div(
输入,
目标,
缩减=self.
缩减,
日志目标=self.
对数目标
)
[文档]
类 MSELoss(_Loss):
r创建一个衡量输入 :math:`x` 和目标 :math:`y` 中每个元素之间均方误差（平方 L2 范数）的准则。
未归一化的损失（即：:attr:`reduction` 设置为 ``'none'``）可以描述为：
未归一化（即：将：attr:`reduction` 设置为 ``'none'``）的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = (x_n - y_n)^2,
其中 :math:`N` 是批大小。如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L)，& \text{如果} \text{reduction} = \text{`sum'}.
\end{cases}
math:`x` 和 :math:`y` 是任意形状的张量，其总形状为
每个元素有 :math:`N` 个。
均值操作仍然对所有元素进行操作，并除以 :math:`N`。
如果设置 `reduction = 'sum'`，则可以避免除以 :math:`N`。
Args:
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
示例：
>>> 损失 = nn.MSELoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()
"源代码"
常量 = [
"减少"]
def 初始化(self,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值) ->
无:
超级().
初始化(
平均大小,
减少,
缩减)
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.mse_loss(
输入,
目标,
缩减=self.
缩减)
[文档]
类 BCELoss(
_加权 Loss):
r创建一个衡量目标与输入概率之间二元交叉熵的准则：
输入概率：
未归一化（即：将：attr:`reduction` 设置为 ``'none'``）的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = - w_n * [y_n * log x_n + (1 - y_n) * log (1 - x_n)],
其中 :math:`N` 是批大小。如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则
.. math::
\ell(x, y) = \begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{如果 reduction} = \text{`sum'.}
\end{cases}
这是用于测量重建误差，例如
一个自动编码器。注意，目标 :math:`y` 应该是数字
在 0 和 1 之间。
注意，如果 :math:`x_n` 是 0 或 1，上述损失方程中的一个对数项将是
在上述损失方程中，如果 :math:`x_n` 是 0 或 1，则其中一个对数项将是数学上未定义的。PyTorch 选择将其设置为
math:`log(0) = -∞`，因为 :math:`lim_{x→0} log(x) = -∞`。
然而，损失方程中的无穷项并不理想，原因有几个。
首先，如果 :math:`y_n = 0` 或 :math:`(1 - y_n) = 0`，那么我们就会
将 0 与无穷相乘。其次，如果我们有一个无穷大的损失值，那么
我们梯度中也会有一个无穷项，
\lim_{x\to 0} \frac{d}{dx} \log (x) = \infty。
这将使得 BCELoss 的反向传播相对于 \( x_n \) 非线性，
使用它进行诸如线性回归等操作将不会简单直接。
我们的解决方案是 BCELoss 将其对数函数输出限制为大于或等于 -100。这样，我们总能有一个有限的损失值和线性反向方法。
或者等于 -100。这样，我们总能有一个有限的损失值和线性反向方法。
的反向方法。
Args:
权重（张量，可选）：分配给损失的手动缩放权重
每个批次元素的总量。如果提供，必须是大小为 `nbatch` 的张量。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 为 ``'none'``，则 :math:`(*)`，与输入相同。
输入形状。
示例：
>>> m = nn.Sigmoid()
>>> 损失 = nn.BCELoss()
>>> input = torch.randn(3, 2, requires_grad=True)
>>> target = torch.rand(3, 2, requires_grad=False)
>>> 输出 = 损失(m(input), target)
>>> output.backward()
"源代码"
常量 = [
"减少"]
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
重量,
平均大小,
减少,
缩减)
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
二元交叉熵(
输入,
目标,
重量=self.
重量,
缩减=self.
减少
)
[文档]
类 BCEWithLogitsLoss(_Loss):
r这个损失函数结合了一个 `Sigmoid` 层和 `BCELoss`，实现为一个单一
的类。这个版本比使用普通的 `Sigmoid` 后跟 `BCELoss` 更数值稳定，
因为通过将操作合并到一个层中，...
我们利用对数和指数技巧来保证数值稳定性。
未归一化（即：将：attr:`reduction` 设置为 ``'none'``）的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = - w_n \left[ y_n \cdot \log \sigma(x_n) \right]
+ (1 - y_n) * log(1 - σ(x_n)) ]
其中 :math:`N` 是批大小。如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则
.. math::
\ell(x, y) = \begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{如果 reduction} = \text{`sum'.}
\end{cases}
这是用于测量重建误差，例如
一个自编码器。注意，目标`t[i]`应该是数字
在 0 和 1 之间。
通过为正例添加权重，可以权衡召回率和精确度。
在多标签分类的情况下，损失可以描述为：
.. math::
\ell_c(x, y) = L_c = \{l_{1,c},\dots,l_{N,c}\}^\top,
l_{n,c} = - w_{n,c} [p_c y_{n,c} · log σ(x_{n,c})]
+（1 - y_{n,c}）· log（1 - σ(x_{n,c}））]
其中 :math:`c` 是类别数（对于多标签二分类，:math:`c > 1`）
对于单标签二分类，:math:`c = 1`
math:`n` 是批次中样本的数量
math:`p_c` 是类别 :math:`c` 正确答案的权重
math:`p_c > 1` 会增加召回率，:math:`p_c < 1` 会增加精确度
例如，如果一个数据集包含一个类别的 100 个正例和 300 个负例，
类的 ``pos_weight`` 应该等于 :math:`\frac{300}{100}=3`。
损失将作用于数据集包含 :math:`3\times 100=300` 个正例的情况。
示例：
>>> target = torch.ones([10, 64], dtype=torch.float32) # 64 个类别，批大小 = 10
>>> output = torch.full([10, 64], 1.5) # 一个预测（logit）
>>> pos_weight = torch.ones([64]) # 所有权重都等于 1
>>> criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
>>> criterion(output, target) # -log(sigmoid(1.5))
tensor(0.20...)
在上述示例中，`pos_weight` 张量的元素对应于 64 个不同的类别
在多标签二进制分类场景中，`pos_weight` 中的每个元素都旨在根据相应类别的正负样本之间的不平衡来调整损失函数
这种方法在类别不平衡程度不同的数据集中很有用，确保损失
这种方法在类别不平衡程度不同的数据集中很有用，确保损失函数能够反映正负样本的不平衡情况
准确计算了每个类别的分布。
Args:
权重（张量，可选）：分配给损失的手动缩放权重
每个批次元素的总量。如果提供，必须是大小为 `nbatch` 的张量。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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]。
在所有空间维度上对 2D 多分类目标 [C, H, W] 使用：[C, 1, 1]。
默认：`None`
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 为 ``'none'``，则 :math:`(*)`，与输入相同。
输入形状。
示例：
>>> 损失 = nn.BCEWithLogitsLoss()
>>> input = torch.randn(3, requires_grad=True)
>>> target = torch.empty(3).random_(2)
>>> output = loss(input, target)
>>> output.backward()
"源代码"
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
正向权重:
可选[
张量] =
无,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.注册缓冲区(
权重,
重量)
self.注册缓冲区(
"正则权重",
正向权重)
self.重量:
可选[
张量]
self.正向权重:
可选[
张量]
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
二元交叉熵（对数）(
输入,
目标,
self.重量,
正向权重=self.
正向权重,
缩减=self.
缩减,
)
[文档]
类 HingeEmbeddingLoss(_Loss):
r评估给定输入张量 :math:`x` 和标签张量 :math:`y` （包含 1 或 -1）的损失
。
这通常用于衡量两个输入是否相似或
不相同，例如使用 L1 成对距离作为：math:`x`，通常
用于学习非线性嵌入或半监督学习。
小批量中第 n 个样本的损失函数为
.. math::
l_n =
x_n, & \text{if}\; y_n = 1,\\
\max \{0, margin - x_n\}, & \text{if}\; y_n = -1,
\end{cases}
总损失函数是
.. math::
\ell(x, y) = \begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{如果 reduction} = \text{`sum'.}
\end{cases}
其中 :math:`L = \{l_1,\dots,l_N\}^\top`.
Args:
边界（float，可选）：具有默认值 `1`.
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(*)` 其中 :math:`*` 表示，任意数量的维度。求和操作
在所有元素上执行。
- 目标：:math:`(*)`，与输入形状相同
- 输出：标量。如果 :attr:`reduction` 为 ``'none'``，则与输入形状相同
"源代码"
常量 = [
边距,
"减少"]
边距:
浮点数
def 初始化(
self,
边距:
浮点数 = 1.0,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.边距 =
边距
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
齐次嵌入损失(
输入,
目标,
边距=self.
边距,
缩减=self.
减少
)
[文档]
类
多标签边界损失(_Loss):
r创建一个优化输入 :math:`x`（一个 2D mini-batch `Tensor`）和输出 :math:`y`（它是一个 2D `Tensor`，包含目标类索引）之间多类别多分类的边界损失（基于边界的损失）的准则。
hinge 损失（基于边界的损失）
和输出 :math:`y`（它是一个 2D `Tensor`，包含目标类索引）。
对于每个小批量中的样本：
.. math::
\text{损失}(x, y) = \sum_{ij}\frac{\max(0, 1 - (x[y[j]] - x[i]))}{\text{x.size}(0)}
其中 :math:`x \in \left\{0, \; \cdots , \; \text{x.size}(0) - 1\right\}`, \
math:`y \in \left\{0, \; \cdots , \; \text{y.size}(0) - 1\right\}`, \
\(0 \leq y[j] \leq \text{x.size}(0)-1\)，
且对于所有 \(i\) 和 \(j\)，有 \(i \neq y[j]\)。
\(y\) 和 \(x\) 必须具有相同的大小。
该标准仅考虑连续的非负目标块。
从前面开始。
这允许不同的样本具有不同数量的目标类别。
Args:
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(C)` 或 :math:`(N, C)`，其中 `N` 是批大小，`C` 是类别数。
是类别数量。
- 目标：:math:`(C)` 或 :math:`(N, C)`，标签目标填充为 -1，确保与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(N)`。
示例：
>>> 损失 = nn.MultiLabelMarginLoss()
>>> x = torch.FloatTensor([[0.1, 0.2, 0.4, 0.8]])
>>> # 对于目标 y，仅考虑标签 3 和 0，不包括标签 -1 之后
>>> y = torch.LongTensor([[3, 0, -1, 1]])
>>> # 0.25 * ((1-(0.1-0.2)) + (1-(0.1-0.4)) + (1-(0.8-0.2)) + (1-(0.8-0.4)))
>>> loss(x, y)
tensor(0.85...)
"源代码"
常量 = [
"减少"]
def 初始化(self,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值) ->
无:
超级().
初始化(
平均大小,
减少,
缩减)
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
多标签边际损失(
输入,
目标,
缩减=self.
缩减)
[文档]
类 SmoothL1Loss(_Loss):
r"""创建一个使用平方项的准则，如果绝对值
它对异常值不如 :class:`torch.nn.MSELoss` 敏感，在某些情况下
它对异常值不如 :class:`torch.nn.MSELoss` 敏感，在某些情况下
防止梯度爆炸（例如，参见 Ross Girshick 的论文《Fast R-CNN》_）。
对于大小为 :math:`N` 的一批数据，未归一化的损失可以描述为：
.. math::
\ell(x, y) = L = {l_1, ..., l_N}^T
的
.. math::
l_n =
0.5(x_n - y_n)^2 / β，& 若 |x_n - y_n| < β
|x_n - y_n| - 0.5 * β，& 否则
\end{cases}
如果 `reduction` 不是 `none`，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L)，& \text{如果} \text{reduction} = \text{`sum'}.
\end{cases}
.. 注意::
平滑 L1 损失可以看作是正好等于 :class:`L1Loss`，但将 :math:`|x - y| < beta`
的部分替换为一个二次函数，使其在 :math:`|x - y| = beta` 时的斜率为 1。
二次段平滑了在 :math:`|x - y| = 0` 附近的 L1 损失。
.. 注意::
平滑 L1 损失与 :class:`HuberLoss` 密切相关
相当于：`huber(x, y) / beta`（注意平滑 L1 的 beta 超参数是）
也称为 Huber 的 delta。这导致以下差异：
* 当 beta -> 0 时，Smooth L1 损失收敛到 :class:`L1Loss`，而 :class:`HuberLoss`
损失收敛到一个常数 0 损失。当 beta 为 0 时，Smooth L1 损失等同于 L1 损失。
* 当 beta -> :math:`+∞`时，Smooth L1 损失收敛到一个常数 0 损失，而
class:`HuberLoss`收敛到 :class:`MSELoss`。
对于 Smooth L1 损失，随着 beta 的变化，损失函数的 L1 部分具有恒定的斜率为 1。
对于: class:`HuberLoss`，L1 部分的斜率为 beta。
.. _`Fast R-CNN`: https://arxiv.org/abs/1504.08083
Args:
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
beta (浮点数，可选)：指定在 L1 损失和 L2 损失之间切换的阈值。
该值必须为非负数。默认：1.0
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(*)`，与输入具有相同的形状。
"源代码"
常量 = [
"减少"]
def 初始化(
self, 平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
测试版:
浮点数 = 1.0
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.测试版 =
测试版
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
平滑 L1 损失(
输入,
目标,
缩减=self.
缩减,
测试版=self.
测试版)
[文档]
类 HuberLoss(_Loss):
r"""创建一个使用平方项的准则，如果绝对值
函数使用平方项如果元素级误差低于 delta，否则使用 delta 缩放的 L1 项。
这种损失结合了`:class:`L1Loss`和`:class:`MSELoss`的优点；
delta-scaled L1 区域使损失对异常值比 :class:`MSELoss` 更不敏感
当 L2 区域在 0 附近对:class:`L1Loss`提供平滑性时。
Huber 损失 了解更多信息。
对于大小为 :math:`N` 的一批数据，未归一化的损失可以描述为：
.. math::
\ell(x, y) = L = {l_1, ..., l_N}^T
的
.. math::
l_n =
0.5 (x_n - y_n)^2, & \text{如果 } |x_n - y_n| < delta
delta * (|x_n - y_n| - 0.5 * delta), & \text{否则 }
\end{cases}
如果 `reduction` 不是 `none`，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L)，& \text{如果} \text{reduction} = \text{`sum'}.
\end{cases}
.. 注意::
当 delta 设置为 1 时，这个损失等同于 :class:`SmoothL1Loss`。
通常，这个损失与 :class:`SmoothL1Loss` 相差一个 delta（又称 beta）因子。
在 Smooth L1 中）。
请参阅：class:`SmoothL1Loss`以了解两个损失函数行为差异的进一步讨论。
两个损失函数之间的差异。
Args:
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
输出元素，``'sum'``：输出将被求和。默认：``'mean'``。
delta（浮点数，可选）：指定在 delta 缩放 L1 和 L2 损失之间切换的阈值。
值必须是正数。默认值：1.0
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
- 目标：:math:`(*)`，与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(*)`，与输入具有相同的形状。
"源代码"
常量 = [
"减少", "delta"]
def 初始化(self,
缩减:
字符串 =
平均值,
Δ:
浮点数 = 1.0) ->
无:
超级().
初始化(
缩减=
缩减)
self.delta = delta
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
胡伯损失(
输入,
目标,
缩减=self.
缩减,
Δ=self.
Δ)
[文档]class SoftMarginLoss(_Loss):
r"""创建一个优化输入张量 :math:`x` 和目标张量 :math:`y` 之间（包含 1 或 -1）的两类分类逻辑损失的准则
(containing 1 or -1).
(包含 1 或 -1)之间的逻辑损失的准则。
数学公式
损失函数为：\text{loss}(x, y) = \sum_i \frac{\log(1 + \exp(-y[i]*x[i]))}{\text{x.nelement}()}
参数：
size_average (布尔值，可选)：已弃用（参见 :attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 :attr:`reduce` 为 ``False`` 时忽略。默认：``True``
对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，
如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 :attr:`reduce` 为 ``False`` 时忽略。
当 :attr:`reduce` 为 ``False`` 时忽略。默认：``True``
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: 不应用任何缩减，
'mean'：输出总和将除以数量
输出元素，``'sum'``：输出将被求和。注意：:attr:`size_average`
和：attr:`reduce` 正在弃用中，同时，
指定这两个参数中的任何一个都将覆盖：attr:`reduction`。默认值：``'mean'``
形状：
- 输入：:math:`(*)`，其中 :math:`*` 表示任意数量的维度。
- 目标：:math:`(*)`，与输入形状相同。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(*)`，与输入形状相同。
- 输入形状相同。
"""
__constants__ = ["reduction"]
def __init__(self, size_average=None, reduce=None, reduction: str = "mean") -> None:
super().__init__(size_average, reduce, reduction)
def forward(self, input: Tensor, target: Tensor) -> Tensor:
return F 软间隔损失(input, target, reduction=self.reduction)
[文档]
类 CrossEntropyLoss(
_加权 Loss):
r"""此标准计算输入 logits 与目标之间的交叉熵损失
和目标。
当训练具有 `C` 个类别的分类问题时很有用。
如果提供，可选参数 :attr:`weight` 应该是一个 1D `Tensor`。
为每个类别分配权重。
这尤其适用于训练集不平衡的情况。
预期的 `input` 应包含每个类别的未归一化 logits（通常不需要是正数或求和为 1）。
`input` 必须是一个大小为 :math:`(C)` 的 Tensor，对于非批处理输入。
`input` 必须是一个大小为 :math:`(C)` 的 Tensor，对于非批处理输入。
`(minibatch, C)` 或 `(minibatch, C, d_1, d_2, ..., d_K)`，其中 `K ≥ 1` 对于 `K` 维度情况。最后一个对于高维输入很有用，例如计算 2D 图像的每个像素的交叉熵损失。
`target` 该标准期望的目标应包含以下内容：
作为一个例子，对于 2D 图像，每个像素的交叉熵损失计算很有用。
期望的目标 `target` 应包含以下内容：
- 类别索引范围：[0, C) 其中 C 是类别数；如果
`ignore_index` 被指定，此损失也接受此类索引（此索引
可能不一定在类范围内）。未缩减的（即带有：attr:`reduction`）
将此设置为 ''none'') 的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = - w_{y_n} \log \frac{\exp(x_{n,y_n})}{\sum_{c=1}^C \exp(x_{n,c})}
\cdot \mathbb{1}\{y_n \not= \text{ignore\_index}\}
其中 :math:`x` 是输入，:math:`y` 是目标，:math:`w` 是权重，
`C` 是类别数，而 `N` 覆盖了小批量维度。
对于 `K` 维度的情况，有 `d_1, ..., d_k`。
如果 `reduction` 不是 `'none'`（默认为 `'mean'`），则 ...
.. math::
\ell(x, y) = \begin{cases}
\sum_{n=1}^N \frac{1}{\sum_{n=1}^N w_{y_n} \cdot \mathbb{1}\{y_n \not= \text{ignore\_index}\}} l_n, &
\text{if reduction} = \text{`mean';}\\
\sum_{n=1}^N l_n, &
\text{if reduction} = \text{`sum'}.
\end{cases}
请注意，此情况等价于应用 :class:`~torch.nn.LogSoftmax`
在一个输入后，接着是：:class:`~torch.nn.NLLLoss`。
每个类别的概率；当每个小批量项超过一个类别标签时很有用
需要，例如用于混合标签、标签平滑等。未归一化（即带有
attr:`reduction` 设置为 ``'none'``) 此情况的损失可以描述为：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top,
l_n = - \sum_{c=1}^C w_c \log \frac{\exp(x_{n,c})}{\sum_{i=1}^C \exp(x_{n,i})} y_{n,c}
其中 :math:`x` 是输入，:math:`y` 是目标，:math:`w` 是权重，
`C` 是类别数，而 `N` 覆盖了小批量维度。
对于 `K` 维度的情况，有 `d_1, ..., d_k`。
如果 `reduction` 不是 `'none'`（默认为 `'mean'`），则 ...
.. math::
\ell(x, y) = \begin{cases}
\frac{\sum_{n=1}^N l_n}{N}, &
\text{if reduction} = \text{`mean';}\\
\sum_{n=1}^N l_n, &
\text{if reduction} = \text{`sum'}.
\end{cases}
.. 注意::
当`target`包含类别索引时，此标准的性能通常更好，因为这允许进行优化计算。
考虑仅在单个类别标签对每个 minibatch 项过于限制时，仅提供`target`的类别概率。
权重（Tensor，可选）：为每个类别提供的手动缩放权重。
Args:
权重（Tensor，可选）：为每个类别提供的手动缩放权重。
如果提供，必须是一个大小为 `C` 的浮点型 Tensor
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`reduce` 为 ``False`` 时。默认：``True``
忽略索引（int，可选）：指定一个要忽略的目标值
并且不贡献于输入梯度。当 :attr:`size_average` 为 ``True`` 时，
“True”，损失是针对非忽略目标平均的。注意，
attr:`ignore_index` 仅在目标包含类别索引时适用。
减少（布尔值，可选）：已弃用（见：attr：`reduction`）。默认情况下，
损失在每个小批量上的观测值被平均或求和
在：attr:`size_average`。当：attr:`reduce`为``False``时，返回每个样本的损失
批量元素而不是，并忽略：attr:`size_average`。默认：``True``
reduction（字符串，可选）：指定应用于输出的缩减
``'none'`` | ``'mean'`` | ``'sum'``。``'none'``：不进行降维
应用于，``'mean'``：取输出值的加权平均值
'sum'：输出将被求和。注意：:attr:`size_average`
`and :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)`，其中
在 K 维损失的情况下，K 应大于等于 1，其中每个值应在[0, C)范围内。当使用类别索引时，目标数据类型必须为长整型。如果包含类别概率，则目标必须与输入形状相同，并且每个值应在[0, 1]范围内。这意味着目标
的目标数据类型必须为长整型。如果包含类别概率，则目标必须与输入形状相同，并且每个值应在[0, 1]范围内。这意味着目标
必须与输入形状相同，并且每个值应在[0, 1]范围内。这意味着目标
使用类概率时，数据类型必须为浮点数。
- 输出：如果 reduction 为'none'，形状为：math:`()`, :math:`(N)` 或 :math:`(N, d_1, d_2, ..., d_K)`，其中 :math:`K \geq 1`
在 K 维损失的情况下，取决于输入的形状。否则，为标量。
其中：
.. math::
\begin{aligned}
C ={} & \text{类别数量} \\
N ={} & \text{批量大小} \\
\end{aligned}
示例：
>>> # 示例：带有类别索引的目标
>>> loss = nn.CrossEntropyLoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.empty(3, dtype=torch.long).random_(5)
>>> output = loss(input, target)
>>> output.backward()
...
>>> # 示例：带有概率类的目标
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5).softmax(dim=1)
>>> output = loss(input, target)
>>> output.backward()
"源代码"
常量 = ["ignore_index",
"减少", "label_smoothing"]
忽略索引:
整型
标签平滑:
浮点数
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
忽略索引:
整型 = -100,
减少=
无,
缩减:
字符串 =
平均值,
标签平滑:
浮点数 = 0.0,
) -> 无:
超级().
初始化(
重量,
平均大小,
减少,
缩减)
self.ignore_index = ignore_index
self.label_smoothing = 标签平滑
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
交叉熵(
输入,
目标,
重量=self.
重量,
忽略索引=self.
忽略索引,
缩减=self.
缩减,
标签平滑=self.
标签平滑,
)
[文档]
类
多标签软间隔损失(
_加权 Loss):
r创建一个优化多标签一对一所有类的标准
基于最大熵的损失，在输入 :math:`x` 和目标 :math:`y` 之间
\( (N, C) \).
对于每个小批量中的样本：
.. math::
损失函数 \( loss(x, y) = - \frac{1}{C} \sum_i y[i] \log\left((1 + \exp(-x[i]))^{-1}\right) \)
+ (1-y[i]) \log\left(\frac{\exp(-x[i])}{(1 + \exp(-x[i]))}\right)
当 :math:`i \in \left\{0, \; \cdots , \; \text{x.nElement}() - 1\right\}` 时，
math:`y[i] \in \left\{0, \; 1\right\}`。
Args:
权重（Tensor，可选）：为每个类别提供的手动缩放权重。如果提供，必须是一个大小为 `C` 的 Tensor。
类。如果提供，它必须是一个大小为 `C` 的张量。否则，它就是
被视为全为 1。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(N, C)` 其中 `N` 是批大小，`C` 是类别数。
- 目标：:math:`(N, C)`，标签目标必须与输入具有相同的形状。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则 :math:`(N)`。
"源代码"
常量 = [
"减少"]
def 初始化(
self,
重量:
可选[
张量] =
无,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
重量,
平均大小,
减少,
缩减)
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
多标签软边际损失(
输入,
目标,
重量=self.
重量,
缩减=self.
减少
)
[文档]
类
余弦嵌入损失(_Loss):
r"""创建一个测量给定输入张量的损失的准则
\(x_1\), \(x_2\) 以及一个标签为 \(y\) 的 `Tensor`，其值为 1 或 -1。
使用 (\(y=1\)) 来最大化两个输入之间的余弦相似度，否则使用 (\(y=-1\))。
这通常用于学习非线性
嵌入或半监督学习。
每个样本的损失函数为：
.. math::
\text{loss}(x, y) =
\begin{cases}
1 - \cos(x_1, x_2), & \text{if } y = 1 \\
\max(0, \cos(x_1, x_2) - \text{margin}), & \text{if } y = -1
\end{cases}
Args:
边距（浮点数，可选）：应为从 -1 到 1 的数字，
建议为 0 到 0.5。如果缺少 :attr:`边距`，则
默认值为 0。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入 1：:math:`(N, D)` 或 :math:`(D)`，其中 `N` 是批量大小，`D` 是嵌入维度。
- 输入 2：:math:`(N, D)` 或 :math:`(D)`，与输入 1 形状相同。
- 目标：:math:`(N)` 或 :math:`()`.
如果 :attr:`reduction` 是 ``'none'``，则 :math:`(N)`，否则标量。
示例：
>>> 损失 = nn.CosineEmbeddingLoss()
>>> input1 = torch.randn(3, 5, requires_grad=True)
>>> input2 = torch.randn(3, 5, requires_grad=True)
>>> target = torch.ones(3)
>>> output = loss(input1, input2, target)
>>> output.backward()
"源代码"
常量 = [
边距,
"减少"]
边距:
浮点数
def 初始化(
self,
边距:
浮点数 = 0.0,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.边距 =
边距
def 前向(self,
输入 1:
张量,
输入 2:
张量,
目标:
张量) ->
张量:
返回 F.
余弦嵌入损失(
输入 1,
输入 2,
目标,
边距=self.
边距,
缩减=self.
减少
)
[文档]
类
边距排序损失(_Loss):
r创建一个衡量给定损失的准则
输入：:math:`x1`, :math:`x2`, 两个 1D mini-batch 或 0D 张量
翻译：输入：:math:`x1`, :math:`x2`，两个 1D mini-batch 或 0D 张量
并且一个标签 1D mini-batch 或 0D `Tensor` :math:`y`（包含 1 或-1）。
如果 \( y = 1 \)，则假定第一个输入应该排名更高
(具有更大的值)比第二个输入大，反之亦然对于：\( y = -1 \)。
每个小批量中样本对的损失函数是：
.. math::
损失函数为：\text{loss}(x1, x2, y) = \max(0, -y * (x1 - x2) + \text{margin})
Args:
边距（浮点数，可选）：默认值为 :math:`0`。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入 1：:math:`(N)` 或 :math:`()`，其中 `N` 是批大小。
- 输入 2：:math:`(N)` 或 :math:`()`, 与输入 1 形状相同。
- 目标：:math:`(N)` 或 :math:`()`, 与输入形状相同。
- 输出：标量。如果 :attr:`reduction` 为 ``'none'`` 且输入大小不是 :math:`()`, 则 :math:`(N)`。
示例：
>>> 损失 = nn.MarginRankingLoss()
>>> input1 = torch.randn(3, requires_grad=True)
>>> input2 = torch.randn(3, requires_grad=True)
>>> target = torch.randn(3).sign()
>>> output = loss(input1, input2, target)
>>> output.backward()
"源代码"
常量 = [
边距,
"减少"]
边距:
浮点数
def 初始化(
self,
边距:
浮点数 = 0.0,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
平均大小,
减少,
缩减)
self.边距 =
边距
def 前向(self,
输入 1:
张量,
输入 2:
张量,
目标:
张量) ->
张量:
返回 F.
边缘排序损失(
输入 1,
输入 2,
目标,
边距=self.
边距,
缩减=self.
减少
)
[文档]
类
多边距损失(
_加权 Loss):
r创建一个优化多类分类的 Hinge 损失（基于边界的损失）的准则
在输入 :math:`x`（一个 2D 的小批量`Tensor`）和
输出：\(y\)（它是一个目标类别索引的 1D 张量，
\(0 \leq y \leq \text{x.size}(1)-1\)）：
对于每个 mini-batch 样本，以 1D 输入\(x\)和标量
输出\(y\)的损失为：
.. math::
loss(x, y) = \frac{\sum_i \max(0, \text{margin} - x[y] + x[i])^p}{\text{x.size}(0)}
其中 :math:`i \in \left\{0, \; \cdots , \; \text{x.size}(0) - 1\right\}`
并且 :math:`i \neq y`。
可选地，您可以通过传递非等权重的类。
将一个 1D 的：attr:`权重`张量传入构造函数。
损失函数随后变为：
.. math::
\text{loss}(x, y) = \frac{\sum_i w[y] * \max(0, \text{margin} - x[y] + x[i])^p}{\text{x.size}(0)}
Args:
p（整数，可选）：具有默认值：math:`1`。：math:`1`和：math:`2`
仅支持这些值。
边距（浮点数，可选）：默认值为 :math:`1`。
权重（Tensor，可选）：为每个类别提供的手动缩放权重。如果提供，必须是一个大小为 `C` 的 Tensor。
类。如果提供，它必须是一个大小为 `C` 的张量。否则，它就是
被视为全为 1。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
- 输入：:math:`(N, C)` 或 :math:`(C)`，其中 :math:`N` 是批大小，:math:`C` 是类别数。
- 目标：:math:`(N)` 或 :math:`()`，其中每个值是 :math:`0 \leq \text{targets}[i] \leq C-1`。
- 输出：标量。如果 :attr:`reduction` 是 ``'none'``，则与目标形状相同。
示例：
>>> 损失 = nn.MultiMarginLoss()
>>> x = torch.tensor([[0.1, 0.2, 0.4, 0.8]])
>>> y = torch.tensor([3])
>>> # 0.25 * ((1-(0.8-0.1)) + (1-(0.8-0.2)) + (1-(0.8-0.4)))
>>> loss(x, y)
tensor(0.32...)
"源代码"
常量 = [
p,
边距,
"减少"]
边距:
浮点数
p: 整型
def 初始化(
self,
p: 整型 = 1,
边距:
浮点数 = 1.0,
重量:
可选[
张量] =
无,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
) -> 无:
超级().
初始化(
重量,
平均大小,
减少,
缩减)
如果 p != 1
和 p != 2:
提升 ValueError(
"仅支持 p == 1 和 p == 2")
如果
权重
是 not
无
和
重量.
暗淡() != 1:
提升 ValueError(
f"MultiMarginLoss：期望权重为 None 或 1D 张量，实际得到 D"{
重量.
暗淡()}
而不是 D
)
self.p = p
self.边距 =
边距
def 前向(self,
输入:
张量,
目标:
张量) ->
张量:
返回 F.
多边际损失(
输入,
目标,
p=self.p,
边距=self.
边距,
重量=self.
重量,
缩减=self.
缩减,
)
[文档]
类
三元组边缘损失(_Loss):
r创建一个根据输入测量三元组损失的准则
张量：:math:`x1`, :math:`x2`, :math:`x3` 以及一个大于 :math:`0` 的边界值。
这是用于测量样本之间相对相似度的。一个三元组
由 `a`、`p` 和 `n` 组成（即 `锚点`、`正例` 和 `负例`）。
示例分别）。所有输入张量的形状应
输入文本翻译为简体中文为：
(N, D).
《Immersive Translate》中详细描述了距离交换
基于三元组损失的卷积特征描述符
V. Balntas, E. Riba 等人
每个样本在迷你批次的损失函数为：
.. math::
L(a, p, n) = max {d(a_i, p_i) - d(a_i, n_i) + 边界, 0}
哪里
.. math::
d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p
范数是使用指定的 p 值计算的，并添加了一个小的常数 :math:`\varepsilon` 以提高数值稳定性。
有关更多信息，请参阅 :class:`~torch.nn.TripletMarginWithDistanceLoss`，它计算了
有关更多信息，请参阅 :class:`~torch.nn.TripletMarginWithDistanceLoss`，它计算了
使用自定义距离函数对输入张量进行三元组边缘损失。
Args:
边缘（浮点数，可选）：默认：:math:`1`。
p（整数，可选）：成对距离的范数度。默认：:math:`2`。
eps（浮点数，可选）：用于数值稳定性的小常数。默认：:math:`1e-6`。
交换（bool，可选）：距离交换在论文中有详细描述
《使用三元组损失学习浅层卷积特征描述符》
由 V. Balntas，E. Riba 等人撰写。默认：``False``。
size_average（布尔值，可选）：已弃用（参见：attr:`reduction`）。默认情况下，
批量中的每个损失元素的平均值。注意，对于某些损失，每个样本可能有多个元素。如果将字段 :attr:`size_average` 设置为 ``False``，则损失将改为对每个小批量求和。当 reduce 为 ``False`` 时忽略。默认：``True``
一些损失函数，每个样本可能有多个元素。如果字段 :attr:`size_average`
设置为“False”，损失将分别对每个小批量进行求和。忽略
当 :attr:`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'``
形状：
输入：:math:`(N, D)` 或 :math:`(D)`，其中 :math:`D` 是向量维度。
输出：如果 :attr:`reduction` 是 ``'none'``，则形状为 :math:`(N)` 的张量。
输入形状为 :math:`(N, D)`；否则为标量。
示例：
>>> triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2, eps=1e-7)
>>> anchor = torch.randn(100, 128, requires_grad=True)
>>> positive = torch.randn(100, 128, requires_grad=True)
>>> negative = torch.randn(100, 128, requires_grad=True)
>>> output = triplet_loss(anchor, positive, negative)
>>> output.backward()
学习使用三元组损失进行浅层卷积特征描述符
https://bmva-archive.org.uk/bmvc/2016/papers/paper119/index.html
"源代码"
常量 = [
边距,
p,
eps,
交换,
"减少"]
边距:
浮点数
p: 浮点数
eps: 浮点数
交换:
布尔类型
def 初始化(
self,
边距:
浮点数 = 1.0,
p: 浮点数 = 2.0,
eps: 浮点数 = 1e-6,
交换:
布尔类型 =
错误,
平均大小=
无,
减少=
无,
缩减:
字符串 =
平均值,
):
超级().
初始化(
平均大小,
减少,
缩减)
如果
边距
≤ 0:
提升 ValueError(
fTripletMarginLoss：期望间隔大于 0，得到{
边距}
而不是
)
self.边距 =
边距
self.p = p
self.eps = eps
self.交换 =
交换
def 前向(self,
锚点:
张量,
正的:
张量,
负的:
张量) ->
张量:
返回 F.
三重边界损失(
锚点,
正的,
负的,
边距=self.
边距,
p=self.p,
eps=self.eps,
交换=self.
交换,
缩减=self.
缩减,
)
[文档]
类
三元组距离损失(_Loss):
r创建一个衡量输入三元组损失的准则
张量：:math:`a`、:math:`p` 和 :math:`n`（表示锚点）
正负示例，以及非负示例，分别），
实值函数（距离函数）用于计算关系
在锚点和正例（“正距离”）之间
锚点和负例（"负距离"）。
未归一化的损失（即，将：attr:`reduction` 设置为 ``'none'``）
可以描述为：
.. math::
\ell(a, p, n) = L = \{l_1,\dots,l_N\}^\top, \quad
l_i = \max \{d(a_i, p_i) - d(a_i, n_i) + {\rm margin}, 0\}
其中 :math:`N` 是批大小；:math:`d` 是一个非负的实值函数
量化两个张量的接近程度，称为：:attr:`距离函数`
并且 :math:`margin` 是一个非负的边界，表示最小差值
在正负距离之间，这是损失所需的
输入张量各有 \(N\) 个元素，可以是任何形状。
那个距离函数可以处理的。
如果 :attr:`reduction` 不是 ``'none'``
（默认 ``'mean'``），则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{如果 reduction} = \text{`mean';}\\
\operatorname{sum}(L)，& \text{如果} \text{reduction} = \text{`sum'}.
\end{cases}
参见 :class:`~torch.nn.TripletMarginLoss`，它使用 :math:`l_p` 距离作为距离函数来计算输入张量的三元组损失。
距离函数 (Callable, 可选): 一个非负的、实值函数，用于量化两个张量之间的接近程度。如果未指定，
Args:
距离函数 (Callable, 可选): 一个非负的、实值函数，用于量化两个张量之间的接近程度。如果未指定，
距离函数 (Callable, 可选): 一个非负的、实值函数，用于量化两个张量之间的接近程度。如果未指定，
`nn.PairwiseDistance` 将被使用。默认：`None`
(浮点数，可选)：表示最小差异的非负边距
在正负距离之间，使得损失为 0。
边际惩罚那些负例不够远离的情况
锚点相对于正例。默认值：:math:`1`。
交换（bool，可选）：是否使用论文中描述的距离交换
《使用三元组损失学习浅层卷积特征描述符》
由 V. Balntas, E. Riba 等人所著。如果为 True，并且正例更接近于
负面示例比锚点更差，交换了正面示例和锚点
损失计算。默认：``False``。
reduction (str, 可选): 指定应用于输出的（可选）缩减操作：
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``：输出总和将除以输出元素的数量，
输出元素，``'sum'``：输出将被求和。默认：``'mean'``。
形状：
输入：:math:`(N, *)` 其中 :math:`*` 代表任意数量的额外维度
支持距离函数。
输出：如果 :attr:`reduction` 是 ``'none'``，则形状为 :math:`(N)` 的张量，或者是一个标量
否则。
示例：
>>> # 初始化嵌入
>>> embedding = nn.Embedding(1000, 128)
>>> anchor_ids = torch.randint(0, 1000, (1,))
>>> positive_ids = torch.randint(0, 1000, (1,))
>>> negative_ids = torch.randint(0, 1000, (1,))
>>> 锚点 = 嵌入(锚点 ID)
>>> 正面 = 嵌入(正面 ID)
>>> 负面 = 嵌入(负面 ID)
...
>>> # 内置距离函数
>>> triplet_loss = \
>>> nn.TripletMarginWithDistanceLoss(distance_function=nn.PairwiseDistance())
>>> output = triplet_loss(anchor, positive, negative)
>>> output.backward()
...
>>> # 自定义距离函数
>>> def l_infinity(x1, x2):
>>> return torch.max(torch.abs(x1 - x2), dim=1).values
...
>>> # xdoctest: +SKIP("FIXME: 两次调用反向传播")
>>> triplet_loss = (
>>> nn.TripletMarginWithDistanceLoss(distance_function=l_infinity, margin=1.5))
>>> output = triplet_loss(anchor, positive, negative)
>>> output.backward()
...
>>> # 自定义距离函数（Lambda）
>>> triplet_loss = (
>>> nn.TripletMarginWithDistanceLoss(
>>> distance_function=lambda x, y: 1.0 - F.cosine_similarity(x, y)))
>>> output = triplet_loss(anchor, positive, negative)
>>> output.backward()
参考文献：
V. Balntas 等人：使用三元组损失学习浅层卷积特征描述符：
https://bmva-archive.org.uk/bmvc/2016/papers/paper119/index.html
"源代码"
常量 = [
边距,
交换,
"减少"]
边距:
浮点数
交换:
布尔类型
def 初始化(
self,
*,
距离函数:
可选[
可调用[[
张量,
张量
]
张量]] =
无,
边距:
浮点数 = 1.0,
交换:
布尔类型 =
错误,
缩减:
字符串 =
平均值,
):
超级().
初始化(
平均大小=
无,
减少=
无,
缩减=
缩减)
如果
边距
≤ 0:
提升 ValueError(
fTripletMarginWithDistanceLoss：期望间隔大于 0，得到{
边距}
而不是
)
self.距离函数:
可选[
可调用[[
张量,
张量
]
张量]] = (
距离函数
如果
距离函数
是 not
无
否则
对距()
)
self.边距 =
边距
self.交换 =
交换
def 前向(self,
锚点:
张量,
正的:
张量,
负的:
张量) ->
张量:
返回 F.
三重边距与距离损失(
锚点,
正的,
负的,
距离函数=self.
距离函数,
边距=self.
边距,
交换=self.
交换,
缩减=self.
缩减,
)
[文档]
类 CTCLoss(_Loss):
r“连接主义时序分类损失”
计算连续（未分割）时间序列与目标序列之间的损失。CTCLoss 对输入到目标的所有可能的对齐概率进行求和，产生一个可微分的损失值。
对输入到目标的所有可能的对齐概率进行求和，产生一个可微分的损失值。
针对每个输入节点。输入与目标的对齐假设为“多对一”，
限制目标序列的长度，使其必须小于等于输入长度。
Args:
空白（int，可选）：空白标签。默认为 0。
reduction（字符串，可选）：指定应用于输出的缩减
``'none'``：不应用缩减，``'mean'``：应用平均值缩减，``'sum'``：应用总和缩减
``'mean'``: 输出的损失将除以目标长度，然后取批次的平均值，
然后取批次的平均值，``'sum'``：输出损失将求和。
默认: ``'mean'``
zero_infinity (bool, optional):
是否将无穷大的损失及其关联的梯度置零。
默认：``False``
无穷大的损失主要发生在输入太短时。
与目标对齐。
形状：
- 对数概率：大小为 :math:`(T, N, C)` 或 :math:`(T, C)` 的张量，
其中 :math:`T = \text{输入长度}`，
math:`N = \text{批大小}`，以及
math:`C = \text{类别数（包括空白）}`。
输出对数的概率（例如，使用
:func:`torch.nn.functional.log_softmax`)
目标：大小为 :math:`(N, S)` 的张量
（目标长度之和）
其中 :math:`N = \text{批大小}` 和
\(S = \text{max target length, if shape is } (N, S)\)
它代表目标序列。目标序列中的每个元素是一个类别索引。目标索引不能为空（默认=0）
在 \((N, S)\) 形式中，目标序列被填充到
在 \((N, S)\) 形式中，目标序列被填充到
最长序列的长度，并堆叠。
在 :math:`(\operatorname{sum}(\text{target\_lengths}))` 形式下，
假设目标长度未填充，
在 1 个维度内连接。
- 输入长度：大小为 :math:`(N)` 或 :math:`()` 的元组或张量
`其中 :math:`N = \text{批大小}`。它表示长度为`
输入（必须每个都：数学`≤ T`）。长度已指定
对于每个序列，在假设序列下实现掩码
都填充到相同的长度。
- 目标长度：大小为 :math:`(N)` 或 :math:`()` 的元组或张量，
其中 :math:`N = \text{批大小}`。它表示目标长度。
为每个序列指定长度以实现掩码。
假设序列被填充到相同的长度。如果目标形状是
math:`(N,S)`，则目标长度实际上是停止索引
math:`s_n` 对于每个目标序列，使得 ``target_n = targets[n,0:s_n]`` 对于
批处理中的每个目标。长度必须每个都小于等于 :math:`S`
如果目标以 1 维张量形式给出，该张量是各个目标的拼接，则目标长度之和必须等于张量的总长度。
如果目标长度之和等于张量的总长度，则目标以 1 维张量形式给出。
- 输出：如果：attr:`reduction` 是 ``'mean'``（默认）或 ``'sum'``，则为标量。如果：attr:`reduction` 是 ``'none'``，则为 (N, *) 形状
如果输入是批处理，则如果 `:attr:`reduction` 是 `'none'`，则为 :math:`(N)`。
如果输入未分批，则为 :math:`()`，其中 :math:`N` 为批大小。
示例：
>>> 目标需要填充
>>> T = 50 # 输入序列长度
>>> C = 20 # 类别数量（包括空白）
>>> N = 16 # 批处理大小
>>> S = 30 # 批处理中最长目标序列的长度（填充长度）
>>> S_min = 10 # 最小目标长度，用于演示
...
>>> # 初始化随机输入向量批次，大小为 (T,N,C)
>>> input = torch.randn(T, N, C).log_softmax(2).detach().requires_grad_()
...
>>> # 初始化随机目标批次（0 = 空白，1:C = 类别）
>>> target = torch.randint(low=1, high=C, size=(N, S), dtype=torch.long)
...
>>> input_lengths = torch.full(size=(N,), fill_value=T, dtype=torch.long)
>>> target_lengths = torch.randint(low=S_min, high=S, size=(N,), dtype=torch.long)
>>> ctc_loss = nn.CTCLoss()
>>> loss = ctc_loss(input, target, input_lengths, target_lengths)
>>> loss.backward()
...
...
>>> # 目标是取消填充
>>> T = 50 # 输入序列长度
>>> C = 20 # 类别数量（包括空白）
>>> N = 16 # 批处理大小
...
>>> # 初始化随机输入向量批次，大小为 (T,N,C)
>>> input = torch.randn(T, N, C).log_softmax(2).detach().requires_grad_()
>>> input_lengths = torch.full(size=(N,), fill_value=T, dtype=torch.long)
...
>>> # 初始化随机目标批次（0 = 空白，1:C = 类别）
>>> target_lengths = torch.randint(low=1, high=T, size=(N,), dtype=torch.long)
>>> target = torch.randint(low=1, high=C, size=(sum(target_lengths),), dtype=torch.long)
>>> ctc_loss = nn.CTCLoss()
>>> loss = ctc_loss(input, target, input_lengths, target_lengths)
>>> loss.backward()
...
...
>>> # 目标是取消填充和取消批处理（实际上 N=1）
>>> T = 50 # 输入序列长度
>>> C = 20 # 类别数量（包括空白）
...
>>> # 初始化随机输入向量批次，大小为 *size = (T,C)
>>> # xdoctest: +SKIP("FIXME: 错误在 doctest 中")
>>> input = torch.randn(T, C).log_softmax(1).detach().requires_grad_()
>>> input_lengths = torch.tensor(T, dtype=torch.long)
...
>>> # 初始化随机目标批次（0 = 空白，1:C = 类别）
>>> target_lengths = torch.randint(low=1, high=T, size=(), dtype=torch.long)
>>> target = torch.randint(low=1, high=C, size=(target_lengths,), dtype=torch.long)
>>> ctc_loss = nn.CTCLoss()
>>> loss = ctc_loss(input, target, input_lengths, target_lengths)
>>> loss.backward()
参考文献：
A. Graves 等人：连接主义时序分类：
使用循环神经网络对未分割序列数据进行标注：
https://www.cs.toronto.edu/~graves/icml_2006.pdf
注意：
为了使用 CuDNN，必须满足以下条件：:attr:`targets`必须为
连接格式，所有:attr:`input_lengths`必须为`T`。:math:`blank=0`，
attr:`target_lengths` :math:`\leq 256`，整数参数必须是 dtype :attr:`torch.int32`类型。
的。
常规实现使用（在 PyTorch 中更常见）的 `torch.long` 数据类型。
注意：
在某些情况下，使用 CUDA 后端和 CuDNN 时，此运算符
可以选择一个非确定性算法来提高性能。如果这
不可取，您可以尝试将操作设置为确定性（可能
会有性能成本）通过设置 `torch.backends.cudnn.deterministic =
True`。
请参阅：doc:`/notes/randomness` 中的笔记以获取背景信息。
"源代码"
常量 = [
"空白",
"减少"]
空白:
整型
零无穷:
布尔类型
def 初始化(
self, 空白:
整型 = 0,
缩减:
字符串 =
平均值,
零无穷:
布尔类型 =
假
):
超级().
初始化(
缩减=
缩减)
self.空白 =
空白
self.零无穷 =
零无穷
def 前向(
self,
log_probs: 张量,
targets: 张量,
input_lengths: 张量,
目标长度:
张量,
) -> 张量:
返回 F.ctc_loss(
log_probs,
targets,
input_lengths,
目标长度,
self.空白,
self.缩减,
self.零无穷,
)
# TODO: L1HingeEmbeddingCriterion
# TODO: 均方误差准则权重
# TODO: 简单准则类
