mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -14,21 +14,18 @@
 # ============================================================================
 """constexpr util"""
 
-from itertools import compress, zip_longest
-from functools import partial
-from collections import deque
 import operator
+from functools import partial
+from itertools import compress
 
 import numpy as np
-
-from mindspore.ops.primitive import constexpr
-from mindspore import log as logger
+from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
-from mindspore.common.tensor import Tensor
 from mindspore.common._register_for_tensor import tensor_operator_registry
-from mindspore.ops import _utils as op_utils
-from mindspore._checkparam import Validator as validator
+from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore import log as logger
 from mindspore import context
 
 ALL_TENSOR = 0
@@ -49,6 +46,30 @@ SET_ITEM_BY_ONE_TENSOR = 0
 SET_ITEM_BY_TUPLE_OF_TENSOR = 1
 SET_ITEM_BY_NON_TENSOR = 2
 
+type_priority_map = {
+    mstype.bool_: 0,
+    mstype.uint8: 1,
+    mstype.int8: 2,
+    mstype.uint16: 3,
+    mstype.int16: 4,
+    mstype.uint32: 5,
+    mstype.int32: 6,
+    mstype.uint64: 7,
+    mstype.int64: 8,
+    mstype.float16: 9,
+    mstype.float32: 10,
+    mstype.float64: 11
+}
+
+complex_priority_map = {
+    mstype.float32: 0,
+    mstype.float64: 1,
+    mstype.complex64: 2,
+    mstype.complex128: 4
+}
+
+complex_types = [mstype.complex64, mstype.complex128]
+
 
 @constexpr
 def raise_value_error(msg):
@@ -75,6 +96,7 @@ def raise_unimplemented_error(msg):
 
 @constexpr
 def log_warning(msg):
+    """Adds warning to logger."""
     logger.warning(msg)
 
 
@@ -93,9 +115,9 @@ def make_empty_slice():
 
 
 @constexpr
-def _deep_list(array_like, dim_size=-1):
+def _deep_list(array_like, dim_size=None):
     """convert nested tuple/list mixtures to pure nested list"""
-    if dim_size != -1:
+    if dim_size is not None:
         array_like = check_range(array_like, dim_size)
     if isinstance(array_like, (list, tuple)):
         return list(map(lambda x: _deep_list(x, dim_size), array_like))
@@ -136,7 +158,7 @@ def _deep_tensor_to_nparray(array_like):
 
 @constexpr
 def check_range(x, dim_size):
-    if dim_size == -1:
+    if dim_size is None:
         return x
     if isinstance(x, int) and not isinstance(x, bool):
         if x >= dim_size or x < -dim_size:
@@ -146,7 +168,7 @@ def check_range(x, dim_size):
 
 
 @constexpr
-def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=-1):
+def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
     """
     Converts the input to tensor.
 
@@ -168,9 +190,9 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=-1):
         return Tensor(np.zeros(data_shape), dtype)
 
     if not isinstance(a, (list, tuple, int, float, bool)):
-        raise TypeError("input data must be `int`, `float`, `bool`, `list` or `tuple`")
+        raise TypeError(f"Input data must be `int`, `float`, `bool`, `list` or `tuple`, but got {a}")
 
-    if dim_size != -1:
+    if dim_size is not None:
         a = check_range(a, dim_size)
 
     if isinstance(a, (list, tuple)):
@@ -191,7 +213,6 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=-1):
 tensor_operator_registry.register('make_tensor', make_tensor)
 
 
-@constexpr
 def judge_data_dim(data_dim, min_data_dim=0, max_data_dim=8):
     """Judges whether the data dim is valid."""
     if data_dim < min_data_dim or data_dim > max_data_dim:
@@ -199,21 +220,11 @@ def judge_data_dim(data_dim, min_data_dim=0, max_data_dim=8):
                          f"{max_data_dim}], but got '{data_dim}'.")
 
 
-@constexpr
 def get_source_shape(data_shape, value_shape):
     """Returns the shape of value that will be used to broadcast against data."""
-    cannot_broadcast = False
-    source_shape = value_shape
-    for i, j in zip(reversed(data_shape), reversed(value_shape)):
-        if j not in (1, i):
-            cannot_broadcast = True
-    for i in range(len(value_shape) - len(data_shape)):
-        source_shape = data_shape
-        if value_shape[i] != 1:
-            cannot_broadcast = True
-    if cannot_broadcast:
-        raise ValueError(f'could not broadcast input array from shape {value_shape} to {data_shape}')
-    return source_shape
+    if len(value_shape) > len(data_shape):
+        return data_shape
+    return value_shape
 
 
 @constexpr
@@ -383,10 +394,21 @@ def slice2indices(input_slice, shape):
     start, stop, step = normalize_slice(input_slice, shape[0])
     if check_slice_empty(start, stop, step):
         return False
-    grids = ([np.array(list(range(start, stop, step)), dtype=np.int64)] +
-             [np.array(list(range(dim_size)), dtype=np.int64) for dim_size in shape[1:]])
-    mesh = np.ix_(*grids)
-    return Tensor(np.stack(np.broadcast_arrays(*mesh), axis=-1))
+    ndim = len(shape)
+    mesh = list()
+    grids = [P.Range()(P.Fill()(mstype.int64, (), start), P.Fill()(
+        mstype.int64, (), stop), P.Fill()(mstype.int64, (), step))]
+    grids += [P.Range()(Tensor(0, mstype.int64), P.Fill()(mstype.int64, (), dim_size),
+                        Tensor(1, mstype.int64)) for dim_size in shape[1:]]
+    for j, grid in enumerate(grids):
+        mesh.append(P.Reshape()(grid, tuple(
+            [grid.size if j == t else 1 for t in range(ndim)])))
+    shapes = map(P.Shape(), mesh)
+    out_shape = infer_out_shape(*shapes)
+    mesh_arrays = list()
+    for arr in mesh:
+        mesh_arrays.append(P.BroadcastTo(out_shape)(arr))
+    return P.Stack(-1)(mesh_arrays)
 
 
 @constexpr
@@ -398,7 +420,7 @@ def check_indices(indices_size, index):
     return indices_size
 
 
-@constexpr
+@_primexpr
 def check_indices_value_size(indices_size, value_size):
     """Checks if the sizes are already matched."""
     if value_size < 1:
@@ -455,35 +477,61 @@ def check_tensors_dtype_same(data_dtype, value_dtype, op_name):
                     f"is not consistent with assigned tensor data type {data_dtype}.")
 
 
+@constexpr
+def get_broadcast_shape(x_shape, y_shape, prim_name):
+    """Get broadcast shape from input shapes."""
+    if x_shape is None or y_shape is None:
+        raise ValueError("get_broadcast_shape has dynamic rank input")
+    if None in x_shape or None in y_shape:
+        raise ValueError("get_broadcast_shape has dynamic shape input")
+    if x_shape == y_shape:
+        return x_shape
+    x_len = len(x_shape)
+    y_len = len(y_shape)
+    length = x_len if x_len < y_len else y_len
+    broadcast_shape_back = []
+
+    for i in range(-length, 0):
+        if x_shape[i] == 1:
+            broadcast_shape_back.append(y_shape[i])
+        elif y_shape[i] == 1:
+            broadcast_shape_back.append(x_shape[i])
+        elif x_shape[i] == y_shape[i]:
+            broadcast_shape_back.append(x_shape[i])
+        else:
+            raise ValueError(f"For '{prim_name}', x.shape and y.shape need to "
+                             f"broadcast. The value of x.shape[{i}] or y.shape[{i}]"
+                             f" must be 1 or -1 when they are not the same, "
+                             f"but got x.shape = {x_shape} "
+                             f"and y.shape = {y_shape}.")
+
+    broadcast_shape_front = y_shape[0: y_len - length] if length == x_len else x_shape[0: x_len - length]
+    broadcast_shape = list(broadcast_shape_front) + broadcast_shape_back
+    return broadcast_shape
+
+
 @constexpr
 def generate_broadcast_shape(shapes, op_name):
     """Generate broadcast shape for a tuple of shape."""
     if not shapes:
         return ()
     broadcast_shape = shapes[0]
-    for i, shape in enumerate(shapes):
-        logger.debug(f"Broadcasts the {i}th tensor, the shape is {shape}.")
-        try:
-            broadcast_shape = op_utils.get_broadcast_shape(
-                broadcast_shape, shape, op_name)
-        except ValueError as ex:
-            raise IndexError(ex)
+    for shape in shapes:
+        broadcast_shape = get_broadcast_shape(tuple(broadcast_shape), shape, op_name)
     return tuple(broadcast_shape)
 
 
-@constexpr
+@_primexpr
 def check_two_shapes_need_broadcast(shape_x, shape_y):
     """Check shape_y needs to be broadcast to shape_x."""
-    if any(j not in (i, 1) for i, j in zip(reversed(shape_x), reversed(shape_y))):
-        raise ValueError(f"{shape_y} could not broadcast with {shape_x}.")
     return shape_y != shape_x
 
 
-@constexpr
+@_primexpr
 def compute_multiples(origin_shape, broadcast_shape):
     """Compute multiples between origin shape with broadcast shape."""
     len_gap = len(broadcast_shape) - len(origin_shape)
-    return broadcast_shape[0:len_gap] + tuple(map(lambda x, y: x // y, broadcast_shape[len_gap:], origin_shape))
+    return broadcast_shape[0:len_gap] + tuple(map(lambda x, y: x // y, broadcast_shape[len_gap:], tuple(origin_shape)))
 
 
 @constexpr
@@ -493,7 +541,7 @@ def convert_scalar_to_tensor(data_shape, data_dtype, indices_shape, value, op_ty
         updates_shape = indices_shape + data_shape[1:]
     else:
         updates_shape = indices_shape[:-1] + data_shape[indices_shape[-1]:]
-    return Tensor(np.full(updates_shape, value), dtype=data_dtype)
+    return P.Fill()(data_dtype, updates_shape, value)
 
 
 def generate_updates_shape(data_shape, index_shape, op_type, is_dynamic):
@@ -554,12 +602,6 @@ def _judge_order_continuous(order_sequence):
 @constexpr
 def scalar_in_sequence(x, y):
     """Determine whether the scalar in the sequence."""
-    if x is None:
-        raise ValueError("Judge scalar in tuple or list require scalar and sequence must be constant, "
-                         "but the scalar is not.")
-    if y is None:
-        raise ValueError("Judge scalar in tuple or list require scalar and sequence must be constant, "
-                         "but the sequence is not.")
     return x in y
 
 
@@ -582,7 +624,7 @@ def check_number_index_type(number):
                      .format(number, type(number)))
 
 
-@constexpr
+@_primexpr
 def get_stride_info_from_slice(data_shape, slice_index):
     """Get stride info from a python slice"""
     begin, end, step = get_slice_stride(slice_index, data_shape[0])
@@ -683,7 +725,7 @@ def unpack(x):
     return x
 
 
-@constexpr
+@_primexpr
 def normalize_start(start, dim_size):
     """
     Normalize `start` according to the number of dimensions (`dim_size`).
@@ -691,24 +733,24 @@ def normalize_start(start, dim_size):
     """
     if start is None:
         return 0
-    if dim_size == -1:
+    if dim_size is None:
         return start
     if start < 0:
         return 0 if start < -dim_size else start % dim_size
     return start if start < dim_size else dim_size
 
 
-@constexpr
+@_primexpr
 def normalize_stop(stop, dim_size):
     """
     Normalize `stop` according to the number of dimensions (`dim_size`).
     If the number of dimensions is not given, return the original input directly.
     """
-    if stop is None and dim_size == -1:
+    if stop is None and dim_size is None:
         raise IndexError("Not Support stop is None when dim is dynamic")
     if stop is None:
         return dim_size
-    if dim_size == -1:
+    if dim_size is None:
         return stop
     if stop < 0:
         return 0 if stop < -dim_size else stop % dim_size
@@ -724,11 +766,9 @@ def get_step_from_slice(input_slice):
     return step
 
 
-@constexpr
+@_primexpr
 def normalize_slice(input_slice, dim_size):
     """Normalizes start, stop, step in a slice."""
-    start = normalize_start(input_slice.start, dim_size)
-    stop = normalize_stop(input_slice.stop, dim_size)
     step = input_slice.step
     if step is None:
         step = 1
@@ -747,7 +787,6 @@ def tuple_slice(tup, start, end):
     return tup[start:end]
 
 
-@constexpr
 def expanded_shape(shape, expand_size):
     return (1,)*expand_size + shape
 
@@ -780,12 +819,20 @@ def is_slice(x):
     return isinstance(x, slice)
 
 
-@constexpr
+@_primexpr
 def filter_expanded_dims(shape, not_expanded_dim):
+    """filter_expanded_dims"""
+    def _check(diff, shape):
+        if diff < 0:
+            raise ValueError(f'unable to broadcast {shape}')
+
     diff = len(not_expanded_dim) - len(shape)
-    if diff < 0:
-        raise ValueError(f'unable to broadcast {shape}')
-    return tuple(compress(shape, not_expanded_dim[diff:]))
+    _check(diff, shape)
+    res = list()
+    for i, flag in zip(shape, not_expanded_dim[diff:]):
+        if flag:
+            res.append(i)
+    return tuple(res)
 
 
 @constexpr
@@ -794,7 +841,7 @@ def sequence_to_index(sequence, dim_size):
     if not sequence:
         return False
     if all(isinstance(i, bool) for i in sequence):
-        if dim_size == -1:
+        if dim_size is None:
             raise IndexError("Not supported to take the subscript of dynamic shape tensor using Boolean type")
         seq_size = len(sequence)
         if seq_size != dim_size:
@@ -805,19 +852,30 @@ def sequence_to_index(sequence, dim_size):
     return make_tensor(sequence, mstype.int64, None, dim_size)
 
 
-@constexpr
+@_primexpr
 def int_to_index(i, shape):
     """Converts integer to tensor indices."""
+    def _check(i, dim_size):
+        if i < -dim_size or i >= dim_size:
+            raise IndexError(f'index {i} is out of bounds for axis 0 with size {dim_size}')
+
     dim_size = shape[0]
-    if i < -dim_size or i >= dim_size:
-        raise IndexError(f'index {i} is out of bounds for axis 0 with size {dim_size}')
-    i = i % dim_size
+    _check(i, dim_size)
+    i = (i + dim_size) % dim_size
     if len(shape) == 1:
-        return Tensor([[i]])
-    grids = [np.array(list(range(size)), dtype=np.int64) for size in shape[1:]]
-    mesh = np.ix_(*grids)
-    index = np.stack(np.broadcast_arrays(*mesh), -1)
-    return Tensor(np.insert(index, 0, i, -1))
+        return P.Fill()(mstype.int64, (1, 1), i)
+    mesh = list()
+    ndim = len(shape) - 1
+    for j, size in enumerate(shape[1:]):
+        grid = P.Range()(Tensor(0, mstype.int64), P.Fill()(mstype.int64, (), size), Tensor(1, mstype.int64))
+        mesh.append(P.Reshape()(grid, tuple([size if j == t else 1 for t in range(ndim)])))
+    shapes = map(P.Shape(), mesh)
+    out_shape = infer_out_shape(*shapes)
+    mesh_arrays = list()
+    for arr in mesh:
+        mesh_arrays.append(P.BroadcastTo(out_shape)(arr))
+    index = P.Stack(-1)(mesh_arrays)
+    return P.Concat(-1)((P.Fill()(mstype.int64, P.Shape()(index)[:-1] + (1,), i), index))
 
 
 @constexpr
@@ -839,12 +897,12 @@ def rem_not_expanded_dims(idx_advanced, expand_true, tensor_index_ndim, rem_ndim
     return not_expanded_dim, idx_advanced
 
 
-@constexpr
+@_primexpr
 def check_slice_empty(start, stop, step):
     return (start - stop)*step >= 0
 
 
-@constexpr
+@_primexpr
 def real_axes(ndim_orig, ndim_out, axes_orig):
     """Returns the real axes to be reduced after performing broadcast"""
     _diff = ndim_out - ndim_orig
@@ -856,7 +914,7 @@ def real_axes(ndim_orig, ndim_out, axes_orig):
 check_axis_valid_const = constexpr(validator.check_axis_valid)
 
 
-@constexpr
+@_primexpr
 def compute_slice_shape(slice_shape, broadcast_shape_len, slice_cnt, fancy_position):
     """Computes slice tensor shapes"""
     shape = [1] * len(slice_shape)
@@ -865,18 +923,19 @@ def compute_slice_shape(slice_shape, broadcast_shape_len, slice_cnt, fancy_posit
     return shape
 
 
-@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):
+    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)
-        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.append(max_size)
     return tuple(shape_out)
 
 
@@ -891,9 +950,51 @@ def use_copy_slice(tuple_index):
 
 @constexpr
 def is_ascend():
+    """Device target is Ascend or not"""
     return context.get_context('device_target') == "Ascend"
 
 
 @constexpr
 def gen_exception_msg(msg_format, *args):
     return msg_format.format(*args)
+
+
+@constexpr
+def get_output_dtype(dtype_1, dtype_2, use_complex=False):
+    """Returns output dtype after type promotion."""
+    if use_complex:
+        priority_map = complex_priority_map
+        type_str = "Complex binary"
+    else:
+        priority_map = type_priority_map
+        type_str = "Binary"
+    priority_1 = priority_map.get(dtype_1, None)
+    priority_2 = priority_map.get(dtype_2, None)
+    if not priority_1 or not priority_2:
+        raise ValueError(f"{type_str} op type promotion not supported for {dtype_1} and {dtype_2}")
+    if priority_1 > priority_2:
+        return dtype_1
+    return dtype_2
+
+
+@constexpr
+def promote_binary_dtype(dtype_1, dtype_2):
+    """
+    promote binary types
+    """
+    if dtype_1 == dtype_2:
+        return dtype_1
+    if dtype_1 in complex_types or dtype_2 in complex_types:
+        return get_output_dtype(dtype_1, dtype_2, True)
+    return get_output_dtype(dtype_1, dtype_2, False)
+
+
+@_primexpr
+def generate_padding_shape(shape, length):
+    """
+    pad the `shape` to `length` with 1.
+    """
+    if len(shape) > length:
+        raise ValueError(f"Can not pad {shape} to length {length}.")
+
+    return shape + (1,) * (length - len(shape))

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -14,12 +14,14 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `add` operations."""
+from __future__ import absolute_import
 
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.composite.multitype_ops._constexpr_utils import make_tensor, check_equal
 from mindspore.common import CSRTensor, COOTensor
+from ...operations._sequence_ops import SequenceAdd
 
 
 add = base.MultitypeFuncGraph('add', True)
@@ -194,6 +196,8 @@ def _list_add_list(x, y):
         Returns:
             list, has the same dtype as x.
     """
+    if F.is_sequence_shape_unknown(x) or F.is_sequence_shape_unknown(y):
+        return SequenceAdd()(x, y)
     for i in y:
         x.append(i)
     return x
@@ -271,6 +275,8 @@ def _add_tuple(x, y):
     Returns:
         Tuple, consists of elements of x and elements of y.
     """
+    if F.is_sequence_shape_unknown(x) or F.is_sequence_shape_unknown(y):
+        return SequenceAdd()(x, y)
     return _tuple_add(x, y)
 
 
@@ -303,7 +309,7 @@ def _add_cootensor(x, y):
         COOTensor, consists of elements of x and elements of y.
     """
     check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
-    return F.sparse_add(x, y, make_tensor(0, x.values.dtype))
+    return F.coo_add(x, y, make_tensor(0, x.values.dtype))
 
 
 @add.register("COOTensor", "Tensor")
@@ -513,4 +519,20 @@ def _add_tuple_cootensor(x, y):
     x = COOTensor(x[0], x[1], y.shape)
     return _add_cootensor_cootensor(x, y)
 
+
+@_add_backward.register("MapTensor", "MapTensor")
+def _map_tensor_add_backward(x, y):
+    """
+   Adds MapTensors for backward.
+
+   Args:
+       x (MapTensor): x
+       y (MapTensor): y
+
+   Returns:
+       MapTensor.
+   """
+    return x
+
+
 hyper_add = base.HyperMap(_add_backward)

mindspore/ops/composite/multitype_ops/div_impl.py

@@ -14,12 +14,13 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `div` operations."""
+from __future__ import division
 
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite.multitype_ops._constexpr_utils import log_warning, check_equal
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
-from mindspore.common import CSRTensor, COOTensor
+from mindspore.common import COOTensor
 
 
 div = base.MultitypeFuncGraph("div", True)
@@ -38,8 +39,7 @@ def _csrtensor_div_tensor(x, y):
        CSRTensor, equal to x / y.
     """
     log_warning("For CSR divide, zero values in the dense tensor are ignored.")
-    data = F.csr_div(x, y)
-    return CSRTensor(x.indptr, x.indices, data, x.shape)
+    return F.csr_div(x, y)
 
 
 @div.register("COOTensor", "Tensor")

mindspore/ops/composite/multitype_ops/equal_impl.py

@@ -14,6 +14,7 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `equal` operations."""
+from __future__ import absolute_import
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F

mindspore/ops/composite/multitype_ops/floordiv_impl.py

@@ -14,7 +14,7 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `floordiv` operations."""
-
+from __future__ import absolute_import
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F