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

mindspore/ops/functional.py

@@ -20,7 +20,7 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import chunk_ext, zero_
-from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext
+from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext, bernoulli_
 from mindspore.ops.function.random_func import random_, uniform_ext, uniform_, normal_, exponential_
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
@@ -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_)
@@ -397,6 +398,7 @@ setattr(tensor_operator_registry, 'inplace_scatter_add', auto_generate.inplace_s
 setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
 setattr(tensor_operator_registry, 'select_scatter', select_scatter)
 setattr(tensor_operator_registry, 'bernoulli', bernoulli_ext)
+setattr(tensor_operator_registry, 'bernoulli_', bernoulli_)
 setattr(tensor_operator_registry, 'poisson', P.Poisson)
 setattr(tensor_operator_registry, 'randperm', P.Randperm)
 setattr(tensor_operator_registry, 'multinomial', multinomial)
@@ -451,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)

mindspore/ops/functional_overload.py

@@ -17,8 +17,11 @@ from mindspore._c_expression import _add_instance
 from mindspore._c_expression import _addcdiv_instance
 from mindspore._c_expression import _all_gather_matmul_instance
 from mindspore._c_expression import _any_instance
+from mindspore._c_expression import _bernoulli__instance
 from mindspore._c_expression import _bitwise_not_instance
 from mindspore._c_expression import _clamp_instance
+from mindspore._c_expression import _conv1d_instance
+from mindspore._c_expression import _conv2d_instance
 from mindspore._c_expression import _conv3d_instance
 from mindspore._c_expression import _div_instance
 from mindspore._c_expression import _einsum_instance
@@ -31,6 +34,7 @@ from mindspore._c_expression import _gmm_instance
 from mindspore._c_expression import _gmm_backward_instance
 from mindspore._c_expression import _gmm_backward_fusion_instance
 from mindspore._c_expression import _greater_equal_instance
+from mindspore._c_expression import _imag_instance
 from mindspore._c_expression import _index_add_instance
 from mindspore._c_expression import _kthvalue_instance
 from mindspore._c_expression import _lerp_instance
@@ -40,6 +44,7 @@ from mindspore._c_expression import _min_instance
 from mindspore._c_expression import _nansum_instance
 from mindspore._c_expression import _pixel_shuffle_instance
 from mindspore._c_expression import _quant_matmul_instance
+from mindspore._c_expression import _real_instance
 from mindspore._c_expression import _remainder_instance
 from mindspore._c_expression import _repeat_interleave_instance
 from mindspore._c_expression import _rmod_instance
@@ -66,10 +71,10 @@ def add(*args, **kwargs):
     Args:
         input (Union[Tensor, number.Number, bool]): `input` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
         alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
@@ -317,6 +322,15 @@ def any(*args, **kwargs):
     return _any_instance(*args, **kwargs)
 
 
+def bernoulli_(*args, **kwargs):
+    r"""
+    bernoulli_(input, p, seed, offset) -> Tensor
+
+    Inner function, used for Tensor.bernoulli_.
+    """
+    return _bernoulli__instance(*args, **kwargs)
+
+
 def bitwise_not(*args, **kwargs):
     r"""
     bitwise_not(input) -> Tensor
@@ -429,6 +443,245 @@ def clip(*args, **kwargs):
     return _clamp_instance(*args, **kwargs)
 
 
+def conv1d(*args, **kwargs):
+    r"""
+    conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
+
+    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>`_.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
+        weight (Tensor): Tensor of shape
+            :math:`(C_{out}, 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`` .
+            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})`
+
+    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:
+        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: 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.
+        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 `kernel_size` 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)
+    """
+    return _conv1d_instance(*args, **kwargs)
+
+
+def conv2d(*args, **kwargs):
+    r"""
+    Applies a 2D convolution over an input tensor. The input tensor is typically of
+    shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`,
+    where :math:`N` is batch size, :math:`C` is channel number, :math:`H` is feature height, :math:`W` is feature width.
+
+    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_{out_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{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[0]}, \text{kernel_size[1]})`,
+    where :math:`\text{kernel_size[0]}` and :math:`\text{kernel_size[1]}` are the 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}, \text{kernel_size[0]}, \text{kernel_size[1]})`,
+    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>`_ and
+    `ConvNets <http://cs231n.github.io/convolutional-networks/>`_.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`.
+        weight (Tensor): Tensor of shape
+            :math:`(N, C_{in} / \text{groups}, \text{kernel_size[0]}, \text{kernel_size[1]})`, then the size of kernel
+            is :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})`.
+        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 height and width of movement are both strides, or a tuple of two int numbers that
+            represent height and width of movement respectively. Default: ``1`` .
+        padding (Union[int, tuple[int], list[int], str], optional): The number of padding
+            on the height and width directions of the input.
+            The data type is an integer or a tuple of two integers or string {`valid`, `same`}. If `padding` is an
+            integer, then `padding_{H}` and `padding_{W}` are all equal to `padding`.
+            If `padding` is a tuple of 2 integers, then `padding_{H}` and `padding_{W}`
+            is equal to `padding[0]` and `padding[1]` respectively.
+            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/bottom 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 height and width. Extra pixels that could not complete a full stride will
+              be discarded.
+
+        dilation (Union(int, tuple[int], list[int]), optional): Gaps between kernel elements.The data type
+            is int or a tuple of 2 integers. Specifies the dilation rate to use for dilated convolution.
+            If set to be :math:`k > 1`,
+            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`` .
+
+            - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
+              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
+
+    Returns:
+        Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`.
+        To see how different pad modes affect the output shape, please refer to
+        :class:`mindspore.mint.nn.Conv2d` 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. For more details on the output
+            formula, please refer to :class:`mindspore.mint.nn.Conv2d`.
+        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 nor a tuple.
+        TypeError: If `bias` is not a Tensor.
+        ValueError: If  the shape of `bias` is not :math:`(C_{out})` .
+        ValueError: If `stride` or `dilation` is less than 1.
+        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, 32]), mindspore.float32)
+        >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
+        >>> output = mint.nn.functional.conv2d(x, weight)
+        >>> print(output.shape)
+        (10, 32, 30, 30)
+    """
+    return _conv2d_instance(*args, **kwargs)
+
+
 def conv3d(*args, **kwargs):
     r"""
     conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
@@ -579,7 +832,7 @@ def div(*args, **kwargs):
     .. note::
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
 
@@ -730,13 +983,10 @@ def einsum(*args, **kwargs):
 
 def empty(*args, **kwargs):
     r"""
-    empty(*size, *, dtype=None, device=None) -> Tensor
+    empty(*size, *, dtype=None, device=None, pin_memory=False) -> Tensor
 
     Creates a tensor with uninitialized data, whose shape, dtype and device are described by the argument `size`,
-    `dtype` and `device` respectively.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
+    `dtype` and `device` respectively. If `pin_memory` is True, the tensor will be allocated in pinned memory.
 
     Args:
         size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Can be variable numbers of
@@ -745,15 +995,18 @@ def empty(*args, **kwargs):
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
             `mindspore.float32` will be used. Default: ``None`` .
-        device (string, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
+        device (str, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
             ``"cpu"`` and ``"CPU"`` are supported. In graph mode O0, ``"Ascend"`` and ``"npu"`` are supported. If `device = None`,
             `mindspore.context.device_target` will be used. Default ``None``.
+        pin_memory (bool, optional): If set `pin_memory` to True, the tensor will be allocated in pinned memory, and `device`
+            should be ``"cpu"`` or ``"CPU"`` . Default ``False``.
 
     Returns:
         Tensor, whose shape, dtype and device are defined by input.
 
     Raises:
         TypeError:  If `size` is neither an int nor a tuple or list of int.
+        RuntimeError: If `pin_memory` is True, and `device` is neither  ``"cpu"`` nor ``"CPU"`` .
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -771,13 +1024,10 @@ def empty(*args, **kwargs):
 
 def empty_like(*args, **kwargs):
     r"""
-    empty_like(input, *, dtype=None, device=None) -> Tensor
+    empty_like(input, *, dtype=None, device=None, pin_memory=False) -> Tensor
 
     Returns an uninitialized Tensor with the same shape as the `input`. Its dtype is specified by `dtype` and its
-    device is specified by `device`.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
+    device is specified by `device`. If `pin_memory` is True, the tensor will be allocated in pinned memory.
 
     Args:
         input (Tensor): Tensor of any dimension.
@@ -785,15 +1035,18 @@ def empty_like(*args, **kwargs):
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`, the
             tensor will have the same dtype as input `input`. Default ``None``.
-        device (string, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
+        device (str, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
             ``"cpu"`` and ``"CPU"`` are supported. In graph mode O0, ``"Ascend"`` and ``"npu"`` are supported. If `device = None`,
             the value set by :func:`mindspore.set_device` will be used. Default ``None``.
+        pin_memory (bool, optional): If set `pin_memory` to True, the tensor will be allocated in pinned memory, and `device`
+            should be ``"cpu"`` or ``"CPU"`` . Default ``False``.
 
     Returns:
         Tensor, has the same shape, type and device as `input` but with uninitialized data (May be a random value).
 
     Raises:
         TypeError: If `input` is not a Tensor.
+        RuntimeError: If `pin_memory` is True, and `device` is neither  ``"cpu"`` nor ``"CPU"`` .
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -833,9 +1086,6 @@ def floor_divide(*args, **kwargs):
     where the :math:`floor` indicates the Floor operator. For more details,
     please refer to the :class:`mindspore.mint.floor` operator.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Union[Tensor, Number, bool]): The first input is a number or
             a bool or a tensor whose data type is number or bool.
@@ -1107,10 +1357,10 @@ def greater_equal(*args, **kwargs):
 
     Args:
         input (Union[Tensor, Number]): The first input is a number
-            or a tensor whose data type is `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ or `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_.
+            or a tensor whose data type is `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ or `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_.
         other (Union[Tensor, Number]): Second input. When the first input is a Tensor, the second input should be a Number,
-            or a Tensor of the number or bool_ data type. When the first input is a Scalar,
-            the second input must be a Tensor of number or bool_ data type.
+            or a Tensor of the number or bool data type. When the first input is a Scalar,
+            the second input must be a Tensor of number or bool data type.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
@@ -1147,6 +1397,54 @@ def ge(*args, **kwargs):
     return _greater_equal_instance(*args, **kwargs)
 
 
+def imag(*args, **kwargs):
+    r"""
+    imag(input) -> Tensor
+
+    Return a new tensor containing the imaginary values of the input tensor.
+    The returned tensor and input tensor share the same underlying storage.
+
+    Note:
+        - Only support Pynative mode.
+        - Only support complex64 and complex128 tensors.
+
+    Args:
+        input (Tensor): The input tensor, the data type must be complex64 or complex128.
+
+    Returns:
+        Tensor, the shape is same as `input`. The data type is float32 if `input` is complex64, float64 when `input` is complex128.
+
+    Raises:
+        TypeError: If dtype of `input` is not complex64 or complex128.
+        ValueError: If input tensor has no storage info.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops, context
+        >>> context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+        >>> real = Tensor([1.1, 2.1, 3.1], mindspore.float32)
+        >>> imag = Tensor([4.1, 5.1, 6.1], mindspore.float32)
+        >>> x = ops.Complex()(real, imag)
+        >>> output = ops.functional_overload.imag(x)
+        >>> print(output)
+        [4.1 5.1 6.1]
+        >>> print(output.dtype)
+        Float32
+        >>> real = Tensor([1.1, 2.1, 3.1], mindspore.float64)
+        >>> imag = Tensor([4.1, 5.1, 6.1], mindspore.float64)
+        >>> x = ops.Complex()(real, imag)
+        >>> output = ops.functional_overload.imag(x)
+        >>> print(output)
+        [4.1 5.1 6.1]
+        >>> print(output.dtype)
+        Float64
+    """
+    return _imag_instance(*args, **kwargs)
+
+
 def index_add(*args, **kwargs):
     r"""
     index_add(input, dim, index, source, *, alpha=1) -> Tensor
@@ -1615,9 +1913,6 @@ def pixel_shuffle(*args, **kwargs):
     For detailed introduction to the pixel_shuffle algorithm, refer to
     `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158>`_ .
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): Tensor of shape :math:`(*, C \times r^2, H, W)` . The dimension of `input` is larger than 2,
             and the length of third to last dimension can be divisible by the square of `upscale_factor`.
@@ -1699,6 +1994,53 @@ def quant_matmul(*args, **kwargs):
     return _quant_matmul_instance(*args, **kwargs)
 
 
+def real(*args, **kwargs):
+    r"""
+    real(input) -> Tensor
+
+    Return a new tensor containing the real values of the input tensor. If input is real, it is returned unchanged.
+    The returned tensor and input tensor share the same underlying storage.
+
+    Note:
+        Only support Pynative mode.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, the shape is same as `input`. The data type is float32 if `input` is complex64, float64 when `input` is complex128.
+        Otherwise, the data type is the same as `input`.
+
+    Raises:
+        ValueError: If input tensor has no storage info.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops, context
+        >>> context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+        >>> real = Tensor([1.1, 2.1, 3.1], mindspore.float32)
+        >>> imag = Tensor([4.1, 5.1, 6.1], mindspore.float32)
+        >>> x = ops.Complex()(real, imag)
+        >>> output = ops.functional_overload.real(x)
+        >>> print(output)
+        [1.1 2.1 3.1]
+        >>> print(output.dtype)
+        Float32
+        >>> real = Tensor([1.1, 2.1, 3.1], mindspore.float64)
+        >>> imag = Tensor([4.1, 5.1, 6.1], mindspore.float64)
+        >>> x = ops.Complex()(real, imag)
+        >>> output = ops.functional_overload.real(x)
+        >>> print(output)
+        [1.1 2.1 3.1]
+        >>> print(output.dtype)
+        Float64
+    """
+    return _real_instance(*args, **kwargs)
+
+
 def remainder(*args, **kwargs):
     r"""
     remainder(input, other) -> Tensor
@@ -1719,10 +2061,10 @@ def remainder(*args, **kwargs):
         input (Union[Tensor, numbers.Number, bool]): The dividend is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
-            a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
-            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool\_.
+            a bool or a tensor whose data type is number or bool when the dividend is a tensor.
+            When the dividend is Scalar, the divisor must be a Tensor whose data type is number or bool.
 
     Returns:
         Tensor, with dtype promoted and shape broadcasted.
@@ -1816,10 +2158,10 @@ def sub(*args, **kwargs):
     Args:
         input (Union[Tensor, number.Number, bool]): `input` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
         alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
@@ -1935,7 +2277,7 @@ def xlogy(*args, **kwargs):
         input (Union[Tensor, numbers.Number, bool]): The first input is a numbers.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, numbers.Number, bool]): The second input is a numbers.Number or
             a bool or a tensor whose data type is number or bool when the first input is a tensor.
             When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -1969,9 +2311,12 @@ __all__ = [
     "addcdiv",
     "all_gather_matmul",
     "any",
+    "bernoulli_",
     "bitwise_not",
     "clamp",
     "clip",
+    "conv1d",
+    "conv2d",
     "conv3d",
     "div",
     "divide",
@@ -1986,6 +2331,7 @@ __all__ = [
     "gmm_backward_fusion",
     "greater_equal",
     "ge",
+    "imag",
     "index_add",
     "kthvalue",
     "lerp",
@@ -1995,6 +2341,7 @@ __all__ = [
     "nansum",
     "pixel_shuffle",
     "quant_matmul",
+    "real",
     "remainder",
     "repeat_interleave",
     "rmod",

mindspore/ops/operations/__init__.py

@@ -55,7 +55,7 @@ from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborE
                        Broadcast, CollectiveGather, CollectiveScatter, Barrier, Send, Receive, BatchISendIRecv,
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
                        _VirtualOutput, _VirtualDiv, _GetTensorSlice, _VirtualAdd, _VirtualAssignAdd, _VirtualAccuGrad,
-                       _HostAllGather, _HostReduceScatter, _MirrorMicroStepOperator, _MicroStepAllGather,
+                       _HostAllGather, _HostReduceScatter, _MirrorMicroStepOperator, _MicroStepAllGather, AlltoAllVC,
                        _VirtualPipelineEnd, AlltoAllV, ReduceScatter, _VirtualAssignKvCache, AllGatherV, ReduceScatterV)
 from .control_ops import GeSwitch, Merge
 from .custom_ops import (Custom, CustomOpBuilder)
@@ -129,7 +129,6 @@ from .random_ops import (RandomChoiceWithMask, StandardNormal, Gamma, RandomGamm
                          LogUniformCandidateSampler, TruncatedNormal, LogNormalReverse, NonDeterministicInts,
                          ParameterizedTruncatedNormal, RandomPoisson, MultinomialWithReplacement, RandomShuffle,
                          RandpermV2)
-from .rl_ops import (BufferAppend, BufferGetItem, BufferSample)
 from .sparse_ops import (
     SparseToDense, SparseTensorDenseMatmul, SparseTensorDenseAdd, SparseSlice)
 from .spectral_ops import (BartlettWindow, BlackmanWindow)
@@ -406,6 +405,7 @@ __all__ = [
     "AllReduce",
     "AllGatherV",
     "ReduceScatterV",
+    "AlltoAllVC",
     "Reduce",
     "_AllSwap",
     "ReduceScatter",
@@ -532,9 +532,6 @@ __all__ = [
     "HShrink",
     "PyExecute",
     "PyFunc",
-    "BufferAppend",
-    "BufferGetItem",
-    "BufferSample",
     "Erfinv",
     "Conj",
     "Real",