mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

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.
@@ -25,6 +25,7 @@ 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 ... 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):
@@ -1844,39 +1812,24 @@ def searchsorted(x, v, side='left', sorter=None):
         2
     """
 
-    def get_log2_size(size):
-        """Get log2 size"""
-        log2_res = F.log2(F.cast(size, mstype.float32))
-        ceil_res = F.ceil(log2_res)
-        cast_res = F.cast(ceil_res, mstype.int64)
-        return cast_res
-
     if side not in ('left', 'right'):
-        const_utils.raise_value_error('invalid value for keyword "side"')
-    a = x.astype(mstype.float32)
-    if not check_is_tensor(F.typeof(v)):
+        raise ValueError(f"For 'Tensor.searchsorted', the argument 'side' should be one of in "
+                            f"['left', 'right'], but got {side}.")
+    if not isinstance(v, Tensor):
         v = const_utils.make_tensor(v)
-    shape = v.shape
     if sorter is not None:
-        if sorter.ndim != 1 or sorter.size != a.size:
-            const_utils.raise_value_error(
-                'sorter must be 1-D array with the same size as `a`')
-        sorter = const_utils.make_tensor(sorter)
-        sorter = sorter.reshape(sorter.shape + (1,))
-        a = F.gather_nd(a, sorter)
-    less_op = F.tensor_le if side == 'left' else F.tensor_lt
-    i = F.fill(mstype.int32, shape, 0)
-    j = F.fill(mstype.int32, shape, a.size)
-
-    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
-        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)
-        index += 1
-    return j
+        if not isinstance(sorter, (int, list, tuple, Tensor)):
+            raise TypeError("For Tensor.searchsorted, the type of the argument 'sorter' must be one of 'int', "
+                            "'list', 'tuple', 'Tensor', but got {}.".format(type(sorter)))
+        if not isinstance(sorter, Tensor):
+            sorter = const_utils.make_tensor(sorter)
+        if sorter.size != x.size:
+            raise ValueError('The size of sorter must be the same as the Tensor')
+
+    dtype = mstype.int32
+    right = (side == 'right')
+    search_sorted_ = P.SearchSorted(dtype, right)
+    return search_sorted_(x, v, sorter)
 
 
 def fill(x, value):
@@ -2307,6 +2260,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 +2299,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 +2334,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 +2372,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 +2403,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(
@@ -2469,21 +2418,11 @@ def float_func(*data):
     return cast_to_float(data)
 
 
-def list_func(*data):
+def list_func(data):
     """Implementation of `list`."""
-    data_len = len(data)
-    if data_len >= 2:
-        const_utils.raise_type_error("list() requires 0 or 1 arguments.")
-    if data_len == 0:
-        return F.make_list()
-    data = data[0]
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
-        const_utils.raise_type_error(
+        raise TypeError(
             "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):
@@ -2492,24 +2431,14 @@ def list_func(*data):
             return ret
     else:
         ret = F.make_list()
-    for i in range(len(data)):
-        ret = ret + F.make_list(data[i])
+    for i in data:
+        ret = ret + F.make_list(i)
     return ret
 
-
-def tuple_func(*data):
+def tuple_func(data):
     """Implementation of `tuple`."""
-    data_len = len(data)
-    if data_len >= 2:
-        raise TypeError("tuple() requires 0 or 1 arguments.")
-    if data_len == 0:
-        return F.make_tuple()
-    data = data[0]
     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):
@@ -2518,11 +2447,23 @@ def tuple_func(*data):
             return ret
     else:
         ret = F.make_tuple()
-    for i in range(len(data)):
-        ret = ret + F.make_tuple(data[i])
+    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 +2484,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 +2496,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 +2516,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 +2530,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 +2612,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 +2688,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 +2859,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):
@@ -3143,11 +3052,11 @@ def negative(input):
     return F.neg(input)
 
 
-def nonzero(input):
+def nonzero(input, as_tuple=False):
     """
     Return a Tensor of the positions of all non-zero values.
     """
-    return F.nonzero(input)
+    return F.nonzero(input, as_tuple)
 
 
 def new_zeros(x, size, *, dtype=None):
@@ -3249,7 +3158,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 +3432,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 +3450,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 +4035,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)
 
 
@@ -4470,6 +4353,13 @@ def amax(input, axis=None, keep_dims=False):
     return F.amax(input, axis, keep_dims)
 
 
+def uniform(input, from_=0., to=1., generator=None):
+    r"""
+    Generates random numbers in the half-open interval [from_, to).
+    """
+    return F.uniform_ext(input, from_, to, generator)
+
+
 def amin(input, axis=None, keep_dims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.amin`.
@@ -4533,3 +4423,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)