mindspore-Ecosystem
/
mindspore
21
0
Fork 27
Code Issues Pull Requests 6 Projects Releases Wiki Activity

!27421 modify api annotation 

Merge pull request !27421 from xumengjuan1/code_docs_xmj8
This commit is contained in:
i-robot 2021-12-08 08:16:17 +00:00 committed by Gitee
parent 895256f69a 3374dc3d96
commit ebc0561bfe
30 changed files with 910 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
docs/api/api_python/mindspore.nn.rst
View File

@ -18,6 +18,19 @@ Containers
mindspore.nn.CellList
mindspore.nn.SequentialCell
Convolution Layers
--------------------
.. cnmsplatformautosummary::
:toctree: nn
mindspore.nn.Conv1d
mindspore.nn.Conv1dTranspose
mindspore.nn.Conv2d
mindspore.nn.Conv2dTranspose
mindspore.nn.Conv3d
mindspore.nn.Conv3dTranspose
Gradient
---------
@ -34,12 +47,18 @@ Non-linear Activations
:toctree: nn
mindspore.nn.FastGelu
mindspore.nn.HShrink
mindspore.nn.HSigmoid
mindspore.nn.HSwish
mindspore.nn.LeakyReLU
mindspore.nn.LogSigmoid
mindspore.nn.LogSoftmax
mindspore.nn.ReLU
mindspore.nn.ELU
mindspore.nn.GELU
mindspore.nn.Sigmoid
mindspore.nn.Softmax
mindspore.nn.Tanh
Utilities
---------
@ -56,6 +75,9 @@ Loss Functions
.. cnmsplatformautosummary::
:toctree: nn
mindspore.nn.L1Loss
mindspore.nn.MAELoss
mindspore.nn.MSELoss
mindspore.nn.SmoothL1Loss
Optimizer Functions

66
docs/api/api_python/nn/mindspore.nn.Conv1d.rst Normal file
View File

@ -0,0 +1,66 @@
mindspore.nn.Conv1d
======================
.. py:class:: mindspore.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')
一维卷积层。
在输入Tensor上应用一维卷积，该Tensor的shape通常为 :math:`(N, C_{in}, W_{in})` ，其中 :math:`N` 是batch size， :math:`C_{in}` 是通道数。
对于每个batch中的Tensor，其shape为 :math:`(C_{in}, W_{in})` ，公式定义为：
.. math::
out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
其中， :math:`ccor` 为互关联算子， :math:`C_{in}` 为输入通道数， :math:`j` 的范围从 :math:`0` 到 :math:`C_{out} - 1` ， :math:`W_{ij}` 对应第 :math:`j` 个过滤器的第 :math:`i` 个通道， :math:`out_{j}` 对应输出的第 :math:`j` 个通道。
:math:`W_{ij}`是kernel的切片，它的shape为 :math:`(\text{ks_w})` ，其中 :math:`\text{ks_w}` 是卷积核的宽度。
完整kernel的shape为 :math:`(C_{out}, C_{in} // \text{group}, \text{ks_w})` ，其中group是在通道维度上分割输入 `x` 的组数。
如果'pad_mode'设置为"valid"，则输出宽度将为 :math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} - (\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` 。
论文 `Gradient Based Learning Applied to Document Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ 首次提出卷积层。
**参数：**
- **in_channels** (int) - 输入通道数 :math:`C_{in}` 。
- **out_channels** (int) - 输出通道数 :math:`C_{out}` 。
- **kernel_size** (int) - 指定一维卷积核的宽度。
- **stride** (int) - 步长大小，表示移到宽度。默认值：1。
- **pad_mode** (str) - 指定填充模式。可选值为"same"、"valid"、"pad"。默认值："same"。
- same：采用补全方式。输出的宽度与输入 `x` 一致。填充总数将在水平上进行计算。并尽可能均匀分布到左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的宽度的输出。多余的像素会被丢弃。如果设置此模式，则 `padding` 必须为0。
- pad：输入 `x` 两侧的隐式填充。 `padding` 的数量将填充到输入Tensor边框上。 `padding` 必须大于或等于0。
- **padding** (int) - 输入 `x` 两侧的隐式填充。默认值：0。
- **dilation** (int) - 指定用于扩张卷积的扩张速率。如果设置为 :math:`k > 1` ，则每个采样位置都跳过 :math:`k - 1` 个像素。其值必须大于或等于1，并以输入 `x` 的宽度为界。默认值：1。
- **group** (int) - 将过滤器拆分为组， `in_ channels` 和 `out_channels` 必须可被组数整除。默认值：1。
- **has_bias** (bool) - 指定图层是否使用偏置矢量。默认值：False。
- **weight_init** (Union[Tensor, str, Initializer, numbers.Number]) - 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (Union[Tensor, str, Initializer, numbers.Number]) - 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
**输入：**
- **x** (Tensor) - shape为 :math:`(N, C_{in}, W_{in})` 的Tensor。
**输出：**
Tensor，shape为:math:`(N, C_{out}, W_{out})`。
**异常：**
- **TypeError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 、 `padding` 或 `dilation` 不是int。
- **ValueError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是'same'，'valid'，或'pad'。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv1d(120, 240, 4, has_bias=False, weight_init='normal')
>>> x = Tensor(np.ones([1, 120, 640]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 240, 640)

65
docs/api/api_python/nn/mindspore.nn.Conv1d.txt
View File

@ -1,65 +0,0 @@
Class mindspore.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')
一维卷积层。
在输入Tensor上应用一维卷积，该Tensor的shape通常为:math:`(N, C_{in}, W_{in})`，其中:math:`N`是batch size，:math:`C_{in}`是通道数。
对于每个batch中的Tensor，其shape为 :math:`(C_{in}, W_{in})`，公式定义为：
.. math::
out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
其中，:math:`ccor`为互关联算子，:math:`C_{in}`为输入通道数，:math:`j`的范围从:math:`0`到:math:`C_{out} - 1`，:math:`W_{ij}`对应第:math:`j`个过滤器的第:math:`i`个通道，:math:`out_{j}`对应输出的第:math:`j`个通道。
:math:`W_{ij}`是kernel的切片，它的shape为:math:`(\text{ks_w})`，其中:math:`\text{ks_w}`是卷积核的宽度。
完整kernel的shape为:math:`(C_{out}, C_{in} // \text{group}, \text{ks_w})`，其中group是在通道维度上分割输入 `x` 的组数。
如果'pad_mode'设置为"valid"，则输出宽度将为:math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} - (\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor`。
论文`Gradient Based Learning Applied to Document Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ 首次提出卷积层。
参数：
in_channels (int)：输入通道数 :math:`C_{in}`。
out_channels (int)：输出通道数 :math:`C_{out}`。
kernel_size (int)：指定一维卷积核的宽度。
stride (int)：步长大小，表示移到宽度。默认值：1。
pad_mode (str)：指定填充模式。可选值为"same"、"valid"、"pad"。默认值："same"。
- same：采用补全方式。输出的宽度与输入 `x` 一致。填充总数将在水平上进行计算。并尽可能均匀分布到左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的宽度的输出。多余的像素会被丢弃。如果设置此模式，则`padding`必须为0。
- pad：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
padding (int)：输入`x`两侧的隐式填充。默认值：0。
dilation (int)：指定用于扩张卷积的扩张速率。如果设置为:math:`k > 1`，则每个采样位置都跳过:math:`k - 1`个像素。其值必须大于或等于1，并以输入`x`的宽度为界。默认值：1。
group (int)：将过滤器拆分为组，`in_ channels`和`out_channels`必须可被组数整除。默认值：1。
has_bias (bool)：指定图层是否使用偏置矢量。默认值：False。
weight_init (Union[Tensor, str, Initializer, numbers.Number])：卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
bias_init (Union[Tensor, str, Initializer, numbers.Number])：偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
输入：
- **x** (Tensor)：shape为:math:`(N, C_{in}, W_{in})`的Tensor。
输出：
Tensor，shape为:math:`(N, C_{out}, W_{out})`。
异常：
TypeError：`in_channels`、`out_channels`、`kernel_size`、`stride`、`padding`或`dilation`不是int。
ValueError：`in_channels`、`out_channels`、`kernel_size`、`stride`或`dilation`小于1。
ValueError：`padding`小于0。
ValueError：`pad_mode`不是'same'，'valid'，或'pad'。
支持平台：
``Ascend`` ``GPU`` ``CPU``
样例：
>>> net = nn.Conv1d(120, 240, 4, has_bias=False, weight_init='normal')
>>> x = Tensor(np.ones([1, 120, 640]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 240, 640)

72
docs/api/api_python/nn/mindspore.nn.Conv1dTranspose.rst Normal file
View File

@ -0,0 +1,72 @@
mindspore.nn.Conv1dTranspose
=============================
.. py:class:: mindspore.nn.Conv1dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')
一维转置卷积层。
计算一维转置卷积，也称为反卷积（实际不是真正的反卷积）。
该算子可以看成Conv1d相对于其输入的梯度。
`x` 的shape通常是 :math:`(N, C, W)` ，其中 :math:`N` 是batch size， :math:`C` 是通道数， :math:`W` 是特征长度。
对输入填充 :math:`dilation * (kernel\_size - 1) - padding` 个零。
因此，当Conv1d和ConvTranspose1d使用相同的参数初始化时，它们的输入和输出shape是互逆的。
但是，当stride>1时，Conv1d将多个输入的shape映射到同一个输出shape。
输出宽度定义如下：
.. math::
W_{out} = \begin{cases}
(W_{in} - 1) \times \text{stride} - 2 \times \text{padding} + \text{dilation} \times
(\text{ks_w} - 1) + 1, & \text{if pad_mode='pad'}\\
(W_{in} + \text{stride} - 1)/\text{stride}, & \text{if pad_mode='same'}\\
(W_{in} - 1) \times \text{stride} + \text{dilation} \times
(\text{ks_w} - 1) + 1, & \text{if pad_mode='valid'}
\end{cases}
其中 :math:`\text{ks_w}` 是卷积核的宽度。
**参数：**
- **in_channels** (int) - 输入的通道数。
- **out_channels** (int) - 输出的通道数。
- **kernel_size** (int) - 指定一维卷积窗口的宽度。
- **stride** (int) - 步长大小，表示移到宽度。默认值：1。
- **pad_mode** (str) - 选择填充模式。可选值为"pad"，"same"，"valid"。默认值："same"。
- same：采用补全方式。输出的宽度与输入 `x` 一致。填充总数将在水平上进行计算。并尽可能均匀分布到左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式， `padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的宽度的输出。多余的像素会被丢弃。如果设置此模式，则 `padding` 必须为0。
- pad：输入 `x` 两侧的隐式填充。 `padding` 的数量将填充到输入Tensor边框上。 `padding` 必须大于或等于0。
- **padding** (int) - 输入`x`两侧的隐式填充。默认值：0。
- **dilation** (int) - 指定用于扩张卷积的扩张速率。如果设置为 :math:`k > 1` ，则每个采样位置都跳过 :math:`k - 1` 个像素。其值必须大于或等于1，并以输入 `x` 的宽度为界。默认值：1。
- **group** (int) - 将过滤器拆分为组， `in_ channels` 和 `out_channels` 必须可被组数整除。当组数>1时，不支持Davinci设备。默认值：1。
- **has_bias** (bool) - 指定图层是否使用偏置矢量。默认值：False。
- **weight_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
**输入：**
- **x** (Tensor) - shape为 :math:`(N, C_{in}, W_{in})` 的Tensor。
**输出：**
Tensor，shape为 :math:`(N, C_{out}, W_{out})` 。
**异常：**
- **TypeError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 、 `padding`或 `dilation` 不是int。
- **ValueError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是'same'，'valid'，或'pad'。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv1dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
>>> x = Tensor(np.ones([1, 3, 50]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 64, 53)

69
docs/api/api_python/nn/mindspore.nn.Conv1dTranspose.txt
View File

@ -1,69 +0,0 @@
Class mindspore.nn.Conv1dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')
一维转置卷积层。
计算一维转置卷积，也称为反卷积（实际不是真正的反卷积）。
该算子可以看成Conv1d相对于其输入的梯度。
`x`的shape通常是:math:`(N, C, W)`，其中:math:`N`是batch size，:math:`C`是通道数，:math:`W`是特征长度。
对输入填充:math:`dilation * (kernel\_size - 1) - padding`个零。
因此，当Conv1d和ConvTranspose1d使用相同的参数初始化时，它们的输入和输出shape是互逆的。
但是，当stride>1时，Conv1d将多个输入的shape映射到同一个输出shape。
输出宽度定义如下：
.. math::
W_{out} = \begin{cases}
(W_{in} - 1) \times \text{stride} - 2 \times \text{padding} + \text{dilation} \times
(\text{ks_w} - 1) + 1, & \text{if pad_mode='pad'}\\
(W_{in} + \text{stride} - 1)/\text{stride}, & \text{if pad_mode='same'}\\
(W_{in} - 1) \times \text{stride} + \text{dilation} \times
(\text{ks_w} - 1) + 1, & \text{if pad_mode='valid'}
\end{cases}
其中:math:`\text{ks_w}`是卷积核的宽度。
参数：
in_channels (int)：输入的通道数。
out_channels (int)：输出的通道数。
kernel_size (int)：指定一维卷积窗口的宽度。
stride (int)：步长大小，表示移到宽度。默认值：1。
pad_mode (str)：选择填充模式。可选值为"pad"，"same"，"valid"。默认值："same"。
- same：采用补全方式。输出的宽度与输入 `x` 一致。填充总数将在水平上进行计算。并尽可能均匀分布到左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的宽度的输出。多余的像素会被丢弃。如果设置此模式，则`padding`必须为0。
- pad：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
padding (int)：输入`x`两侧的隐式填充。默认值：0。
dilation (int)：指定用于扩张卷积的扩张速率。如果设置为:math:`k > 1`，则每个采样位置都跳过:math:`k - 1`个像素。其值必须大于或等于1，并以输入`x`的宽度为界。默认值：1。
group (int)：将过滤器拆分为组，`in_ channels`和`out_channels`必须可被组数整除。当组数>1时，不支持Davinci设备。默认值：1。
has_bias (bool)：指定图层是否使用偏置矢量。默认值：False。
weight_init： (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
bias_init： (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
输入：
- **x** (Tensor)：shape为:math:`(N, C_{in}, W_{in})`的Tensor。
输出：
Tensor，shape为:math:`(N, C_{out}, W_{out})`。
异常：
TypeError：`in_channels`、`out_channels`、`kernel_size`、`stride`、`padding`或`dilation`不是int。
ValueError：`in_channels`、`out_channels`、`kernel_size`、`stride`或`dilation`小于1。
ValueError：`padding`小于0。
ValueError：`pad_mode`不是'same'，'valid'，或'pad'。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> net = nn.Conv1dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
>>> x = Tensor(np.ones([1, 3, 50]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 64, 53)

70
docs/api/api_python/nn/mindspore.nn.Conv3d.rst Normal file
View File

@ -0,0 +1,70 @@
mindspore.nn.Conv3d
=============================
.. py:class:: mindspore.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')
三维卷积层。
在输入Tensor上应用三维卷积，该Tensor的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，输出shape为 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` ，其中 :math:`N` 是batch size， :math:`C` 是通道数。公式定义如下：
.. math::
\operatorname{out}\left(N_{i}, C_{\text {out}_j}\right)=\operatorname{bias}\left(C_{\text {out}_j}\right)+
\sum_{k=0}^{C_{in}-1} ccor(\text {weight}\left(C_{\text {out}_j}, k\right),
\operatorname{input}\left(N_{i}, k\right))
其中 :math:`corr` 是互关联算子。
如果'pad_mode'设置为"valid"，则输出深度、高度和宽度将分别为 :math:`\left \lfloor{1 + \frac{D_{in} + \text{padding[0]} + \text{padding[1]} - \text{kernel_size[0]} - (\text{kernel_size[0]} - 1) \times (\text{dilation[0]} - 1) }{\text{stride[0]}}} \right \rfloor` 、 :math:`\left \lfloor{1 + \frac{H_{in} + \text{padding[2]} + \text{padding[3]} - \text{kernel_size[1]} - (\text{kernel_size[1]} - 1) \times (\text{dilation[1]} - 1) }{\text{stride[1]}}} \right \rfloor` 和 :math:`\left \lfloor{1 + \frac{W_{in} + \text{padding[4]} + \text{padding[5]} - \text{kernel_size[2]} - (\text{kernel_size[2]} - 1) \times (\text{dilation[2]} - 1) }{\text{stride[2]}}} \right \rfloor` 。
**参数：**
- **in_channels** (int) - 输入通道数 :math:`C_{in}` 。
- **out_channels** (int) - 输出通道数 :math:`C_{out}` 。
- **kernel_size** (Union[int, tuple[int]]) - 指定三维卷积窗口的深度、高度和宽度。数据类型为int或包含3个整数的tuple。一个整数表示卷积核的深度、高度和宽度均为该值该值。包含3个整数的tuple分别表示卷积核的深度、高度和宽度。
- **stride** (Union[int, tuple[int]]) - 步长大小。数据类型为整型或3个整型的tuple。一个整数表示在深度、高度和宽度方向的滑动步长均为该值。3个整数的tuple分别表示在深度、高度和宽度方向的滑动步长。默认值：1。
- **pad_mode** (str) - 指定填充模式。可选值为“same”，“valid”，“pad”。默认值：“same”。
- same：采用补全方式。输出的深度、高度和宽度与输入 `x` 一致。填充总数将在深度、水平和垂直方向进行计算。并尽可能均匀分布到头部、尾部、顶部、底部、左侧和右侧。否则，最后一次将从尾部、底部和右侧进行额外的填充。若设置该模式， `padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的深度、高度和宽度的输出。多余的像素会被丢弃。若设置该模式， `padding` 必须为0。
- pad：输入 `x` 两侧的隐式填充。 `padding` 的数量将填充到输入Tensor边框上。 `padding` 必须大于或等于0。
- **padding** (Union(int, tuple[int])) - 输入 `x` 两侧的隐式填充。数据类型为int或包含6个整数的tuple。如果 `padding` 是一个整数，则头部、尾部、顶部，底部，左边和右边的填充都等于 `padding` 。如果 `padding` 是6个整数的tuple，则头部、尾部、顶部、底部、左边和右边的填充分别等于填充padding[0]、padding[1]、padding[2]、padding[3]、padding[4]和padding[5]。默认值：0。
- **dilation** (Union[int, tuple[int]]) - 指定用于扩张卷积的扩张速率。数据类型为int或3个整数的tuple。 :math:`(dilation_d, dilation_h, dilation_w)`。目前，深度扩张仅支持1个用例的情况。如果设置为 :math:`k > 1` ，则每个采样位置都跳过 :math:`k - 1` 个像素。其值必须大于或等于1，并以输入 `x` 的深度、高度和宽度为界。默认值：1。
- **group** (int) - 将过滤器拆分为组， `in_ channels` 和 `out_channels` 必须可被组数整除。默认值：1。当前仅支持1个。
- **has_bias** (bool) - 指定图层是否使用偏置矢量。默认值：False。
- **weight_init** (Union[Tensor, str, Initializer, numbers.Number]) - 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (Union[Tensor, str, Initializer, numbers.Number]) - 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
- **data_format** (str) - 数据格式的可选值。目前仅支持'NCDHW'。
**输入：**
- **x** (Tensor) - shape为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` 的Tensor。目前输入数据类型只支持float16和float32。
**输出：**
Tensor，shape为 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` 。
**异常：**
- **TypeError** - `in_channels` 、 `out_channels` 或 `group` 不是int。
- **TypeError** - `kernel_size` 、 `stride` 、 `padding` 或 `dilation` 既不是int也不是tuple。
- **ValueError** - `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是“same”，“valid”或“pad”。
- **ValueError** - `padding` 是长度不等于6的tuple。
- **ValueError** - `pad_mode` 不等于'pad'且 `padding` 不等于(0, 0, 0, 0, 0, 0)。
- **ValueError** - `data_format` 不是'NCDHW'。
**支持平台：**
``Ascend`` ``GPU``
**样例：**
>>> x = Tensor(np.ones([16, 3, 10, 32, 32]), mindspore.float32)
>>> conv3d = nn.Conv3d(in_channels=3, out_channels=32, kernel_size=(4, 3, 3))
>>> output = conv3d(x)
>>> print(output.shape)
(16, 32, 10, 32, 32)

63
docs/api/api_python/nn/mindspore.nn.Conv3d.txt
View File

@ -1,63 +0,0 @@
Class mindspore.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')
三维卷积层。
在输入Tensor上应用三维卷积，该Tensor的shape通常为:math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`，输出shape为:math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`，其中:math:`N`是batch size，:math:`C`是通道数。公式定义如下：
.. math::
\operatorname{out}\left(N_{i}, C_{\text {out}_j}\right)=\operatorname{bias}\left(C_{\text {out}_j}\right)+
\sum_{k=0}^{C_{in}-1} ccor(\text {weight}\left(C_{\text {out}_j}, k\right),
\operatorname{input}\left(N_{i}, k\right))
其中 :math:`corr` 是互关联算子。
如果'pad_mode'设置为"valid"，则输出深度、高度和宽度将分别为:math:`\left \lfloor{1 + \frac{D_{in} + \text{padding[0]} + \text{padding[1]} - \text{kernel_size[0]} - (\text{kernel_size[0]} - 1) \times (\text{dilation[0]} - 1) }{\text{stride[0]}}} \right \rfloor`、:math:`\left \lfloor{1 + \frac{H_{in} + \text{padding[2]} + \text{padding[3]} - \text{kernel_size[1]} - (\text{kernel_size[1]} - 1) \times (\text{dilation[1]} - 1) }{\text{stride[1]}}} \right \rfloor`和:math:`\left \lfloor{1 + \frac{W_{in} + \text{padding[4]} + \text{padding[5]} - \text{kernel_size[2]} - (\text{kernel_size[2]} - 1) \times (\text{dilation[2]} - 1) }{\text{stride[2]}}} \right \rfloor`。
参数：
in_channels (int)：输入通道数 :math:`C_{in}`。
out_channels (int)：输出通道数 :math:`C_{out}`。
kernel_size (Union[int, tuple[int]])：指定三维卷积窗口的深度、高度和宽度。数据类型为int或包含3个整数的tuple。一个整数表示卷积核的深度、高度和宽度均为该值该值。包含3个整数的tuple分别表示卷积核的深度、高度和宽度。
stride (Union[int, tuple[int]])：步长大小。数据类型为整型或3个整型的tuple。一个整数表示在深度、高度和宽度方向的滑动步长均为该值。3个整数的tuple分别表示在深度、高度和宽度方向的滑动步长。默认值：1。
pad_mode (str)：指定填充模式。可选值为“same”，“valid”，“pad”。默认值：“same”。
- same：采用补全方式。输出的深度、高度和宽度与输入 `x` 一致。填充总数将在深度、水平和垂直方向进行计算。并尽可能均匀分布到头部、尾部、顶部、底部、左侧和右侧。否则，最后一次将从尾部、底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的深度、高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 必须为0。
- pad：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
padding (Union(int, tuple[int]))：输入`x`两侧的隐式填充。数据类型为int或包含6个整数的tuple。如果`padding`是一个整数，则头部、尾部、顶部，底部，左边和右边的填充都等于 `padding`。如果`padding`是6个整数的tuple，则头部、尾部、顶部、底部、左边和右边的填充分别等于填充padding[0]、padding[1]、padding[2]、padding[3]、padding[4]和padding[5]。默认值：0。
dilation (Union[int, tuple[int]])：指定用于扩张卷积的扩张速率。数据类型为int或3个整数的tuple: math:`(dilation_d, dilation_h, dilation_w)`。
目前，深度扩张仅支持1个用例的情况。如果设置为:math:`k > 1`，则每个采样位置都跳过:math:`k - 1`个像素。其值必须大于或等于1，并以输入`x`的深度、高度和宽度为界。默认值：1。
group (int)：将过滤器拆分为组，`in_ channels`和`out_channels`必须可被组数整除。默认值：1。当前仅支持1个。
has_bias (bool)：指定图层是否使用偏置矢量。默认值：False。
weight_init (Union[Tensor, str, Initializer, numbers.Number])：卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
bias_init (Union[Tensor, str, Initializer, numbers.Number])：偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
data_format (str)：数据格式的可选值。目前仅支持'NCDHW'。
输入：
- **x** (Tensor)：shape为:math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`的Tensor。
目前输入数据类型只支持float16和float32。
输出：
Tensor，shape为:math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`。
异常：
TypeError：`in_channels`、`out_channels`或`group`不是int。
TypeError：`kernel_size`、`stride`、`padding`或`dilation`既不是int也不是tuple。
ValueError：`out_channels`、`kernel_size`、`stride`或`dilation`小于1。
ValueError：`padding`小于0。
ValueError：`pad_mode`不是“same”，“valid”或“pad”。
ValueError：`padding`是长度不等于6的tuple。
ValueError：`pad_mode`不等于'pad'且`padding`不等于(0, 0, 0, 0, 0, 0)。
ValueError：`data_format`不是'NCDHW'。
支持平台：
``Ascend`` ``GPU``
样例：
>>> x = Tensor(np.ones([16, 3, 10, 32, 32]), mindspore.float32)
>>> conv3d = nn.Conv3d(in_channels=3, out_channels=32, kernel_size=(4, 3, 3))
>>> output = conv3d(x)
>>> print(output.shape)
(16, 32, 10, 32, 32)

109
docs/api/api_python/nn/mindspore.nn.Conv3dTranspose.rst Normal file
View File

@ -0,0 +1,109 @@
mindspore.nn.Conv3dTranspose
=============================
.. py:class:: mindspore.nn.Conv3dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, output_padding=0, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')
三维转置卷积层。
计算三维转置卷积，也称为反卷积（实际不是实际的反卷积）。
转置卷积算子将每个输入元素乘以learnable kernel，并把所有输入特征平面的输出相加。
该算子可以看成Conv3d相对于其输入的梯度。
`x` 通常shape为 :math:`(N, C, D, H, W)` ，其中 :math:`N` 是batch size， :math:`C` 是通道数， :math:`D` 是特征层的深度， :math:`H` 是特征高度， :math:`W` 是特征层的宽度。
转置卷积的计算过程相当于卷积的反向计算。
对输入填充 :math:`dilation * (kernel\_size - 1) - padding` 个零。
因此，当Conv3d和ConvTranspose3d使用相同的参数初始化时，它们的输入和输出shape是互逆的。
但是，当stride>1时，Conv3d将多个输入的shape映射到同一个输出shape。
ConvTranspose3d提供padding参数，增加一侧或多侧计算的输出shape。
输出的高度和宽度定义如下：
如果'pad_mode'设置为"pad"，
.. math::
D_{out} = (D_{in} - 1) \times \text{stride_d} - 2 \times \text{padding_d} + \text{dilation_d} \times
(\text{kernel_size_d} - 1) + \text{output_padding_d} + 1
H_{out} = (H_{in} - 1) \times \text{stride_h} - 2 \times \text{padding_h} + \text{dilation_h} \times
(\text{kernel_size_h} - 1) + \text{output_padding_h} + 1
W_{out} = (W_{in} - 1) \times \text{stride_w} - 2 \times \text{padding_w} + \text{dilation_w} \times
(\text{kernel_size_w} - 1) + \text{output_padding_w} + 1
如果'pad_mode'设置为"same"，
.. math::
D_{out} = (D_{in} + \text{stride_d} - 1)/\text{stride_d} \\
H_{out} = (H_{in} + \text{stride_h} - 1)/\text{stride_h} \\
W_{out} = (W_{in} + \text{stride_w} - 1)/\text{stride_w}
如果'pad_mode'设置为"valid"，
.. math::
D_{out} = (D_{in} - 1) \times \text{stride_d} + \text{dilation_d} \times
(\text{kernel_size_d} - 1) + 1 \\
H_{out} = (H_{in} - 1) \times \text{stride_h} + \text{dilation_h} \times
(\text{kernel_size_h} - 1) + 1 \\
W_{out} = (W_{in} - 1) \times \text{stride_w} + \text{dilation_w} \times
(\text{kernel_size_w} - 1) + 1
**参数：**
- **in_channels** (int) - 输入通道数 :math:`C_{in}` 。
- **out_channels** (int) - 输出通道数 :math:`C_{out}` 。
- **kernel_size** (Union[int, tuple[int]]) - 指定三维卷积窗口的深度、高度和宽度。数据类型为int或包含3个整数的tuple。一个整数表示卷积核的深度、高度和宽度均为该值该值。包含3个整数的tuple分别表示卷积核的深度、高度和宽度。
- **stride** (Union[int, tuple[int]]) - 步长大小。数据类型为整型或3个整型的tuple。一个整数表示在深度、高度和宽度方向的滑动步长均为该值。3个整数的tuple分别表示在深度、高度和宽度方向的滑动步长。必须大于等于1。默认值：1。
- **pad_mode** (str) - 选择填充模式。可选值为"pad"、"same"、"valid"。默认值："same"。
- same：采用补全方式。输出的深度、高度和宽度与输入 `x` 一致。填充总数将在深度、水平和垂直方向进行计算。并尽可能均匀分布到头部、尾部、顶部、底部、左侧和右侧。否则，最后一次将从尾部、底部和右侧进行额外的填充。若设置该模式， `padding` 和 `output_padding` 必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的深度、高度和宽度的输出。多余的像素会被丢弃。若设置该模式， `padding` 和 `output_padding` 必须为0。
- pad：输入 `x` 两侧的隐式填充。 `padding` 的数量将填充到输入Tensor边框上。 `padding` 必须大于或等于0。
- **padding** (Union(int, tuple[int])) - 待填充的padding值。数据类型为int或包含6个整数的tuple。如果 `padding` 是一个整数，则头部、尾部、顶部，底部，左边和右边的填充都等于 `padding` 。如果 `padding` 是6个整数的tuple，则头部、尾部、顶部、底部、左边和右边的填充分别等于填充padding[0]、padding[1]、padding[2]、padding[3]、padding[4]和padding[5]。默认值：0。
- **dilation** (Union(int, tuple[int])) - 指定用于扩张卷积的扩张速率。数据类型为int或3个整数的tuple。:math:`(dilation_d, dilation_h, dilation_w)` 。目前，深度扩张仅支持1个用例的情况。如果设置为 :math:`k > 1` ，则每个采样位置都跳过 :math:`k - 1` 个像素。其值必须大于或等于1，并以输入 `x` 的深度、高度和宽度为界。默认值：1。
- **group** (int) - 将过滤器拆分为组， `in_ channels` 和 `out_channels` 必须可被组数整除。默认值：1。当前仅支持1个。
- **output_padding** (Union(int, tuple[int])) - 为输出的每个维度添加额外的大小。默认值：0。必须大于或等于0。
- **has_bias** (bool) - 指定图层是否使用偏置矢量。默认值：False。
- **weight_init** (Union[Tensor, str, Initializer, numbers.Number]) - 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (Union[Tensor, str, Initializer, numbers.Number]) - 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
- **data_format** (str) - 数据格式的可选值。目前仅支持'NCDHW'。
**输入：**
- **x** (Tensor) - shape为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` 的Tensor。目前输入数据类型只支持float16和float32。
**输出：**
Tensor，shape为 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` 。
**支持平台：**
``Ascend`` ``GPU``
**异常：**
- **TypeError** - `in_channels` 、 `out_channels` 或 `group` 不是int。
- **TypeError** - `kernel_size` 、 `stride` 、 `padding` 、 `dilation` 或 `output_padding` 既不是int也不是tuple。
- **TypeError** - 输入数据类型不是float16或float32。
- **ValueError** - `in_channels` 、 `out_channels` 、 `kernel_size` 、 `stride` 或 `dilation` 小于1。
- **ValueError** - `padding` 小于0。
- **ValueError** - `pad_mode` 不是“same”，“valid”或“pad”。
- **ValueError** - `padding` 是长度不等于6的tuple。
- **ValueError** - `pad_mode` 不等于'pad'且 `padding` 不等于(0, 0, 0, 0, 0, 0)。
- **ValueError** - `data_format` 不是'NCDHW'。
**样例：**
>>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float32)
>>> conv3d_transpose = nn.Conv3dTranspose(in_channels=16, out_channels=3, kernel_size=(4, 6, 2),
... pad_mode='pad')
>>> output = conv3d_transpose(x)
>>> print(output.shape)
(32, 3, 13, 37, 33)

103
docs/api/api_python/nn/mindspore.nn.Conv3dTranspose.txt
View File

@ -1,103 +0,0 @@
Class mindspore.nn.Conv3dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, output_padding=0, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')
三维转置卷积层。
计算三维转置卷积，也称为反卷积（实际不是实际的反卷积）。
转置卷积算子将每个输入元素乘以learnable kernel，并把所有输入特征平面的输出相加。
该算子可以看成Conv3d相对于其输入的梯度。
`x`通常shape为:math:`(N, C, D, H, W)`，其中:math:`N`是batch size，:math:`C`是通道数，:math:`D`是特征层的深度，:math:`H`是特征高度，:math:`W`是特征层的宽度。
转置卷积的计算过程相当于卷积的反向计算。
对输入填充:math:`dilation * (kernel\_size - 1) - padding`个零。
因此，当Conv3d和ConvTranspose3d使用相同的参数初始化时，它们的输入和输出shape是互逆的。
但是，当stride>1时，Conv3d将多个输入的shape映射到同一个输出shape。
ConvTranspose3d提供padding参数，增加一侧或多侧计算的输出shape。
输出的高度和宽度定义如下：
如果'pad_mode'设置为"pad"，
.. math::
D_{out} = (D_{in} - 1) \times \text{stride_d} - 2 \times \text{padding_d} + \text{dilation_d} \times
(\text{kernel_size_d} - 1) + \text{output_padding_d} + 1
H_{out} = (H_{in} - 1) \times \text{stride_h} - 2 \times \text{padding_h} + \text{dilation_h} \times
(\text{kernel_size_h} - 1) + \text{output_padding_h} + 1
W_{out} = (W_{in} - 1) \times \text{stride_w} - 2 \times \text{padding_w} + \text{dilation_w} \times
(\text{kernel_size_w} - 1) + \text{output_padding_w} + 1
如果'pad_mode'设置为"same"，
.. math::
D_{out} = (D_{in} + \text{stride_d} - 1)/\text{stride_d} \\
H_{out} = (H_{in} + \text{stride_h} - 1)/\text{stride_h} \\
W_{out} = (W_{in} + \text{stride_w} - 1)/\text{stride_w}
如果'pad_mode'设置为"valid"，
.. math::
D_{out} = (D_{in} - 1) \times \text{stride_d} + \text{dilation_d} \times
(\text{kernel_size_d} - 1) + 1 \\
H_{out} = (H_{in} - 1) \times \text{stride_h} + \text{dilation_h} \times
(\text{kernel_size_h} - 1) + 1 \\
W_{out} = (W_{in} - 1) \times \text{stride_w} + \text{dilation_w} \times
(\text{kernel_size_w} - 1) + 1
参数：
in_channels (int)：输入通道数 :math:`C_{in}`。
out_channels (int)：输出通道数 :math:`C_{out}`。
kernel_size (Union[int, tuple[int]])：指定三维卷积窗口的深度、高度和宽度。数据类型为int或包含3个整数的tuple。一个整数表示卷积核的深度、高度和宽度均为该值该值。包含3个整数的tuple分别表示卷积核的深度、高度和宽度。
stride (Union[int, tuple[int]])：步长大小。数据类型为整型或3个整型的tuple。一个整数表示在深度、高度和宽度方向的滑动步长均为该值。3个整数的tuple分别表示在深度、高度和宽度方向的滑动步长。必须大于等于1。默认值：1。
pad_mode (str)：选择填充模式。可选值为"pad"、"same"、"valid"。默认值："same"。
- same：采用补全方式。输出的深度、高度和宽度与输入 `x` 一致。填充总数将在深度、水平和垂直方向进行计算。并尽可能均匀分布到头部、尾部、顶部、底部、左侧和右侧。否则，最后一次将从尾部、底部和右侧进行额外的填充。若设置该模式，`padding` 和`output_padding`必须为0。
- valid：采用的丢弃方式。在不填充的前提下返回可能大的深度、高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 和`output_padding`必须为0。
- pad：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
padding (Union(int, tuple[int]))：待填充的padding值。数据类型为int或包含6个整数的tuple。如果`padding`是一个整数，则头部、尾部、顶部，底部，左边和右边的填充都等于 `padding`。如果`padding`是6个整数的tuple，则头部、尾部、顶部、底部、左边和右边的填充分别等于填充padding[0]、padding[1]、padding[2]、padding[3]、padding[4]和padding[5]。默认值：0。
dilation (Union(int, tuple[int]))：指定用于扩张卷积的扩张速率。数据类型为int或3个整数的tuple: math:`(dilation_d, dilation_h, dilation_w)`。
目前，深度扩张仅支持1个用例的情况。如果设置为:math:`k > 1`，则每个采样位置都跳过:math:`k - 1`个像素。其值必须大于或等于1，并以输入`x`的深度、高度和宽度为界。默认值：1。
group (int)：将过滤器拆分为组，`in_ channels`和`out_channels`必须可被组数整除。默认值：1。当前仅支持1个。
output_padding (Union(int, tuple[int]))：为输出的每个维度添加额外的大小。默认值：0。必须大于或等于0。
has_bias (bool)：指定图层是否使用偏置矢量。默认值：False。
weight_init (Union[Tensor, str, Initializer, numbers.Number])：卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
bias_init (Union[Tensor, str, Initializer, numbers.Number])：偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
data_format (str)：数据格式的可选值。目前仅支持'NCDHW'。
输入：
- **x** (Tensor)：shape为:math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`的Tensor。
目前输入数据类型只支持float16和float32。
输出：
Tensor，shape为:math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`。
支持平台：
``Ascend`` ``GPU``
异常：
TypeError：`in_channels`、`out_channels`或`group`不是int。
TypeError：kernel_size`、`stride`、`padding`、`dilation`或`output_padding`既不是int也不是tuple。
TypeError：输入数据类型不是float16或float32。
ValueError：`in_channels`、`out_channels`、`kernel_size`、`stride`或`dilation`小于1。
ValueError：`padding`小于0。
ValueError：`pad_mode`不是“same”，“valid”或“pad”。
ValueError：`padding`是长度不等于6的tuple。
ValueError：`pad_mode`不等于'pad'且`padding`不等于(0, 0, 0, 0, 0, 0)。
ValueError：`data_format`不是'NCDHW'。
样例：
>>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float32)
>>> conv3d_transpose = nn.Conv3dTranspose(in_channels=16, out_channels=3, kernel_size=(4, 6, 2),
... pad_mode='pad')
>>> output = conv3d_transpose(x)
>>> print(output.shape)
(32, 3, 13, 37, 33)

45
docs/api/api_python/nn/mindspore.nn.HShrink.rst Normal file
View File

@ -0,0 +1,45 @@
mindspore.nn.HShrink
=============================
.. py:class:: mindspore.nn.HShrink(lambd=0.5)
按元素计算Hard Shrink函数，公式定义如下：
.. math::
\text{HardShrink}(x) =
\begin{cases}
x, & \text{ if } x > \lambda \\
x, & \text{ if } x < -\lambda \\
0, & \text{ otherwise }
\end{cases}
**参数：**
**lambd** (float) - Hard Shrink公式定义的阈值。默认值：0.5。
**输入：**
- **input_x** (Tensor) - Hard Shrink的输入，数据类型为float16或float32。
**输出：**
Tensor，shape和数据类型与输入相同。
**支持平台：**
``Ascend``
**异常：**
- **TypeError** - `lambd` 不是float。
- **TypeError** - `input_x` 的dtype既不是float16也不是float32。
**样例：**
>>> input_x = Tensor(np.array([[ 0.5, 1, 2.0],[0.0533,0.0776,-2.1233]]),mstype.float32)
>>> hshrink = nn.HShrink()
>>> output = hshrink(input_x)
>>> print(output)
[[ 0. 1. 2. ]
[ 0. 0. -2.1233]]

36
docs/api/api_python/nn/mindspore.nn.HShrink.txt
View File

@ -1,36 +0,0 @@
Class mindspore.nn.HShrink(lambd=0.5)
按元素计算Hard Shrink函数，公式定义如下：
.. math::
\text{HardShrink}(x) =
\begin{cases}
x, & \text{ if } x > \lambda \\
x, & \text{ if } x < -\lambda \\
0, & \text{ otherwise }
\end{cases}
参数：
lambd (float)：Hard Shrink公式定义的阈值。默认值：0.5。
输入：
- **input_x** (Tensor)：Hard Shrink的输入，数据类型为float16或float32。
输出：
Tensor，shape和数据类型与输入相同。
支持平台：
``Ascend``
异常：
TypeError：`lambd`不是float。
TypeError：`input_x`的dtype既不是float16也不是float32。
示例：
>>> input_x = Tensor(np.array([[ 0.5, 1, 2.0],[0.0533,0.0776,-2.1233]]),mstype.float32)
>>> hshrink = nn.HShrink()
>>> output = hshrink(input_x)
>>> print(output)
[[ 0. 1. 2. ]
[ 0. 0. -2.1233]]

40
docs/api/api_python/nn/mindspore.nn.HSigmoid.rst Normal file
View File

@ -0,0 +1,40 @@
mindspore.nn.HSigmoid
=============================
.. py:class:: mindspore.nn.HSigmoid
Hard Sigmoid激活函数。
按元素计算Hard Sigmoid激活函数。
Hard Sigmoid定义为：
.. math::
\text{hsigmoid}(x_{i}) = max(0, min(1, \frac{x_{i} + 3}{6})),
其中，:math:`x_i` 是输入Tensor的一个元素。
**输入：**
- **input_x** (Tensor) - Hard Sigmoid的输入。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度。
**输出：**
Tensor，数据类型和shape与 `input_x` 的相同。
**异常：**
**TypeError** - `input_x` 不是tensor。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> hsigmoid = nn.HSigmoid()
>>> result = hsigmoid(x)
>>> print(result)
[0.3333 0.1666 0.5 0.8335 0.6665]

33
docs/api/api_python/nn/mindspore.nn.HSigmoid.txt
View File

@ -1,33 +0,0 @@
Class mindspore.nn.HSigmoid
Hard Sigmoid激活函数。
按元素计算Hard Sigmoid激活函数。
Hard sigmoid定义为：
.. math::
\text{hsigmoid}(x_{i}) = max(0, min(1, \frac{x_{i} + 3}{6})),
其中，:math:`x_i` 是输入Tensor的一个元素。
输入：
- **input_x** (Tensor)：Hard Sigmoid的输入。shape为:math:`(N,*)`，其中:math:`*`表示任意的附加维度。
输出：
Tensor，数据类型和shape与 `input_x` 的相同。
异常：
TypeError：`input_x`不是tensor。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> hsigmoid = nn.HSigmoid()
>>> result = hsigmoid(x)
>>> print(result)
[0.3333 0.1666 0.5 0.8335 0.6665]

60
docs/api/api_python/nn/mindspore.nn.L1Loss.rst Normal file
View File

@ -0,0 +1,60 @@
mindspore.nn.L1Loss
=============================
.. py:class:: mindspore.nn.L1Loss(reduction='mean')
L1Loss用于测量 :math:`x` 和 :math:`y` 元素之间的平均绝对误差（MAE），其中 :math:`x` 是输入Tensor和 :math:`y` 是标签Tensor。
假设 :math:`x` 和 :math:`y` 为一维Tensor，长度 :math:`N` ，则计算 :math:`x` 和 :math:`y` 的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
其中， :math:`N` 为batch size。如果 `reduction` 不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{'sum'.}
\end{cases}
**参数：**
**reduction** (str) - 应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。默认值："mean"。
**输入：**
- **logits** (Tensor) - shape为 :math:`(N, *)` 的tensor，其中 :math:`*` 表示任意的附加维度。
- **labels** (Tensor) - shape为 :math:`(N, *)` 的tensor，在通常情况下与 `logits` 的shape相同。但是如果 `logits` 和 `labels` 的shape不同，需要保证他们之间可以互相广播。
**输出：**
Tensor，为loss float tensor，如果 `reduction` 为'mean'或'sum'，则shape为零；如果 `reduction` 为'none'，则输出的shape为广播的shape。
**异常：**
**ValueError** - `reduction` 不为"mean"，"sum"，或"none"。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.L1Loss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
0.33333334
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.L1Loss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 2.]
[0. 0. 1.]]

56
docs/api/api_python/nn/mindspore.nn.L1Loss.txt
View File

@ -1,56 +0,0 @@
Class mindspore.nn.L1Loss(reduction='mean')
L1Loss用于测量:math:`x`和:math:`y`元素之间的平均绝对误差（MAE），其中:math:`x`是输入Tensor和:math:'y'是标签Tensor。
假设:math:`x`和:math:`y`为一维Tensor，长度:math:`N`，则计算:math:`x`和:math:`y`的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
其中，:math:`N`为batch size。如果`reduction`不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{'sum'.}
\end{cases}
参数：
reduction (str)：应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。
默认值："mean"。
输入：
- **logits** (Tensor)：shape为:math:`(N, *)`的tensor，其中:math:`*`表示任意的附加维度。
- **labels** (Tensor)：shape为:math:`(N, *)`的tensor，在通常情况下与`logits`的shape相同。
但是如果`logits`和`labels`的shape不同，需要保证他们之间可以互相广播。
输出：
Tensor，为loss float tensor，如果`reduction`为'mean'或'sum'，则shape为零；如果`reduction`为'none'，则输出的shape为广播的shape。
异常：
ValueError：`reduction`不为"mean"，"sum"，或"none"。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.L1Loss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
0.33333334
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.L1Loss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 2.]
[0. 0. 1.]]

40
docs/api/api_python/nn/mindspore.nn.LogSigmoid.rst Normal file
View File

@ -0,0 +1,40 @@
mindspore.nn.LogSigmoid
=============================
.. py:class:: mindspore.nn.LogSigmoid
Log Sigmoid激活函数。
按元素计算Log Sigmoid激活函数。
Log Sigmoid定义为：
.. math::
\text{logsigmoid}(x_{i}) = log(\frac{1}{1 + \exp(-x_i)}),
其中，:math:`x_i` 是输入Tensor的一个元素。
**输入：**
- **x** (Tensor) - Log Sigmoid的输入，数据类型为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度。
**输出：**
Tensor，数据类型和shape与 `x` 的相同。
**异常：**
**TypeError** - `x` 的数据类型既不是float16也不是float32。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.LogSigmoid()
>>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> output = net(x)
>>> print(output)
[-0.31326166 -0.12692806 -0.04858734]

32
docs/api/api_python/nn/mindspore.nn.LogSigmoid.txt
View File

@ -1,32 +0,0 @@
Class mindspore.nn.LogSigmoid
Log Sigmoid激活函数。
按元素计算Log Sigmoid激活函数。
Log Sigmoid定义为：
.. math::
\text{logsigmoid}(x_{i}) = log(\frac{1}{1 + \exp(-x_i)}),
其中，:math:`x_i` 是输入Tensor的一个元素。
输入：
- **x** (Tensor)：Log Sigmoid的输入，数据类型为float16或float32。shape为:math:`(N,*)`，其中:math:`*`表示任意的附加维度。
输出：
Tensor，数据类型和shape与 `x` 的相同。
异常：
TypeError：`x`的数据类型既不是float16也不是float32。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> net = nn.LogSigmoid()
>>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> output = net(x)
>>> print(output)
[-0.31326166 -0.12692806 -0.04858734]

50
docs/api/api_python/nn/mindspore.nn.LogSoftmax.rst Normal file
View File

@ -0,0 +1,50 @@
mindspore.nn.LogSoftmax
=============================
.. py:class:: mindspore.nn.LogSoftmax(axis=-1)
Log Softmax激活函数。
按元素计算Log Softmax激活函数。
输入经Softmax函数、Log函数转换后，值的范围在[-inf,0)。
Log Softmax定义如下：
.. math::
\text{logsoftmax}(x_i) = \log \left(\frac{\exp(x_i)}{\sum_{j=0}^{n-1} \exp(x_j)}\right),
其中，:math:`x_i` 是输入Tensor的一个元素。
**参数：**
**axis** (int) - Log Softmax运算的axis，-1表示最后一个维度。默认值：-1。
**输入：**
- **x** (Tensor) - Log Softmax的输入，数据类型为float16或float32。
**输出：**
Tensor，数据类型和shape与`x`相同，值的范围在[-inf,0)。
**异常：**
- **TypeError** - `axis` 不是int。
- **TypeError** - `x` 的数据类型既不是float16也不是float32。
- **ValueError** - `axis` 不在[-len(x), len(x))范围中。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> log_softmax = nn.LogSoftmax()
>>> output = log_softmax(x)
>>> print(output)
[[-5.00672150e+00 -6.72150636e-03 -1.20067215e+01]
[-7.00091219e+00 -1.40009127e+01 -9.12250078e-04]]

41
docs/api/api_python/nn/mindspore.nn.LogSoftmax.txt
View File

@ -1,41 +0,0 @@
Class mindspore.nn.LogSoftmax(axis=-1)
Log Softmax激活函数。
按元素计算Log Softmax激活函数。
输入经Softmax函数、Log函数转换后，值的范围在[-inf,0)。
Log Softmax定义如下：
.. math::
\text{logsoftmax}(x_i) = \log \left(\frac{\exp(x_i)}{\sum_{j=0}^{n-1} \exp(x_j)}\right),
其中，:math:`x_i` 是输入Tensor的一个元素。
参数：
axis (int)：Log Softmax运算的axis，-1表示最后一个维度。默认值：-1。
输入：
- **x** (Tensor)：Log Softmax的输入，数据类型为float16或float32。
输出：
Tensor，数据类型和shape与`x`相同，值的范围在[-inf,0)。
异常：
TypeError：`axis`不是int。
TypeError：`x`的数据类型既不是float16也不是float32。
ValueError：`axis`不在[-len(x), len(x))范围中。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
>>> log_softmax = nn.LogSoftmax()
>>> output = log_softmax(x)
>>> print(output)
[[-5.00672150e+00 -6.72150636e-03 -1.20067215e+01]
[-7.00091219e+00 -1.40009127e+01 -9.12250078e-04]]

60
docs/api/api_python/nn/mindspore.nn.MAELoss.rst Normal file
View File

@ -0,0 +1,60 @@
mindspore.nn.MAELoss
=============================
.. py:class:: mindspore.nn.MAELoss(reduction='mean')
MAELoss用于测量 :math:`x` 和 :math:`y` 元素之间的平均绝对误差，其中 :math:`x` 是输入Tensor， :math:`y` 是标签Tensor。
假设 :math:`x` 和 :math:`y` 为一维Tensor，长度 :math:`N` ，则计算 :math:`x` 和 :math:`y` 的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
其中， :math:`N` 为batch size。如果 `reduction` 不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{'sum'.}
\end{cases}
**参数：**
**reduction** (str) - 应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。默认值："mean"。
**输入：**
- **logits** (Tensor) - shape为 :math:`(M, *)` 的tensor，其中 :math:`*` 表示任意的附加维度。
- **labels** (Tensor) - shape为 :math:`(N, *)` 的tensor，在通常情况下与 `logits` 的shape相同。但是如果 `logits` 和 `labels` 的shape不同，需要保证他们之间可以互相广播。
**输出：**
Tensor，为加权loss float tensor，如果 `reduction` 为"mean"或"sum"，则shape为零；如果 `reduction` 为"none"，则输出的shape为输入Tensor广播后的shape。
**异常：**
**ValueError** - `reduction` 不为"mean"，"sum"，或"none"。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.MAELoss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
0.33333334
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.MAELoss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 2.]
[0. 0. 1.]]

56
docs/api/api_python/nn/mindspore.nn.MAELoss.txt
View File

@ -1,56 +0,0 @@
Class mindspore.nn.MAELoss(reduction='mean')
MAELoss用于测量:math:`x`和:math:`y`元素之间的平均绝对误差，其中:math:`x`是输入Tensor，:math:`y`是标签Tensor。
假设:math:`x`和:math:`y`为一维Tensor，长度:math:`N`，则计算:math:`x`和:math:`y`的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
其中，:math:`N`为batch size。如果`reduction`不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{'sum'.}
\end{cases}
参数：
reduction (str)：应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。
默认值："mean"。
输入：
- **logits** (Tensor)：shape为:math:`(M, *)`的tensor，其中:math:`*`表示任意的附加维度。
- **labels** (Tensor)：shape为:math:`(N, *)`的tensor，在通常情况下与`logits`的shape相同。
但是如果`logits`和`labels`的shape不同，需要保证他们之间可以互相广播。
输出：
Tensor，为加权loss float tensor，如果`reduction`为"mean"或"sum"，则shape为零；如果`reduction`为"none"，则输出的shape为输入Tensor广播后的shape。
异常：
ValueError：`reduction`不为"mean"，"sum"，或"none"。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.MAELoss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 2, 2]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
0.33333334
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.MAELoss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 2.]
[0. 0. 1.]]

60
docs/api/api_python/nn/mindspore.nn.MSELoss.rst Normal file
View File

@ -0,0 +1,60 @@
mindspore.nn.MSELoss
=============================
.. py:class:: mindspore.nn.MSELoss(reduction='mean')
MSELoss是用来测量 :math:`x` 和 :math:`y` 对应元素之间的均方差，其中 :math:`x` 是输入Tensor， :math:`y` 是标签Tensor。
假设 :math:`x` 和 :math:`y` 为一维Tensor，长度 :math:`N` ，则计算 :math:`x` 和 :math:`y` 的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with} \quad l_n = (x_n - y_n)^2.
其中， :math:`N` 为batch size。如果 `reduction` 不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{`sum'.}
\end{cases}
**参数：**
**reduction** (str) - 应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。默认值："mean"。
**输入：**
- **logits** (Tensor) - shape为 :math:`(N, *)` 的Tensor，其中 :math:`*` 表示任意的附加维度。
- **labels** (Tensor) - shape为 :math:`(N, *)` 的Tensor，在通常情况下与 `logits` 的shape相同。但是如果 `logits` 和 `labels` 的shape不同，需要保证他们之间可以互相广播。
**输出：**
Tensor，为loss float tensor，如果 `reduction` 为"mean"或"sum"，则shape为零；如果 `reduction` 为"none"，则输出的shape为输入Tensor广播后的shape。
**异常：**
**ValueError** - `reduction` 不为"mean"，"sum"，或"none"。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.MSELoss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 1, 1]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
1.6666667
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.MSELoss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 4.] [0. 0. 1.]]

56
docs/api/api_python/nn/mindspore.nn.MSELoss.txt
View File

@ -1,56 +0,0 @@
Class mindspore.nn.MSELoss(reduction='mean')
MSELoss是用来测量:math:`x`和:math:`y`对应元素之间的均方差，其中:math:`x`是输入Tensor，:math:`y`是标签Tensor。
假设:math:`x`和:math:`y`为一维Tensor，长度:math:`N`，则计算:math:`x`和:math:`y`的unreduced loss（即reduction参数设置为"none"）的公式如下：
.. math::
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with} \quad l_n = (x_n - y_n)^2.
其中，:math:`N`为batch size。如果`reduction`不是"none"，则：
.. math::
\ell(x, y) =
\begin{cases}
\operatorname{mean}(L), & \text{if reduction} = \text{`mean';}\\
\operatorname{sum}(L), & \text{if reduction} = \text{`sum'.}
\end{cases}
参数：
reduction (str)：应用于loss的reduction类型。取值为"mean"，"sum"，或"none"。
默认值："mean"。
输入：
- **logits** (Tensor)：shape为:math:`(N, *)`的Tensor，其中:math:`*`表示任意的附加维度。
- **labels** (Tensor)：shape为:math:`(N, *)`的Tensor，在通常情况下与`logits`的shape相同。
但是如果`logits`和`labels`的shape不同，需要保证他们之间可以互相广播。
输出：
Tensor，为loss float tensor，如果`reduction`为"mean"或"sum"，则shape为零；如果`reduction`为"none"，则输出的shape为输入Tensor广播后的shape。
异常：
ValueError：`reduction`不为"mean"，"sum"，或"none"。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> #用例1：logits.shape = labels.shape = (3,)
>>> loss = nn.MSELoss()
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([1, 1, 1]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
1.6666667
>>> #用例2：logits.shape = (3,), labels.shape = (2, 3)
>>> loss = nn.MSELoss(reduction='none')
>>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
>>> output = loss(logits, labels)
>>> print(output)
[[0. 1. 4.] [0. 0. 1.]]

43
docs/api/api_python/nn/mindspore.nn.Sigmoid.rst Normal file
View File

@ -0,0 +1,43 @@
mindspore.nn.Sigmoid
=============================
.. py:class:: mindspore.nn.Sigmoid
Sgmoid激活函数。
按元素计算Sgmoid激活函数。
Sigmoid函数定义为：
.. math::
\text{sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)},
其中 :math:`x_i` 是输入的元素。
关于Sigmoid的图例见`Sigmoid <https://en.wikipedia.org/wiki/Sigmoid_function#/media/File:Logistic-curve.svg>`_。
**输入：**
- **x** (Tensor) - 数据类型为float16或float32的Sgmoid输入。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度。
**输出：**
Tensor，数据类型和shape与 `x` 的相同。
**异常：**
**TypeError** - `x` 的数据类型既不是float16也不是float32。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> sigmoid = nn.Sigmoid()
>>> output = sigmoid(x)
>>> print(output)
[0.2688 0.11914 0.5 0.881 0.7305 ]

36
docs/api/api_python/nn/mindspore.nn.Sigmoid.txt
View File

@ -1,36 +0,0 @@
Class mindspore.nn.Sigmoid
Sgmoid激活函数。
按元素计算Sgmoid激活函数。
Sigmoid函数定义为：
.. math::
\text{sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)},
其中:math:`x_i`是输入的元素。
关于Sigmoid的图例见`Sigmoid <https://en.wikipedia.org/wiki/Sigmoid_function#/media/File:Logistic-curve.svg>`_。
输入：
- **x** (Tensor) - 数据类型为float16或float32的Sgmoid输入。
shape为:math:`(N,*)`，其中:math:`*`表示任意的附加维度。
输出：
Tensor，数据类型和shape与 `x` 的相同。
异常：
TypeError：`x`的数据类型既不是float16也不是float32。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
>>> sigmoid = nn.Sigmoid()
>>> output = sigmoid(x)
>>> print(output)
[0.2688 0.11914 0.5 0.881 0.7305 ]

40
docs/api/api_python/nn/mindspore.nn.Tanh.rst Normal file
View File

@ -0,0 +1,40 @@
mindspore.nn.Tanh
=============================
.. py:class:: mindspore.nn.Tanh
Tanh激活函数。
按元素计算Tanh函数，返回一个新的Tensor，该Tensor是输入元素的双曲正切值。
Tanh函数定义为：
.. math::
tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
其中 :math:`x_i` 是输入Tensor的元素。
**输入：**
- **x** (Tensor) - 数据类型为float16或float32的Tanh输入。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度。
**输出：**
Tensor，数据类型和shape与 `x` 的相同。
**异常：**
**TypeError** - `x` 的数据类型既不是float16也不是float32。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> x = Tensor(np.array([1, 2, 3, 2, 1]), mindspore.float16)
>>> tanh = nn.Tanh()
>>> output = tanh(x)
>>> print(output)
[0.7617 0.964 0.995 0.964 0.7617]

33
docs/api/api_python/nn/mindspore.nn.Tanh.txt
View File

@ -1,33 +0,0 @@
Class mindspore.nn.Tanh
Tanh激活函数。
按元素计算Tanh函数，返回一个新的Tensor，该Tensor是输入元素的双曲正切值。
Tanh函数定义为：
.. math::
tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
其中:math:`x_i`是输入Tensor的元素。
输入：
- **x** (Tensor)：数据类型为float16或float32的Tanh输入。
shape为:math:`(N,*)`，其中:math:`*`表示任意的附加维度。
输出：
Tensor，数据类型和shape与 `x` 的相同。
异常：
TypeError：`x`的数据类型既不是float16也不是float32。
支持平台：
``Ascend`` ``GPU`` ``CPU``
示例：
>>> x = Tensor(np.array([1, 2, 3, 2, 1]), mindspore.float16)
>>> tanh = nn.Tanh()
>>> output = tanh(x)
>>> print(output)
[0.7617 0.964 0.995 0.964 0.7617]

139
docs/api/api_python/nn/mindspore.nn.conv2d.txt → docs/api/api_python/nn/mindspore.nn.conv2d.rst
View File

@ -1,69 +1,70 @@
mindspore.nn.Conv2d
====================
.. py:class:: mindspore.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros", data_format="NCHW")
二维卷积层。
对输入Tensor进行二维卷积，该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})`，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数，:math:`H_{in},W_{in}` 分别为高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，二维卷积公式定义如下：
.. math:: out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
其中 :math:`corr` 是互关联算子，:math:`C_{in}` 是输入通道数目，:math:`j` 的范围在 :math:`[0，C_{out}-1]` 内，:math:`W_{ij}`对应第 :math:`j`个过滤器的第 :math:`i` 个通道，:math:`out_j`对应输出的第 :math:`j` 个通道。:math:`W_{ij}` 是shape为 :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})` 的kernel切片。其中 :math:`\text{kernel_size[0]}` 和 :math:`\text{kernel_size[1]}` 是卷积核的高度和宽度。完整kernel的shape为 :math:`(C_{out}, C_{in} // \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})`，其中group是在通道维度上分割输入 `x` 的组数。
如果'pad_mode'被设置为 "valid"，输出高度和宽度分别为 :math:`\left \lfloor{1 + \frac{H_{in} + \text{padding[0]} + \text{padding[1]} - \text{kernel_size[0]} -
(\text{kernel_size[0]} - 1) \times (\text{dilation[0]} - 1) }{\text{stride[0]}}} \right \rfloor` 和 :math:`\left \lfloor{1 + \frac{W_{in} + \text{padding[2]} + \text{padding[3]} - \text{kernel_size[1]} -
(\text{kernel_size[1]} - 1) \times (\text{dilation[1]} - 1) }{\text{stride[1]}}} \right \rfloor`。
详细介绍请参考论文 `Gradient Based Learning Applied to Document Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ 。
**参数** ：
- **in_channels** (`int`) – 输入的通道数 :math:`C_{in}`。
- **out_channels** (`dict`) - 输出的通道数 :math:`C_{out}`。
- **kernel_size** (`Union[int, tuple[int]]`) – 指定二维卷积窗口的高度和宽度。数据类型为整型或2个整型的tuple。一个整数表示卷积核的高度和宽度均为该值。2个整数的tuple分别表示卷积核的高度和宽度。
- **stride** (`Union[int, tuple[int]]`) – 步长大小。数据类型为整型或2个整型的tuple。一个整数表示在高度和宽度方向的滑动步长均为该值。2个整数的tuple分别表示在高度和宽度方向的滑动步长。默认值：1。
- **pad_mode** (`str`) – 指定填充模式。可选值为“same”，“valid”，“pad”。默认值：“same”。
- **same**：采用补全方式。输出的高度和宽度与输入 `x` 一致。填充总数将在水平和垂直方向进行计算。并尽可能均匀分布到顶部、底部、左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- **valid**：采用丢弃方式。在不填充的前提下返回可能大的高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 必须为0。
- **pad**：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
- **padding** (`Union[int, tuple[int]]`) – 输入 `x` 两侧的隐式填充。数据类型为int或包含4个整数的tuple。如果 `padding` 是一个整数，那么上、下、左、右的填充都等于 `padding` 。如果 `padding` 是一个有4个整数的tuple，那么上、下、左、右的填充分别等于 `padding[0]`、`padding[1]`、`padding[2]` 和 `padding[3]`。默认值：0。
- **dilation** (`Union[int, tuple[int]]`) – 指定用于扩张卷积的扩张速率。数据类型为整型或具有2个整型的tuple。如果设置 :math:`k > 1`，则每个采样位置将跳过 :math:`k-1` 个像素。其值必须大于或等于1，并以输入的高度和宽度为边界。默认值：1。
- **group** (`int`) – 将过滤器分组， `in_channels` 和 `out_channels` 必须被组数整除。如果组数等于 `in_channels` 和 `out_channels`，这个二维卷积层也被称为二维深度卷积层。默认值：1.
- **has_bias** (`bool`) – 指定图层是否使用偏置向量。默认值：False。
- **weight_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
- **data_format** (`str`) – 数据格式的可选值有“NHWC”，“NCHW”。默认值：“NCHW”。
**输入** ：
- **x** (Tensor) - Shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 或者 :math:`(N, H_{in}, W_{in}, C_{in})` 的Tensor。
**输出** ：
Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 或者 :math:`(N, H_{out}, W_{out}, C_{out})` 。
**异常** ：
- **TypeError** - 如果 `in_channels`，`out_channels` 或者 `group` 不是整数。
- **TypeError** - 如果 `kernel_size`，`stride`，`padding` 或者 `dilation` 既不是整数也不是tuple。
- **ValueError** - 如果 `in_channels`，`out_channels`，`kernel_size`，`stride` 或者 `dilation` 小于1。
- **ValueError** - 如果 `padding` 小于0。
- **ValueError** - 如果 `pad_mode` 不是“same”，“valid”，“pad”中的一个。
- **ValueError** - 如果 `padding` 是一个长度不等于4的tuple。
- **ValueError** - 如果 `pad_mode` 不等于“pad”且 `padding` 不等于(0,0,0,0)。
- **ValueError** - 如果 `data_format` 既不是“NCHW”也不是“NHWC”。
**支持平台** ：
`Ascend` `GPU` `CPU`
**样例** :
>>> net = nn.Conv2d(120, 240, 4, has_bias=False, weight_init='normal')
>>> x = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 240, 1024, 640)
mindspore.nn.Conv2d
====================
.. py:class:: mindspore.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros", data_format="NCHW")
二维卷积层。
对输入Tensor进行二维卷积，该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})`，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数，:math:`H_{in},W_{in}` 分别为高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，二维卷积公式定义如下：
.. math:: out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
其中 :math:`corr` 是互关联算子，:math:`C_{in}` 是输入通道数目，:math:`j` 的范围在 :math:`[0，C_{out}-1]` 内，:math:`W_{ij}`对应第 :math:`j` 个过滤器的第 :math:`i` 个通道，:math:`out_j` 对应输出的第 :math:`j` 个通道。:math:`W_{ij}` 是shape为 :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})` 的kernel切片。其中 :math:`\text{kernel_size[0]}` 和 :math:`\text{kernel_size[1]}` 是卷积核的高度和宽度。完整kernel的shape为 :math:`(C_{out}, C_{in} // \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})`，其中group是在通道维度上分割输入 `x` 的组数。
如果'pad_mode'被设置为 "valid"，输出高度和宽度分别为 :math:`\left \lfloor{1 + \frac{H_{in} + \text{padding[0]} + \text{padding[1]} - \text{kernel_size[0]} -
(\text{kernel_size[0]} - 1) \times (\text{dilation[0]} - 1) }{\text{stride[0]}}} \right \rfloor` 和 :math:`\left \lfloor{1 + \frac{W_{in} + \text{padding[2]} + \text{padding[3]} - \text{kernel_size[1]} -
(\text{kernel_size[1]} - 1) \times (\text{dilation[1]} - 1) }{\text{stride[1]}}} \right \rfloor`。
详细介绍请参考论文 `Gradient Based Learning Applied to Document Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ 。
**参数：**
- **in_channels** (`int`) – 输入的通道数 :math:`C_{in}` 。
- **out_channels** (`dict`) - 输出的通道数 :math:`C_{out}` 。
- **kernel_size** (`Union[int, tuple[int]]`) – 指定二维卷积窗口的高度和宽度。数据类型为整型或2个整型的tuple。一个整数表示卷积核的高度和宽度均为该值。2个整数的tuple分别表示卷积核的高度和宽度。
- **stride** (`Union[int, tuple[int]]`) – 步长大小。数据类型为整型或2个整型的tuple。一个整数表示在高度和宽度方向的滑动步长均为该值。2个整数的tuple分别表示在高度和宽度方向的滑动步长。默认值：1。
- **pad_mode** (`str`) – 指定填充模式。可选值为“same”，“valid”，“pad”。默认值：“same”。
- **same**：采用补全方式。输出的高度和宽度与输入 `x` 一致。填充总数将在水平和垂直方向进行计算。并尽可能均匀分布到顶部、底部、左侧和右侧。否则，最后一次将从底部和右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- **valid**：采用丢弃方式。在不填充的前提下返回可能大的高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 必须为0。
- **pad**：输入 `x` 两侧的隐式填充。`padding` 的数量将填充到输入Tensor边框上。`padding` 必须大于或等于0。
- **padding** (`Union[int, tuple[int]]`) – 输入 `x` 两侧的隐式填充。数据类型为int或包含4个整数的tuple。如果 `padding` 是一个整数，那么上、下、左、右的填充都等于 `padding` 。如果 `padding` 是一个有4个整数的tuple，那么上、下、左、右的填充分别等于 `padding[0]` 、 `padding[1]` 、 `padding[2]` 和 `padding[3]` 。默认值：0。
- **dilation** (`Union[int, tuple[int]]`) – 指定用于扩张卷积的扩张速率。数据类型为整型或具有2个整型的tuple。如果设置 :math:`k > 1` ，则每个采样位置将跳过 :math:`k-1` 个像素。其值必须大于或等于1，并以输入的高度和宽度为边界。默认值：1。
- **group** (`int`) – 将过滤器分组， `in_channels` 和 `out_channels` 必须被组数整除。如果组数等于 `in_channels` 和 `out_channels` ，这个二维卷积层也被称为二维深度卷积层。默认值：1.
- **has_bias** (`bool`) – 指定图层是否使用偏置向量。默认值：False。
- **weight_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
- **data_format** (`str`) – 数据格式的可选值有“NHWC”，“NCHW”。默认值：“NCHW”。
**输入：**
- **x** (Tensor) - Shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 或者 :math:`(N, H_{in}, W_{in}, C_{in})` 的Tensor。
**输出：**
Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 或者 :math:`(N, H_{out}, W_{out}, C_{out})` 。
**异常：**
- **TypeError** - 如果 `in_channels` ， `out_channels` 或者 `group` 不是整数。
- **TypeError** - 如果 `kernel_size` ， `stride`，`padding` 或者 `dilation` 既不是整数也不是tuple。
- **ValueError** - 如果 `in_channels` ， `out_channels`，`kernel_size` ， `stride` 或者 `dilation` 小于1。
- **ValueError** - 如果 `padding` 小于0。
- **ValueError** - 如果 `pad_mode` 不是“same”，“valid”，“pad”中的一个。
- **ValueError** - 如果 `padding` 是一个长度不等于4的tuple。
- **ValueError** - 如果 `pad_mode` 不等于“pad”且 `padding` 不等于(0,0,0,0)。
- **ValueError** - 如果 `data_format` 既不是“NCHW”也不是“NHWC”。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv2d(120, 240, 4, has_bias=False, weight_init='normal')
>>> x = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 240, 1024, 640)

63
docs/api/api_python/nn/mindspore.nn.conv2dtranspose.rst Normal file
View File

@ -0,0 +1,63 @@
mindspore.nn.Conv2dTranspose
============================
.. py:class:: mindspore.nn.Conv2dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros")
二维转置卷积层。
计算二维转置卷积，这也被称为反卷积（实际不是真正的反卷积）。
`x` 的shape通常为 :math:`(N, C, H, W)` ，其中 :math:`N` 是batch size，:math:`C` 是通道数。如果'pad_mode'设为 "pad"，输出的高度和宽度分别为：
.. math:: \begin{align}\begin{aligned}H_{out} = (H_{in} - 1) \times \text{stride[0]} - \left (\text{padding[0]} + \text{padding[1]}\right ) + \text{dilation[0]} \times (\text{kernel_size[0]} - 1) + 1\\W_{out} = (W_{in} - 1) \times \text{stride[1]} - \left (\text{padding[2]} + \text{padding[3]}\right ) + \text{dilation[1]} \times (\text{kernel_size[1]} - 1) + 1\end{aligned}\end{align}
其中 :math:`\text{kernel_size[0]}` 是卷积核的高度， :math:`\text{kernel_size[1]}` 是卷积核的宽度。
**参数：**
- **in_channels** (`int`) – 输入的通道数。
- **out_channels** (`dict`) - 输出的通道数。
- **kernel_size** (`Union[int, tuple[int]]`) – 该参数指定二维卷积窗口的高度和宽度。数据类型为整型或2个整型的tuple。一个整数表示卷积核的高度和宽度均为该值。2个整数的tuple分别表示卷积核高度和宽度。
- **stride** (`Union[int, tuple[int]]`) – 步长大小。数据类型为整型或2个整型的tuple。一个整数表示在高度和宽度方向的滑动步长均为该值。2个整数的tuple分别表示在高度和宽度方向的滑动步长。默认值：1。
- **pad_mode** (`str`) – 指定填充模式。可选值为“pad”，“same”，“valid”。默认值：“same”。
- **same**：采用补全方式。输出的高度和宽度与输入 `x` 一致。填充总数将在水平和垂直方向进行计算。并尽可能均匀分布到顶部、底部、左侧和右侧。否则，最后一次将从底部到右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- **valid**：采用丢弃方式。在不填充的前提下返回可能大的高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 必须为0。
- **pad**：输入 `x` 两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。 `padding` 必须大于或等于0。
- **padding** (`Union[int, tuple[int]]`) – 输入 `x` 两侧的隐式填充。数据类型为int或包含4个整数的tuple。如果 `padding` 是一个整数，那么上、下、左、右的填充都等于 `padding` 。如果 `padding` 是一个有4个整数的tuple，那么上、下、左、右的填充分别等于 `padding[0]` 、 `padding[1]` 、 `padding[2]` 和 `padding[3]` 。默认值：0。
- **dilation** (`Union[int, tuple[int]]`) – 指定用于扩张卷积的扩张速率。数据类型为整型或具有2个整型的tuple。如果设置 :math:`k > 1`，则每个采样位置将跳过 :math:`k-1` 个像素。其值必须大于或等于1，并以输入的高度和宽度为边界。默认值：1。
- **group** (`int`) – 将过滤器分组， `in_channels` 和 `out_channels` 必须被组数整除。当组数大于1时，不支持达芬奇（Davinci）设备。默认值：1.
- **has_bias** (`bool`) – 指定图层是否使用偏置向量。默认值：False。
- **weight_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
**输入：**
- **x** (Tensor) - Shape 为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
**输出：**
Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 。
**异常：**
- **TypeError** - 如果 `in_channels` ，`out_channels` 或者 `group` 不是整数。
- **TypeError** - 如果 `kernel_size` ，`stride` ，`padding` 或者 `dilation` 既不是整数也不是tuple。
- **ValueError** - 如果 `in_channels` ，`out_channels` ， `kernel_size`， `stride` 或者 `dilation` 小于1。
- **ValueError** - 如果 `padding` 小于0。
- **ValueError** - 如果 `pad_mode` 不是“same”，“valid”，“pad”中的一个。
- **ValueError** - 如果 `padding` 是一个长度不等于4的tuple。
- **ValueError** - 如果 `pad_mode` 不等于“pad”且 `padding` 不等于(0,0,0,0)。
**支持平台：**
``Ascend`` ``GPU`` ``CPU``
**样例：**
>>> net = nn.Conv2dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
>>> x = Tensor(np.ones([1, 3, 16, 50]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 64, 19, 53)

62
docs/api/api_python/nn/mindspore.nn.conv2dtranspose.txt
View File

@ -1,62 +0,0 @@
mindspore.nn.Conv2dTranspose
============================
.. py:class:: mindspore.nn.Conv2dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros")
二维转置卷积层。
计算二维转置卷积，这也被称为反卷积（实际不是真正的反卷积）。
`x` 的shape通常为 :math:`(N, C, H, W)` ，其中 :math:`N` 是batch size，:math:`C` 是通道数。如果'pad_mode'设为 "pad"，输出的高度和宽度分别为：
.. math:: \begin{align}\begin{aligned}H_{out} = (H_{in} - 1) \times \text{stride[0]} - \left (\text{padding[0]} + \text{padding[1]}\right ) + \text{dilation[0]} \times (\text{kernel_size[0]} - 1) + 1\\W_{out} = (W_{in} - 1) \times \text{stride[1]} - \left (\text{padding[2]} + \text{padding[3]}\right ) + \text{dilation[1]} \times (\text{kernel_size[1]} - 1) + 1\end{aligned}\end{align}
其中 :math:`\text{kernel_size[0]}` 是卷积核的高度， :math:`\text{kernel_size[1]}` 是卷积核的宽度。
**参数** ：
- **in_channels** (`int`) – 输入的通道数。
- **out_channels** (`dict`) - 输出的通道数。
- **kernel_size** (`Union[int, tuple[int]]`) – 该参数指定二维卷积窗口的高度和宽度。数据类型为整型或2个整型的tuple。一个整数表示卷积核的高度和宽度均为该值。2个整数的tuple分别表示卷积核高度和宽度。
- **stride** (`Union[int, tuple[int]]`) – 步长大小。数据类型为整型或2个整型的tuple。一个整数表示在高度和宽度方向的滑动步长均为该值。2个整数的tuple分别表示在高度和宽度方向的滑动步长。默认值：1。
- **pad_mode** (`str`) – 指定填充模式。可选值为“pad”，“same”，“valid”。默认值：“same”。
- **same**：采用补全方式。输出的高度和宽度与输入 `x` 一致。填充总数将在水平和垂直方向进行计算。并尽可能均匀分布到顶部、底部、左侧和右侧。否则，最后一次将从底部到右侧进行额外的填充。若设置该模式，`padding` 必须为0。
- **valid**：采用丢弃方式。在不填充的前提下返回可能大的高度和宽度的输出。多余的像素会被丢弃。若设置该模式，`padding` 必须为0。
- **pad**：输入`x`两侧的隐式填充。`padding`的数量将填充到输入Tensor边框上。`padding`必须大于或等于0。
- **padding** (`Union[int, tuple[int]]`) – 输入 `x` 两侧的隐式填充。数据类型为int或包含4个整数的tuple。如果 `padding` 是一个整数，那么上、下、左、右的填充都等于 `padding` 。如果 `padding` 是一个有4个整数的tuple，那么上、下、左、右的填充分别等于 `padding[0]`、`padding[1]`、`padding[2]` 和 `padding[3]`。默认值：0。
- **dilation** (`Union[int, tuple[int]]`) – 指定用于扩张卷积的扩张速率。数据类型为整型或具有2个整型的tuple。如果设置 :math:`k > 1`，则每个采样位置将跳过 :math:`k-1` 个像素。其值必须大于或等于1，并以输入的高度和宽度为边界。默认值：1。
- **group** (`int`) – 将过滤器分组， `in_channels` 和 `out_channels` 必须被组数整除。当组数大于1时，不支持达芬奇（Davinci）设备。默认值：1.
- **has_bias** (`bool`) – 指定图层是否使用偏置向量。默认值：False。
- **weight_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 卷积核的初始化方法。它可以是Tensor，str，初始化实例或numbers.Number。当使用str时，可选“TruncatedNormal”，“Normal”，“Uniform”，“HeUniform”和“XavierUniform”分布以及常量“One”和“Zero”分布的值，可接受别名“ xavier_uniform”，“ he_uniform”，“ ones”和“ zeros”。上述字符串大小写均可。更多细节请参考Initializer的值。默认值：“normal”。
- **bias_init** (`Union[Tensor, str, Initializer, numbers.Number]`) – 偏置向量的初始化方法。可以使用的初始化方法和字符串与“weight_init”相同。更多细节请参考Initializer的值。默认值：“zeros”。
**输入** ：
- **x** (Tensor) - Shape 为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
**输出** ：
Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 。
**异常** ：
- **TypeError** - 如果 `in_channels`，`out_channels` 或者 `group` 不是整数。
- **TypeError** - 如果 `kernel_size`，`stride`，`padding` 或者 `dilation` 既不是整数也不是tuple。
- **ValueError** - 如果 `in_channels`，`out_channels`，`kernel_size`，`stride` 或者 `dilation` 小于1。
- **ValueError** - 如果 `padding` 小于0。
- **ValueError** - 如果 `pad_mode` 不是“same”，“valid”，“pad”中的一个。
- **ValueError** - 如果 `padding` 是一个长度不等于4的tuple。
- **ValueError** - 如果 `pad_mode` 不等于“pad”且 `padding` 不等于(0,0,0,0)。
**支持平台** ：
`Ascend` `GPU` `CPU`
**样例** :
>>> net = nn.Conv2dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
>>> x = Tensor(np.ones([1, 3, 16, 50]), mindspore.float32)
>>> output = net(x).shape
>>> print(output)
(1, 64, 19, 53)