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

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -14,21 +14,19 @@
 # ============================================================================
 """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
 NO_TENSOR = 1
@@ -117,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))
@@ -160,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:
@@ -170,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.
 
@@ -192,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)):
@@ -215,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:
@@ -223,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
@@ -407,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
@@ -422,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:
@@ -479,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
@@ -517,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):
@@ -578,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
 
 
@@ -606,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])
@@ -707,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`).
@@ -715,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
@@ -748,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
@@ -771,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
 
@@ -804,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
@@ -818,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:
@@ -829,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
@@ -863,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
@@ -880,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)
@@ -889,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)
 
 
@@ -913,6 +948,12 @@ def use_copy_slice(tuple_index):
     return False
 
 
+@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)
@@ -938,8 +979,22 @@ def get_output_dtype(dtype_1, dtype_2, use_complex=False):
 
 @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

@@ -21,6 +21,7 @@ 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)
@@ -195,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
@@ -272,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)
 
 
@@ -304,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")

mindspore/ops/composite/multitype_ops/div_impl.py

@@ -20,7 +20,7 @@ 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)
@@ -39,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/getitem_impl.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 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.
@@ -20,13 +20,20 @@ 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
 
-getitem = base.MultitypeFuncGraph('getitem', True)
+DOC_URL = "https://mindspore.cn/docs/zh-CN/master/note/index_support.html"
+
+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_):
     """
@@ -126,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)
 
 
@@ -141,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)
 
 
@@ -172,6 +189,17 @@ 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)
 
 

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)