mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/numpy/array_ops.py

@@ -18,14 +18,15 @@ 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, _dyn_infer_out_shape
+    _check_input_tensor, _broadcast_to, _to_tensor, _callable
 from mindspore.numpy.utils_const import _check_axes_range, _check_start_normalize, \
     _raise_type_error, _raise_value_error, _infer_out_shape, _empty, _promote, \
     _check_same_type, _check_axis_valid, _add_unit_axes, _broadcast_tuples, \
@@ -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,8 +719,9 @@ 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))
-    # broadcasts input tensors
+    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),
                                      F.shape(x), F.shape(y))
@@ -730,13 +729,13 @@ def where(condition, x=None, y=None):
         x = _broadcast_to_shape(x, shape_out)
         y = _broadcast_to_shape(y, shape_out)
     else:
-        dyn_shapes = []
-        for tensor in [condition, x, y]:
-            dyn_shapes.append(P.TensorShape()(tensor))
-        shape_out = _dyn_infer_out_shape(dyn_shapes)
-        condition = DynamicBroadcastTo()(condition, shape_out)
-        x = DynamicBroadcastTo()(x, shape_out)
-        y = DynamicBroadcastTo()(y, shape_out)
+        # Get the broadcast shape through broadcast calculation
+        add_x_y = x + y
+        add_out = condition + F.cast(add_x_y, condition.dtype)
+        shape_out = P.TensorShape()(add_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_)
@@ -1105,19 +1104,21 @@ def roll(a, shift, axis=None):
         a = a.reshape(original_shape)
     if not _check_is_float(original_dtype):
         if not original_dtype in (mstype.complex64, mstype.complex128):
-            a = a.astype(mstype.float32)
+            a = a.astype(original_dtype)
     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]
+    dest_sorted_idx = [i for i, _ in sorted(enumerate(destination), key=operator.itemgetter(1))]
+    axes_orig = mutable([], True)
+    for i in range(ndim):
+        if i not in source:
+            axes_orig = axes_orig + [i]
 
     k = 0
     m = 0
@@ -1136,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
@@ -1246,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)
@@ -1285,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)
 
 
@@ -1433,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)
@@ -1626,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)])
 
@@ -1810,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)
 
 
@@ -2001,9 +2005,9 @@ def rot90(a, k=1, axes=(0, 1)):
         _raise_type_error("tuple(ints) or list(ints) expected, but got ", axes)
     if len(axes) != 2:
         _raise_value_error("len(axes) must be 2.")
-    axis1, axis2 = axes[0], axes[1]
-    axis1 = _canonicalize_axis(axis1, a.ndim)
-    axis2 = _canonicalize_axis(axis2, a.ndim)
+    axis1_tmp, axis2_tmp = axes[0], axes[1]
+    axis1 = _canonicalize_axis(axis1_tmp, a.ndim)
+    axis2 = _canonicalize_axis(axis2_tmp, a.ndim)
     if axis1 == axis2:
         _raise_value_error('Axes must be different.')
 
@@ -2088,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):
@@ -1512,7 +1515,7 @@ def hypot(x1, x2, dtype=None):
         On CPU, the supported dtypes are np.float16, np.float32, and np.float64.
 
     Args:
-        x1 (Tensor): Leg of the traingle(s).
+        x1 (Tensor): Leg of the triangle(s).
         x2 (Tensor): Leg of the triangle(s). If ``x1.shape != x2.shape``, they
             must be broadcastable to a common shape (which becomes the shape of
             the output).
@@ -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):
@@ -2269,6 +2272,8 @@ def _handle_inputs(cov_input, rowvar):
     if cov_input.ndim > 2:
         _raise_value_error("input array has dimension more than 2.")
     cov_input = cov_input.astype("float32")
+    if cov_input.size == 0:
+        _raise_value_error("The value of cov_input should not be None, but got {}.".format(cov_input))
     cov_input = _expand(cov_input, 2)
     if not isinstance(rowvar, bool):
         _raise_type_error("input rowvar should be boolean.")
@@ -2405,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
@@ -2419,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)
@@ -3542,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.
 
@@ -3551,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.
@@ -3567,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):
@@ -3800,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
@@ -4110,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.
@@ -4247,6 +4252,8 @@ def argmax(a, axis=None):
         [2 2]
     """
     a = _to_tensor(a)
+    if a.dtype == mstype.bool_:
+        a = a.astype(mstype.int32)
     return a.argmax(axis)
 
 

mindspore/numpy/utils.py

@@ -206,13 +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)
-
-
-def _dyn_infer_out_shape(*tensor_shapes):
-    shape_out = tensor_shapes[0]
-    for i in range(1, len(tensor_shapes)):
-        shape_out = F.maximum(shape_out, tensor_shapes[i])
-    return shape_out