mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/_extends/parse/resources.py

@@ -70,9 +70,7 @@ parse_object_map = {
 
     # operation symbol type
     'getitem':      (composite_ns, 'getitem', ''),
-    'ms_iter':      (composite_ns, 'ms_iter', ''),
     'ms_next':      (composite_ns, 'ms_next', ''),
-    'hasnext':      (composite_ns, 'hasnext', ''),
 
     # undefined type
     SYMBOL_UNDEFINE: (None, 'undefine', ''),
@@ -134,12 +132,12 @@ convert_object_map = {
     # system function
     T.abs:          Primitive('inner_abs'),
     T.round:        Primitive('inner_round'),
-    T.len:          Primitive('inner_len'),
+    T.len:          M.ms_len,
     T.bool_:        M.bool_,
     T.map:          C.Map(),
     T.filter:       M.filter_,
     T.partial:      F.partial,
-    T.zip:          C.zip_operation,
+    T.zip:          M.ms_zip,
     T.enumerate:    M.enumerate_,
     T.isinstance:   Primitive('isinstance'),
     T.max:          M.ms_max,
@@ -149,9 +147,9 @@ convert_object_map = {
     T.hasattr:      M.hasattr,
 
     # custom define operation
-    T.iter:         M.ms_iter,
-    T.next:         M.ms_next,
-    T.hasnext:      M.hasnext,
+    T.iter:         C.iter_converter,
+    T.next:         C.ms_next,
+    T.hasnext:      C.ms_hasnext,
     T.MakeTuple:    F.make_tuple,
     T.make_dict:    F.make_dict,
     T.make_list:    F.make_list,
@@ -180,3 +178,38 @@ convert_class_to_function_map = {
     "class 'bool'":  M.bool_func,
     "class 'str'":   M.str_func
 }
+
+constant_fold_functions = [
+    abs,
+    all,
+    any,
+    float,
+    int,
+    bool,
+    len,
+    max,
+    min,
+    pow,
+    repr,
+    round,
+    str,
+    sum,
+    type,
+    T.add,
+    T.sub,
+    T.mul,
+    T.truediv,
+    T.floordiv,
+    T.mod,
+    T.pos,
+    T.neg,
+    T.not_,
+    T.and_,
+    T.or_,
+    T.xor,
+    T.lshift,
+    T.rshift,
+    T.matmul,
+    T.getitem,
+    T.invert
+]

mindspore/_extends/parse/standard_method.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2023 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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,11 +20,12 @@ from __future__ import absolute_import
 from mindspore import Tensor, CSRTensor, COOTensor
 from mindspore import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore.common import mutable
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
+from mindspore.ops.operations._sequence_ops import TensorToTuple
+from mindspore.ops_generate.gen_ops_inner_prim import ListToTuple, TupleToList
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -34,13 +35,14 @@ from ...ops import operations as P
 from ...ops import composite
 from ...ops.operations import array_ops
 from ...ops.composite import MultitypeFuncGraph, env_get, hyper_add, \
-    zeros_like, ones_like, repeat_elements
+    zeros_like, ones_like, repeat_elements, multitype_ops
 from ...ops.composite.multitype_ops import _constexpr_utils as const_utils
 from ...ops.composite.multitype_ops import _compile_utils as compile_utils
 from ...ops.operations.math_ops import Median
 from ...ops.operations._inner_ops import Format
 from ...ops.operations import _csr_ops
 from ...ops.operations import _map_tensor_ops
+from ...ops.operations._sequence_ops import TensorToScalar
 from ...ops.primitive import constexpr, _primexpr
 from ...common import dtype as mstype
 from ...ops.operations._sequence_ops import ListAppend, ListInsert, SequenceMax, SequenceMin, \
@@ -99,7 +101,7 @@ def ndimension(x):
     return len(x.shape)
 
 
-def prod(input, axis=None, keep_dims=False):
+def prod(input, axis=None, keep_dims=False, dtype=None):
     """
     Reduces a dimension of a tensor by product all elements in the dimension.
 
@@ -108,6 +110,7 @@ def prod(input, axis=None, keep_dims=False):
         axis (Union[None, int, tuple(int), list(int)]): Dimensions of reduction,
             when axis is None or empty tuple, reduce all dimensions. Default: ``None``.
         keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
+        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
 
     Returns:
         Tensor, has the same data type as input tensor.
@@ -123,7 +126,7 @@ def prod(input, axis=None, keep_dims=False):
         >>> print(output)
         6.0
     """
-    return F.prod(input, axis, keep_dims)
+    return F.prod(input, axis, keep_dims, dtype)
 
 
 def addcdiv(input, tensor1, tensor2, value=1):
@@ -549,8 +552,17 @@ def transpose(x, *axis):
     return F.transpose(x, perm)
 
 
+def T(x):
+    """
+    Return the transposed tensor.
+    """
+    if x.ndim <= 1:
+        return x
+    return transpose(x)
+
+
 # `tensor.T` is used as a property in graph mode
-T_ = transpose
+T_ = T
 
 
 def reshape(x, *shape):
@@ -1405,51 +1417,7 @@ def diagonal(x, offset=0, axis1=0, axis2=1):
     if ndim < 2:
         const_utils.raise_value_error(
             'diagonal requires an array of at least two dimensions')
-    dtype = x.dtype
-
-    axes = check_axis_valid((axis1, axis2), ndim)
-    perm = ()
-    for i in range(ndim):
-        if i not in axes:
-            perm += (i,)
-    perm += axes
-    x = x.transpose(perm)
-
-    shape = x.shape
-    n, m = shape[-2:]
-
-    e = F.eye(n, m, dtype)
-    if offset >= m or offset <= -n:
-        zero_shape = shape[:-2] + (0,)
-        return F.zeros(zero_shape, dtype)
-    if offset != 0:
-        e = e.astype(mstype.float32)
-        if offset > 0:
-            e_left = F.fill(dtype, (n, offset), 0)
-            e_right = e[..., 0:m - offset:1]
-            e = P.Concat(1)((e_left, e_right)).astype(dtype)
-        elif offset < 0:
-            e_upper = F.fill(dtype, (-offset, m), 0)
-            e_lower = e[0:n + offset:1, ...]
-            e = P.Concat(0)((e_upper, e_lower)).astype(dtype)
-    e = F.broadcast_to(e, shape)
-
-    prod_val = F.tensor_mul(x, e)
-    res = F.reduce_sum(prod_val.astype(mstype.float32), -1)
-
-    begin = ()
-    for _ in range(ndim - 2):
-        begin += (0,)
-    last_dim_begin = max_(0, -offset)
-    begin += (last_dim_begin,)
-    size = res.shape[:-1]
-    last_dim_end = min_(
-        shape[-2], max_(0, shape[-1] - offset)) - last_dim_begin
-    if last_dim_end <= 0:
-        return empty_compile(dtype, (0,))
-    size += (last_dim_end,)
-    res = F.tensor_slice(res, begin, size)
-    return res.astype(dtype)
+    return F.diagonal(x, offset, axis1, axis2)
 
 
 def diagonal_scatter(input, src, offset, dim1=0, dim2=1):
@@ -1871,7 +1839,7 @@ def searchsorted(x, v, side='left', sorter=None):
     loop_num = get_log2_size(F.shape_mul(a.shape) + 1)
     index = Tensor([0])
     while index < loop_num:
-        mid = (i - F.neg_tensor(j)) // 2
+        mid = (i - F.neg(j)) // 2
         mask = less_op(v, F.gather_nd(a, mid.reshape(mid.shape + (1,))))
         i = F.select(mask, i, mid)
         j = F.select(mask, mid, j)
@@ -2307,6 +2275,10 @@ def hypot(x, other):
     return F.hypot(x, other)
 
 
+def softmax(input, axis, dtype=None):
+    return F.softmax(input, axis, dtype=dtype)
+
+
 def soft_shrink(input, lambd=0.5):
     """Apply the soft shrink function for a tensor. Calculates the output according to the input elements."""
     return F.soft_shrink(input, lambd)
@@ -2342,31 +2314,6 @@ def itemset(data, *args):
     return compile_utils.tensor_itemset(data, *args)
 
 
-def ms_iter(xs):
-    """Implementation of `iter`."""
-    return xs.__ms_iter__
-
-
-def ms_next(it):
-    """Implementation of `next`."""
-    return it.__ms_next__
-
-
-def hasnext(it):
-    """Implementation of `hasnext`."""
-    return it.__ms_hasnext__
-
-
-def str_next(xs):
-    """Next string."""
-    return xs[0], xs[1:]
-
-
-def str_hasnext(xs):
-    """Whether the string is empty or not."""
-    return len(xs) > 0
-
-
 @constexpr
 def cast_to_str(data):
     return str(data)
@@ -2402,7 +2349,8 @@ def bool_func(*data):
         tensor_shape = F.shape(data)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
-            return F.scalar_cast(data, mstype.bool_)
+            data = F.cast(data, mstype.bool_)
+            return TensorToScalar()(data)
         raise ValueError("The truth value of an array with more than one element is ambiguous.")
     if not F.isconstant(data):
         if hasattr(data, "__bool__"):
@@ -2439,6 +2387,14 @@ def int_func(*data):
     if not F.isconstant(target):
         if base != 10:
             const_utils.raise_type_error("int() does not support non-constant input when 'base' is specified.")
+        if isinstance(target, Tensor):
+            tensor_shape = F.shape(target)
+            tensor_shape_len = len(tensor_shape)
+            if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
+                target = F.cast(target, mstype.int64)
+                return TensorToScalar()(target)
+            raise ValueError(f"Can not convert Tensor with more than one element to Scalar, "
+                             f"while the data's shape is : {tensor_shape}")
         return F.scalar_cast(target, mstype.int64)
     if isinstance(target, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
@@ -2462,6 +2418,14 @@ def float_func(*data):
         return 0.0
     data = data[0]
     if not F.isconstant(data):
+        if isinstance(data, Tensor):
+            tensor_shape = F.shape(data)
+            tensor_shape_len = len(tensor_shape)
+            if tensor_shape_len == 0 or (tensor_shape_len == 1 and tensor_shape[0] == 1):
+                data = F.cast(data, mstype.float32)
+                return TensorToScalar()(data)
+            raise ValueError(f"Can not convert Tensor with more than one element to Scalar, "
+                             f"while the data's shape is: {tensor_shape}")
         return F.scalar_cast(data, mstype.float32)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
@@ -2477,23 +2441,18 @@ def list_func(*data):
     if data_len == 0:
         return F.make_list()
     data = data[0]
+    if isinstance(data, list):
+        return data
+    if isinstance(data, tuple):
+        return TupleToList()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         const_utils.raise_type_error(
             "list() does not support single sparse tensor input.")
-    if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
-        data_type = F.typeof(data)
-        const_utils.raise_type_error(
-            str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable([], True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_list()
-    for i in range(len(data)):
-        ret = ret + F.make_list(data[i])
+    ret = F.make_list()
+    for i in data:
+        ret = ret + F.make_list(i)
     return ret
 
 
@@ -2505,24 +2464,32 @@ def tuple_func(*data):
     if data_len == 0:
         return F.make_tuple()
     data = data[0]
+    if isinstance(data, tuple):
+        return data
+    if isinstance(data, list):
+        return ListToTuple()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         raise TypeError("tuple() does not support single sparse tensor input.")
-    if not isinstance(data, Tensor) and not hasattr(data, "__ms_iter__"):
-        data_type = F.typeof(data)
-        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable((), True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_tuple()
-    for i in range(len(data)):
-        ret = ret + F.make_tuple(data[i])
+    ret = F.make_tuple()
+    for i in data:
+        ret = ret + F.make_tuple(i)
     return ret
 
 
+def ms_zip(*data):
+    """Implementation of `tuple`."""
+    x = ()
+    for i in data:
+        if isinstance(i, Tensor):
+            if len(F.shape(i)) == 0:
+                raise TypeError("Cannot iterate over a scalar tensor.")
+            i = tuple(i)
+        x = x + (i,)
+    return composite.zip_operation(*x)
+
+
 def max_tensor(*data):
     """Get the max of tensor inputs."""
     if len(data) == 1:
@@ -2543,8 +2510,7 @@ def get_max_min_data_len(*data):
     if isinstance(data, (dict, list, tuple)):
         len_data = len(data)
     else:
-        const_utils.raise_type_error(
-            "max() or min() does not support the data type.")
+        raise TypeError("max() or min() does not support the data type.")
     return len_data
 
 
@@ -2556,8 +2522,7 @@ def get_tensor_num(data):
             tensor_shape = F.shape(input_data)
             tensor_shape_len = len(tensor_shape)
             if tensor_shape_len != 0 and not (tensor_shape_len == 1 and tensor_shape[0] == 1):
-                const_utils.raise_value_error(
-                    "The truth value of an array with more than one element is ambiguous.")
+                raise ValueError("The truth value of an array with more than one element is ambiguous.")
             tensor_num = tensor_num + 1
     return tensor_num
 
@@ -2577,9 +2542,9 @@ def check_sequence_all_variable_scalar(x, str_info):
     """Check whether x can be used in SequenceMax and SequenceMin"""
     if F.is_sequence_shape_unknown(x):
         if F.is_dynamic_sequence_element_unknown(x):
-            const_utils.raise_value_error(str_info + "() arg is an empty sequence.")
+            raise ValueError(str_info + "() arg is an empty sequence.")
         if not isinstance(x[0], (int, float)):
-            const_utils.raise_value_error(
+            raise ValueError(
                 "When the input to " + str_info + "() is dynamic length sequence, only support scalar type input")
         return True
     contain_variable_scalar = False
@@ -2591,74 +2556,53 @@ def check_sequence_all_variable_scalar(x, str_info):
     return contain_variable_scalar
 
 
-def get_data_type_str(input_data):
-    """Get the type of input."""
-    if isinstance(input_data, (int, float, bool)):
-        return "variable " + str(F.typeof(input_data))
-    return str(F.typeof(input_data))
-
-
-def check_isconstant(input_data, func_name):
-    """Check the input data of func is constant."""
-    if not F.isconstant(input_data):
-        const_utils.raise_type_error("The input of " + func_name + " only support Tensor, List, Tuple, constant Scalar,"
-                                                                   " but got " + get_data_type_str(input_data))
-
-
 def ms_max_one_element(x):
     """Implementation of `max` which inputs has only one element."""
     if isinstance(x, Tensor):
         tensor_shape = F.shape(x)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
         if tensor_shape_len >= 2:
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
         return x.max()
     # Deal with Tensor in tuple or list
     if isinstance(x, (list, tuple)):
         if check_sequence_all_variable_scalar(x, "max"):
             return SequenceMax()(x)
         if len(x) == 0:
-            const_utils.raise_value_error("max() arg is an empty sequence.")
+            raise ValueError("max() arg is an empty sequence.")
         tensor_num = get_tensor_num(x)
-        if tensor_num == len(x):
+        if F.isconstant(tensor_num) and F.isconstant(len(x)) and tensor_num == len(x):
             return max_tensor(x)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "max() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("max(x)", {}, {"x": x})
         if exist_tensor(x):
-            const_utils.raise_type_error(
-                "max() cannot support tensor in list or tuple nested now.")
-    check_isconstant(x, "max()")
-    return max_(x)
+            raise TypeError("max() cannot support tensor in list or tuple nested now.")
+    if not isinstance(x, (int, float, bool)):
+        return F._py_interpret("max(x)", {}, {"x": x})
+    raise TypeError("The object is not iterable.")
 
 
 def ms_max(*data):
     """Implementation of `max`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0:
-        const_utils.raise_type_error("max() requires 1 argument at least.")
+    if len_data <= 0: # pylint: disable=no-else-raise
+        raise TypeError("max() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
         return ms_max_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
-        if tensor_num == len_data:
+        if F.isconstant(tensor_num) and F.isconstant(len_data) and tensor_num == len_data:
             return max_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "max() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("max(data)", {}, {"data": data})
         # exist tensor in list/tuple
         if exist_tensor(data):
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
-    for input_data in data:
-        check_isconstant(input_data, "max()")
-    return max_(*data)
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
+    return F._py_interpret("max(data)", {}, {"data": data})
 
 
 def min_tensor(*data):
@@ -2694,71 +2638,62 @@ def ms_min_one_element(x):
         tensor_shape = F.shape(x)
         tensor_shape_len = len(tensor_shape)
         if tensor_shape_len == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
         if tensor_shape_len >= 2:
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
         return x.min()
     # Deal with Tensor in tuple or list
     if isinstance(x, (list, tuple)):
         if check_sequence_all_variable_scalar(x, "min"):
             return SequenceMin()(x)
         if len(x) == 0:
-            const_utils.raise_value_error("min() arg is an empty sequence.")
+            raise ValueError("min() arg is an empty sequence.")
         tensor_num = get_tensor_num(x)
-        if tensor_num == len(x):
+        if F.isconstant(tensor_num) and F.isconstant(len(x)) and tensor_num == len(x):
             return min_tensor(x)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "min() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("min(x)", {}, {"x": x})
         if exist_tensor(x):
-            const_utils.raise_type_error(
-                "min() cannot support tensor in list or tuple nested now.")
-    check_isconstant(x, "min()")
-    return min_(x)
+            raise TypeError("min() cannot support tensor in list or tuple nested now.")
+    if not isinstance(x, (int, float, bool)):
+        return F._py_interpret("min(x)", {}, {"x": x})
+    raise TypeError("The object is not iterable.")
 
 
 def ms_min(*data):
     """Implementation of `min`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0:
-        const_utils.raise_type_error("min() requires 1 argument at least.")
+    if len_data <= 0: # pylint: disable=no-else-raise
+        raise TypeError("min() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
         return ms_min_one_element(x)
     elif len_data >= 2:
         tensor_num = get_tensor_num(data)
         # All inputs is Tensor
-        if tensor_num == len_data:
+        if F.isconstant(tensor_num) and F.isconstant(len_data) and tensor_num == len_data:
             return min_tensor(*data)
         if tensor_num != 0:
-            const_utils.raise_type_error(
-                "min() cannot contain both tensor and non-tensor type.")
+            return F._py_interpret("min(data)", {}, {"data": data})
         # exist tensor in list/tuple
         if exist_tensor(data):
-            const_utils.raise_value_error(
-                "The truth value of an array with more than one element is ambiguous.")
-    for input_data in data:
-        check_isconstant(input_data, "min()")
-    return min_(*data)
+            raise ValueError("The truth value of an array with more than one element is ambiguous.")
+    return F._py_interpret("min(data)", {}, {"data": data})
 
 
 def ms_sum(*data):
     """Implementation of `sum`."""
     len_data = len(data)
     if len_data <= 0 or len_data > 2:
-        const_utils.raise_type_error("sum() requires 1 or 2 arguments.")
+        raise TypeError("sum() requires 1 or 2 arguments.")
     x = data[0]
-    if not isinstance(x, Tensor) and not hasattr(x, "__ms_iter__"):
+    if isinstance(x, (int, float, bool)):
         data_type = F.typeof(x)
-        const_utils.raise_type_error(
-            str(data_type) + " object is not iterable.")
+        raise TypeError(str(data_type) + " object is not iterable.")
     if isinstance(x, Tensor):
         tensor_shape = F.shape(x)
         if len(tensor_shape) == 0:
-            const_utils.raise_type_error(
-                "Cannot iterate over a scalar tensor.")
+            raise TypeError("Cannot iterate over a scalar tensor.")
     if isinstance(x, dict):
         x = x.keys()
     result = 0
@@ -2779,7 +2714,7 @@ def ms_len(data):
 
 def floor(x):
     """Rounds a tensor down to the closest integer element-wise."""
-    return x.__floor__()
+    return F.floor(x)
 
 
 def floor_divide(input, other):
@@ -2950,7 +2885,7 @@ def select(x, condition, y):
             input_y = F.cast(input_y, mstype.int32)
         else:
             input_y = F.cast(input_y, mstype.float32)
-    return F.select(condition, x, y)
+    return F.select(condition, x, input_y)
 
 
 def view(x, *shape):
@@ -3249,7 +3184,7 @@ def random_categorical(x, num_sample, seed=0, dtype=mstype.int64):
 @constexpr
 def empty_tensor(dtype):
     """Return empty tensor"""
-    return Tensor([], dtype)
+    return Tensor_([], dtype)
 
 
 @constexpr
@@ -3523,26 +3458,16 @@ def triu(input, diagonal=0):
 #############
 
 
-def tuple_next(xs):
-    """Next tuple."""
-    return xs[0], xs[1:]
-
-
-def tuple_hasnext(xs):
-    """Whether the tuple is empty or not."""
+def ms_hasnext(xs):
+    """Whether the input has next element"""
     return len(xs) > 0
 
 
-def list_next(xs):
-    """Next list."""
+def ms_next(xs):
+    """Get next element and res elements"""
     return xs[0], xs[1:]
 
 
-def list_hasnext(xs):
-    """Whether the list is empty or not."""
-    return len(xs) > 0
-
-
 def dict_next(xs):
     """Next array."""
     keys = xs.keys()
@@ -3551,23 +3476,7 @@ def dict_next(xs):
     for i in range(1, len(keys)):
         new_keys.append(keys[i])
         new_values.append(xs[keys[i]])
-    new_dict = {}
-    return keys[0], new_dict.fromkeys(new_keys, new_values)
-
-
-def dict_hasnext(xs):
-    """Whether the dict is empty or not."""
-    return len(xs) > 0
-
-
-def array_next(xs):
-    """Next array."""
-    return xs[0], xs[1:]
-
-
-def array_hasnext(xs):
-    """Whether the array is empty or not."""
-    return len(xs) > 0
+    return keys[0], F.make_dict(new_keys, new_values)
 
 
 def list_append(self_, list_item):
@@ -4152,7 +4061,7 @@ def expand(input, size):
     r"""
     Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
     """
-    size = P.TensorToTuple()(size)
+    size = TensorToTuple()(size)
     return F.broadcast_to(input, size)
 
 
@@ -4533,3 +4442,15 @@ def outer(input, vec2):
     For details, please refer to :func:`mindspore.ops.vec2`.
     """
     return F.outer(input, vec2)
+
+def sigmoid(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.sigmoid`.
+    """
+    return F.sigmoid(input)
+
+def _getitem(data, index):
+    return multitype_ops.getitem(data, index)
+
+def _setitem(data, index, value):
+    return multitype_ops.setitem(data, index, value)