mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/function/clip_func.py

@@ -248,7 +248,7 @@ def clamp(input, min=None, max=None):
           max (Union(Tensor, float, int), optional): The maximum value. Default: ``None`` .
 
     Returns:
-          Tensor, a clipped Tensor.
+          Union(Tensor), a clipped Tensor.
           The data type and shape are the same as input.
 
     Raises:

mindspore/ops/function/grad/grad_func.py

@@ -483,7 +483,7 @@ def jet(fn, primals, series):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -593,7 +593,7 @@ def derivative(fn, primals, order):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -1388,7 +1388,7 @@ def stop_gradient(value):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
         >>> def net(x, y):

mindspore/ops/function/math_func.py

@@ -43,8 +43,8 @@ from mindspore.ops.auto_generate import (minimum, maximum, mul, sin, sinc, sinh,
                                          matrix_exp, sqrt, rsqrt, square, trace, nextafter, abs, acos, acosh, angle,
                                          asin, asinh, atan, atan2, atanh, ceil, equal, erf, erfc, erfinv, exp, expm1,
                                          floor, floor_divide, floor_mod, gcd, greater, greater_equal, less, less_equal,
-                                         log, log1p, neg, not_equal, pow, round, isfinite, argmax_ext, mean_ext_op,
-                                         sum_ext_op, prod_ext_op, all, matrix_inverse_ext, atan2_ext, sign)
+                                         log, log1p, neg, not_equal, pow, round, isfinite, argmax, mean_ext_op,
+                                         sum_ext_op, prod_ext_op, all)
 from mindspore.ops.auto_generate import tanh
 from mindspore.nn import layer
 from mindspore._checkparam import check_is_number
@@ -131,8 +131,6 @@ pows = tensor_pow
 tensor_sub = P.Sub()
 transpose_ = P.Transpose()
 xdivy_ = P.Xdivy()
-tensor_div_ = P.Div()
-tensor_divmod_ = DivMod()
 
 #####################################
 # Private Operation Functions.
@@ -762,9 +760,9 @@ def div(input, other, *, rounding_mode=None):
     if rounding_mode is not None and rounding_mode not in ['floor', 'trunc']:
         raise ValueError("For ops.div, rounding_mode value should be None, 'floor' or 'trunc'.")
     if rounding_mode:
-        output = tensor_divmod_(input, other, rounding_mode)
+        output = DivMod()(input, other, rounding_mode)
     else:
-        output = tensor_div_(input, other)
+        output = P.Div()(input, other)
     return output
 
 
@@ -1263,6 +1261,49 @@ def logical_and(input, other):
     return logical_and_(input, other)
 
 
+def sign(input):
+    r"""
+    Returns an element-wise indication of the sign of a number.
+
+    .. math::
+        \text{out}_{i} = \begin{cases}
+                          -1 & \text{input}_{i} < 0 \\
+                           0 & \text{input}_{i} = 0 \\
+                           1 & \text{input}_{i} > 0
+                         \end{cases}
+
+    Args:
+        input (Tensor): Input Tensor.
+
+    Returns:
+        Tensor, the sign of input.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import mindspore.ops as ops
+        >>> input = ms.Tensor([[-1, 0, 2, 4, 6], [2, 3, 5, -6, 0]])
+        >>> output = ops.sign(input)
+        >>> print(output)
+        [[-1  0  1  1  1]
+         [ 1  1  1 -1  0]]
+        >>> ms.set_context(device_target="CPU")
+        >>> x = ms.Tensor([[-1, 0, float('inf'), 4, float('nan')], [2, 3, float('-inf'), -6, 0]])
+        >>> output = ops.sign(x)
+        >>> print(output)
+        [[-1.  0.  1.  1.  0.]
+         [ 1.  1. -1. -1.  0.]]
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f"For sign, the input must be a Tensor, but got {type(input)}")
+    return sign_(input)
+
+
 def signbit(input):
     r"""
     Determine the symbol of each element. If the element value is less than 0,
@@ -1282,7 +1323,7 @@ def signbit(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> input = ms.Tensor([0.3, 1.2, 0., -2.5])
         >>> output = ops.signbit(input)
         >>> print(output)
@@ -1320,7 +1361,7 @@ def sgn(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> input = ms.Tensor([[3 + 4j, 7 - 24j, 0, 6 + 8j, 8], [15 + 20j, 7 - 24j, 0, 3 + 4j, 20]], dtype=ms.complex64)
         >>> output = ops.sgn(input)
         >>> print(output)
@@ -1336,7 +1377,7 @@ def sgn(input):
     non_zero_modulus = ops.masked_fill(modulus, zeros_mask, ops.cast(1, modulus.dtype))
     zeros_modulus = ops.zeros_like(non_zero_modulus)
     complex_modulus = ops.Complex()(non_zero_modulus, zeros_modulus)
-    res = tensor_div(input, complex_modulus)
+    res = input / complex_modulus
     return res
 
 
@@ -1367,7 +1408,7 @@ def cosine_similarity(x1, x2, dim=1, eps=1e-08):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x1 = ms.Tensor([[-0.0256, 0.0127, -0.2475, 0.2316, 0.8037],
         ...                 [0.5809, -1.2712, -0.7038, -0.2558, 0.7494]], dtype=ms.float32)
         >>> x2 = ms.Tensor([[-0.6115, -0.1965, -0.8484, 0.2389, 0.2409],
@@ -1469,7 +1510,7 @@ def cov(input, *, correction=1, fweights=None, aweights=None):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x = ms.Tensor([[0., 3.], [5., 5.], [7., 0.]]).T
         >>> print(x)
         [[0. 5. 7.]
@@ -1714,26 +1755,6 @@ def arctan2(input, other):
     return atan2_(input, other)
 
 
-def arctan2_ext(input, other):
-    r"""
-    Alias for :func:`mindspore.ops.atan2_ext`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> x = Tensor(np.array([0, 1]), mindspore.float32)
-        >>> y = Tensor(np.array([1, 1]), mindspore.float32)
-        >>> output = ops.arctan2_ext(x, y)
-        >>> print(output)
-        [0.        0.7853982]
-    """
-    return atan2_ext(input, other)
-
-
 def polar(abs, angle):  # pylint: disable=redefined-outer-name
     r"""
     Converts polar coordinates to Cartesian coordinates.
@@ -2073,7 +2094,7 @@ def inverse(input):
 
     Args:
         input (Tensor): A matrix to be calculated. Input `input` must be at least two dimensions, and the size of
-            the last two dimensions must be the same size. And the matrix must be invertible.
+            the last two dimensions must be the same size.
 
     Returns:
         Tensor, has the same type and shape as input `input`.
@@ -2098,36 +2119,6 @@ def inverse(input):
     return matrix_inverse_(input)
 
 
-def inverse_ext(input):
-    """
-    Compute the inverse of the input matrix.
-
-    Args:
-        input (Tensor): A matrix to be calculated. Input `input` must be at least two dimensions, and the size of
-            the last two dimensions must be the same size. And the matrix must be invertible.
-
-    Returns:
-        Tensor, has the same type and shape as input `input`.
-
-    Raises:
-        ValueError: If the size of the last two dimensions of `input` is not the same.
-        ValueError: If `input` is not empty and its dimensions are less than 2.
-        ValueError: If the dimensions of `input` are larger than 6.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> x = Tensor([[1., 2.], [3., 4.]], mstype.float32)
-        >>> print(ops.inverse_ext(x))
-        [[-2.   1. ]
-         [ 1.5 -0.5]]
-    """
-    return matrix_inverse_ext(input)
-
-
 def invert(x):
     r"""
     Flips all bits of input tensor element-wise.
@@ -2582,7 +2573,7 @@ def linspace_ext(start, end, steps, *, dtype=None):
         >>> start = Tensor(1, mindspore.float32)
         >>> end = Tensor(10, mindspore.float32)
         >>> steps = 5
-        >>> output = ops.function.math_func.linspace_ext(start, end, steps, dtype=mindspore.float32)
+        >>> output = ops.linspace_ext(start, end, steps, dtype=mindspore.float32)
         >>> print(output)
         [ 1.    3.25  5.5   7.75 10.  ]
     """
@@ -3174,7 +3165,6 @@ def eq(input, other):
 
     Note:
         - `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
-        - The input must be two Tensors, or a Tensor and a Scalar.
         - The shapes of the inputs can be broadcasted to each other.
 
     Args:
@@ -3359,24 +3349,23 @@ def isclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False):
         |input-other| ≤ atol + rtol × |other|
 
     Args:
-        input (Tensor): First tensor to compare.
-            Support dtype: float16, float32, float64, int8, int16, int32, int64 and uint8.
-            On Ascend, more dtypes are support: bool and bfloat16.
-        other (Tensor): Second tensor to compare. Dtype must be same as `input`.
-        rtol (Union[float, int, bool], optional): Relative tolerance. Default: ``1e-05`` .
-        atol (Union[float, int, bool], optional): Absolute tolerance. Default: ``1e-08`` .
-        equal_nan (bool, optional): If ``True`` , then two NaNs will be considered equal. Default: ``False``.
+        input (Tensor): First Tensor to compare, with data type belongs to float32, float16, int32.
+        other (Tensor): Second Tensor to compare, with data type belongs to float32, float16, int32.
+        rtol (float, optional): Relative tolerance. Default: ``1e-05`` .
+        atol (float, optional): Absolute tolerance. Default: ``1e-08`` .
+        equal_nan (bool, optional): If True, then two NaNs will be considered equal. Default: ``False`` .
 
     Returns:
         A bool Tensor, with the shape as broadcasted result of the input `input` and `other`.
 
     Raises:
-        TypeError: `input` or `other` is not Tensor.
-        TypeError: `input` or `other` dtype is not support.
-        TypeError: `atol` or `rtol` is not float, int or bool.
-        TypeError: `equal_nan` is not bool.
-        TypeError: `input` and `other` have different dtypes.
-        ValueError: `input` and `other` cannot broadcast.
+        TypeError: If either of `input` and `other` is not Tensor.
+        TypeError: If either of `input` and `other` is not float16, float32 or int32.
+        TypeError: If either of `atol` and `rtol` is not float.
+        TypeError: If `equal_nan` is not bool.
+        TypeError: If the dtype of `input` is not same as the `other`.
+        ValueError: If `input` and `other` can not be broadcast.
+        ValueError: If either of `atol` and `rtol` is less than zero.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4481,7 +4470,7 @@ def reciprocal(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> input = ms.Tensor(np.array([1.0, 2.0, 4.0]), ms.float32)
         >>> output = ops.reciprocal(input)
@@ -5008,7 +4997,7 @@ def bernoulli(input, p=0.5, seed=None):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int8)
         >>> output = ops.bernoulli(input_x, p=1.0)
         >>> print(output)
@@ -5245,7 +5234,7 @@ def rad2deg(x):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x = Tensor([[6.283, -3.142],[1.570, -6.283],[3.142, -1.570]], mindspore.float32)
         >>> output = ops.rad2deg(x)
         >>> print(output)
@@ -5285,7 +5274,7 @@ def frac(x):
         >>> import mindspore
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x = Tensor([2, 4.2, -2.5], mstype.float16)
         >>> output = ops.frac(x)
         >>> print(output)
@@ -5406,7 +5395,7 @@ def cumsum(x, axis, dtype=None):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
         >>> # case 1: along the axis 0
         >>> y = ops.cumsum(x, 0)
@@ -6243,7 +6232,7 @@ def copysign(x, other):
 
     Examples:
         >>> import mindspore.numpy as np
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> x = np.array([[0.3, -0.7], [0.5, 0.5]])
         >>> other = np.array([[-0.4, 0.6], [0.4, -0.6]])
         >>> out = ops.copysign(x, other)
@@ -6389,7 +6378,7 @@ def logcumsumexp(input, axis):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> x = ms.Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
         >>> output = ops.logcumsumexp(x, 0)
@@ -6661,15 +6650,11 @@ def mean(x, axis=None, keep_dims=False):
     And reduce a dimension of `x` along the specified `axis`. `keep_dims`
     determines whether the dimensions of the output and input are the same.
 
-    Note:
-        The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
-
     Args:
         x (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
           :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        axis (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce. Default: ``None`` ,
-            reduce all dimensions. Only constant value is allowed. Assume the rank of `x` is r,
-            and the value range is [-r,r).
+        axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Default: ``None`` , reduce all dimensions.
+          Only constant value is allowed. Assume the rank of `x` is r, and the value range is [-r,r).
         keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
                           If false, don't keep these dimensions. Default: ``False`` .
 
@@ -6685,7 +6670,7 @@ def mean(x, axis=None, keep_dims=False):
 
     Raises:
         TypeError: If `x` is not a Tensor.
-        TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
+        TypeError: If `axis` is not one of the following: int, tuple or list.
         TypeError: If `keep_dims` is not a bool.
         ValueError: If `axis` is out of range.
 
@@ -6761,19 +6746,19 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
 
     Returns:
-        Tensor, has the same data type as the `input`.
+        Tensor, has the same data type as input tensor.
 
         - If `axis` is ``None`` , and `keep_dims` is ``False`` ,
-          the output is a 0-D tensor representing the product of all elements in the input tensor.
+            the output is a 0-D tensor representing the product of all elements in the input tensor.
         - If `axis` is int, set as 1, and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(input_0, input_2, ..., input_R)`.
+            the shape of output is :math:`(x_0, x_2, ..., x_R)`.
         - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(input_0, input_3, ..., input_R)`.
+            the shape of output is :math:`(x_0, x_3, ..., x_R)`.
         - If `axis` is 1-D Tensor, set as [1, 2], and `keep_dims` is ``False`` ,
-          the shape of output is :math:`(input_0, input_3, ..., input_R)`.
+            the shape of output is :math:`(x_0, x_3, ..., x_R)`.
 
     Raises:
-        TypeError: If `input` is not a Tensor.
+        TypeError: If `x` is not a Tensor.
         TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
         TypeError: If `keep_dims` is not a bool.
         ValueError: If `axis` is out of range.
@@ -6786,7 +6771,7 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = ops.function.math_func.mean_ext(x, 1, keep_dims=True)
+        >>> output = ops.mean(x, 1, keep_dims=True)
         >>> result = output.shape
         >>> print(result)
         (3, 1, 5, 6)
@@ -6795,25 +6780,25 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
         ... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
         ... mindspore.float32)
-        >>> output = ops.function.math_func.mean_ext(x)
+        >>> output = ops.mean(x)
         >>> print(output)
         5.0
         >>> print(output.shape)
         ()
         >>> # case 2: Reduces a dimension along the axis 0
-        >>> output = ops.function.math_func.mean_ext(x, 0, True)
+        >>> output = ops.mean(x, 0, True)
         >>> print(output)
         [[[4. 4. 4. 4. 4. 4.]
         [5. 5. 5. 5. 5. 5.]
         [6. 6. 6. 6. 6. 6.]]]
         >>> # case 3: Reduces a dimension along the axis 1
-        >>> output = ops.function.math_func.mean_ext(x, 1, True)
+        >>> output = ops.mean(x, 1, True)
         >>> print(output)
         [[[2. 2. 2. 2. 2. 2.]]
         [[5. 5. 5. 5. 5. 5.]]
         [[8. 8. 8. 8. 8. 8.]]]
         >>> # case 4: Reduces a dimension along the axis 2
-        >>> output = ops.function.math_func.mean_ext(x, 2, True)
+        >>> output = ops.mean(x, 2, True)
         >>> print(output)
         [[[ 2.]
         [ 2.]
@@ -6847,7 +6832,7 @@ def prod(input, axis=None, keep_dims=False, dtype=None):
         dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
 
     Returns:
-        Tensor, has the same data type as the `input`.
+        Tensor, has the same data type as input tensor.
 
         - If `axis` is ``None`` , and `keep_dims` is ``False`` ,
           the output is a 0-D tensor representing the product of all elements in the input tensor.
@@ -7072,7 +7057,7 @@ def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> data_range = ops.arange(-13, 13, dtype=ms.float32)
         >>> # Exclude 0 from original data for 0 is invalid input when `ord` is negative.
         >>> x = data_range[data_range != 0]
@@ -7336,16 +7321,16 @@ def norm_ext(A, ord=None, dim=None, keepdim=False, *, dtype=None):
         ``Ascend``
 
     Note:
-        Currently, it only support `ops.function.math_func.norm_ext(A)`.
+        Currently, it only support `ops.norm_ext(A)`.
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> data_range = ops.arange(-13, 13, dtype=ms.float32)
         >>> # Exclude 0 from original data for 0 is invalid input when `ord` is negative.
         >>> x = data_range[data_range != 0]
         >>> y = x.reshape(5, 5)
-        >>> print(ops.function.math_func.norm_ext(x))
+        >>> print(ops.norm_ext(x))
         38.327538
         >>> print(ops.norm(x, 0))
         25.0
@@ -7761,11 +7746,6 @@ def gumbel_softmax(logits, tau=1.0, hard=False, dim=-1):
     _check_logits_shape(logits)
     logits_dtype = dtype_(logits)
     _check_input_dtype("logits", logits_dtype, [mstype.float16, mstype.float32], "gumbel_softmax")
-    valid_types = [mstype.float16, mstype.float32]
-    if logits_dtype not in valid_types:
-        names = [t.__name__ if hasattr(t, "__name__") else t for t in valid_types]
-        logits_dtype = logits_dtype.__name__ if hasattr(logits_dtype, '__name__') else repr(logits_dtype)
-        raise TypeError(f"For 'gumbel_softmax', the 'logits' should be one of '{names}', but got type '{logits_dtype}'")
     _check_attr_dtype("tau", tau, [float], "gumbel_softmax")
     _check_attr_dtype("hard", hard, [bool], "gumbel_softmax")
     _check_attr_dtype("dim", dim, [int], "gumbel_softmax")
@@ -8054,6 +8034,8 @@ def matmul(input, other):
     Note:
         Numpy arguments `out`, `casting`, `order`, `subok`, `signature`, and `extobj` are
         not supported.
+        On GPU, the supported dtypes are np.float16 and np.float32.
+        On CPU, the supported dtypes are np.float16 and np.float32.
         The dtype of `input` and `other` must be same.
         On Ascend, the rank of `input` or `other` must be between 1 and 6.
 
@@ -8074,7 +8056,7 @@ def matmul(input, other):
         ValueError: If the last dimension of `input` is not the same size as the
             second-to-last dimension of `other`, or if a scalar value is passed in.
         ValueError: If the shape of `input` and `input` could not broadcast together.
-        RuntimeError: If the rank of `input` or `other` is less than 1 or greater than 6 on the Ascend platform.
+        RuntimeError: If the rank of `input` or `other` is less than 1 or greater than 6.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -8561,7 +8543,7 @@ def roll(input, shifts, dims=None):
     Examples:
         >>> import numpy as np
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> input_x = Tensor(np.array([0, 1, 2, 3, 4]).astype(np.float32))
         >>> output = ops.roll(input_x, shifts=2, dims=0)
@@ -10105,7 +10087,7 @@ def sum(input, dim=None, keepdim=False, *, dtype=None):
         dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
 
     Returns:
-        A Tensor, sum of elements over a given dim in `input`.
+       A Tensor, sum of elements over a given `dim` in `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
@@ -10156,7 +10138,7 @@ def tanhshrink(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> import numpy as np
         >>> input = Tensor(np.array([1, 2, 3, 2, 1]), ms.float16)
@@ -10168,7 +10150,7 @@ def tanhshrink(input):
         raise TypeError(f"For tanhshrink, the input must be a Tensor, but got {type(input)}.")
 
     if input.dtype in mstype.int_type + mstype.uint_type:
-        input = input.astype(mstype.float32)
+        input = input.astype(mstype.float64)
     return input - tanh_(input)
 
 
@@ -11609,6 +11591,7 @@ __all__ = [
     'addcdiv',
     'addcmul',
     'angle',
+    'argmax',
     'argmin',
     'arccosh',
     'arcsin',
@@ -11626,6 +11609,7 @@ __all__ = [
     'le',
     'lerp',
     'norm',
+    'norm_ext',
     'vector_norm',
     'matrix_norm',
     'tensor_gt',
@@ -11695,6 +11679,7 @@ __all__ = [
     'matrix_determinant',
     'det',
     'linspace',
+    'linspace_ext',
     'logspace',
     'lu_solve',
     'matrix_solve',
@@ -11782,6 +11767,7 @@ __all__ = [
     'amin',
     'amax',
     'mean',
+    'mean_ext',
     'prod',
     'all',
     'any',