mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/nn/wrap/loss_scale.py

@@ -23,6 +23,7 @@ from mindspore.nn.cell import Cell
 from mindspore.common import Tensor
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.common.parameter import Parameter
+from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
 from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore.ops import operations as P
@@ -244,7 +245,7 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
             the shape should be :math:`()` or :math:`(1,)`.
 
     Inputs:
-        - **(*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tuple of 3 Tensor, the loss, overflow flag and current loss scale value.
@@ -255,7 +256,7 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
 
     Raises:
         TypeError: If `scale_sense` is neither Cell nor Tensor.
-        ValueError: If shape of `scale_sense` is neither (1,) nor ().
+        ValueError: If shape of `scale_sense` is neither :math:`(1,)` nor :math:`()`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -309,8 +310,11 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
         super(TrainOneStepWithLossScaleCell, self).__init__(network, optimizer, sens=None)
         self.hyper_map = C.HyperMap()
         self.base = Tensor(1, mstype.float32)
+        self.base0 = Tensor(0, mstype.int32)
         self.reduce_sum = P.ReduceSum(keep_dims=False)
+        self.reduce_any = P.ReduceAny(keep_dims=False)
         self.less_equal = P.LessEqual()
+        self.not_equal = P.NotEqual()
         self.allreduce = P.AllReduce()
         self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
         self.gpu_target = (context.get_context("device_target") == "GPU")
@@ -385,18 +389,17 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
               cleared before executing the computation.
 
         Returns:
-            Tuple[object, object], the first value is False for GPU backend, while it is an instance of
-            NPUAllocFloatStatus for other backend. The status is used to detect overflow during `get_overflow_status`.
-            The second value is the same as the input of `compute_input`, but contains some information about the
-            execution order.
+            Tuple[object, object], the first output is used to control the execution sequence. To ensure that the
+            `start_overflow_check` is executed before get_overflow_status after compilation optimization is performed.
+            This value should be used as the first input of get_overflow_status. The second output is the same as
+            the input of compute_input, used to control the execution sequence, and make ensure that the overflow flag
+            is cleaned up when the function returns.
         """
-        status = False
+        status = Tensor([0] * 8, mstype.int32)
         if not self.gpu_target:
-            # init overflow buffer
-            status = P.NPUAllocFloatStatus()()
             status = F.depend(status, pre_cond)
             # clear overflow buffer
-            clear_status = P.NPUClearFloatStatus()(status)
+            clear_status = NPUClearFloatStatusV2()(status)
             compute_input = F.depend(compute_input, clear_status)
         return status, compute_input
 
@@ -409,32 +412,45 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
         based on this class can also call this interface to process the overflow.
 
         Args:
-            status (object): A status instance used to detect the overflow.
-            compute_output: Overflow detection should be performed on a certain computation. Set `compute_output`
-              as the output of the computation, to ensure overflow `status` is acquired before executing the
-              computation.
+            status (object): To control the execution sequence with start_overflow_check, it should be set as the first
+              output of start_overflow_check.
+            compute_output: Overflow detection should be performed in a certain computation process. Set
+              `compute_output` as the output of the computation process.
 
         Returns:
             bool, whether the overflow occurs or not.
         """
         if not self.gpu_target:
             status = F.depend(status, compute_output)
-            get_status = P.NPUGetFloatStatus()(status)
-            status = F.depend(status, get_status)
-            # sum overflow buffer elements, 0:not overflow , >0:overflow
-            flag_sum = self.reduce_sum(status, (0,))
+            get_status = NPUGetFloatStatusV2()(status)
+
+            if self.is_distributed:
+                # sum overflow flag over devices
+                flag_reduce = self.allreduce(get_status)
+                # get_status not equal to [0]*8 means overflow
+                flag = self.not_equal(self.base0, flag_reduce)
+                status = F.depend(status, flag)
+                # distributed needs to skip allreduce to avoid its overflow affecting the next step
+                clear_status = NPUClearFloatStatusV2()(status)
+                flag = F.depend(flag, clear_status)
+            else:
+                status = F.depend(status, get_status)
+                clear_status = NPUClearFloatStatusV2()(status)
+                get_status = F.depend(get_status, clear_status)
+                flag = self.not_equal(self.base0, get_status)
+            overflow = self.reduce_any(flag)
         else:
             flag_sum = self.hyper_map(F.partial(_grad_overflow), compute_output)
             flag_sum = P.AddN()(flag_sum)
             # convert flag_sum to scalar
             flag_sum = P.Reshape()(flag_sum, (()))
 
-        if self.is_distributed:
-            # sum overflow flag over devices
-            flag_reduce = self.allreduce(flag_sum)
-            overflow = self.less_equal(self.base, flag_reduce)
-        else:
-            overflow = self.less_equal(self.base, flag_sum)
+            if self.is_distributed:
+                # sum overflow flag over devices
+                flag_reduce = self.allreduce(flag_sum)
+                overflow = self.less_equal(self.base, flag_reduce)
+            else:
+                overflow = self.less_equal(self.base, flag_sum)
         return overflow
 
     def process_loss_scale(self, overflow):

mindspore/numpy/array_creations.py

@@ -22,12 +22,14 @@ import operator
 import numpy as onp
 
 from mindspore import context
+from mindspore import ops
 from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 from mindspore.common.seed import get_seed
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore.ops.function.random_func import _get_seed
 from mindspore.nn.layer.basic import tril as nn_tril
 from mindspore.nn.layer.basic import triu as nn_triu
 from mindspore._c_expression import Tensor as Tensor_
@@ -454,7 +456,8 @@ def randn(*shape, dtype=mstype.float32):
     size = _generate_shapes(shape)
     seed = get_seed()
     if seed is not None:
-        stdnormal = P.StandardNormal(seed=seed)
+        seed1, seed2 = _get_seed(seed, "StandardNormal")
+        stdnormal = P.StandardNormal(seed=seed1, seed2=seed2)
     else:
         stdnormal = P.StandardNormal()
     return stdnormal(size).astype(dtype)
@@ -494,7 +497,8 @@ def rand(*shape, dtype=mstype.float32):
     size = _generate_shapes(shape)
     seed = get_seed()
     if seed is not None:
-        uniformreal = P.UniformReal(seed=seed)
+        seed1, seed2 = _get_seed(seed, "UniformReal")
+        uniformreal = P.UniformReal(seed=seed1, seed2=seed2)
     else:
         uniformreal = P.UniformReal()
     return uniformreal(size).astype(dtype)
@@ -563,7 +567,8 @@ def randint(minval, maxval=None, shape=None, dtype=mstype.int32):
         shape = _check_shape(shape)
     seed = get_seed()
     if seed is not None:
-        uniformint = P.UniformInt(seed=seed)
+        seed1, seed2 = _get_seed(seed, "UniformInt")
+        uniformint = P.UniformInt(seed=seed1, seed2=seed2)
     else:
         uniformint = P.UniformInt()
     t_min = _type_convert(Tensor, minval).astype(dtype)
@@ -971,12 +976,10 @@ def empty(shape, dtype=mstype.float32):
         >>> import mindspore.numpy as np
         >>> output = np.empty((2, 3))
         >>> print(output)
-        Tensor(shape=[2, 3], dtype=Float32, value=
-        <uninitialized>)
+        [[0. 0. 0.]
+         [0. 0. 0.]]
     """
-    shape = _check_shape(shape)
-    dtype = _check_dtype(dtype)
-    return empty_compile(dtype, shape)
+    return ops.zeros(shape, dtype)
 
 
 def _get_shape(array_like):
@@ -1042,8 +1045,10 @@ def empty_like(prototype, dtype=None, shape=None):
         >>> a = np.ones((4,1,2))
         >>> output = np.empty_like(a)
         >>> print(output)
-        Tensor(shape=[4, 1, 2], dtype=Float32, value=
-        <uninitialized>)
+        [[[0. 0.]]
+         [[0. 0.]]
+         [[0. 0.]]
+         [[0. 0.]]]
     """
     return _x_like(prototype, dtype, shape, empty)
 
@@ -1240,6 +1245,13 @@ def tril(m, k=0):
         m = asarray_const(m)
     dtype = m.dtype
     device_target = _device_target()
+    # check rank
+    rank = len(m.shape)
+    if rank < 1:
+        _raise_value_error("input m's rank should be larger than 0")
+    elif rank == 1:
+        mask = tri(m.shape[0], k=k, dtype=mstype.bool_)
+        return where(mask, m, zeros(1, m.dtype))
     # Only Ascend hardware will reduce accuracy
     if device_target == "Ascend":
         m = m.astype(mstype.float32)
@@ -1287,6 +1299,13 @@ def triu(m, k=0):
         m = asarray_const(m)
     dtype = m.dtype
     device_target = _device_target()
+    # check rank
+    rank = len(m.shape)
+    if rank < 1:
+        _raise_value_error("input m's rank should be larger than 0")
+    elif rank == 1:
+        mask = tri(m.shape[0], k=k-1, dtype=mstype.bool_)
+        return where(mask, zeros(1, m.dtype), m)
     # Only Ascend hardware will reduce accuracy
     if device_target == "Ascend":
         m = m.astype(mstype.float32)
@@ -1403,14 +1422,6 @@ def trace(a, offset=0, axis1=0, axis2=1, dtype=None):
         >>> output = np.trace(np.eye(3))
         >>> print(output)
         3.0
-        >>> a = np.arange(8).reshape((2,2,2))
-        >>> output = np.trace(a)
-        >>> print(output)
-        [6 8]
-        >>> a = np.arange(24).reshape((2,2,2,3))
-        >>> output = np.trace(a).shape
-        >>> print(output)
-        (2, 3)
     """
     return a.trace(offset=offset, axis1=axis1, axis2=axis2, dtype=dtype)
 
@@ -1565,7 +1576,7 @@ class NdGrid:
         if self.sparse:
             return grids
 
-        if isinstance(grids, Tensor_):
+        if isinstance(grids, (Tensor, Tensor_)):
             return grids
         expanded = []
         for grid in grids:
@@ -2564,13 +2575,13 @@ def _pad_func(arr, pad_width, func, **kwargs):
     return arr
 
 
-@constexpr
+@_primexpr
 def _make_stat_length(shape):
     """converts the stat_length values."""
     return tuple((shape[i], shape[i]) for i, _ in enumerate(shape))
 
 
-@constexpr
+@_primexpr
 def _limit_stat_length(stat_length, shape):
     """limits the stat_length to current array length along given dimension."""
     return tuple((min(stat_pair[0], shape[i]), min(stat_pair[1], shape[i])) for i, stat_pair in enumerate(stat_length))

mindspore/numpy/array_ops.py

@@ -18,11 +18,12 @@ from __future__ import absolute_import
 import operator
 
 from mindspore.common import dtype as mstype
-from mindspore.common import Tensor
+from mindspore.common import Tensor, mutable
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn import Cell
+from mindspore import ops
 
 from mindspore.numpy.utils import _convert_list_tensor_to_tuple_tensor, _expand, _broadcast_to_shape, \
     _check_input_tensor, _broadcast_to, _to_tensor, _callable
@@ -33,8 +34,6 @@ from mindspore.numpy.utils_const import _check_axes_range, _check_start_normaliz
     _list_comprehensions, _check_element_int, _is_shape_empty, _type_convert, \
     _tuple_slice, _expanded_shape, _seq_prod, _tuple_setitem, _iota, \
     _raise_unimplemented_error, _cumprod, _get_device, _check_is_int
-from mindspore.ops._utils.utils import is_shape_unknown
-from ..ops.operations._inner_ops import DynamicBroadcastTo
 
 
 # According to official numpy reference, the dimension of a numpy array must be less
@@ -328,7 +327,7 @@ def ravel(x):
     return x.ravel()
 
 
-@constexpr
+@_primexpr
 def _move_axes_for_concatenate(arr_shape, axis):
     """
     Moves axis 0 to the desiganated position, while keeps other axes' relative
@@ -711,8 +710,7 @@ def where(condition, x=None, y=None):
         x = F.cast(x, dtype)
     if not _check_same_type(dtype2, dtype):
         y = F.cast(y, dtype)
-    is_bool = _check_same_type(dtype1, mstype.bool_) and _check_same_type(
-        dtype2, mstype.bool_)
+    is_bool = _check_same_type(dtype1, mstype.bool_) and _check_same_type(dtype2, mstype.bool_)
     if is_bool:
         # select does not support bool type for x or y
         x = F.cast(x, mstype.float32)
@@ -721,7 +719,8 @@ def where(condition, x=None, y=None):
     if not _check_same_type(F.dtype(condition), mstype.float32):
         # tiling with bool is not supported on GPU
         condition = F.cast(condition, mstype.float32)
-    dynamic = is_shape_unknown(F.shape(condition)) or is_shape_unknown(F.shape(x)) or is_shape_unknown(F.shape(y))
+    dynamic = F.is_sequence_value_unknown(F.shape(condition)) or F.is_sequence_value_unknown(F.shape(x))\
+              or F.is_sequence_value_unknown(F.shape(y))
     # As select op currently does not support broadcast, broadcasts input tensors
     if not dynamic:
         shape_out = _infer_out_shape(F.shape(condition),
@@ -734,9 +733,9 @@ def where(condition, x=None, y=None):
         add_x_y = x + y
         add_out = condition + F.cast(add_x_y, condition.dtype)
         shape_out = P.TensorShape()(add_out)
-        condition = DynamicBroadcastTo()(condition, shape_out)
-        x = DynamicBroadcastTo()(x, shape_out)
-        y = DynamicBroadcastTo()(y, shape_out)
+        condition = ops.broadcast_to(condition, shape_out)
+        x = ops.broadcast_to(x, shape_out)
+        y = ops.broadcast_to(y, shape_out)
 
     if not _check_same_type(F.dtype(condition), mstype.bool_):
         condition = F.cast(condition, mstype.bool_)
@@ -1109,14 +1108,17 @@ def roll(a, shift, axis=None):
     return a
 
 
-@constexpr
+@_primexpr
 def _get_moved_perm(ndim, source, destination):
     """
     Helper function for moveaxis, returns permutation after moving axes
     from source to destination.
     """
     dest_sorted_idx = [i for i, _ in sorted(enumerate(destination), key=operator.itemgetter(1))]
-    axes_orig = [i for i in range(ndim) if i not in source]
+    axes_orig = mutable([], True)
+    for i in range(ndim):
+        if i not in source:
+            axes_orig = axes_orig + [i]
 
     k = 0
     m = 0
@@ -1135,7 +1137,7 @@ def _get_moved_perm(ndim, source, destination):
     return tuple(perm)
 
 
-@constexpr
+@_primexpr
 def _get_moved_shape(shape, perm):
     """
     Helper function for moveaxis, returns the permuated shape after
@@ -1245,7 +1247,7 @@ def tile(a, reps):
     return F.tile(a, reps)
 
 
-@constexpr
+@_primexpr
 def _check_can_broadcast_to(shape, target_shape):
     """Determines if shape can be broadcast to target_shape."""
     ndim = len(shape)
@@ -1284,9 +1286,11 @@ def broadcast_to(array, shape):
         [1 2 3]
         [1 2 3]]
     """
+    def _check(shape_a, shape):
+        if not _check_can_broadcast_to(shape_a, shape):
+            _raise_value_error('cannot broadcast with ', shape)
     shape_a = F.shape(array)
-    if not _check_can_broadcast_to(shape_a, shape):
-        return _raise_value_error('cannot broadcast with ', shape)
+    _check(shape_a, shape)
     return _broadcast_to_shape(array, shape)
 
 
@@ -1432,29 +1436,29 @@ def _split(x, indices_or_sections, opname, axis=0):
     """Splits a tensor based on ``np.split`` or ``np.array_split``."""
     _check_input_tensor(x)
     _ = _check_axis_type(axis, True, False, False)
-    axis = _canonicalize_axis(axis, x.ndim)
+    axis_new = _canonicalize_axis(axis, x.ndim)
     res = None
     arr_shape = x.shape
-    length_along_dim = arr_shape[axis]
+    length_along_dim = arr_shape[axis_new]
     if isinstance(indices_or_sections, int):
         if indices_or_sections > length_along_dim:
             _raise_value_error("empty tensor encountered.")
         if opname == "split" or length_along_dim % indices_or_sections == 0:
-            res = P.Split(axis, indices_or_sections)(x)
+            res = P.Split(axis_new, indices_or_sections)(x)
         else:
             num_long_tensor = length_along_dim % indices_or_sections
             num_short_tensor = indices_or_sections - num_long_tensor
             length1 = num_long_tensor * (length_along_dim // indices_or_sections + 1)
             length2 = length_along_dim - length1
             start1 = _list_comprehensions(F.rank(x), 0, True)
-            size1 = _tuple_setitem(arr_shape, axis, length1)
-            start2 = _tuple_setitem(start1, axis, length1)
-            size2 = _tuple_setitem(arr_shape, axis, length2)
-            res = P.Split(axis, num_long_tensor)(F.tensor_slice(x, start1, size1)) + \
-                P.Split(axis, num_short_tensor)(F.tensor_slice(x, start2, size2))
+            size1 = _tuple_setitem(arr_shape, axis_new, length1)
+            start2 = _tuple_setitem(start1, axis_new, length1)
+            size2 = _tuple_setitem(arr_shape, axis_new, length2)
+            res = P.Split(axis_new, num_long_tensor)(F.tensor_slice(x, start1, size1)) + \
+                P.Split(axis_new, num_short_tensor)(F.tensor_slice(x, start2, size2))
 
     elif isinstance(indices_or_sections, (list, tuple)) and _check_element_int(indices_or_sections):
-        res = _split_sub_tensors(x, indices_or_sections, axis)
+        res = _split_sub_tensors(x, indices_or_sections, axis_new)
     else:
         _raise_type_error("Argument `indices_or_sections` in `mindspore.numpy.split`\
             should be integer, tuple(int) or list(int), but got", indices_or_sections)
@@ -1625,17 +1629,17 @@ def dsplit(x, indices_or_sections):
     return split(x, indices_or_sections, 2)
 
 
-@constexpr
+@_primexpr
 def _get_flip_start(ndim, shape, axes):
     return tuple([shape[i] - 1 if i in axes else 0 for i in range(ndim)])
 
 
-@constexpr
+@_primexpr
 def _get_flip_end(ndim, shape, axes):
     return tuple([-shape[i] - 1 if i in axes else shape[i] + 1 for i in range(ndim)])
 
 
-@constexpr
+@_primexpr
 def _get_flip_strides(ndim, axes):
     return tuple([-1 if i in axes else 1 for i in range(ndim)])
 
@@ -1809,6 +1813,7 @@ def take_along_axis(arr, indices, axis):
                             _tuple_slice(shape_arr, None, axis), ndim)
     indices = _broadcast_to(indices, _tuple_slice(shape_arr, None, axis + 1) +
                             _tuple_slice(shape_indices, axis + 1, None), shape_arr, ndim)
+    arr = _broadcast_to(arr, shape_arr, indices.shape, ndim)
     return F.gather_d(arr, axis, indices)
 
 
@@ -2087,7 +2092,7 @@ def select(condlist, choicelist, default=0):
     return F.reshape(default_slice, (case_size)).astype(dtype)
 
 
-@constexpr
+@_primexpr
 def _get_grid(shape):
     """Returns a grid representing all the indices for an array with the given shape."""
     grids = []

mindspore/numpy/logic_ops.py

@@ -18,11 +18,12 @@ from __future__ import absolute_import
 from mindspore.ops import functional as F
 from mindspore.common import dtype as mstype
 from mindspore.common import Tensor
+from mindspore.ops import operations as P
 
-from mindspore.numpy.math_ops import _apply_tensor_op, absolute
-from mindspore.numpy.array_creations import zeros, ones, empty, asarray
+from mindspore.numpy.math_ops import _apply_tensor_op
+from mindspore.numpy.array_creations import zeros, ones, asarray
 from mindspore.numpy.utils import _check_input_tensor, _to_tensor, _isnan
-from mindspore.numpy.utils_const import _raise_type_error, _is_shape_empty, _infer_out_shape, _check_same_type, \
+from mindspore.numpy.utils_const import _raise_type_error, _check_same_type, \
     _check_axis_type, _canonicalize_axis, _can_broadcast, _isscalar
 
 
@@ -490,30 +491,8 @@ def isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False):
         [ True  True False False  True  True]
     """
     a, b = _to_tensor(a, b)
-    if not isinstance(rtol, (int, float, bool)) or not isinstance(atol, (int, float, bool)):
-        _raise_type_error("rtol and atol are expected to be numbers.")
-    if not isinstance(equal_nan, bool):
-        _raise_type_error("equal_nan is expected to be bool.")
-
-    if _is_shape_empty(a.shape) or _is_shape_empty(b.shape):
-        return empty(_infer_out_shape(a.shape, b.shape), dtype=mstype.bool_)
-    rtol = _to_tensor(rtol).astype("float32")
-    atol = _to_tensor(atol).astype("float32")
-    res = absolute(a - b) <= (atol + rtol * absolute(b))
-    # infs are treated as equal
-    a_posinf = isposinf(a)
-    b_posinf = isposinf(b)
-    a_neginf = isneginf(a)
-    b_neginf = isneginf(b)
-    same_inf = F.logical_or(F.logical_and(a_posinf, b_posinf), F.logical_and(a_neginf, b_neginf))
-    diff_inf = F.logical_or(F.logical_and(a_posinf, b_neginf), F.logical_and(a_neginf, b_posinf))
-    res = F.logical_and(F.logical_or(res, same_inf), F.logical_not(diff_inf))
-    both_nan = F.logical_and(_isnan(a), _isnan(b))
-    if equal_nan:
-        res = F.logical_or(both_nan, res)
-    else:
-        res = F.logical_and(F.logical_not(both_nan), res)
-    return res
+    is_close = P.IsClose(rtol=rtol, atol=atol, equal_nan=equal_nan)
+    return is_close(a, b)
 
 
 def in1d(ar1, ar2, invert=False):

mindspore/numpy/math_ops.py

@@ -25,7 +25,7 @@ from numpy import dtype as nptype
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.ops import composite as C
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.common import dtype as mstype
 from mindspore.common import Tensor
 from mindspore._c_expression import typing
@@ -47,6 +47,7 @@ from mindspore.numpy.utils_const import _infer_out_shape, _check_axis_valid, _ge
     _raise_unimplemented_error, _abs, _in, _tuple_slice, _check_is_inf
 from mindspore.numpy.utils import _expand, _broadcast_to, _broadcast_to_shape, _check_input_tensor, \
     _to_tensor, _to_tensor_origin_dtype, _isnan
+from mindspore.ops.composite.multitype_ops._compile_utils import reduce_
 
 
 ZERO_TENSOR = asarray_const(0)
@@ -1439,7 +1440,8 @@ def amax(a, axis=None, keepdims=False, initial=None, where=True):
         >>> print(output)
         [-1.  3.]
     """
-    return a.max(axis, keepdims, initial, where)
+    return reduce_(a, P.ReduceMax(keepdims), cmp_fn=F.maximum, axis=axis, keepdims=keepdims,
+                   initial=initial, where=where)
 
 
 def amin(a, axis=None, keepdims=False, initial=None, where=True):
@@ -1494,7 +1496,8 @@ def amin(a, axis=None, keepdims=False, initial=None, where=True):
         >>> print(output)
         [10.  1.]
     """
-    return a.min(axis, keepdims, initial, where)
+    return reduce_(a, P.ReduceMin(keepdims), cmp_fn=F.minimum, axis=axis, keepdims=keepdims,
+                   initial=initial, where=where)
 
 
 def hypot(x1, x2, dtype=None):
@@ -1915,7 +1918,7 @@ def diff(a, n=1, axis=-1, prepend=None, append=None):
         prepend/append (Tensor, optional): Values to prepend or append to a along
             `axis` prior to performing the difference. Scalar values are expanded to
             arrays with length 1 in the direction of `axis` and the shape of the input
-            array in along all other axis. Otherwise the dimension and shape must
+            array in along all other axes. Otherwise the dimension and shape must
             match `a` except along axis. Default: `None`.
 
     Returns:
@@ -1939,7 +1942,7 @@ def diff(a, n=1, axis=-1, prepend=None, append=None):
     """
     # This implementation is inspired by jax.numpy
     _check_input_tensor(a)
-    axis = _canonicalize_axis(axis, a.ndim)
+    new_axis = _canonicalize_axis(axis, a.ndim)
     if not isinstance(n, int):
         _raise_type_error("Input n should be int, but got ", n)
     if n < 0:
@@ -1957,17 +1960,17 @@ def diff(a, n=1, axis=-1, prepend=None, append=None):
         combined = _handle_prepend_append(combined, a, append, axis)
 
     if combined:
-        a = concatenate(combined, axis)
+        a = concatenate(combined, new_axis)
 
     # if n > maximum length allowed, the tensor is empty, and is not supported
-    if n >= a.shape[axis]:
+    if n >= a.shape[new_axis]:
         _raise_value_error("n is bigger then the specified dimension, this will result in an empty tensor.")
 
     original_dtype = a.dtype
     # will change once F.tensor_slice supports types other than float32
     if not _check_is_float(original_dtype):
         a = a.astype(mstype.float32)
-    a = moveaxis(a, axis, -1)
+    a = moveaxis(a, new_axis, -1)
     for _ in F.make_range(n):
         slice_start = _list_comprehensions(F.rank(a) - 1, 0, True)
         slice_size = F.shape(a)[:-1] + (F.shape(a)[-1] - 1,)
@@ -1976,7 +1979,7 @@ def diff(a, n=1, axis=-1, prepend=None, append=None):
         a = F.tensor_sub(minuend, subtrahend)
     if not _check_is_float(original_dtype):
         a = a.astype(original_dtype)
-    return moveaxis(a, -1, axis)
+    return moveaxis(a, -1, new_axis)
 
 
 def ediff1d(ary, to_end=None, to_begin=None):
@@ -2407,7 +2410,7 @@ def _real_axes(ndim_orig, ndim_out, axes_orig):
     return axes + tuple(axes_orig)
 
 
-@constexpr
+@_primexpr
 def _shape_reduced_keepdims(shape, axes):
     """
     Reduces dimensions corresponding to argument axes while
@@ -2421,7 +2424,7 @@ def _shape_reduced_keepdims(shape, axes):
     return tuple(shape_out)
 
 
-@constexpr
+@_primexpr
 def _shape_reduced(shape, axes):
     """Removes dimensions corresponding to argument axes"""
     ndim_orig = F.tuple_len(shape)
@@ -3544,7 +3547,7 @@ def arcsin(x, dtype=None):
     return _apply_tensor_op(F.asin, x, dtype=dtype)
 
 
-def arccos(x, dtype=None):
+def arccos(input, dtype=None):
     """
     Trigonometric inverse cosine, element-wise.
 
@@ -3553,7 +3556,7 @@ def arccos(x, dtype=None):
         not supported.
 
     Args:
-        x (Tensor): Input tensor. x-coordinate on the unit circle.
+        input (Tensor): Input tensor. x-coordinate on the unit circle.
             For real arguments, the domain is :math:`[-1, 1]`.
         dtype (:class:`mindspore.dtype`, optional): Default: :class:`None`. Overrides the dtype of the
             output Tensor.
@@ -3569,13 +3572,13 @@ def arccos(x, dtype=None):
 
     Examples:
         >>> import mindspore.numpy as np
-        >>> x = np.asarray([1, -1], np.float32)
-        >>> output = np.arccos(x)
+        >>> input = np.asarray([1, -1], np.float32)
+        >>> output = np.arccos(input)
         >>> print(output)
         [0.        3.1415927]
     """
-    x = _cast_type_for_trigonometric(x)
-    return _apply_tensor_op(F.acos, x, dtype=dtype)
+    input = _cast_type_for_trigonometric(input)
+    return _apply_tensor_op(F.acos, input, dtype=dtype)
 
 
 def arctan(x, dtype=None):
@@ -3802,7 +3805,7 @@ def arctan2(x1, x2, dtype=None):
         if both `x1` and `x2` are scalars.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore.numpy as np
@@ -4112,7 +4115,7 @@ def _min_cost_chain_matmul(dims):
     return s
 
 
-@constexpr
+@_primexpr
 def _get_dims(shapes):
     """
     Returns the chain of the dimensions in arrays.

mindspore/numpy/utils.py

@@ -206,6 +206,6 @@ def _callable(tensor, obj):
 
 
 def _isnan(x):
-    if _get_device() == 'Ascend' or not _check_is_float(F.dtype(x)):
+    if _get_device() == 'Ascend' and not _check_is_float(F.dtype(x)):
         return F.fill(mstype.bool_, F.shape(x), False)
     return F.isnan(x)