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

mindspore/ops/composite/multitype_ops/getitem_impl.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,18 +14,26 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `getitem` operations."""
+from __future__ import absolute_import
 from mindspore.ops.operations import _inner_ops as inner
+from mindspore.ops.operations import _map_tensor_ops
 from mindspore.ops.composite.multitype_ops import _compile_utils as compile_utils
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
+from mindspore.ops.operations._inner_ops import SliceGetItem
+from ...operations._sequence_ops import SequenceSlice
 
+DOC_URL = "https://mindspore.cn/docs/zh-CN/master/note/index_support.html"
 
-getitem = base.MultitypeFuncGraph('getitem', True)
+getitem = base.MultitypeFuncGraph('getitem', doc_url=DOC_URL)
 """
 getitem is a metafuncgraph object which will get item from an object according to input type
 using ".register" decorator.
 """
 
+slice_getitem = SliceGetItem()
+sequence_slice = SequenceSlice()
+
 
 class _TupleSlice(base.SequenceSliceGetItem_):
     """
@@ -125,6 +133,17 @@ def _tuple_getitem_by_slice(data, slice_index):
     Outputs:
         Tuple, element type is the same as the element type of data.
     """
+    if F.is_sequence_shape_unknown(data) or not F.isconstant(slice_index):
+        start = slice_getitem(slice_index, "start")
+        stop = slice_getitem(slice_index, "stop")
+        step = slice_getitem(slice_index, "step")
+        if start is None:
+            start = 0
+        if step is None:
+            step = 1
+        if stop is None:
+            stop = (2**31-1) if step >= 1 else -(2**31-1)
+        return sequence_slice(data, start, stop, step)
     return _tuple_slice(data, slice_index)
 
 
@@ -140,7 +159,6 @@ def _tuple_getitem_by_tensor(data, tensor_index):
     Outputs:
         Type, is the same as the element type of data.
     """
-    tensor_index = F.select(tensor_index >= 0, tensor_index, tensor_index + len(data))
     return _tuple_get_item_tensor(data, tensor_index)
 
 
@@ -171,17 +189,31 @@ def _list_getitem_by_slice(data, slice_index):
     Outputs:
         List, element type is the same as the element type of data.
     """
+    if F.is_sequence_shape_unknown(data) or not F.isconstant(slice_index):
+        start = slice_getitem(slice_index, "start")
+        stop = slice_getitem(slice_index, "stop")
+        step = slice_getitem(slice_index, "step")
+        if start is None:
+            start = 0
+        if step is None:
+            step = 1
+        if stop is None:
+            stop = (2**31-1) if step >= 1 else -(2**31-1)
+        return sequence_slice(data, start, stop, step)
     return _list_slice(data, slice_index)
 
 
+@getitem.register("Dictionary", "Tensor")
+@getitem.register("Dictionary", "Tuple")
+@getitem.register("Dictionary", "Number")
 @getitem.register("Dictionary", "String")
 def _dict_getitem_by_key(data, key):
     """
-    Getting item of dictionary by key which is a string.
+    Getting item of dictionary by key.
 
     Inputs:
         data (Dictionary): data
-        key (str): Key of the data.
+        key (Tensor, Tuple, Number, String): Key of the data.
 
     Outputs:
         Type, is as same as the element type of data.
@@ -307,3 +339,18 @@ def _tensor_getitem_by_tuple(data, tuple_index):
         Tensor, element type is the same as the element type of data.
     """
     return compile_utils.tensor_index_by_tuple(data, tuple_index)
+
+
+@getitem.register("MapTensor", "Tensor")
+def _map_tensor_getitem(map_tensor, key_tensor):
+    """
+    Getting value tensor from map tensor by key tensor.
+
+    Inputs:
+        map_tensor (MapTensor): A map tensor.
+        key_tensor (Tensor): The key tensor.
+
+    Outputs:
+        Tensor, value tensor according the key tensor.
+    """
+    return _map_tensor_ops.MapTensorGet(True)(map_tensor, key_tensor)

mindspore/ops/composite/multitype_ops/greater_equal_impl.py

@@ -17,6 +17,7 @@
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
+from ...operations._sequence_ops import tuple_greater_equal, list_greater_equal
 
 # greater_equal is a metagraph object which will determine if two objects are greater_equal according to input type
 # using ".register" decorator
@@ -68,3 +69,33 @@ def _greater_equal_tensor(x, y):
        Tensor, return value by operator P.GreaterEqual.
    """
     return F.tensor_ge(x, y)
+
+
+@greater_equal.register("Tuple", "Tuple")
+def _greater_equal_tuple(x, y):
+    """
+    Determine whether x is greater 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 tuple_greater_equal()(x, y)
+
+
+@greater_equal.register("List", "List")
+def _greater_equal_list(x, y):
+    """
+    Determine whether x is greater 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 list_greater_equal()(x, y)

mindspore/ops/composite/multitype_ops/greater_impl.py

@@ -18,6 +18,7 @@
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
+from ...operations._sequence_ops import tuple_greater_than, list_greater_than
 
 # greater is a metafuncgraph object which will determine if two objects are greater according to input type
 # using ".register" decorator
@@ -69,3 +70,33 @@ def _greater_tensor(x, y):
        tensor, return operation of x and y by P.Greater.
    """
     return F.tensor_gt(x, y)
+
+
+@greater.register("Tuple", "Tuple")
+def _greater_than_tuple(x, y):
+    """
+    Determine whether x is greater than y.
+
+    Args:
+       x(Tuple): Tuple.
+       y(Tuple): Tuple.
+
+    Returns:
+       bool, if x > y return true in python logic, x <= y return false.
+   """
+    return tuple_greater_than()(x, y)
+
+
+@greater.register("List", "List")
+def _greater_than_list(x, y):
+    """
+    Determine whether x is greater than y.
+
+    Args:
+       x(List): List.
+       y(List): List.
+
+    Returns:
+       bool, if x > y return true in python logic, x <= y return false.
+   """
+    return list_greater_than()(x, y)

mindspore/ops/composite/multitype_ops/in_impl.py

@@ -14,12 +14,13 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `in` operations."""
-
+from __future__ import absolute_import
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 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)
 
 
@@ -103,13 +108,16 @@ def _string_in_list(x, y):
     return const_utils.scalar_in_sequence(x, y)
 
 
+@in_.register("Tensor", "Dictionary")
+@in_.register("Tuple", "Dictionary")
+@in_.register("Number", "Dictionary")
 @in_.register("String", "Dictionary")
 def _str_in_dict(x, y):
     """
-    Determine if a str in dict.
+    Determine if an element is in dict.
 
     Args:
-       x: str
+       x: Tensor, Tuple, Number, String
        y: dict
 
     Returns:
@@ -130,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)
 
 
@@ -145,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

@@ -12,13 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 """Implementation for internal polymorphism `less_equal` operations."""
-
 from __future__ import absolute_import
+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

@@ -15,9 +15,12 @@
 
 """Implementation for internal polymorphism `less` operations."""
 from __future__ import absolute_import
+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
@@ -69,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/logical_and_impl.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 """Implementation for internal polymorphism `logical and` operations."""
-
 from __future__ import absolute_import
+from __future__ import division
+
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 

mindspore/ops/composite/multitype_ops/logical_or_impl.py

@@ -14,8 +14,9 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `logical or` operations."""
-
 from __future__ import absolute_import
+from __future__ import division
+
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -14,7 +14,7 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `mod` 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

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 """Implementation for internal polymorphism `mul` operations."""
-
 from mindspore.ops.operations import _inner_ops as inner
 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)
 """
@@ -103,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:
@@ -119,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:
@@ -135,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:
@@ -151,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:
@@ -231,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")
@@ -243,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

@@ -14,12 +14,13 @@
 # ============================================================================
 
 """Implementation for internal polymorphism `not in` operations."""
-
+from __future__ import absolute_import
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 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)
 
 
@@ -103,13 +108,16 @@ def _string_not_in_list(x, y):
     return not const_utils.scalar_in_sequence(x, y)
 
 
+@not_in_.register("Tensor", "Dictionary")
+@not_in_.register("Tuple", "Dictionary")
+@not_in_.register("Number", "Dictionary")
 @not_in_.register("String", "Dictionary")
 def _str_not_in_dict(x, y):
     """
-    Determine if a str not in dict.
+    Determine if an element is not in dict.
 
     Args:
-       x: str
+       x: Tensor, Tuple, Number, String
        y: dict
 
     Returns:
@@ -130,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)
 
 
@@ -145,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/pow_impl.py

@@ -15,6 +15,7 @@
 
 """Implementation for internal polymorphism `pow` 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