oneflow.nn.functional¶

Functional operations for neural networks¶

oneflow.nn.functional.conv1d(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1) → Tensor¶

文档引用自: https://pytorch.org/docs/stable/generated/torch.nn.functional.conv1d.html?highlight=conv1d

对由多个输入平面组成的输入信号应用一维卷积。

请参阅: Conv1d 获取有关详细信息和输出形状。

参数：

input: 形状的量化输入张量: \((\text{minibatch} , \text{in_channels} , iW)\)
weight: 形状的量化滤波器: \((\text{out_channels} , \frac{\text{in_channels}}{\text{groups}} , iW)\)
bias: 非量化的形状的偏置张量: \((\text{out_channels})\) 。张量类型必须为 flow.float 。
stride: 卷积核的步长。可以是单个数字或元组 (sW,) 。默认值: 1
padding: 输入两侧的隐式填充。可以是单个数字或元组 (padW,) 。默认值: 0
dilation: 内核元素之间的间距。可以是单个数字或元组 (dW,) 。默认值: 1
groups: 将输入分成组: \(\text{in_channels}\) 应该可以被组数整除。默认值: 1

示例：

>>> import oneflow as flow
>>> import oneflow.nn as nn

>>> input = flow.randn(33, 16, 30, dtype=flow.float32)
>>> filters = flow.randn(20, 16, 5, dtype=flow.float32)
>>> out = nn.functional.conv1d(input, filters,stride=[1], padding=[0], dilation=[1], channel_pos="channels_first")

oneflow.nn.functional.conv2d(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1) → Tensor¶

文档引用自： https://pytorch.org/docs/stable/generated/torch.nn.functional.conv2d.html?highlight=conv2d

对由多个输入平面组成的输入信号应用二维卷积。

请参阅 Conv2d 获取有关详细信息和输出形状。

参数：

input - 形状为 \((\text{minibatch} , \text{in_channels} , iH , iW)\) 的量化输入张量
weight - 形状为 \((\text{out_channels} , \frac{\text{in_channels}}{\text{groups}} , kH , kW)\) 的量化滤波器
bias - 形状为 \((\text{out_channels})\) 的非量化偏置张量，其类型必须为 flow.float。
stride - 卷积核的步长。可以是单个数字或元组 (sH, sW)，默认值：1。
padding - 输入两侧的隐式填充。可以是单个数字或元组 (padH, padW)，默认值：0。
dilation - 内核元素之间的间距。可以是单个数字或元组 (dH, dW)，默认值：1。
groups - 将输入分成应该可以被组数整除的 \(\text{in_channels}\)，默认值：1。

oneflow.nn.functional.conv3d(input, weight, bias=None, stride=[1], padding=[0], dilation=[1], groups=1) → Tensor¶

文档引用自： https://pytorch.org/docs/stable/generated/torch.nn.functional.conv3d.html?highlight=conv3d

对由多个输入平面组成的输入信号应用三维卷积。

请参阅 Conv3d 获取有关详细信息和输出形状。

参数：

input - 形状为 \((\text{minibatch} , \text{in_channels} , iD , iH , iW)\) 的量化输入张量
weight - 形状为 \((\text{out_channels} , \frac{\text{in_channels}}{\text{groups}} , kD , kH , kW)\) 的量化滤波器
bias - 形状为 \((\text{out_channels})\) 的化偏置张量，其类型必须为 flow.float。
stride - 卷积核的步长。可以是单个数字或元组 (sD, sH, sW)，默认值：1。
padding - 输入两侧的隐式填充。可以是单个数字或元组 (padD, padH, padW)，默认值：0。
dilation - 内核元素之间的间距。可以是单个数字或元组 (dD, dH, dW)，默认值：1。
groups - 将输入分成应该可以被组数整除的 \(\text{in_channels}\)，默认值：1。

oneflow.nn.functional.conv_transpose1d(input, weight, bias, stride, padding, output_padding, groups, dilation)¶

此文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.conv_transpose1d.html

对多个输入面信号应用一个 1D 转置卷积算子，有时也被称为“反卷积”。

关于输出形状和更多细节，见 ConvTranspose1d

参数：

input: 形状为 \((\text{minibatch} , \text{in_channels} , iW)\) 的输入张量
weight: 形状为 \((\text{in_channels} , \frac{\text{out_channels}}{\text{groups}} , kW)\) 的过滤层
bias: 可选的形状为 \((\text{out_channels})\) 的过滤 bias 。默认值：None
stride: 卷积核的步长。可以是单个数字，也可以是一个 (sW,) 元组。默认值：1
padding: dilation * (kernel_size - 1) - padding 零填充将会被加至所有输入维度的两侧。可以是单个数字，也可以是一个 (padW,) 元组。默认值：0
output_padding: 被加至输出形状的所有维度一侧的额外尺寸。可以是单个数字，也可以是一个 (out_padW) 元组。默认值：0
groups: 将输入切分成组， \(\text{in_channels}\) 需要被组的数量整除。默认值：1
dilation: 内核元素的区间。可以是单个数字，也可以是一个 (dW,) 元组。默认值：1

示例：

>>> import oneflow as flow
>>> import oneflow.nn.functional as F

>>> inputs = flow.randn(20, 16, 50)
>>> weights = flow.randn(16, 33, 5)
>>> outputs = F.conv_transpose1d(inputs, weights)

oneflow.nn.functional.conv_transpose2d(input, weight, bias, stride, padding, output_padding, groups, dilation)¶

此文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.conv_transpose2d.html

对多个输入面信号应用一个 2D 转置卷积算子，有时也被称为 反卷积。

关于输出形状和更多细节，见 ConvTranspose2d

参数：

input: 形状为 \((\text{minibatch} , \text{in_channels} , iH , iW)\) 的输入张量
weight: 形状为 \((\text{in_channels} , \frac{\text{out_channels}}{\text{groups}} , kH , kW)\) 的过滤层
bias: 可选的形状为 \((\text{out_channels})\) 的过滤 bias 。默认值：None
stride: 卷积核的步长。可以是单个数字，也可以是一个 (sH, sW) 元组。默认值：1
padding: dilation * (kernel_size - 1) - padding 零填充将会被加至所有输入维度的两侧。可以是单个数字，也可以是一个 (padH, padW) 元组。默认值：0
output_padding: 被加至输出形状的所有维度一侧的额外尺寸。可以是单个数字，也可以是一个 (out_padH, out_padW) 元组。默认值：0
groups: 将输入切分成组， \(\text{in_channels}\) 需要被组的数量整除。默认值：1
dilation: 内核元素的区间。可以是单个数字，也可以是一个 (dH, dW) 元组。默认值：1

示例：

>>> import oneflow as flow
>>> import oneflow.nn.functional as F

>>> inputs = flow.randn(1, 4, 5, 5)
>>> weights = flow.randn(4, 8, 3, 3)
>>> outputs = F.conv_transpose2d(inputs, weights, padding=1)

oneflow.nn.functional.conv_transpose3d(input, weight, bias, stride, padding, output_padding, groups, dilation)¶

此文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.conv_transpose3d.html

对多个输入面信号应用一个 3D 转置卷积算子，有时也被称为 反卷积。

关于输出形状和更多细节，见 ConvTranspose3d

参数：

input: 形状为 \((\text{minibatch} , \text{in_channels} , iT , iH , iW)\) 的输入张量
weight: 形状为 \((\text{in_channels} , \frac{\text{out_channels}}{\text{groups}} , kT , kH , kW)\) 的过滤层
bias: 可选的形状为 \((\text{out_channels})\) 的过滤 bias 。默认值：None
stride: 卷积核的步长。可以是单个数字，也可以是一个 (sD, sH, sW) 元组。默认值：1
padding: dilation * (kernel_size - 1) - padding 零填充将会被加至所有输入维度的两侧。可以是单个数字，也可以是一个 (padT, padH, padW) 元组。默认值：0
output_padding: 被加至输出形状的所有维度一侧的额外尺寸。可以是单个数字，也可以是一个 (out_padT, out_padH, out_padW) 元组。默认值：0
groups: 将输入切分成组， \(\text{in_channels}\) 需要被组的数量整除。默认值：1
dilation: 内核元素的区间。可以是单个数字，也可以是一个 (dT, dH, dW) 元组。默认值：1

示例：

>>> import oneflow as flow
>>> import oneflow.nn.functional as F

>>> inputs = flow.randn(20, 16, 50, 10, 20)
>>> weights = flow.randn(16, 33, 3, 3, 3)
>>> outputs = F.conv_transpose3d(inputs, weights)

oneflow.nn.functional.adaptive_avg_pool1d(input, output_size) → Tensor¶

在单个由几个输入平面组成的输入信号上应用 1D 自适应平均池化。

更多细节和输出的形状请参考 AdaptiveAvgPool1d。

参数：

input - 输入张量。
output_size - 目标输出大小（单个整数）。

示例：

>>> import oneflow as flow
>>> import numpy as np

>>> arr = np.array([[[ 0.0558, -0.6875, -1.6544, -0.6226,  0.1018,  0.0502, -1.2538, 0.1491]]])
>>> input = flow.tensor(arr, dtype=flow.float32)
>>> flow.nn.functional.adaptive_avg_pool1d(input, output_size=[4])
tensor([[[-0.3158, -1.1385,  0.0760, -0.5524]]], dtype=oneflow.float32)

oneflow.nn.functional.adaptive_avg_pool2d(input, output_size) → Tensor¶

在单个由几个输入平面组成的输入信号上应用 2D 自适应平均池化。

更多细节和输出的形状请参考 AdaptiveAvgPool2d。

参数：

input - 输入张量。
output_size - 目标输出大小（单个整数或二整数元组）。

示例：

>>> import oneflow as flow
>>> import numpy as np

>>> arr = np.array([[[[ 0.1004,  0.0488, -1.0515,  0.9466],[ 0.4538,  0.2361,  1.3437,  0.398 ],[ 0.0558, -0.6875, -1.6544, -0.6226],[ 0.1018,  0.0502, -1.2538,  0.1491]]]])
>>> input = flow.tensor(arr, dtype=flow.float32)
>>> outputs = flow.nn.functional.adaptive_avg_pool2d(input, (2, 2))

oneflow.nn.functional.adaptive_avg_pool3d(input, output_size) → Tensor¶

在单个由几个输入平面组成的输入信号上应用 3D 自适应平均池化。

更多细节和输出的形状请参考 AdaptiveAvgPool3d。

参数：

input - 输入张量。
output_size - 目标输出大小（单个整数或三整数元组）。

示例：

>>> import oneflow as flow
>>> import numpy as np

>>> input = flow.tensor(np.random.randn(1, 1, 4, 4, 4), dtype=flow.float32)
>>> output = flow.nn.functional.adaptive_avg_pool3d(input, (2, 2, 2))

oneflow.nn.functional.relu(input, inplace) → Tensor¶

对 input 逐元素应用 ReLU 函数(Rectified Linear Unit，线性整流函数)。更多信息请参考 ReLU 。

参数：

input (Tensor)
inplace (Bool): 如果为 True ，则以原地算法执行此算子。默认为 False

示例：

>>> import oneflow as flow

>>> input = flow.tensor([1, -2, 3], dtype=flow.float32)
>>> output = flow.relu(input)
>>> output
tensor([1., 0., 3.], dtype=oneflow.float32)

oneflow.nn.functional.hardsigmoid(x: Tensor) → Tensor¶

逐元素应用以下函数:

\[\begin{split}\text{Hardsigmoid}(x) = \begin{cases} 0 & \text{if~} x \le -3, \\ 1 & \text{if~} x \ge +3, \\ x / 6 + 1 / 2 & \text{otherwise} \end{cases}\end{split}\]

更多细节请参考 Hardsigmoid。

oneflow.nn.functional.hardshrink()¶

oneflow.nn.functional.hardswish(x: Tensor) → Tensor¶

按照论文 Searching for MobileNetV3 中的描述，应用 hardswish 函数。

\[\begin{split}\text{Hardswish}(x) = \begin{cases} 0 & \text{if~} x \le -3, \\ x & \text{if~} x \ge +3, \\ x \cdot (x + 3) /6 & \text{otherwise} \end{cases}\end{split}\]

更多细节请参考 Hardswish。

oneflow.nn.functional.hardtanh(input, min_val=- 1., max_val=1.) → Tensor¶: 应用 HardTanh 函数。更多细节请参考 Hardtanh。

oneflow.nn.functional.normalize(input: Tensor, p: float = 2.0, dim: int = 0, epsilon: float = 1e-12) → Tensor¶

对指定维度的输入进行 \(L_p\) 规范化处理。

对于大小为 \((n_0, ..., n_{dim}, ..., n_k)\) 的 input 张量，每一个 \(n_{dim}\) 维向量 \(v\) 沿维度 dim 被转换为：

\[v = \frac{v}{\max(\lVert v \rVert_p, \epsilon)}.\]

在默认参数下，它使用沿维度 \(1\) 的向量上的欧几里得准则进行归一化。

但要注意，当 input.shape[dim] = 1 时，输入张量的梯度计算在不同的框架上有不同的结果。

参数：

input (oneflow.Tensor)- 任何形状的输入张量。
p (float)- 规范表述中的指数值，默认值：2。
dim (int)- 要缩小的尺寸，默认值：1。
eps (float)- 以避免被零除的极小值，默认值：1e-12。

示例：

>>> import oneflow as flow
>>> x = flow.tensor([[1, 2], [3, 4]], dtype=flow.float32)
>>> out = flow.nn.functional.normalize(x, 2, 0)
>>> out
tensor([[0.3162, 0.4472],
        [0.9487, 0.8944]], dtype=oneflow.float32)
>>> out = flow.nn.functional.normalize(x, 2, 1)
>>> out
tensor([[0.4472, 0.8944],
        [0.6000, 0.8000]], dtype=oneflow.float32)

oneflow.nn.functional.layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05) → Tensor¶

对最后一定数量的维度应用图层标准化。

更多细节请参考 LayerNorm。

oneflow.nn.functional.leaky_relu(x: Tensor, alpha: Float) → Tensor¶

逐元素应用以下函数:

\(\text{LeakyReLU}(x) = \max(0, x) + \text{negative_slope} * \min(0, x)\)

更多细节请参考 LeakyReLU。

oneflow.nn.functional.elu(x: Tensor, alpha: Float) → Tensor¶

逐元素应用以下函数:

\(\text{ELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x) - 1))\)

更多细节请参考 ELU。

示例：

>>> import numpy as np
>>> import oneflow as flow

>>> x = np.array([-0.5, 0, 0.5]).astype(np.float32)
>>> input = flow.tensor(x)
>>> out = flow.nn.functional.elu(input, alpha=1.0)
>>> out
tensor([-0.3935,  0.0000,  0.5000], dtype=oneflow.float32)

oneflow.nn.functional.celu(x: Tensor, alpha: Float = 1.0, inplace: bool = False) → Tensor¶

逐元素地应用如下等式：

\[\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))\]

更多细节请参考 CELU 。

示例：

>>> import numpy as np
>>> import oneflow as flow

>>> x = np.array([-0.5, 0, 0.5]).astype(np.float32)
>>> input = flow.tensor(x)
>>> out = flow.nn.functional.celu(input, alpha=0.5)
>>> out
tensor([-0.3161,  0.0000,  0.5000], dtype=oneflow.float32)

oneflow.nn.functional.selu(x) → Tensor¶

应用以下 element-wise 公式：

\(\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)))\) , \(\alpha=1.6732632423543772848170429916717\) , \(scale=1.0507009873554804934193349852946\)

更多信息请参考 SELU 。

示例：

>>> import oneflow as flow

>>> input = flow.tensor([1, 2, 3], dtype=flow.float32)
>>> out = flow.nn.functional.selu(input)
>>> out
tensor([1.0507, 2.1014, 3.1521], dtype=oneflow.float32)

oneflow.nn.functional.sigmoid(input) → Tensor¶

应用以下 element-wise 公式： \(\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}\)

更多信息请参考 Sigmoid 。

示例：

>>> import oneflow as flow

>>> input = flow.tensor([0.81733328, 0.43621480, 0.10351428], dtype=flow.float32)
>>> out = flow.nn.functional.sigmoid(input)
>>> out
tensor([0.6937, 0.6074, 0.5259], dtype=oneflow.float32)

oneflow.nn.functional.pad()¶

填充张量。

填充大小：

对输入张量某些维度的填充大小的描述从最后一个维度开始，然后是前一个维度，依此类推。input 的维度将被填充为 \(\left\lfloor\frac{\text{len(pad)}}{2}\right\rfloor\) 。例如，若只对输入张量的最后一个维度进行填充，那么 pad 的参数应为 \((\text{padding_left}, \text{padding_right})\) ；若填充输入张量的最后两个维度，则参数变成 \((\text{padding_left}, \text{padding_right},\) \(\text{padding_top}, \text{padding_bottom})\)；填充最后 3 个维度时，参数将为 \((\text{padding_left}, \text{padding_right},\) \(\text{padding_top}, \text{padding_bottom}\) \(\text{padding_front}, \text{padding_back})\)。

填充模式：

参考 oneflow.nn.ConstantPad2d， oneflow.nn.ReflectionPad2d，以及 oneflow.nn.ReplicationPad2d 可以得到每个填充模式是如何工作的具体例子。对任意的尺寸实现恒定的填充。复制填充的引入是为了填充 5D 输入张量的最后 3 维，或 4D 输入张量的最后 2 维，或 3D 输入张量的最后一维。反射填充仅用于填充 4D 输入张量的最后两个维度，或 3D 输入张量的最后一个维度。

参数：

input (Tensor)- N 维张量。
pad (tuple)- m 个元素的元组，其中 \(\frac{m}{2} \leq\) 输入维度以及 \(m\) 为偶数。
mode - 'constant'， 'reflect'， 'replicate' 或者 'circular'。默认值： 'constant'。
value - 填充值为 'constant' 的填充。默认值： 0。

示例：

>>> import oneflow as flow
>>> import numpy as np

>>> pad = [2, 2, 1, 1]
>>> input = flow.tensor(np.arange(18).reshape((1, 2, 3, 3)).astype(np.float32))
>>> output = flow.nn.functional.pad(input, pad, mode = "replicate")
>>> output.shape
oneflow.Size([1, 2, 5, 7])
>>> output
tensor([[[[ 0.,  0.,  0.,  1.,  2.,  2.,  2.],
          [ 0.,  0.,  0.,  1.,  2.,  2.,  2.],
          [ 3.,  3.,  3.,  4.,  5.,  5.,  5.],
          [ 6.,  6.,  6.,  7.,  8.,  8.,  8.],
          [ 6.,  6.,  6.,  7.,  8.,  8.,  8.]],

         [[ 9.,  9.,  9., 10., 11., 11., 11.],
          [ 9.,  9.,  9., 10., 11., 11., 11.],
          [12., 12., 12., 13., 14., 14., 14.],
          [15., 15., 15., 16., 17., 17., 17.],
          [15., 15., 15., 16., 17., 17., 17.]]]], dtype=oneflow.float32)

参考 oneflow.nn.ConstantPad2d, oneflow.nn.ReflectionPad2d 和 oneflow.nn.ReplicationPad2d ，可以得到每个填充模式是如何工作的具体例子。

oneflow.nn.functional.prelu(x: Tensor, alpha: Tensor) → Tensor¶

逐元素应用以下函数:

\[prelu(x) = max(0,x) + alpha * min(0,x)\]

示例：

> import numpy as np
> import oneflow as flow

> x = flow.tensor(np.asarray([[[[1, -2], [3, 4]]]]), dtype=flow.float32)
> alpha = flow.nn.Parameter(flow.tensor([1], dtype=flow.float32).fill_(0.25))
> flow.nn.functional.prelu(x, alpha)
tensor([[[[ 1.0000, -0.5000],
          [ 3.0000,  4.0000]]]], dtype=oneflow.float32, grad_fn=<prelu_backward>)

更多细节请参考 PReLU 。

oneflow.nn.functional.logsigmoid(x: Tensor) → Tensor¶

逐元素应用函数:

\[\text{logsigmoid}(x) = \log\left(\frac{ 1 }{ 1 + \exp(-x)}\right)\]

示例：

>>> import numpy as np
>>> import oneflow as flow

>>> x = np.array([-0.5, 0, 0.5]).astype(np.float32)
>>> input = flow.tensor(x)

>>> out = flow.nn.functional.logsigmoid(input)
>>> out
tensor([-0.9741, -0.6931, -0.4741], dtype=oneflow.float32)

更多细节请参考 LogSigmoid 。

oneflow.nn.functional.log_softmax(x: Tensor, dim: int) → Tensor¶

LogSoftmax 的公式为：

\[\text{LogSoftmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right) = x_i - \log({ \sum_j \exp(x_j)})\]

参考 LogSoftmax 获得更多细节。

oneflow.nn.functional.gelu()¶

Gelu 激活算子，其公式为：

\[out = 0.5 * x * (1 + tanh(\sqrt{\frac{2}{\pi}} * (x + 0.044715x^{3})))\]

参数：: x (oneflow.tensor) - 输入张量
返回类型：: oneflow.tensor

示例：

>>> import oneflow as flow

>>> input = flow.tensor([-0.5, 0, 0.5], dtype=flow.float32)
>>> gelu = flow.nn.GELU()

>>> out = gelu(input)
>>> out
tensor([-0.1543,  0.0000,  0.3457], dtype=oneflow.float32)

oneflow.nn.functional.glu(input: Tensor, dim: int) → Tensor¶

glu 的公式为：

\[GLU(input) = GLU(a, b) = a \otimes sigmoid(b)\]

Note

其中输入沿维度 dim 被切分成 a 和 b 两半，⊗ 是矩阵间的按元素积。

示例：

>>> import oneflow as flow
>>> import oneflow.nn as nn
>>> x = flow.tensor([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=flow.float32)
>>> y = nn.functional.glu(x)
>>> y
tensor([[0.9526, 1.9640],
        [4.9954, 5.9980]], dtype=oneflow.float32)

参考 GLU 获得更多细节。

oneflow.nn.functional.softsign(x: Tensor) → Tensor¶

softsign 的公式为：

\[softsign(x) = \frac{x}{1 + |x|}\]

示例：

>>> import numpy as np
>>> import oneflow as flow

>>> x = np.array([1, 2, 3]).astype(np.float32)
>>> input = flow.tensor(x)
>>> out = flow.nn.functional.softsign(input)
>>> out
tensor([0.5000, 0.6667, 0.7500], dtype=oneflow.float32)

参考 Softsign 获得更多细节。

oneflow.nn.functional.softmax(input, dim=None) → Tensor¶

将 Softmax 函数应用于 n 维 input tensor 。并且重新缩放，使输出 tensor 的元素于 [0,1] 范围内并且总和为 1 。

Softmax 的公式为：

\[\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}\]

当输入张量是稀疏张量时，未指定的值将被视为 -inf 。

形状:

Input: \((*)\) ，其中 * 表示任意数量的附加维度
Output: \((*)\) ，与 input 相同的形状

返回类型：

与 input 具有相同维度和形状的张量，其值在 [0, 1] 范围内

参数：

dim (int): 要计算 Softmax 的维度（沿 dim 的每个切片的总和为 1）

示例：

>>> import oneflow as flow

>>> m = flow.nn.Softmax(dim = 2)
>>> x = flow.tensor([[[-0.46716809,  0.40112534,  0.61984003], [-1.31244969, -0.42528763,  1.47953856]]], dtype=flow.float32)
>>> out = m(x)
>>> out
tensor([[[0.1575, 0.3754, 0.4671],
         [0.0507, 0.1230, 0.8263]]], dtype=oneflow.float32)

oneflow.nn.functional.softplus(x: Tensor) → Tensor¶

逐元素地应用此公式：

\[\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))\]

更多细节参考 Softplus 。

oneflow.nn.functional.tanh(x) → Tensor¶

公式为：

\[out = \frac{e^x-e^{-x}}{e^x+e^{-x}}\]

更多信息请参考 Tanh 。

oneflow.nn.functional.threshold()¶

oneflow.nn.functional.softshrink()¶

oneflow.nn.functional.silu(x) → Tensor¶

公式为：

\[\text{silu}(x) = x * sigmoid(x)\]

示例：

>>> import oneflow as flow

>>> input = flow.tensor([1, 2, 3], dtype=flow.float32)
>>> out = flow.silu(input)
>>> out
tensor([0.7311, 1.7616, 2.8577], dtype=oneflow.float32)

更多信息请参考 SiLU 。

oneflow.nn.functional.mish(x: Tensor) → Tensor¶

逐元素地应用此公式：

\[\text{mish}(x) = x * \text{tanh}(\text{softplus}(x))\]

示例：

>>> import oneflow as flow

>>> input = flow.tensor([1, 2, 3], dtype=flow.float32)

>>> out = flow.mish(input)
>>> out
tensor([0.8651, 1.9440, 2.9865], dtype=oneflow.float32)

更多细节参考 Mish 。

oneflow.nn.functional.one_hot(input, num_classes=- 1, on_value=1, off_value=0)¶

该算子根据输入张量生成一个 onehot 张量。

如果输入张量的秩为 N，相应的 onehot 张量的秩为 N+1。

参数：

input (Tensor) - 输入张量。
num_classes (int) - 输出的 onehot 张量的长度。
on_value (Union[int, float], optional) - 当 x[i] == i 时的填充值，默认为 1。
off_value (Union[int, float], optional) - 当 x[i] != i 时的填充值，默认为 0。

Note

输入张量的数据类型应为：int32 或 int64。

返回值：: oneflow.Tensor

示例：

>>> import oneflow as flow
>>> import numpy as np

>>> input=flow.tensor(np.array([0, 3, 1, 2]).astype(np.int64), dtype=flow.int64)
>>> out = flow.nn.functional.one_hot(input, num_classes=5)
>>> out
tensor([[1, 0, 0, 0, 0],
        [0, 0, 0, 1, 0],
        [0, 1, 0, 0, 0],
        [0, 0, 1, 0, 0]], dtype=oneflow.int64)

oneflow.nn.functional.triplet_margin_loss()¶

文档参考自：https://pytorch.org/docs/stable/generated/torch.nn.functional.triplet_margin_loss.html?highlight=triplet_margin_loss

在给定输入张量 \(x1\), \(x2\), \(x3\) 和值大于 \(0\) 的边距的情况下，创建一个测量三元组损失的标准。这用于测量样本之间的相对相似性。三元组由 a, p 和 n 组成（即分别为锚点、正例和负例）。所有输入张量的形状应为 \((N, D)\) 。

Vassileios Balntas、Edgar Riba 等人的 Learning shallow convolutional feature descriptors with triplet losses 一文中详细描述了距离交换。

小批量中每个样本的损失函数为：

\[L(a, p, n) = \max \{d(a_i, p_i) - d(a_i, n_i) + {\rm margin}, 0\}\]

其中

\[d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p\]

参数：

margin (float, optional) - 默认为 \(1\)
p (float, optional) - 成对距离的范数，默认为 \(2.0\)
swap (bool, optional) - 默认为 False 。V. Balntas、E. Riba 等人的 Learning shallow convolutional feature descriptors with triplet losses 一文中详细描述了距离交换。
reduction (string, optional) - 指定应用于输出的 reduction：'none' | 'mean' | 'sum'。若值为 'none' ：不进行 reduction；值为 'mean' ：输出的和将会除以输出中的元素数量；值为 'sum' ：输出将被求和。请注意：size_average 和 reduce 正逐渐被弃用，指定这二者的任何一个都将覆盖 reduction。默认值为 'mean'。

形状：

Input: \((N, D)\) ，其中 \(D\) 是向量维度。
Output: 若 reduction == 'none' 则输出为形状为 \((N)\) 的张量，否则是一个标量。

示例：

>>> import oneflow as flow
>>> import numpy as np
>>> triplet_loss = flow.nn.TripletMarginLoss(margin=1.0, p=2)
>>> anchor = np.array([[1, -1, 1],[-1, 1, -1], [1, 1, 1]])
>>> positive = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> negative = np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]])
>>> output = triplet_loss(flow.Tensor(anchor), flow.Tensor(positive), flow.Tensor(negative))
>>> output
tensor(6.2971, dtype=oneflow.float32)

oneflow.nn.functional.dropout(x: Tensor, p: float = 0.5, training: bool = True, generator: Generator = None, *, addend: Tensor) → Tensor¶

文档引用自： https://pytorch.org/docs/stable/generated/torch.nn.functional.dropout.html 。

在训练期间，使用来自伯努利分布的样本以概率 p 将输入张量的一些元素随机归零。

参数：

x (Tensor) - 将应用 dropout 的张量。
p (float) - 任一元素被归零的概率，默认为 0.5。
training (bool) - 若为 True 则应用 dropout，默认为 True。
generator (Generator, optional) - 用于采样的伪随机数发生器。
addend (Tensor, optional) - 加入到 dropout 结果中的张量，它可以用于模型的残差连接结构。默认为 None。

形状：

Input: \((*)\) ，输入可以为任何形状。
Output: \((*)\) ，与输入形状相同。

示例 1：

>>> import numpy as np
>>> import oneflow as flow


>>> arr = np.array(
...    [
...        [-0.7797, 0.2264, 0.2458, 0.4163],
...        [0.4299, 0.3626, -0.4892, 0.4141],
...        [-1.4115, 1.2183, -0.5503, 0.6520],
...    ]
... )
>>> x = flow.tensor(arr, dtype=flow.float32)
>>> y = flow.nn.functional.dropout(x, p=0)

>>> arr = np.array(
...    [
...        [-0.7797, 0.2264, 0.2458, 0.4163],
...        [0.4299, 0.3626, -0.4892, 0.4141],
...        [-1.4115, 1.2183, -0.5503, 0.6520],
...    ]
... )
>>> x = flow.tensor(arr, dtype=flow.float32)
>>> generator = flow.Generator()
>>> y = flow.nn.functional.dropout(x, p=0.5, generator=generator)

示例 2：

>>> import numpy as np
>>> import oneflow as flow


>>> arr = np.array(
...    [
...        [-0.7797, 0.2264, 0.2458, 0.4163],
...        [0.4299, 0.3626, -0.4892, 0.4141],
...        [-1.4115, 1.2183, -0.5503, 0.6520],
...    ]
... )
>>> x = flow.tensor(arr, dtype=flow.float32)
>>> addend = flow.ones((3, 4), dtype=flow.float32)
>>> y = flow.nn.functional.dropout(x, p=0, addend=addend)
>>> y 
tensor([[ 0.2203,  1.2264,  1.2458,  1.4163],
        [ 1.4299,  1.3626,  0.5108,  1.4141],
        [-0.4115,  2.2183,  0.4497,  1.6520]], dtype=oneflow.float32)

参考 Dropout 获得更多细节。

oneflow.nn.functional.affine_grid(theta, size: List[int], align_corners: bool = False)¶

此接口与 PyTorch 一致。文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.affine_grid.html?highlight=affine_grid#torch.nn.functional.affine_grid 。

给定一批仿射矩阵 theta ，生成 2D 或 3D 流场（采样网格）。

Note

此函数通常与 grid_sample() 结合使用来构建 Spatial Transformer Networks 。

参数：

theta (Tensor) - 形状为 (\(N, 2, 3\))（2D 场景）或形状为 (\(N, 3, 4\))（3D 场景）的仿射矩阵的输入批量。
size (oneflow.Size) - 目标输出图像大小。形状为 (\(N, C, H, W\))（2D 场景）或 (\(N, C, D, H, W\))（3D 场景），例如 oneflow.Size((32, 3, 24, 24))。
align_corners (bool) - 如果为 True，则考虑 -1 和 1 来指代角像素的中心，而不是图像的角。参考 grid_sample() 来获得更详细的描述。由 affine_grid() 生成的网格应使用与此选项相同的设置传递给 grid_sample()。默认为 False。

返回值：

output (Tensor) - 形状为 (\(N, H, W, 2\)) 的输出张量。

示例：

>>> import oneflow as flow
>>> import numpy as np
>>> input = flow.tensor(np.arange(1., 7).reshape((1, 2, 3)), dtype=flow.float32)
>>> output = flow.nn.functional.affine_grid(input, flow.Size([1, 1, 2, 2]), align_corners=True)
>>> output
tensor([[[[ 0., -3.],
          [ 2.,  5.]],

         [[ 4.,  7.],
          [ 6., 15.]]]], dtype=oneflow.float32)

oneflow.nn.functional.grid_sample(input, grid, mode: str = 'bilinear', padding_mode: str = 'zeros', align_corners: bool = False)¶

此接口与 PyTorch 一致。文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html?highlight=grid_sample#torch.nn.functional.grid_sample

给定 input 和流场 grid，使用 input 和 grid 中的像素位置计算输出。目前，仅支持空间 (4-D) 和体积 (5-D) 输入。在空间 (4-D) 情况下，对于形状为 \((N, C, H_{in}, W_{in})\) 的输入和形状为 \((N, H_{out}, W_{out}, 2)\) 的网格，输出将具有形状 \((N, C, H_{out}, W_{out})\)。

对于每个输出位置 output[n, :, h, w]，大小为 2 的向量 grid[n, h, w] 指定输入像素位置 x 和 y，用于插值输出值 output[n, :, h, w]。在 5D 输入的情况下，grid[n, d, h, w] 指定用于插值 output[n, :, d, h, w] 的 x、y、z 像素位置。mode 参数指定对输入像素进行采样的最近或双线性插值方法。网格指定由输入空间维度归一化的采样像素位置。因此，它应该具有 [-1, 1] 范围内的大多数值。例如，x = -1, y = -1 是输入的左上角像素，x = 1, y = 1 是输入的右下角像素。

如果 grid 的值在 [-1, 1] 之外，相应的输出按照 padding_mode 的定义进行处理。那么：

padding_mode="zeros": 使用 0 表示越界网格位置。
padding_mode="border": 使用边界值表示越界网格位置。
padding_mode="reflection": 使用边界反映的位置处的值表示越界网格位置。对于远离边界的位置，它将一直被反射直到进入边界。例如（归一化）像素位置 x = -3.5 由边界 -1 反射并变为 x = 1.5，然后由边界 1 反射并变为 x = -0.5。

Note

此函数通常与 grid_sample() 结合使用来构建 Spatial Transformer Networks 。

Note

grid 中的 NaN 值将被解释为 -1。

参数：

input (Tensor) - 形状为 \((N, C, H_{in}, W_{in})\) （4D 情况下）或形状为 \((N, C, D_{in}, H_{in}, W_{in})\) （5D 情况下）的输入张量
grid (Tensor) - 形状为 \((N, H_{out}, W_{out}, 2)\) （4D 情况下）或形状为 \((N, D_{out}, H_{out}, W_{out}, 3)\) （5D 情况下）的流场
mode (str) - 计算输出值的插值模式：'bilinear' | 'nearest' | 'bicubic'。默认为 'bilinear'。注意 mode='bicubic' 仅支持 4D 输入。当 mode='bilinear' 且输入是 5D 时，内部使用的插值模式实际上是三线性的。然而，当输入是 4D 时，插值模式将是双线性的。
padding_mode (str) - 外部网格值的填充模式：'zeros' | 'border' | 'reflection'。默认为 'zeros'。
align_corners (bool) - 在几何上，我们将输入的像素视为正方形而不是点。如果设置为 True，则极值（-1 和 1）被认为指代输入角像素的中心点。如果设置为 False，则它们被认为是指输入角像素的角点，从而使采样与分辨率无关。此选项与 interpolate() 中的 align_corners 选项一致，因此此处使用的任何选项也应用于在网格采样之前调整输入图像的大小。默认为 False。

返回值：

output (Tensor) - 输出张量。

Note

mode='bicubic' 使用 \(\alpha=-0.75\) 的三次卷积算法实现。常数 \(\alpha\) 可能因包而异。例如 PIL 和 OpenCV 分别使用 -0.5 和 -0.75。该算法可能会“超出”它的插值范围。例如，输入位于 [0, 255] 中的插值时，它可能会产生负值或大于 255 的值。使用 flow.clamp() 钳制结果以确保它们在有效范围内。

示例：

>>> import oneflow as flow
>>> import numpy as np
>>> input = flow.tensor(np.arange(1., 11).reshape((1, 1, 2, 5)), dtype=flow.float32)
>>> np_grid = np.array(
...     [[[-0.9, -4.1], [0, 0.2000], [1, -1], [-0.333, 1e-6], [0.5, 1.0]],
...      [[-1.0, -0.5], [0, 0.3333], [1, -1], [-0.200, 1e-6], [1.5, 0.5]]]
... ).reshape(1, 2, 5, 2)
>>> grid = flow.tensor(np_grid, dtype=flow.float32)
>>> output = flow.nn.functional.grid_sample(input, grid, mode='nearest', padding_mode='zeros',
...                                        align_corners=True)
>>> output
tensor([[[[0., 8., 5., 7., 9.],
          [1., 8., 5., 8., 0.]]]], dtype=oneflow.float32)

oneflow.nn.functional.interpolate(input, size=None, scale_factor=None, mode='nearest', align_corners=None, recompute_scale_factor=None)¶

此接口与 PyTorch 一致。文档参考自：https://pytorch.org/docs/1.9.0/_modules/torch/nn/functional.html#interpolate 。

上/下采样输入到给定大小或给定 scale_factor。用于插值的算法由 mode 确定。目前支持时间、空间和体积采样，即预期输入为三维、四维或五维形状。

输入大小解释为：mini-batch x channels x [optional depth] x [optional height] x width。

可用于调整大小的模式有：nearest、linear （仅限 3D）、bilinear、bicubic （仅限 4D）、trilinear （仅限 5D）、area。

参数：

input (Tensor) - 输入张量。
size - 输出空间大小，可以为一个、两个或三个 int 组成的 tuple。
scale_factor (float or Tuple[float]) - 空间大小的乘数。如果是元组，则必须匹配输入大小。
mode (str) - 选择用于上采样的算法：'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear' | 'area'。默认为 'nearest'
align_corners (bool, optional) - 几何上，我们将输入和输出的像素视为正方形而不是点。如果设置为 True，则输入和输出张量由其角像素的中心点对齐，保留角像素处的值。如果设置为 False，则输入和输出张量通过其角像素的角点对齐，并且插值对边界外的值使用边缘值填充，当 scale_factor 保持相同时，此操作与输入大小无关。这仅在模式为 linear、bilinear、bicubic 或 trilinear 时有效。默认值：False。
recompute_scale_factor (bool, optional) - 重新计算 scale_factor 以用于插值计算。当 scale_factor 作为参数传递时，它用于计算 output_size。如果 recompute_scale_factor 为 False 或未指定，传入的 scale_factor 将用于插值计算。否则，将根据用于插值计算的输出和输入大小计算新的 scale_factor （即计算将与显式传入计算的 output_size 相同）。请注意，当 scale_factor 为浮点数时，由于舍入和精度问题，重新计算的 scale_factor 可能与传入的值不同。

Note

使用 mode='bicubic'，可能会导致过冲，也就是它可以为图像产生负值或大于 255 的值。如果要减少显示图像时的过冲，请显式调用 result.clamp(min=0, max=255)

Warning

若 align_corners = True，线性插值模式（线性、双线性和三线性）不会按比例对齐输出和输入像素，因此输出值可能取决于输入大小。这是 0.3.1 之前这些模式的默认行为，此后的默认行为是 align_corners = False。有关这如何影响输出的具体示例，请参见 Upsample

Warning

当指定 scale_factor 时，如果 recompute_scale_factor=True，则 scale_factor 用于计算输出大小，然后用于推断插值的新比例。

示例：

> import oneflow as flow
> import numpy as np

> input = flow.tensor(np.arange(1, 5).reshape((1, 1, 4)), dtype=flow.float32)
> output = flow.nn.functional.interpolate(input, scale_factor=2.0, mode="linear")
> output
tensor([[[1.0000, 1.2500, 1.7500, 2.2500, 2.7500, 3.2500, 3.7500, 4.0000]]], dtype=oneflow.float32)

oneflow.nn.functional.ctc_greedy_decoder()¶

对输入中给出的 logits 执行贪婪解码（最佳路径）。

参数：

log_probs (oneflow.Tensor) - 形状为 [input_length, batch_size, num_labels] 的张量。输出的对数概率（例如，使用 flow.nn.logsoftmax() 获得）。
input_lengths (oneflow.Tensor) - 形状为 [batch_size] 的张量。它表示输入的长度。并且在序列被填充到相等长度的假设下，为每个序列指定长度以实现掩码。
merge_repeated (bool, optional) - 如果 merge_repeated 为 True，则合并输出中的重复类。这意味着如果连续 logits 的最大索引相同，则仅发出其中的第一个。默认为 True。

返回值：

decoded(oneflow.Tensor) - 形状为 [batch_size, input_length] 的张量，解码后的输出。
neg_sum_logits(oneflow.Tensor) - 一个浮点矩阵 (batch_size x 1)，对于找到的序列，包含每个时间帧最大 logit 总和的负数。

示例：

>>> import oneflow as flow
>>> import numpy as np
>>> log_probs = flow.tensor(
...     [
...         [[-1.54, -1.20, -1.95, -1.65, -1.81], [-1.84, -1.74, -1.58, -1.55, -1.12]],
...         [[-1.68, -1.48, -1.89, -1.30, -2.07], [-1.13, -1.45, -1.24, -1.61, -1.66]],
...         [[-1.56, -1.40, -2.83, -1.67, -1.48], [-1.20, -2.01, -2.05, -1.95, -1.24]],
...         [[-2.09, -1.76, -1.36, -1.67, -1.45], [-1.85, -1.48, -1.34, -2.16, -1.55]],
...     ]
... )
>>> input_lengths = flow.tensor([4, 4])
>>> decoded, neg_sum_logits = flow.nn.functional.ctc_greedy_decoder(log_probs, input_lengths)
>>> decoded
tensor([[1, 3, 1, 2],
        [0, 2, 0, 0]], dtype=oneflow.int64)
>>> neg_sum_logits
tensor([[5.2600],
        [4.7900]], dtype=oneflow.float32)

oneflow.nn.functional.sparse_softmax_cross_entropy(labels, logits)¶

此接口与 TensorFlow 一致。文档参考自：https://www.tensorflow.org/api_docs/python/tf/nn/sparse_softmax_cross_entropy_with_logits

计算 logits 和标签之间的稀疏 softmax 交叉熵。

测量类别互斥（每个条目恰好属于一个类别）的离散分类任务中的概率误差。例如，每张 CIFAR-10 图像都标有一个且只有一个标签：图像可以是狗或卡车，但不能同时是两者。一个常见的用例是具有形状 [batch_size, num_classes] 的 logits 和具有形状 [batch_size] 的标签，但支持更高的维度，在这种情况下，假设第 dim 维度的大小为 num_classes。logits 的数据类型必须为 float16、float32 或 float64，标签的数据类型必须为 int32 或 int64。

参数：

labels (Tensor) - 具有 [d_0, d_1, ..., d_{r-1}] 的形状（其中 r 是标签和输出的 rank），其数据类型是 int32 或 int64。标签中的每个条目必须是 [0, num_classes) 中的索引。
logits (Tensor) - 具有 [d_0, d_1, ..., d_{r-1}, num_classes] 的形状且数据类型是 float16、float32 或 float64 的每个标签激活（通常是线性输出）。这些激活能被解释为非标准化的对数概率。

返回值：

output (Tensor) - 与标签具有相同形状且与 logits 相同类型的张量，具有 softmax 交叉熵损失。

示例：

>>> import numpy as np
>>> import oneflow as flow
>>> np_logits = np.array(
...      [
...          [2.0, -5.0, 0.5, -0.1],
...          [0.0, 0.0, 1.9, 1.4],
...          [-100.0, 100.0, -100.0, -100.0],
...      ]
...  )
>>> np_labels = np.array([0, 3, 1])
>>> logits = flow.tensor(np_logits, dtype=flow.float32)
>>> labels = flow.tensor(np_labels, dtype=flow.int32)
>>> output = flow.nn.functional.sparse_softmax_cross_entropy(
...     labels=labels, logits=logits
... )
>>> output
tensor([ 2.9751e-01,  1.1448e+00, -1.4305e-06], dtype=oneflow.float32)

oneflow.nn.functional.embedding(input, weight, padding_idx=None, max_norm=None, norm_type=None, scale_grad_by_freq=False, sparse=False)¶

一个简单的查找表，可以在固定的字典和大小中查找嵌入项。该模块通常用于使用索引检索词嵌入。模块的输入是索引列表和嵌入矩阵，输出是相应的词嵌入。查看 oneflow.nn.Embedding 获得更多细节。

参数：

input (LongTensor) - 包含嵌入矩阵中的索引的张量。
weight (Tensor) - 行数等于最大可能索引 +1 且列数等于嵌入大小的嵌入矩阵。
padding_idx (int, optional) - 如果指定，则 padding_idx 处的条目不会影响梯度；因此 padding_idx 处的嵌入向量在训练期间不会更新，即它仍然是一个固定的 pad。

示例：

>>> import oneflow as flow
>>> import oneflow.nn.functional as F

>>> # a batch of 2 samples of 4 indices each
>>> input = flow.tensor([[1,2,4,5],[4,3,2,9]])
>>> # an embedding matrix containing 10 tensors of size 3
>>> embedding_matrix = flow.rand(10, 3)
>>> output = F.embedding(input, embedding_matrix)
>>> output.shape
oneflow.Size([2, 4, 3])
>>> # example with padding_idx
>>> input = flow.tensor([[0,2,0,5]])
>>> output = F.embedding(input, embedding_matrix, padding_idx=0)
>>> output.shape
oneflow.Size([1, 4, 3])

oneflow.nn.functional.linear(input, weight, bias=None)¶

对输入数据应用线性变换 \(y = xA^T + b\)。

形状：

Input - \((N, *, in\_features)\)，其中 N 表示 batch size，* 表示任意数量的附加维度。
Weight - \((out\_features, in\_features)\)
Bias - \((out\_features)\)
Output - \((N, *, out\_features)\)

示例：

>>> import numpy as np
>>> import oneflow as flow

>>> input = flow.tensor(np.random.randn(128, 20))
>>> weight = flow.tensor(np.random.randn(30, 20))
>>> output = flow.nn.functional.linear(input, weight)
>>> output.size()
oneflow.Size([128, 30])

oneflow.nn.functional.cross_entropy()¶

文档参考自： https://pytorch.org/docs/stable/generated/torch.nn.functional.cross_entropy.html?highlight=nn%20functional%20cross_entropy#torch.nn.functional.cross_entropy 。查看 CrossEntropyLoss 获得更多细节。

参数：

input (Tensor) : 2D 损失的情况下为 \((N, C)\) ，其中 C = 类的数量或 \((N, C, H, W)\) ；K 维损失下为 \((N, C, d_1, d_2, ..., d_K)\) ，其中 \(K \geq 1\) 。 input 需包括未被规格化的指数。（通常被称为 logits）
target (Tensor) : 如果包括了类索引，形状为 \((N)\) ，其中每个值为 \(0 \leq \text{targets}[i] \leq C-1\) ，在 K 维损失下，则为 \((N, d_1, d_2, ..., d_K)\) ，其中 \(K \geq 1\) 。如果包括类可能性，则与输入相同。
weight (Tensor, 可选): 一个手动重设尺寸的权重，分配给每个类。如果被指定，需要是一个尺寸为 C 的张量。
ignore_index (int, 可选): 指定一个将被忽略且不计入输入梯度的目标值。当 size_average 为真时，损失将为不被忽略的目标的平均。注意 ignore_index 只有在目标包括类索引时可用。默认值：-100
reduction (string, 可选): 指定应用于输出的转置：
'none' | 'mean' | 'sum'. 'none': 没有转置将被应用， 'mean': 输出的和将被除以输出元素个数， 'sum': 输出将被总和。注意： size_average 和 reduce 即将被弃用，而与此同时指定任意两参数都会覆盖 reduction 。默认值： 'mean'

示例：

>>> import oneflow as flow
>>> import oneflow.nn.functional as F
>>> input = flow.randn(3, 5, requires_grad=True)
>>> target = flow.ones(3, dtype=flow.int64)
>>> loss = F.cross_entropy(input, target)
>>> loss.backward()