mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/composite/multitype_ops/in_impl.py

@@ -20,6 +20,7 @@ from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_util
 from mindspore.ops.composite.multitype_ops import _compile_utils as compile_utils
 from mindspore.ops import functional as F
 from mindspore.ops.composite import base
+from mindspore.ops.operations._sequence_ops import InSequence
 
 in_ = base.MultitypeFuncGraph("in", True)
 """
@@ -40,6 +41,8 @@ def _number_in_tuple(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
+    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+        return InSequence()(x, y)
     return const_utils.scalar_in_sequence(x, y)
 
 
@@ -55,6 +58,8 @@ def _number_in_list(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
+    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+        return InSequence()(x, y)
     return const_utils.scalar_in_sequence(x, y)
 
 
@@ -133,6 +138,8 @@ def _tensor_in_list(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
+    if F.is_sequence_shape_unknown(y):
+        return InSequence()(x, y)
     return compile_utils.tensor_in_sequence(x, y)
 
 
@@ -148,6 +155,8 @@ def _tensor_in_tuple(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
+    if F.is_sequence_shape_unknown(y):
+        return InSequence()(x, y)
     return compile_utils.tensor_in_sequence(x, y)
 
 

mindspore/ops/composite/multitype_ops/less_equal_impl.py

@@ -19,6 +19,7 @@ from __future__ import division
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
+from mindspore.ops.operations import _sequence_ops as _seq
 
 # less_equal is a metagraph object which will determine if two objects are less_equal according to input type
 # using ".register" decorator
@@ -70,3 +71,33 @@ def _less_equal_tensor(x, y):
        Tensor, return value by operator P.LessEqual.
    """
     return F.tensor_le(x, y)
+
+
+@less_equal.register("Tuple", "Tuple")
+def _less_equal_tuple(x, y):
+    """
+    Determine whether x is less than or equal to y.
+
+    Args:
+       x(Tuple): Tuple.
+       y(Tuple): Tuple.
+
+    Returns:
+       bool, if x <= y return true in python logic, x > y return false.
+   """
+    return _seq.tuple_le()(x, y)
+
+
+@less_equal.register("List", "List")
+def _less_equal_list(x, y):
+    """
+    Determine whether x is less than or equal to y.
+
+    Args:
+       x(List): List.
+       y(List): List.
+
+    Returns:
+       bool, if x <= y return true in python logic, x > y return false.
+   """
+    return _seq.list_le()(x, y)

mindspore/ops/composite/multitype_ops/less_impl.py

@@ -20,6 +20,7 @@ from __future__ import division
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
+from mindspore.ops.operations import _sequence_ops as _seq
 
 # less is a metafuncgraph object which will determine if two objects are less according to input type
 # using ".register" decorator
@@ -71,3 +72,33 @@ def _less_tensor(x, y):
        Tensor, return value of  x and y by operation P.Less()
    """
     return F.tensor_lt(x, y)
+
+
+@less.register("Tuple", "Tuple")
+def _less_tuple(x, y):
+    """
+    Determine whether x is less than to y.
+
+    Args:
+       x(Tuple): Tuple.
+       y(Tuple): Tuple.
+
+    Returns:
+       bool, if x < y return true in python logic, x >= y return false.
+   """
+    return _seq.tuple_lt()(x, y)
+
+
+@less.register("List", "List")
+def _less_list(x, y):
+    """
+    Determine whether x is less than to y.
+
+    Args:
+       x(List): List.
+       y(List): List.
+
+    Returns:
+       bool, if x < y return true in python logic, x >= y return false.
+   """
+    return _seq.list_lt()(x, y)

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -18,7 +18,9 @@ from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite.multitype_ops._constexpr_utils import 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
+from ...operations._sequence_ops import SequenceMul
+
 
 mul = base.MultitypeFuncGraph("mul", True)
 """
@@ -101,6 +103,10 @@ def _list_mul_scalar(x, y):
     Outputs:
         List.
     """
+    if not isinstance(y, int):
+        raise TypeError(f"can't multiply sequence by non-int of type '{type(y)}'.")
+    if F.is_sequence_shape_unknown(x) or not F.isconstant(y):
+        return SequenceMul()(x, y)
     res = []
     i = 0
     while i < y:
@@ -117,6 +123,10 @@ def _scalar_mul_list(x, y):
     Outputs:
         List.
     """
+    if not isinstance(x, int):
+        raise TypeError(f"can't multiply sequence by non-int of type '{type(x)}'.")
+    if not F.isconstant(x) or F.is_sequence_shape_unknown(y):
+        return SequenceMul()(y, x)
     res = []
     i = 0
     while i < x:
@@ -133,6 +143,10 @@ def _tuple_mul_scalar(x, y):
     Outputs:
         Tuple.
     """
+    if not isinstance(y, int):
+        raise TypeError(f"can't multiply sequence by non-int of type '{type(y)}'.")
+    if F.is_sequence_shape_unknown(x) or not F.isconstant(y):
+        return SequenceMul()(x, y)
     res = ()
     i = 0
     while i < y:
@@ -149,6 +163,10 @@ def _scalar_mul_tuple(x, y):
     Outputs:
         Tuple.
     """
+    if not isinstance(x, int):
+        raise TypeError(f"can't multiply sequence by non-int of type '{type(x)}'.")
+    if not F.isconstant(x) or F.is_sequence_shape_unknown(y):
+        return SequenceMul()(y, x)
     res = ()
     i = 0
     while i < x:
@@ -229,8 +247,7 @@ def _csrtensor_mul_tensor(x, y):
     Outputs:
        CSRTensor, equal to x * y.
     """
-    data = F.csr_mul(x, y)
-    return CSRTensor(x.indptr, x.indices, data, x.shape)
+    return F.csr_mul(x, y)
 
 
 @mul.register("Tensor", "CSRTensor")
@@ -241,8 +258,7 @@ def _tensor_mul_csrtensor(x, y):
     Outputs:
        CSRTensor, equal to x * y.
     """
-    data = F.csr_mul(y, x)
-    return CSRTensor(y.indptr, y.indices, data, y.shape)
+    return F.csr_mul(y, x)
 
 
 @mul.register("COOTensor", "Tensor")

mindspore/ops/composite/multitype_ops/not_in_impl.py

@@ -20,6 +20,7 @@ from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_util
 from mindspore.ops.composite.multitype_ops import _compile_utils as compile_utils
 from mindspore.ops import functional as F
 from mindspore.ops.composite import base
+from mindspore.ops.operations._sequence_ops import InSequence
 
 not_in_ = base.MultitypeFuncGraph("not_in", True)
 """
@@ -40,6 +41,8 @@ def _number_not_in_tuple(x, y):
     Returns:
        bool, if x not in y return true, x in y return false.
    """
+    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+        return not InSequence()(x, y)
     return not const_utils.scalar_in_sequence(x, y)
 
 
@@ -55,6 +58,8 @@ def _number_not_in_list(x, y):
     Returns:
        bool, if x not in y return true, x in y return false.
    """
+    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+        return not InSequence()(x, y)
     return not const_utils.scalar_in_sequence(x, y)
 
 
@@ -133,6 +138,8 @@ def _tensor_not_in_list(x, y):
     Returns:
        bool, if x not in y return true, x in y return false.
    """
+    if F.is_sequence_shape_unknown(y):
+        return not InSequence()(x, y)
     return not compile_utils.tensor_in_sequence(x, y)
 
 
@@ -148,6 +155,8 @@ def _tensor_not_in_tuple(x, y):
     Returns:
        bool, if x not in y return true, x in y return false.
    """
+    if F.is_sequence_shape_unknown(y):
+        return not InSequence()(x, y)
     return not compile_utils.tensor_in_sequence(x, y)
 
 

mindspore/ops/composite/multitype_ops/ones_like_impl.py

@@ -46,16 +46,14 @@ def _ones_like_scalar(x):
 @ones_like_leaf.register("Tensor")
 def _ones_like_tensor(x):
     """Returns a tensor with the same shape and dtype as x and all elements are 1."""
-    return P.Fill()(P.DType()(x), P.Shape()(x), 1.0)
+    return P.OnesLike()(x)
 
 
 @ones_like_leaf.register("COOTensor")
 def _ones_like_coo_tensor(x):
     """Returns a tensor with the same shape and dtype as x and all elements are 1."""
     values_ = F.coo_tensor_get_values(x)
-    values = P.Fill()(P.DType()(values_),
-                      P.Shape()(values_),
-                      1.0)
+    values = P.OnesLike()(values_)
     return F.make_coo_tensor(F.coo_tensor_get_indices(x), values, F.coo_tensor_get_dense_shape(x))
 
 

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -22,10 +22,12 @@ from mindspore.ops.operations._inner_ops import SliceGetItem
 from mindspore.ops.operations import _map_tensor_ops
 from mindspore.ops.composite import base
 from mindspore.common import Tensor
+from ...operations._sequence_ops import SequenceSliceSetItem
 
-setitem = base.MultitypeFuncGraph('setitem')
-
+DOC_URL = "https://mindspore.cn/docs/zh-CN/r2.0/note/index_support.html"
+setitem = base.MultitypeFuncGraph('setitem', doc_url=DOC_URL)
 slice_get_item = SliceGetItem()
+sequence_slice_setitem = SequenceSliceSetItem()
 
 
 class _ListSliceSetItem(base.ListSliceSetItem_):
@@ -145,6 +147,11 @@ def _list_slice_setitem_with_tuple(data, slice_index, value):
     Outputs:
         list, type is the same as the element type of data.
     """
+    if F.is_sequence_shape_unknown(data) or F.is_sequence_shape_unknown(value) or not F.isconstant(slice_index):
+        start = slice_get_item(slice_index, "start")
+        stop = slice_get_item(slice_index, "stop")
+        step = slice_get_item(slice_index, "step")
+        return sequence_slice_setitem(data, value, start, stop, step)
     list_value = list(value)
     return _list_slice_set_item(data, slice_index, list_value)
 
@@ -162,6 +169,11 @@ def _list_slice_setitem_with_list(data, slice_index, value):
     Outputs:
         list, type is the same as the element type of data.
     """
+    if F.is_sequence_shape_unknown(data) or F.is_sequence_shape_unknown(value) or not F.isconstant(slice_index):
+        start = slice_get_item(slice_index, "start")
+        stop = slice_get_item(slice_index, "stop")
+        step = slice_get_item(slice_index, "step")
+        return sequence_slice_setitem(data, value, start, stop, step)
     return _list_slice_set_item(data, slice_index, value)
 
 
@@ -179,6 +191,11 @@ def _list_slice_setitem_with_tensor(data, slice_index, value):
         list, type is the same as the element type of data.
     """
     value_list = list(value)
+    if F.is_sequence_shape_unknown(data) or F.is_sequence_shape_unknown(value_list) or not F.isconstant(slice_index):
+        start = slice_get_item(slice_index, "start")
+        stop = slice_get_item(slice_index, "stop")
+        step = slice_get_item(slice_index, "step")
+        return sequence_slice_setitem(data, value_list, start, stop, step)
     return _list_slice_set_item(data, slice_index, value_list)
 
 
@@ -849,4 +866,5 @@ def _map_tensor_setitem(map_tensor, key_tensor, value_tensor):
     Outputs:
         MapTensor, the map tensor be updated.
     """
-    return _map_tensor_ops.put(map_tensor, key_tensor, value_tensor)
+    _map_tensor_ops.put(map_tensor, key_tensor, value_tensor)
+    return map_tensor

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -92,7 +92,7 @@ def _sub_csrtensor(x, y):
 def _sub_cootensor(x, y):
     """Returns x - y where x and y are all COO tensors."""
     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))
 
 
 @sub.register("Tensor", "COOTensor")

mindspore/ops/composite/multitype_ops/zeros_like_impl.py

@@ -18,6 +18,8 @@
 from __future__ import absolute_import
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
+from mindspore.ops.operations import _sequence_ops as seq
+from mindspore.ops.primitive import Primitive
 
 zeros_like_leaf = base.MultitypeFuncGraph('zeros_like_leaf', True)
 """
@@ -29,7 +31,9 @@ using ".register" decorator.
 @zeros_like_leaf.register("Number")
 def _zeros_like_scalar(x):
     """Returns 0 which has the same dtype as x where x is a scalar."""
-    return 0
+    if isinstance(x, int):
+        return 0
+    return 0.
 
 
 @zeros_like_leaf.register("Bool")
@@ -138,6 +142,23 @@ def _zeros_like_dict(x):
     return F.make_dict(keys, new_values)
 
 
+_extract_keyword_arg = Primitive("extract_keyword_arg")
+
+
+@zeros_like_leaf.register("Keyword")
+def _zeros_like_keyword(x):
+    """
+    Handle Keyword input.
+
+    Args:
+        x (Keyword): the input
+
+    Returns:
+        zeros_like_leaf.
+    """
+    return zeros_like_leaf(_extract_keyword_arg(x))
+
+
 @zeros_like_leaf.register("UMonad")
 def _zeros_like_u_monad(x):
     """
@@ -180,6 +201,16 @@ def _zeros_like_env_type(x):
     return F.environ_create()
 
 
-# zeros_like is an object that will generate graph of zero_like operation for different type
-zeros_like = base.HyperMap(zeros_like_leaf)
-"""`zeros_like` is an object that will generate graph of `zero_like` operation for different type."""
+class _ZerosLike(base.ZerosLike_):
+    def __init__(self, name, fn_leaf):
+        """Initialize _ZerosLike."""
+        base.ZerosLike_.__init__(self, name, fn_leaf)
+        self.fn_leaf = fn_leaf
+
+    def __call__(self, x):
+        if isinstance(x, (tuple, list)) and F.is_sequence_shape_unknown(x):
+            return seq.SequenceZerosLike()(x)
+        return self.fn_leaf(x)
+
+
+zeros_like = _ZerosLike('zeros_like', zeros_like_leaf)