mindspore 2.7.0__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/ops/functional_overload.py

@@ -20,6 +20,8 @@ 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
@@ -32,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
@@ -41,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
@@ -439,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
@@ -740,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
@@ -755,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``
@@ -781,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.
@@ -795,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``
@@ -843,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.
@@ -1157,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
@@ -1625,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`.
@@ -1709,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
@@ -1983,6 +2315,8 @@ __all__ = [
     "bitwise_not",
     "clamp",
     "clip",
+    "conv1d",
+    "conv2d",
     "conv3d",
     "div",
     "divide",
@@ -1997,6 +2331,7 @@ __all__ = [
     "gmm_backward_fusion",
     "greater_equal",
     "ge",
+    "imag",
     "index_add",
     "kthvalue",
     "lerp",
@@ -2006,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",

mindspore/ops/operations/_custom_ops_utils.py

@@ -228,20 +228,18 @@ class ExtensionBuilder:
             source_file.write(content)
 
     def _run_ninja_build(self, module_name):
-        """Run ninja build."""
+        """Run ninja build and log output to .build_log.txt"""
         cmd = ['ninja', '-v']
         env = os.environ.copy()
+        log_file = os.path.join(self.build_dir, '.build_log.txt')
 
         try:
-            subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=self.build_dir, check=True, env=env)
-            # If the build succeeds, do nothing with the output (silent)
+            with open(log_file, 'w', encoding='utf-8') as f:
+                # If the build succeeds, do nothing with the output (silent)
+                subprocess.run(cmd, stdout=f, stderr=f, cwd=self.build_dir, check=True, env=env)
         except subprocess.CalledProcessError as e:
-            # Capture the error details
-            stderr_output = e.stderr.decode() if e.stderr else ""
-            stdout_output = e.stdout.decode() if e.stdout else ""
-            full_output = stderr_output + stdout_output
-
-            # Format the error message
+            with open(log_file, 'r', encoding='utf-8') as rf:
+                full_output = rf.read()
             msg = f"Error building extension '{module_name}': {full_output}"
 
             # In multi-card situation, only one process build the library.

mindspore/ops/operations/_inner_ops.py

@@ -1413,6 +1413,7 @@ class PsROIPooling(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, pooled_height, pooled_width, num_rois, spatial_scale, out_dim, group_size):
+
         """Initialize PsROIPooling"""
         validator.check_value_type("pooled_height", pooled_height, [int], self.name)
         validator.check_value_type("pooled_width", pooled_width, [int], self.name)
@@ -1726,44 +1727,6 @@ class Format(PrimitiveWithInfer):
         return {'dtype': mstype.string, 'shape': [], 'value': value}
 
 
-class FlattenConcat(Primitive):
-    """
-    Flatten input tensors and concatenate them into several chunk tensors grouped by data types.
-
-    Args:
-        fusion_size (int): Maximum memory chunk size in bytes, 0 for unlimited. Default: 0.
-
-    Inputs:
-        - **tensors** (tuple[Tensor], list[Tensor]) - The input Tensors to be flattened and concatenated.
-
-    Outputs:
-        tuple[Tensor], result chunk tensors.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore.ops.operations import _inner_ops as inner
-        >>> t1 = Tensor(np.array([1]).astype(np.float32))
-        >>> t2 = Tensor(np.array([2]).astype(np.float32))
-        >>> t3 = Tensor(np.array([3]).astype(np.float64))
-        >>> t4 = Tensor(np.array([4]).astype(np.float32))
-        >>> t5 = Tensor(np.array([5]).astype(np.float64))
-        >>> chunks = inner.FlattenConcat()([t1, t2, t2, t3, t4, t5])
-        >>> print(chunks[0].asnumpy())
-        >>> print(chunks[1].asnumpy())
-        [1. 2. 4.]
-        [3. 5.]
-    """
-
-    @prim_attr_register
-    def __init__(self, fusion_size=0):
-        """Initialize FlattenConcat"""
-        validator.check_non_negative_int(fusion_size, 'fusion_size', self.name)
-        self.fusion_size = fusion_size
-        self.add_prim_attr('fusion_size', fusion_size)
-
-
 class KMeansCentroids(PrimitiveWithInfer):
     """
     Calculate the segment_sum, segment_count, kmean_total_sum that are clustering results