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

mindspore/numpy/utils_const.py

@@ -16,31 +16,37 @@
 from __future__ import absolute_import
 
 import math
-from itertools import zip_longest, accumulate
-from collections import deque
+from itertools import accumulate
 import operator
 
 import mindspore.context as context
 from mindspore.ops import functional as F
 from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
 from mindspore.common import dtype as mstype
 from mindspore.common import Tensor
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore._c_expression import typing
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 
 from mindspore.numpy.dtypes import promotion_rule, dtype_tuple, all_types, dtype_map, rule_for_trigonometric
 
-
 _check_axis_type = constexpr(validator.check_axis_type)
 
 
-@constexpr
+@_primexpr
 def _check_shape(shape):
     """check the shape param to match the numpy style"""
+    # convert tensor to int/list, use followed if statements to do further conversions
+    def _check(shape):
+        for s in shape:
+            if not isinstance(s, int):
+                raise TypeError("each entry in shape should be int.")
+            if s < 0:
+                raise ValueError("each entry in shape should no less than 0.")
+
     if not isinstance(shape, (int, tuple, list, Tensor, typing.Tuple, typing.List)):
         raise TypeError(f"only int, tuple, list and tensor are allowed for shape, but got {type(shape)}")
-    # convert tensor to int/list, use followed if statements to do further conversions
     if isinstance(shape, Tensor):
         shape = shape.asnumpy().tolist()
         # this may return an int, don't change the next if to elif
@@ -48,11 +54,7 @@ def _check_shape(shape):
         shape = (shape,)
     elif isinstance(shape, (list, typing.List)):
         shape = tuple(shape)
-    for s in shape:
-        if not isinstance(s, int):
-            raise TypeError("each entry in shape should be int.")
-        if s < 0:
-            raise ValueError("each entry in shape should no less than 0.")
+    _check(shape)
     return shape
 
 
@@ -75,25 +77,32 @@ def _check_dtype(dtype):
     return dtype
 
 
-@constexpr
+@_primexpr
 def _is_shape_empty(shp):
     """Check whether shape contains zero"""
+    if F.is_sequence_shape_unknown(shp):
+        return False
     if isinstance(shp, int):
         return shp == 0
+    if isinstance(shp, (tuple, list)):
+        return 0 in shp
     return F.shape_mul(shp) == 0
 
 
-@constexpr
+@_primexpr
 def _check_start_normalize(start, ndim):
     """check and normalize start argument for rollaxis."""
-    if start < -ndim or start > ndim:
-        raise ValueError(f"For rollaxis, start {start} is out of bounds. Ranging from {-ndim} to {ndim} is allowed.")
+    def _check():
+        if start < -ndim or start > ndim:
+            raise ValueError(f"For rollaxis, start {start} is out of bounds."
+                             f"Ranging from {-ndim} to {ndim} is allowed.")
+    _check()
     if start < 0:
         start = start + ndim
     return start
 
 
-@constexpr
+@_primexpr
 def _check_axes_range(axes, ndim):
     """
     Check axes type and normalize the negative axes.
@@ -122,70 +131,81 @@ def _get_device():
     return context.get_context('device_target')
 
 
-@constexpr
+@_primexpr
 def _infer_out_shape(*shapes):
     """
     Returns shape of output after broadcasting. Raises ValueError if shapes cannot be broadcast.
     """
-    shape_out = deque()
-    reversed_shapes = map(reversed, shapes)
-    for items in zip_longest(*reversed_shapes, fillvalue=1):
-        max_size = 0 if 0 in items else max(items)
+    def _check():
         if any(item not in (1, max_size) for item in items):
             raise ValueError(f'operands could not be broadcast together with shapes {*shapes,}')
-        shape_out.appendleft(max_size)
+
+    shape_out = list()
+    max_len = max([len(it) for it in shapes])
+    for i in range(max_len):
+        items = [it[i-max_len+len(it)] if i-max_len +
+                 len(it) >= 0 else 1 for it in shapes]
+        max_size = 0 if 0 in items else max(items)
+        _check()
+        shape_out.append(max_size)
     return tuple(shape_out)
 
 
-@constexpr
+@_primexpr
 def _can_broadcast(*shapes):
     """
     Returns Ture if shapes can broadcast, False if they cannot.
     """
-    try:
-        _infer_out_shape(*shapes)
-    except ValueError:
-        return False
-    finally:
-        pass
+    max_len = max([len(it) for it in shapes])
+    for i in range(max_len):
+        items = [it[i-max_len+len(it)] if i-max_len +
+                 len(it) >= 0 else 1 for it in shapes]
+        max_size = 0 if 0 in items else max(items)
+        if any(item not in (1, max_size) for item in items):
+            return False
     return True
 
 
-@constexpr
+@_primexpr
 def _check_axis_in_range(axis, ndim):
     """Checks axes are with the bounds of ndim"""
-    if not isinstance(axis, int):
-        raise TypeError(f'axes should be integers, not {type(axis)}')
-    if not -ndim <= axis < ndim:
-        raise ValueError(f'axis {axis} is out of bounds for array of dimension {ndim}')
-    return axis % ndim
+    def _check():
+        if not isinstance(axis, int):
+            raise TypeError(f'axes should be integers, not {type(axis)}')
+        if not -ndim <= axis < ndim:
+            raise ValueError(f'axis {axis} is out of bounds for array of dimension {ndim}')
+    _check()
+    return axis - axis // ndim * ndim
 
 
-@constexpr
+@_primexpr
 def _check_axis_valid(axes, ndim):
     """
     Checks axes are valid given ndim, and returns axes that can be passed
     to the built-in operator (non-negative, int or tuple)
     """
+    def _check(axes):
+        if any(axes.count(el) > 1 for el in axes):
+            raise ValueError('duplicate value in "axis"')
+
     if axes is None:
         axes = F.make_range(ndim)
         return axes
     if isinstance(axes, (tuple, list)):
         axes = tuple(map(lambda x: _check_axis_in_range(x, ndim), axes))
-        if any(axes.count(el) > 1 for el in axes):
-            raise ValueError('duplicate value in "axis"')
+        _check(axes)
         return axes
     return (_check_axis_in_range(axes, ndim),)
 
 
-@constexpr
+@_primexpr
 def _check_shape_aligned(shape1, shape2):
     """Checks shape1 and shape2 are valid shapes to perform inner product"""
     if shape1[-1] != shape2[-1]:
         raise ValueError(f'shapes {shape1} {shape2} not aligned: {shape1[-1]} (dim 0) != {shape2[-1]} (dim 0)')
 
 
-@constexpr
+@_primexpr
 def _tile_size(shape, out_shape, ndim):
     """Returns tile_size such that shape*tile_size = out_shape"""
     size = [1]*ndim
@@ -259,7 +279,7 @@ def _raise_unimplemented_error(info, param=None):
     raise NotImplementedError(info + f"{param}")
 
 
-@constexpr
+@_primexpr
 def _empty(dtype, shape):
     """Returns an uninitialized array with dtype and shape."""
     return Tensor_(dtype, shape)
@@ -285,13 +305,13 @@ def _promote_for_trigonometric(dtype):
     return res_dtype
 
 
-@constexpr
+@_primexpr
 def _max(*args):
     """Returns the maximum value."""
     return max(*args)
 
 
-@constexpr
+@_primexpr
 def _min(*args):
     """"Returns the minimum value."""
     return min(*args)
@@ -319,7 +339,7 @@ def _check_is_int(dtype):
     return isinstance(dtype, typing.Int)
 
 
-@constexpr
+@_primexpr
 def _canonicalize_axis(axis, ndim):
     """
     Check axes are within the number of dimensions of tensor x and normalize the negative axes.
@@ -329,6 +349,10 @@ def _canonicalize_axis(axis, ndim):
     Return:
         Axis (Union[int, tuple(int)]). If input is integer, return integer, else tuple.
     """
+    def _check():
+        if not all(axis.count(el) <= 1 for el in axis):
+            raise ValueError(f"duplicate axes in {axis}.")
+
     if isinstance(axis, int):
         axis = [axis]
     for ax in axis:
@@ -337,10 +361,32 @@ def _canonicalize_axis(axis, ndim):
     def canonicalizer(ax):
         return ax + ndim if ax < 0 else ax
 
+    def _sort_axis(ax):
+        def merge(left, right):
+            result = ()
+            i = j = 0
+            while i < len(left) and j < len(right):
+                if left[i] <= right[j]:
+                    result += (left[i],)
+                    i += 1
+                else:
+                    result += (right[j],)
+                    j += 1
+
+            return result + left[i:] + right[j:]
+
+        if len(ax) <= 1:
+            return ax
+
+        middle = len(ax) // 2
+        left = _sort_axis(ax[:middle])
+        right = _sort_axis(ax[middle:])
+
+        return merge(left, right)
+
     axis = tuple([canonicalizer(axis) for axis in axis])
-    if all(axis.count(el) <= 1 for el in axis):
-        return tuple(sorted(axis)) if len(axis) > 1 else axis[0]
-    raise ValueError(f"duplicate axes in {axis}.")
+    _check()
+    return tuple(_sort_axis(axis)) if len(axis) > 1 else axis[0]
 
 
 @constexpr
@@ -349,22 +395,26 @@ def _broadcast_tuples(tup1, tup2):
     Broadcast two 1D tuples to the same length, if inputs are ints, convert to
     tuples first.
     """
+    def _check():
+        if not isinstance(tup1, (tuple, list)) or not isinstance(tup2, (tuple, list)):
+            raise TypeError("input shift and axis must be tuple or list or int.")
+        if len(tup1) == len(tup2) or len(tup1) == 1 or len(tup2) == 1:
+            return None
+        raise ValueError("shape mismatch: objects cannot be broadcast to a single shape")
+
     tup1 = (tup1,) if isinstance(tup1, int) else tup1
     tup2 = (tup2,) if isinstance(tup2, int) else tup2
-    if not isinstance(tup1, (tuple, list)) or not isinstance(tup2, (tuple, list)):
-        raise TypeError("input shift and axis must be tuple or list or int.")
+    _check()
     if len(tup1) == len(tup2):
         return tup1, tup2
     if len(tup1) == 1:
         tup1 *= len(tup2)
-    elif len(tup2) == 1:
+    else: # case: len(tup2) == 1
         tup2 *= len(tup1)
-    else:
-        raise ValueError("shape mismatch: objects cannot be broadcast to a single shape")
     return tup1, tup2
 
 
-@constexpr
+@_primexpr
 def _expanded_shape(ndim, axis_size, axis):
     """
     Returns a shape with size = 1 for all dimensions
@@ -373,7 +423,7 @@ def _expanded_shape(ndim, axis_size, axis):
     return tuple([axis_size if i == axis else 1 for i in range(ndim)])
 
 
-@constexpr
+@_primexpr
 def _add_unit_axes(shape, ndim, append=False):
     """
     Prepends shape with 1s so that it has the number of dimensions ndim.
@@ -409,7 +459,7 @@ def _type_convert(force, obj):
     return force(obj)
 
 
-@constexpr
+@_primexpr
 def _list_comprehensions(obj, item=None, return_tuple=False, make_none=False):
     """
     Generates a new list/tuple by list comprehension.
@@ -440,7 +490,7 @@ def _list_comprehensions(obj, item=None, return_tuple=False, make_none=False):
     return res
 
 
-@constexpr
+@_primexpr
 def _tuple_setitem(tup, idx, value):
     """
     Returns a tuple with specified `idx` set to `value`.
@@ -467,7 +517,7 @@ def _ceil(number):
     return math.ceil(number)
 
 
-@constexpr
+@_primexpr
 def _seq_prod(seq1, seq2):
     """Returns the element-wise product of seq1 and seq2."""
     return tuple(map(lambda x, y: x*y, seq1, seq2))
@@ -479,7 +529,7 @@ def _make_tensor(val, dtype):
     return Tensor(val, dtype)
 
 
-@constexpr
+@_primexpr
 def _tuple_slice(tup, start, end):
     """get sliced tuple from start and end."""
     return tup[start:end]

mindspore/ops/_constants.py

@@ -18,12 +18,6 @@
 """ Define constants"""
 
 # Arithmetic
-kScalarAdd = "ScalarAdd"
-kScalarSub = "ScalarSub"
-kScalarMul = "ScalarMul"
-kScalarDiv = "ScalarDiv"
-kScalarFloordiv = "ScalarFloordiv"
-kScalarMod = "ScalarMod"
 kScalarPow = "ScalarPow"
 kScalarTrunc = "ScalarTrunc"
 kScalarFloor = "ScalarFloor"

mindspore/ops/_grad/__init__.py

@@ -17,6 +17,7 @@
 from __future__ import absolute_import
 from mindspore.ops._grad.grad_base import get_bprop_fn, get_taylor_fprop_fn
 from . import grad_array_ops, grad_comm_ops, grad_debug_ops, grad_implementations, grad_clip_ops, \
-               grad_math_ops, grad_nn_ops, grad_other_ops, grad_quant_ops, grad_sparse, grad_inner_ops, taylor_rule
+              grad_math_ops, grad_nn_ops, grad_other_ops, grad_quant_ops, grad_sparse,            \
+              grad_inner_ops, taylor_rule, grad_sequence_ops
 
 __all__ = ['get_bprop_fn', 'get_taylor_fprop_fn']