mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/ops/auto_generate/gen_extend_func.py

@@ -17,6 +17,82 @@ from mindspore.common import dtype as mstype
 from mindspore.ops.auto_generate.pyboost_inner_prim import *
 
 
+def acos(input):
+    r"""
+    Computes arccosine of input tensors element-wise.
+    
+    .. math::
+    
+        out_i = \cos^{-1}(input_i)
+    
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.acos_ext(input)
+        >>> print(output)
+        [0.7377037  1.5307857 1.2661037 0.9764114]
+    """
+    return acos_impl(input)
+
+
+def acosh(input):
+    r"""
+    Computes inverse hyperbolic cosine of the inputs element-wise.
+    
+    .. math::
+    
+        out_i = \cosh^{-1}(input_i)
+    
+    .. note::
+        Given an input tensor input, the function computes inverse hyperbolic cosine of every element.
+        Input range is [1, inf].
+    
+    Args:
+        input (Tensor): The input tensor of inverse hyperbolic cosine function.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.acosh_ext(input)
+        >>> print(output)
+        [0.        0.9624236 1.7627472 5.298292 ]
+    """
+    return acosh_impl(input)
+
+
+def adaptive_avg_pool2d_grad(grad_output, x):
+    r"""
+    None
+    """
+    return adaptive_avg_pool2d_grad_impl(grad_output, x)
+
+
 def add(input, other, alpha=1):
     r"""
     Adds scaled other value to input Tensor.
@@ -34,12 +110,12 @@ def add(input, other, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first 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.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `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>`_.
         other (Union[Tensor, number.Number, bool]): The second 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.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `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>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
     
     Returns:
@@ -106,6 +182,104 @@ def argmax(input, dim=None, keepdim=False):
     return argmax_impl(input, dim, keepdim)
 
 
+def argmin(input, dim=None, keepdim=False):
+    r"""
+    Return the indices of the minimum values of a tensor across a dimension.
+    
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, None], optional): Specify the axis for calculation. If `dim` is ``None`` , the indices of the minimum
+            value within the flattened input will be returned. Default: ``None`` .
+        keepdim (bool, optional): Whether the output tensor retains the specified
+            dimension. Ignored if `dim` is None. Default: ``False`` .
+    
+    Returns:
+        Tensor, indices of the minimum values of the input tensor across a dimension.
+    
+    Raises:
+        TypeError: If `keepdim` is not bool.
+        ValueError: If `dim` is out of range.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import mint
+        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
+        >>> output = mint.argmin(x, dim=-1)
+        >>> print(output)
+        [0 1 2]
+    """
+    return argmin_impl(input, dim, keepdim)
+
+
+def asin(input):
+    r"""
+    Computes arcsine of input tensors element-wise.
+    
+    .. math::
+    
+        out_i = \sin^{-1}(input_i)
+    
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.asin_ext(input)
+        >>> print(output)
+        [0.8330927  0.04001068  0.30469266  0.59438497 ]
+    """
+    return asin_impl(input)
+
+
+def asinh(input):
+    r"""
+    Computes inverse hyperbolic sine of the input element-wise.
+    
+    .. math::
+    
+        out_i = \sinh^{-1}(input_i)
+    
+    Args:
+        input (Tensor): The input tensor of inverse hyperbolic sine function.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.asinh_ext(input)
+        >>> print(output)
+        [-2.3124385  1.1947632  1.8184465  5.298342 ]
+    """
+    return asinh_impl(input)
+
+
 def atan2(input, other):
     r"""
     Returns arctangent of input/other element-wise.
@@ -124,7 +298,9 @@ def atan2(input, other):
             its shape is able to broadcast with `input`.
     
     Returns:
-        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+        Tensor, the shape is the same as the one after broadcasting.
+        The dtype of output is float32 when dtype of `input` is in
+        [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
     
     Raises:
         TypeError: If `input` or `other` is not a Tensor or scalar.
@@ -147,6 +323,39 @@ def atan2(input, other):
     return atan2_impl(input, other)
 
 
+def atan(input):
+    r"""
+    Computes the trigonometric inverse tangent of the input element-wise.
+    
+    .. math::
+    
+        out_i = \tan^{-1}(input_i)
+    
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.0, 0.0]), mindspore.float32)
+        >>> output = ops.atan_ext(input)
+        >>> print(output)
+        [0.7853982 0.       ]
+    """
+    return atan_impl(input)
+
+
 def bmm(input, mat2):
     r"""
     Performs batch matrix-matrix multiplication of two three-dimensional tensors.
@@ -254,6 +463,56 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
     return fold_impl(input, converted_output_size, converted_kernel_size, converted_dilation, converted_padding, converted_stride)
 
 
+def copy(variable, value):
+    r"""
+    None
+    """
+    return copy_impl(variable, value)
+
+
+def cummin(input, dim):
+    r"""
+    Returns a tuple (values, indices) where `values` is the cumulative minimum value of input Tensor `input`
+    along the dimension `dim`, and `indices` is the index location of each minimum value.
+    
+    .. math::
+        \begin{array}{ll} \\
+            y_{i} = \min(x_{1}, x_{2}, ... , x_{i})
+        \end{array}
+    
+    Args:
+        input (Tensor): The input Tensor, The dimension must be greater than 0.
+        dim (int): Operation dimension. The value of `dim` must be in the range `[-input.ndim, input.ndim - 1]`.
+    
+    Returns:
+        tuple [Tensor], tuple of 2 Tensors, containing the cumulative minimum of elements and the index.
+        The shape of each output tensor is the same as that of input `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is a Tensor, but the type is complex or bool.
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is out the range of `[-input.ndim, input.ndim - 1]`.
+    
+    .. note::
+        O2 mode is not supported in Ascend.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import mindspore
+        >>> a = Tensor([-0.2284, -0.6628,  0.0975,  0.2680, -1.3298, -0.4220], mindspore.float32)
+        >>> output = ops.cummin_ext(a, dim=0)
+        >>> print(output[0])
+        [-0.2284 -0.6628 -0.6628 -0.6628 -1.3298 -1.3298]
+        >>> print(output[1])
+        [0 1 1 1 4 4]
+    """
+    return cummin_impl(input, dim)
+
+
 def cumsum(input, dim, dtype=None):
     r"""
     Computes the cumulative sum of input Tensor along `dim`.
@@ -365,8 +624,6 @@ def flatten(input, start_dim=0, end_dim=-1):
     
     Args:
         input (Tensor): The input Tensor.
-    
-    Keyword Args:
         start_dim (int, optional): The first dimension to flatten. Default: ``0`` .
         end_dim (int, optional): The last dimension to flatten. Default: ``-1`` .
     
@@ -386,15 +643,58 @@ def flatten(input, start_dim=0, end_dim=-1):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
-        >>> output = mint.flatten(input_x)
+        >>> output = ops.auto_generate.flatten_ext(input_x)
         >>> print(output.shape)
         (24,)
     """
     return flatten_impl(input, start_dim, end_dim)
 
 
+def histc(input, bins=100, min=0, max=0):
+    r"""
+    Computes the histogram of a tensor.
+    
+    The elements are sorted into equal width bins between `min` and `max`.
+    If `min` and `max` are both zero, the minimum and maximum values of the data are used.
+    
+    Elements lower than min or higher than max are ignored.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+        If input is int64, valid values fit within int32; exceeding this may cause precision errors.
+    
+    Args:
+        input (Tensor): the input tensor.
+        bins (int, optional): Number of histogram bins, optional. If specified, must be positive. Default: ``100`` .
+        min (int, float, optional): the lower end of the range (inclusive), optional. Default: ``0`` .
+        max (int, float, optional): the upper end of the range (inclusive), optional. Default: ``0`` .
+    
+    Returns:
+        A 1-D Tensor, has the same type as `input` with the shape :math:`(bins, )`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` datatype is not in support list.
+        TypeError: If attr `min` or `max` is not float or int.
+        TypeError: If attr `bins` is not int.
+        ValueError: If attr value `min` > `max`.
+        ValueError: If attr `bins` <= 0.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([1., 2, 1])
+        >>> y = ops.histc_ext(x, bins=4, min=0, max=3)
+        >>> print(y)
+        [0 2 1 0]
+    """
+    return histc_impl(input, bins, min, max)
+
+
 def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     r"""
     Extracts sliding local blocks from a batched input tensor.
@@ -513,6 +813,79 @@ def index_select(input, dim, index):
     return index_select_impl(input, dim, index)
 
 
+def inplace_add(input, other, alpha=1):
+    r"""
+    None
+    """
+    return inplace_add_impl(input, other, alpha)
+
+
+def inplace_adds(input, other, alpha=1):
+    r"""
+    None
+    """
+    return inplace_adds_impl(input, other, alpha)
+
+
+def l1_loss(input, target, reduction='mean'):
+    r"""
+    Calculate the mean absolute error between the `input` value and the `target` value.
+    
+    Assuming that the :math:`x` and :math:`y` are the predicted value and target value,
+    both are one-dimensional tensors of length :math:`N`, length :math:`N`, `reduction` is set to ``'none'`` ,
+    then calculate the loss of :math:`x` and :math:`y` without dimensionality reduction.
+    
+    The formula is as follows:
+    
+    .. math::
+        \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
+    
+    where :math:`N` is the batch size.
+    
+    If `reduction` is ``'mean'`` or ``'sum'`` , then:
+    
+    .. math::
+        \ell(x, y) =
+        \begin{cases}
+            \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
+            \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+    
+    Args:
+        input (Tensor): Predicted value, Tensor of any dimension.
+        target (Tensor): Target value, usually has the same shape as the `input`.
+            If `input` and `target` have different shapes, make sure they can broadcast to each other.
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+    
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output. Notice: At least one of the input and target is float type when the reduction is ``'mean'`` .
+            - ``'sum'``: the output elements will be summed.
+    
+    Returns:
+        Tensor or Scalar, if `reduction` is ``'none'`` , return a Tensor with same shape and dtype as `input`.
+        Otherwise, a scalar value will be returned.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `target` is not a Tensor.
+        ValueError: If `reduction` is not one of ``'none'`` , ``'mean'`` or ``'sum'`` .
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
+        >>> target = Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
+        >>> output = ops.l1_loss_ext(x, target, reduction="mean")
+        >>> print(output)
+        3.0
+    """
+    return l1_loss_impl(input, target, converted_reduction)
+
+
 def leaky_relu(input, negative_slope=0.01):
     r"""
     leaky_relu activation function. The element of `input` less than 0 times `negative_slope` .
@@ -560,6 +933,89 @@ def leaky_relu(input, negative_slope=0.01):
     return leaky_relu_impl(input, negative_slope)
 
 
+def log_softmax(input, dim=None, dtype=None):
+    r"""
+    Applies the Log Softmax function to the input tensor on the specified axis.
+    Supposes a slice in the given axis, :math:`x` for each element :math:`x_i`,
+    the Log Softmax function is shown as follows:
+    
+    .. math::
+        \text{output}(x_i) = \log \left(\frac{\exp(x_i)} {\sum_{j = 0}^{N-1}\exp(x_j)}\right),
+    
+    where :math:`N` is the length of the Tensor.
+    
+    Args:
+        input (Tensor): The input Tensor.
+        dim (int, optional): The axis to perform the Log softmax operation. Default: ``None`` .
+    
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If not set to None, the input
+            Tensor will be cast to `dtype` before the operation is performed. This is useful for preventing overflows.
+            If set to None, stay the same as original Tensor. Default: ``None`` . Supported data type is {float16, float32, double, bfloat16}.
+    
+    Returns:
+        Tensor, with the same shape as the input.
+    
+    Raises:
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is not in range [-len(input.shape), len(input.shape)).
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> logits = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+        >>> output = ops.auto_generate.log_softmax(logits, dim=-1)
+        >>> print(output)
+        [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
+    """
+    return log_softmax_impl(input, dim, dtype)
+
+
+def logaddexp(input, other):
+    r"""
+    Computes the logarithm of the sum of exponentiations of the inputs.
+    This function is useful in statistics where the calculated probabilities of events may be
+    so small as to exceed the range of normal floating point numbers.
+    
+    .. math::
+    
+        out_i = \log(exp(input_i) + \exp(other_i))
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): Input Tensor. The dtype of `input` must be float.
+        other (Tensor): Input Tensor. The dtype of `other` must be float.
+            If the shape of `input` is not equal to the shape of `other`,
+            they must be broadcastable to a common shape (which becomes the shape of the output).
+    
+    Returns:
+        Tensor, with the same dtype as `input` and `other`.
+    
+    Raises:
+        TypeError: If `input` or `other` is not a Tensor.
+        TypeError: The dtype of `input` or `other` is not float.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor(np.array([1, 2, 3]).astype(np.float16))
+        >>> x2 = Tensor(np.array(2).astype(np.float16))
+        >>> output = ops.logaddexp_ext(x1, x2)
+        >>> print(output)
+        [2.312 2.693 3.312]
+    """
+    return logaddexp_impl(input, other)
+
+
 def matmul(input, mat2):
     r"""
     None
@@ -684,6 +1140,138 @@ def mean(input, axis=None, keep_dims=False, dtype=None):
     return mean_impl(input, axis, keep_dims, dtype)
 
 
+def mish(input):
+    r"""
+    Computes MISH (A Self Regularized Non-Monotonic Neural Activation Function)
+    of input tensors element-wise.
+    
+    The formula is defined as follows:
+    
+    .. math::
+        \text{mish}(input) = input * \tanh(softplus(\text{input}))
+    
+    See more details in `A Self Regularized Non-Monotonic Neural Activation Function 
+    <https://arxiv.org/abs/1908.08681>`_.
+    
+    Mish Activation Function Graph:
+    
+    .. image:: ../images/Mish.png
+        :align: center
+    
+    Args:
+        input (Tensor): The input of MISH. Supported dtypes: 
+    
+            - Ascend: float16, float32.
+    
+    Returns:
+        Tensor, has the same type and shape as the `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not float16 or float32.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> x = Tensor(np.array([[-1.1, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
+        >>> output = ops.mish(x)
+        >>> print(output)
+        [[-3.0764845e-01 3.9974124e+00 -2.6832507e-03]
+         [ 1.9439589e+00 -3.3576239e-02 8.9999990e+00]]
+    """
+    return mish_impl(input)
+
+
+def mse_loss(input, target, reduction='mean'):
+    r"""
+    Calculates the mean squared error between the predicted value and the label value.
+    
+    For detailed information, please refer to :class:`mindspore.nn.MSELoss`.
+    
+    Args:
+        input (Tensor): Tensor of any dimension. The data type needs to be consistent with the `target`.
+            It should also be broadcastable with the `target`.
+        target (Tensor): The input label. Tensor of any dimension. The data type needs to be consistent with the `input`.
+            It should also be broadcastable with the `input`.
+        reduction (str, optional): Apply specific reduction method to the output: ``'mean'`` , ``'none'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+    
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
+    
+    Returns:
+        - Tensor. If `reduction` is ``'mean'`` or ``'sum'``, the shape of output is `Tensor Scalar`.
+        - If reduction is ``'none'``, the shape of output is the broadcasted shape of **input** and **target** .
+    
+    Raises:
+        ValueError: If `reduction` is not one of ``'mean'`` , ``'sum'`` or ``'none'``.
+        ValueError: If `input` and `target` are not broadcastable.
+        TypeError: If `input` and `target` are in different data type.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
+        >>> output = ops.mse_loss_ext(logits, labels, reduction='none')
+        >>> print(output)
+        [[0. 1. 4.]
+         [0. 0. 1.]]
+    """
+    return mse_loss_impl(input, target, converted_reduction)
+
+
+def outer(input, vec2):
+    r"""
+    Return outer product of `input` and `vec2`. If `input` is a vector of size :math:`n`
+    and `vec2` is a vector of size :math:`m` , then output must be a matrix of shape :math:`(n, m)` .
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    .. note::
+        This function does not broadcast.
+    
+    Args:
+        input (Tensor): 1-D input vector.
+        vec2 (Tensor): 1-D input vector.
+    
+    Returns:
+        out, 2-D matrix, the outer product of two vectors.
+    
+    Raises:
+        TypeError: If `input` or `vec2` is not a Tensor.
+        TypeError: The implicitly converted data types of `input` and `vec2` are not one of float16, float32, float64, bool, uint8, int8, int16, int32, int64, complex64, complex128, bfloat16
+        ValueError: If the dimension of `input` or `vec2` is not equal to 1.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> input = Tensor(np.array([7, 8, 9]), mindspore.int32)
+        >>> vec2 = Tensor(np.array([7, 10, 11]), mindspore.int32)
+        >>> out = ops.outer(input, vec2)
+        >>> print(out)
+        [[49 70 77]
+         [56 80 88]
+         [63 90 99]]
+    """
+    return outer_impl(input, vec2)
+
+
 def prod(input, axis=None, keep_dims=False, dtype=None):
     r"""
     Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
@@ -762,6 +1350,56 @@ def prod(input, axis=None, keep_dims=False, dtype=None):
     return prod_impl(input, axis, keep_dims, dtype)
 
 
+def selu(input):
+    r"""
+    Activation function SELU (Scaled exponential Linear Unit).
+    
+    The activation function is defined as:
+    
+    .. math::
+        E_{i} =
+        scale *
+        \begin{cases}
+        x_{i}, &\text{if } x_{i} \geq 0; \cr
+        \text{alpha} * (\exp(x_i) - 1), &\text{otherwise.}
+        \end{cases}
+    
+    where :math:`alpha` and :math:`scale` are pre-defined constants(:math:`alpha=1.67326324`
+    and :math:`scale=1.05070098`).
+    
+    See more details in `Self-Normalizing Neural Networks <https://arxiv.org/abs/1706.02515>`_.
+    
+    SELU Activation Function Graph:
+    
+    .. image:: ../images/SeLU.png
+        :align: center
+    
+    Args:
+        input (Tensor): Tensor of any dimension.
+            The data type is float16, float32, bfloat16.
+    
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+    
+    Raises:
+        TypeError: If dtype of `input` is not float16, float32, bfloat16.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
+        >>> output = mint.nn.functional.selu(input)
+        >>> print(output)
+        [[-1.1113307 4.202804 -1.7575096]
+        [ 2.101402 -1.7462534 9.456309 ]]
+    """
+    return selu_impl(input)
+
+
 def softplus(input, beta=1, threshold=20):
     r"""
     Applies softplus function to `input` element-wise.
@@ -867,12 +1505,12 @@ def sub(input, other, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first 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.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `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>`_.
         other (Union[Tensor, number.Number, bool]): The second 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.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `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>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
     
     Returns:
@@ -978,3 +1616,86 @@ def topk(input, k, dim=-1, largest=True, sorted=True):
     """
     return topk_impl(input, k, dim, largest, sorted)
 
+
+def trace(input):
+    r"""
+    Returns a new tensor that is the sum of the `input` main trace.
+    
+    Note:
+        Input must be tensor.
+    
+    Args:
+        input (Tensor): 2-D Tensor.
+    
+    Returns:
+        Tensor, when the data type of `input` is integer or bool, its data type is int64, otherwise it is the same as `input`, and size equals to 1.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        ValueError: If the dimension of `input` is not equal to 2.
+        TypeError:  If the dtype of `input` is not one of float16, float32, float64, bool, uint8, int8, int16, int32, int64, complex64, complex128, bfloat16.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[10, 11, 12], [13, 14, 15], [16, 17, 18]]), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        42.0
+        >>> input = Tensor(np.arange(1, 13).reshape(3, 4), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        18.0
+        >>> input = Tensor(np.arange(12, 0, -1).reshape(4, 3), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        24.0
+    """
+    return trace_impl(input)
+
+
+def transpose(input, dim0, dim1):
+    r"""
+    Interchange two axes of a tensor.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input(Tensor): Input tensor.
+        dim0 (int): First axis.
+        dim1 (int): Second axis.
+    
+    Returns:
+        Transposed tensor, has the same data type as `input`.
+    
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: If `dim0` or `dim1` is not integer.
+        ValueError: If `dim0` or `dim1` is not in the range of :math:`[-ndim, ndim-1]`.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import mint
+        >>> from mindspore import Tensor
+        >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
+        >>> output = mint.transpose(input, 0, 2)
+        >>> print(output.shape)
+        (4, 3, 2)
+    """
+    return transpose_impl(input, dim0, dim1)
+
+
+def tril(input, diagonal=0):
+    r"""
+    None
+    """
+    return tril_impl(input, diagonal)
+