mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops/function/nn_func.py

@@ -28,6 +28,7 @@ from mindspore.ops.operations import _sequence_ops as seq
 import mindspore.common.dtype as mstype
 from mindspore.ops.function.math_func import logsumexp, div
 from mindspore.ops.function.random_func import _get_seed, _set_prim_op_user_data
+from mindspore.ops.functional_overload import conv2d as conv2d_op
 from mindspore.common.tensor import Tensor
 from mindspore._c_expression import TensorPy as Tensor_
 from mindspore.ops._primitive_cache import _get_cache_prim
@@ -41,7 +42,7 @@ from mindspore.ops.operations.nn_ops import TripletMarginLoss
 from mindspore.ops.operations._sequence_ops import TupleToTensor, TensorToTuple, ListToTensor
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import log_softmax, dense, prelu, celu, fast_gelu, silu, elu, sigmoid, relu6, \
-    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op, l1_loss_ext
+    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op, l1_loss_ext, inplace_sigmoid
 from mindspore.ops.auto_generate import relu_op, inplace_relu_op
 from mindspore.ops.auto_generate import group_norm_op, rms_norm, add_rms_norm, layer_norm_ext_op, batch_norm_ext_op,\
     mse_loss_ext
@@ -54,7 +55,7 @@ from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d
                                          upsample_linear1d_op, upsample_bilinear2d_op, upsample_bicubic2d_op,
                                          upsample_trilinear3d_impl, fill_scalar_op, floor_op, nllloss_2d_op,
                                          masked_fill_op, masked_select, ones, flatten_ext, conv_transpose2d,
-                                         func_max_pool2d_op)
+                                         func_max_pool2d_op, dropout2d_ext_op)
 # 2
 from mindspore.ops.auto_generate.pyboost_inner_prim import grid_sampler_2d_impl, grid_sampler_3d_impl
 # 3
@@ -92,11 +93,9 @@ from mindspore.ops.auto_generate import avg_pool3d_ext_op
 # 19
 
 # 20
-from mindspore.ops.functional_overload import conv3d as conv3d_op
 from mindspore.ops.auto_generate.gen_ops_prim import embedding_op, MaxPoolWithIndices, \
     PromptFlashAttention, MaxPoolWithMask
-from mindspore.ops.auto_generate.gen_ops_prim import conv2d_ext_op, \
-    conv2d_padding_op, conv1d_ext_op, conv1d_padding_op, speed_fusion_attention_op
+from mindspore.ops.auto_generate.gen_ops_prim import speed_fusion_attention_op
 from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import hardshrink, hardsigmoid, hardswish
 from mindspore.ops.auto_generate import softshrink
@@ -280,9 +279,6 @@ def adaptive_avg_pool2d_ext(input, output_size):
         * (w_{end}- w_{start})}
         \end{align}
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input of adaptive_avg_pool2d, which is a 3D or 4D tensor,
             with float16 or float32 data type.
@@ -952,7 +948,7 @@ def adaptive_max_pool1d(input, output_size):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> input = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float16)
         >>> output = ops.adaptive_max_pool1d(input, output_size=2)
         >>> print(output.shape)
         (1, 3, 2)
@@ -1771,6 +1767,58 @@ def dropout2d(input, p=0.5, training=True):
     return out
 
 
+def dropout2d_ext(input, p=0.5, training=True, inplace=False):
+    r"""
+    During training, randomly zeroes some channels of the input tensor with probability `p`
+    from a Bernoulli distribution (For a 4-dimensional tensor with a shape of :math:`(N, C, H, W)`,
+    the channel feature map refers to a 2-dimensional feature map with the shape of :math:`(H, W)`).
+
+    For example, the :math:`j\_th` channel of the :math:`i\_th` sample in the batched input is a to-be-processed
+    `2D` tensor input[i,j].
+    Each channel will be zeroed out independently on every forward call which based on Bernoulli distribution
+    probability `p`.
+    The parper `Dropout: A Simple Way to Prevent Neural Networks from Overfitting
+    <http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf>`_ mentioned this technology, and it is proved that
+    it can effectively reduce over fitting and prevent neuronal coadaptation.
+    For more details, refer to `Improving neural networks by preventing co-adaptation of feature detectors
+    <https://arxiv.org/pdf/1207.0580.pdf>`_ .
+
+    `dropout2d` can improve the independence between channel feature maps.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): A `4D` tensor with shape :math:`(N, C, H, W)`, where `N` is the batch size, `C` is the number
+            of channels, `H` is the feature height, and `W` is the feature width.
+        p (float, optional): The dropping probability of a channel, between 0 and 1, e.g. `p` = 0.8,
+            which means dropping out 80% of channels. Default: ``0.5`` .
+        training(bool, optional): If `training` is True, applying dropout, otherwise, not applying. Default: ``True`` .
+        inplace (bool, optional): If set to ``True`` , will do this operation in-place. Default: ``False`` .
+
+    Returns:
+        Tensor, output, with the same shape and data type as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        ValueError: If `p` is out of the range `[0.0, 1.0]`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.ones([2, 1, 2, 3]), mindspore.float32)
+        >>> output = mint.nn.functional.dropout2d(input, 0.5)
+        >>> print(output.shape)
+        (2, 1, 2, 3)
+    """
+    seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
+    return dropout2d_ext_op(input, p, training, inplace, seed, offset)
+
+
 def dropout3d(input, p=0.5, training=True):
     r"""
     During training, randomly zeroes some channels of the input tensor
@@ -2855,9 +2903,6 @@ def interpolate_ext(input,
     r"""
     Samples the input Tensor to the given size or scale_factor by using one of the interpolate algorithms.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     .. note::
         - In 'linear' mode, the scenarios, where `scale_factor` is not None and `align_corners` is False,
           is not supported.
@@ -3443,9 +3488,6 @@ def logsigmoid_ext(input):
     .. image:: ../images/LogSigmoid.png
         :align: center
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input of LogSigmoid with data type of bfloat16, float16 or float32.
             The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
@@ -4430,9 +4472,6 @@ def nll_loss_ext(input, target, weight=None, ignore_index=-100, reduction='mean'
         \sum_{n=1}^{N} l_{n}, & \text { if reduction }=\text { 'sum' }
         \end{array}\right.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): :math:`(N)` or :math:`(N, C)` where `C = number of classes` , `N = batch size` ,
             or :math:`(N, C, d_1, d_2, ..., d_K)` (for high-dimensional data).
@@ -5193,7 +5232,7 @@ def margin_ranking_loss(input1, input2, target, margin=0.0, reduction='mean'):
     _check_is_tensor('target', target, "margin_ranking_loss")
     check_input_dtype('input1', input1, 'input2', input2, 'margin_ranking_loss')
     check_input_dtype('target', target, 'input1', input1, 'margin_ranking_loss')
-    x = maximum_(-target * (input1 - input2) + margin, 0)
+    x = ops.clamp(-target * (input1 - input2) + margin, min=0)
     return _get_loss(x, reduction, "margin_ranking_loss")
 
 
@@ -5534,8 +5573,8 @@ def ctc_loss(log_probs, targets, input_lengths, target_lengths, blank=0, reducti
         >>> print(loss)
         -2.2986124
         >>> print(log_alpha)
-        [[[0.3       0.3            -inf      -inf      -inf]
-          [1.2       1.8931472 1.2            -inf      -inf]]]
+        [[[0.3       0.3            -inf      -inf 1.8931472 1.2       0.   0.       ]
+          [0.        0.       0.        0.       0.        0.          0.   0.       ]]]
     """
     _check_ctc_loss_inputs(blank, reduction, zero_infinity, 'ctc_loss')
     ctc_loss_op = NN_OPS.CTCLossV2(blank=blank, reduction="none", zero_infinity=zero_infinity)
@@ -6229,127 +6268,6 @@ def conv2d(input, weight, bias=None, stride=1, pad_mode="valid", padding=0, dila
     return output
 
 
-def conv1d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
-    r"""
-    Applies a 1D convolution over an input tensor. The input tenor is typically
-    of shape :math:`(N, C_{in}, L_{in})`,
-    where :math:`N` is batch size, :math:`C` is channel number, :math:`L` is sequence length.
-
-    The output is calculated based on formula:
-
-    .. math::
-
-        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
-        \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
-
-    where :math:`bias` is the output channel bias, :math:`ccor` is
-    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
-
-    - :math:`i` corresponds to the batch number, the range is :math:`[0, N-1]`,
-      where :math:`N` is the batch size of the input.
-
-    - :math:`j` corresponds to the output channel, the range is :math:`[0, C_{out}-1]`,
-      where :math:`C_{out}` is the number of
-      output channels, which is also equal to the number of kernels.
-
-    - :math:`k` corresponds to the input channel, the range is :math:`[0, C_{in}-1]`,
-      where :math:`C_{in}` is the number of
-      input channels, which is also equal to the number of channels in the convolutional kernels.
-
-    Therefore, in the above formula, :math:`{bias}(C_{\text{out}_j})` represents the bias of the :math:`j`-th
-    output channel, :math:`{weight}(C_{\text{out}_j}, k)` represents the slice of the :math:`j`-th convolutional
-    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
-    channel in the :math:`i`-th batch of the input feature map.
-
-    The shape of the convolutional kernel is given by :math:`(\text{kernel_size})`,
-    where :math:`\text{kernel_size}` is the length of the kernel.
-    If we consider the input and output channels as well as the `groups` parameter, the complete kernel shape
-    will be :math:`(C_{out}, C_{in} / \text{groups}, \text{kernel_size})`,
-    where `groups` is the number of groups dividing `x`'s input channel when applying groups convolution.
-
-    For more details about convolution layer, please refer to `Gradient Based Learning Applied to Document Recognition
-    <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        input (Tensor): Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
-        weight (Tensor): Tensor of shape
-            :math:`(N, C_{in} / \text{groups}, \text{kernel_size})`, then the size of kernel
-            is :math:`(\text{kernel_size})`.
-        bias (Tensor, optional): Bias Tensor with shape :math:`(C_{out})`.
-            When bias is ``None`` , zeros will be used. Default: ``None`` .
-        stride (Union[int, tuple[int], list[int]], optional): The movement stride of the 1D convolution kernel.
-            The data type is an integer or a tuple of one integer. Default: ``1`` .` .
-        padding (Union[int, tuple[int], list[int], str], optional): The number of padding
-            on the input.
-            The data type is an integer or a tuple of one integer or string {`valid`, `same`}.
-            The value should be greater than or equal to 0. Default: ``0`` .
-
-            - ``"same"``: Pad the input around its edges so that the shape of input and output
-              are the same when `stride` is set to ``1``.
-              The amount of padding to is calculated by the operator internally, If the amount is even, it is
-              uniformly distributed around the input, if it is odd, the excess amount goes to the right side.
-              If this mode is set, `stride` must be 1.
-
-            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
-              possible length. Extra sequence that could not complete a full stride will
-              be discarded.
-
-        dilation (Union[int, tuple[int], list[int]], optional): Specifies the dilation rate to use for
-            dilated convolution. It can be a single int or a tuple of 1 integer.
-            Assuming :math:`dilation=(d)`, the convolutional kernel samples the input with a
-            spacing of :math:`d-1` elements in the length direction.
-            Default: ``1`` .
-        groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
-            divisible by `groups`. If the groups is equal to `in_channels` and `out_channels`,
-            this 1D convolution layer also can be called 1D depthwise convolution layer. Default: ``1`` .
-
-            - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`。
-
-    Returns:
-        Tensor, the value that applied 1D convolution. The shape is :math:`(N, C_{out}, L_{out})`.
-        To see how different pad modes affect the output shape, please refer to
-        :class:`mindspore.mint.nn.Conv1d` for more details.
-
-    Raises:
-        ValueError: Args and size of the input feature map should satisfy the output formula to ensure that the size of
-            the output feature map is positive; otherwise, an error will be reported.
-        RuntimeError: On Ascend, due to the limitation of the L1 cache size of different NPU chip, if input size or
-            kernel size is too large, it may trigger an error.
-        TypeError: If `in_channels`, `out_channels` or `groups` is not an int.
-        TypeError: If `kernel_size`, `stride` or `dilation` is neither an int not a tuple.
-        ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
-        ValueError: If `padding` is less than 0.
-        ValueError: If `padding` is `same` , `stride` is not equal to 1.
-        ValueError: The input parameters do not satisfy the convolution output formula.
-        ValueError: The KernelSize cannot exceed the size of the input feature map.
-        ValueError: The value of padding cannot cause the calculation area to exceed the input size.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops, mint
-        >>> x = Tensor(np.ones([10, 32, 32]), mindspore.float32)
-        >>> weight = Tensor(np.ones([32, 32, 3]), mindspore.float32)
-        >>> output = mint.nn.functional.conv1d(x, weight)
-        >>> print(output.shape)
-        (10, 32, 30)
-    """
-    if isinstance(padding, (int, tuple, list)):
-        return conv1d_ext_op(input, weight, bias, stride, padding, dilation, groups)
-    if isinstance(padding, str):
-        return conv1d_padding_op(input, weight, bias, stride, padding, dilation, groups)
-    raise TypeError(f"For conv1d, the parameter 'padding' must be a tuple/list " \
-                    f"or a string, but got {type(padding)}")
-
-
 def _check_stride_when_same_mode(stride):
     """ stride must be 1 when pad mode is same """
     if isinstance(stride, int):
@@ -6473,9 +6391,12 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
             there will be :math:`k - 1` pixels skipped for each sampling location. Its value must
             be greater than or equal to 1 and bounded by the height and width of the input `x`. Default: ``1`` .
         groups (int, optional): Splits `input` into groups. Default: ``1`` .
+            The following restraints should be met:
 
-            - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`
+            - :math:`(C_{in} \text{ % } \text{groups} == 0)`
+            - :math:`(C_{out} \text{ % } \text{groups} == 0)`
+            - :math:`(C_{out} >= \text{groups})`
+            - :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
     Returns:
         Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`.
@@ -6511,12 +6432,7 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
         >>> print(output.shape)
         (10, 32, 30, 30)
     """
-    if isinstance(padding, (int, tuple, list)):
-        return conv2d_ext_op(input, weight, bias, stride, padding, dilation, groups)
-    if isinstance(padding, str):
-        return conv2d_padding_op(input, weight, bias, stride, padding, dilation, groups)
-    raise TypeError(f"For conv2d, the parameter 'padding' must be a tuple/list " \
-                    f"or a string, but got {type(padding)}")
+    return conv2d_op(input, weight, bias, stride, padding, dilation, groups)
 
 
 def hardtanh(input, min_val=-1.0, max_val=1.0):
@@ -7310,142 +7226,6 @@ def conv3d(input, weight, bias=None, stride=1, pad_mode="valid", padding=0, dila
     return output
 
 
-def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
-    r"""
-    Applies a 3D convolution over an input tensor. The input tensor is typically of
-    shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` or :math:`(C_{in}, D_{in}, H_{in}, W_{in})`,
-    where :math:`N` is batch size, :math:`C` is channel number, :math:`D, H, W` are the depth,
-    height and width of the feature graph, respectively.
-
-    The output is calculated based on formula:
-
-    .. math::
-
-        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
-        \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
-
-    where :math:`bias` is the output channel bias, :math:`ccor` is
-    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_
-    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
-
-    Here are the indices' meanings:
-
-    - :math:`i` corresponds to the batch number, the range is :math:`[0, N-1]`,
-      where :math:`N` is the batch size of the input.
-
-    - :math:`j` corresponds to the output channel, the range is :math:`[0, C_{out}-1]`,
-      where :math:`C_{out}` is the number of
-      output channels, which is also equal to the number of kernels.
-
-    - :math:`k` corresponds to the input channel, the range is :math:`[0, C_{in}-1]`,
-      where :math:`C_{in}` is the number of
-      input channels, which is also equal to the number of channels in the convolutional kernels.
-
-    Therefore, in the above formula, :math:`{bias}(C_{\text{out}_j})` represents the bias of the :math:`j`-th
-    output channel, :math:`{weight}(C_{\text{out}_j}, k)` represents the slice of the :math:`j`-th convolutional
-    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
-    channel in the :math:`i`-th batch of the input feature map.
-
-    The shape of the convolutional kernel is given by :math:`(kd, kh, kw)` where :math:`kd` , :math:`kd` and\
-    :math:`kw` are the depth, height and width of the kernel, respectively.
-    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
-    will be :math:`(C_{out}, C_{in} / \text{group}, kd, kh, kw)`,
-    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
-
-    For more details about convolution layer, please refer to `Gradient Based Learning Applied to Document Recognition
-    <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
-
-    The following lists some of the limitations of the parameters.
-
-    - input -- The input to the conv3d. The input must have each dimension size within the range [1, int32_max].
-    - weight -- Filters of shape :math:`(C_{out}, C_{in} / groups, kd, kh, kw)`. The value of :math:`kh`
-      and :math:`kw` is in the range [1, 511]. The remaining values are in the range [1, int32_max].
-      And :math:`kh*kw*k0` is less 65536 (k0 is 16. If data type is float32, k0 is 8).
-    - bias -- Bias Tensor with shape :math:`(C_{out})`. The shape must equal the first dimension of the weight.
-    - stride -- The distance of kernel moving. It can be an int number or
-      tuple (noted by :math:`(stride_d, stride_h, stride_w)`). stride_h and stride_w are in the range [1, 63].
-      stride_d is in the range [1, 255].
-    - padding -- If padding is an int number, it is in the range [0, 255].
-    - dilation -- The value is in the range [1, 255].
-    - groups -- The value is in the range [1, 65535].
-    - :math:`C_{in} \% \text{groups} == 0 \quad \text{and} \quad C_{out} \% \text{groups} == 0` .
-    - :math:`weight[1] == C_{in} / groups` .
-    - :math:`H_{in} + PadUp + PadDown >= (kh - 1) * DilationH + 1` .
-    - :math:`W_{in} + PadLeft + PadRight >= (kw - 1) * DilationW + 1` .
-    - :math:`D_{in} + PadFront + PadBack >= (kd - 1) * DilationD + 1` .
-    - :math:`H_{out} = (H_{in} + PadUp + PadDown - ((kh - 1) * DilationH + 1)) / StrideH + 1` .
-    - :math:`W_{out} = (W_{in} + PadLeft + PadRight - ((kw - 1) * DilationW + 1)) / StrideW + 1` .
-    - :math:`D_{out} = (D_{in} + PadFront + PadBack - ((kd - 1) * DilationD + 1)) / StrideD + 1` .
-    - :math:`(D_{in}+PadFront+PadBack - ((kd-1)*DilationD+1)) \% StrideD <= PadBack` .
-    - :math:`(H_{in}+PadUp+PadDown - ((kh-1)*Dilationh+1)) \% StrideH <= PadDown` .
-    - :math:`stride_d <= kernel_d` .
-    - :math:`PadUp < kh` and :math:`PadDown < kh` . When `padding` = ``'valid'``, both PadUp and PadDown are zeros.
-      When `padding` = ``'same'``, pad can be calculated by
-      :math:`floor(((H_{out}-1) * strideH + (kh - 1) * DilationH + 1 - H_{in}) / 2)` for high dimension.
-      It is similar way to calculate the padding for depth and width dimension. And the depth and width
-      dimensions also have the same constraints.
-    - :math:`((kh - 1) * DilationH - PadUp)` should be in [0, 255]. It is the same constraint for depth
-      and width dimension.
-    - If `padding` is ``'same'``, `stride` must be 1.
-
-    .. warning::
-        This API does not support Atlas series products.
-
-    Args:
-        input (Tensor): Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
-        weight (Tensor): Set size of kernel is :math:`(kd, kh,
-            kw)`, then the shape is :math:`(C_{out}, C_{in} / groups, kd, kh, kw)`.
-        bias (Tensor, optional): Bias Tensor with shape :math:`(C_{out})`.
-            When bias is ``None`` , zeros will be used. Default: ``None`` .
-        stride (Union(int, tuple[int], list[int]), optional): The distance of kernel moving, an int
-            number that represents the depth, the height and width of movement are both strides, or a
-            tuple of triple int numbers that
-            represent the depth, height and width of movement respectively. Default: ``1`` .
-        padding (Union(int, tuple[int], list[int], str), optional): Implicit paddings on both sides of the input `x`.
-            Can be a string, one integer or a tuple/list with 3 integers.
-            If `padding` is a string, the optional values are ``"same"`` , ``"valid"``.
-
-            - same: Adopts the way of completion. The height and width of the output will be equal to
-              the input `x` divided by stride. The padding will be evenly calculated in top and bottom,
-              left and right possiblily. Otherwise, the last extra padding will be calculated from the bottom
-              and the right side. If this mode is set, `stride` must be 1.
-
-            - valid: Adopts the way of discarding. The possible largest height and width of output will be returned
-              without padding. Extra pixels will be discarded.
-
-            If `padding` is one integer, the paddings of top, bottom, left and right are the same, equal to padding.
-            If `padding` is a tuple/list with 3 integers, the padding of head, tail, top, bottom,
-            left and right equal to pad[0], pad[0], pad[1], pad[1], pad[2] and pad[2] correspondingly. Default: ``0`` .
-        dilation (Union[int, tuple[int], list[int]], optional): Controlling the space between the kernel points.
-            Default: ``1`` .
-        groups (int, optional): Splits `input` into groups. Default: ``1`` .
-
-    Returns:
-        Tensor, the same dtype as the `input`, with the shape :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
-        or :math:`(C_{out}, D_{out}, H_{out}, W_{out})`.
-
-    Raises:
-        TypeError: If `stride`, `padding` or `dilation` is neither an int nor a tuple.
-        TypeError: `groups` is not an int.
-        TypeError: If `bias` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import mint
-        >>> x = mindspore.Tensor(np.random.randn(12, 1, 60, 50, 8), mindspore.float16)
-        >>> w = mindspore.Tensor(np.random.randn(26, 1, 2, 4, 4), mindspore.float16)
-        >>> out = mint.nn.functional.conv3d(x, w)
-        >>> print(out.shape)
-        (12, 26, 59, 47, 5)
-    """
-
-    return conv3d_op(input, weight, bias, stride, padding, dilation, groups)
-
-
 @_primexpr
 def _check_positive_int(arg_value, arg_name=None, prim_name=None):
     validator.check_positive_int(arg_value, arg_name=arg_name, prim_name=prim_name)
@@ -9329,14 +9109,14 @@ def embedding(input, weight, padding_idx=None, max_norm=None, norm_type=2.0, sca
         >>> weight = Parameter(np.random.randn(3, 3).astype(np.float32))
         >>> output = ops.embedding(input, weight, max_norm=0.4)
         >>> print(output)
-        [[[ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
-          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
-          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
-          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01]],
-         [[ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
-          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01],
-          [ 5.49015924e-02,  3.47811311e-01, -1.89771220e-01],
-          [ 2.09307984e-01, -2.24846993e-02,  3.40124398e-01]]]
+        [[[ 5.49015924  3.47811311 -1.89771220],
+          [ 2.09307984 -2.24846993  3.40124398],
+          [ 5.49015924  3.47811311 -1.89771220],
+          [ 5.49015924  3.47811311 -1.89771220]],
+         [[ 2.09307984 -2.24846993  3.40124398],
+          [ 2.09307984 -2.24846993  3.40124398],
+          [ 5.49015924  3.47811311 -1.89771220],
+          [ 2.09307984 -2.24846993  3.40124398]]]
     """
     return embedding_op(input, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq)
 
@@ -9630,6 +9410,7 @@ __all__ = [
     'conv2d',
     'conv_transpose2d',
     'sigmoid',
+    'inplace_sigmoid',
     'soft_margin_loss',
     'logsigmoid',
     'relu',

mindspore/ops/function/random_func.py

@@ -1262,9 +1262,6 @@ def randn_ext(*size, generator=None, dtype=None):
     Returns a new tensor filled with numbers from the normal distribution over an interval :math:`[0, 1)`
     based on the given shape and dtype.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         size (Union[int, tuple(int), list(int)]): Shape of the new tensor, e.g. :math:`(2, 3)` or :math:`2`.
 
@@ -1341,9 +1338,6 @@ def randint_ext(*args, generator=None, dtype=None):
     Returns a new tensor filled with integer numbers from the uniform distribution over an interval :math:`[low, high)`
     based on the given shape and dtype.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         low (int, optional): the lower bound of the generated random number. Default: ``0``.
         high (int): the upper bound of the generated random number
@@ -1680,9 +1674,6 @@ def randperm_ext(n, *, generator=None, dtype=mstype.int64):
     r"""
     Generates random permutation of integers from 0 to n-1.
 
-    .. warning::
-        - This is an experimental API that is subject to change or deletion.
-
     Args:
         n (Union[Tensor, int]): size of the permutation. int or Tensor with shape: () or (1,) and
             data type int64. The value of `n` must be greater than zero.
@@ -1957,10 +1948,10 @@ def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
         >>> # input1 and input2 have the same meaning.
         >>> output1 = ops.multinomial_ext(input1, 2)
         >>> output2 = ops.multinomial_ext(input2, 2)
-        >>> # print(output1)
-        >>> # [0 1]
-        >>> # print(output2)
-        >>> # [0 1]
+        >>> print(output1)
+        [0 1]
+        >>> print(output2)
+        [0 1]
         >>> print(len(output1))
         2
         >>> print(len(output2))
@@ -1968,8 +1959,8 @@ def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
         >>> # case 2: The output is random, and the length of the output is the same as num_sample.
         >>> # replacement is True.
         >>> output3 = ops.multinomial_ext(input1, 10, replacement=True)
-        >>> # print(output3)
-        >>> # [0 0 1 0 0 0 0 0 0 0]
+        >>> print(output3)
+        [0 0 1 0 0 0 0 0 0 0]
         >>> print(len(output3))
         10
         >>> # case 3: The output is random, and the length of the output is the same as num_sample.
@@ -1977,9 +1968,9 @@ def multinomial_ext(input, num_samples, replacement=False, *, generator=None):
         >>> # rank is 2
         >>> input4 = Tensor([[90, 10, 0], [10, 90, 0]], mstype.float32)
         >>> output4 = ops.multinomial_ext(input4, 10, replacement=True)
-        >>> # print(output4)
-        >>> # [[0 0 0 0 0 0 0 0 1 0]
-        >>> #  [1 1 1 1 1 0 1 1 1 1]]
+        >>> print(output4)
+        [[0 0 0 0 0 0 0 0 1 0]
+         [1 1 1 1 1 0 1 1 1 1]]
     """
     if generator is None:
         generator = default_generator

mindspore/ops/functional.py

@@ -266,6 +266,7 @@ setattr(tensor_operator_registry, 'erf', erf)
 setattr(tensor_operator_registry, 'erfc', erfc)
 setattr(tensor_operator_registry, 'standard_normal', P.StandardNormal)
 setattr(tensor_operator_registry, 'sigmoid', sigmoid)
+setattr(tensor_operator_registry, 'sigmoid_', auto_generate.inplace_sigmoid)
 setattr(tensor_operator_registry, 'median', Median)
 setattr(tensor_operator_registry, 'tanh', tanh)
 setattr(tensor_operator_registry, 'tanh_', tanh_)
@@ -452,6 +453,7 @@ setattr(tensor_operator_registry, 'ne', ne)
 setattr(tensor_operator_registry, 'not_equal', not_equal)
 setattr(tensor_operator_registry, 'sgn', sgn)
 setattr(tensor_operator_registry, 'sign', sign)
+setattr(tensor_operator_registry, 'sign_', auto_generate.inplace_sign)
 setattr(tensor_operator_registry, 'signbit', signbit)
 setattr(tensor_operator_registry, 'sinh', sinh)
 setattr(tensor_operator_registry, 'trunc', trunc)