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

mindspore/ops/auto_generate/pyboost_inner_prim.py

@@ -0,0 +1,359 @@
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+from mindspore.common._stub_tensor import _convert_stub
+from mindspore.ops.auto_generate.gen_arg_handler import *
+from mindspore._c_expression import ArgMaxWithValuePrim_
+from mindspore._c_expression import ArgMinWithValuePrim_
+from mindspore._c_expression import BatchMatMulPrim_
+from mindspore._c_expression import BatchNormGradExtPrim_
+from mindspore._c_expression import BroadcastToPrim_
+from mindspore._c_expression import ConcatPrim_
+from mindspore._c_expression import ConvolutionGradPrim_
+from mindspore._c_expression import ConvolutionPrim_
+from mindspore._c_expression import FFNExtPrim_
+from mindspore._c_expression import FlashAttentionScoreGradPrim_
+from mindspore._c_expression import FlashAttentionScorePrim_
+from mindspore._c_expression import GridSampler2DGradPrim_
+from mindspore._c_expression import GridSampler2DPrim_
+from mindspore._c_expression import GridSampler3DGradPrim_
+from mindspore._c_expression import GridSampler3DPrim_
+from mindspore._c_expression import MatMulPrim_
+from mindspore._c_expression import MaxPoolGradWithIndicesPrim_
+from mindspore._c_expression import MaxPoolGradWithMaskPrim_
+from mindspore._c_expression import MaxPoolWithIndicesPrim_
+from mindspore._c_expression import MaxPoolWithMaskPrim_
+from mindspore._c_expression import OneHotExtPrim_
+from mindspore._c_expression import QuantBatchMatmulPrim_
+from mindspore._c_expression import ReduceAllPrim_
+from mindspore._c_expression import ReduceAnyPrim_
+from mindspore._c_expression import ReverseV2Prim_
+from mindspore._c_expression import SoftmaxPrim_
+from mindspore._c_expression import StackExtPrim_
+from mindspore._c_expression import TrilPrim_
+from mindspore._c_expression import TriuPrim_
+from mindspore._c_expression import UpsampleTrilinear3DGradPrim_
+from mindspore._c_expression import UpsampleTrilinear3DPrim_
+from mindspore._c_expression import WeightQuantBatchMatmulPrim_
+
+
+class _PyboostArgMaxWithValuePrim(ArgMaxWithValuePrim_):
+    def __call__(self, input, axis, keep_dims):
+
+        return _convert_stub(super().__call__(input, axis, keep_dims))
+
+
+argmax_with_value_impl = _PyboostArgMaxWithValuePrim()
+
+
+class _PyboostArgMinWithValuePrim(ArgMinWithValuePrim_):
+    def __call__(self, input, axis, keep_dims):
+
+        return _convert_stub(super().__call__(input, axis, keep_dims))
+
+
+argmin_with_value_impl = _PyboostArgMinWithValuePrim()
+
+
+class _PyboostBatchMatMulPrim(BatchMatMulPrim_):
+    def __call__(self, x, y, transpose_a, transpose_b):
+
+        return _convert_stub(super().__call__(x, y, transpose_a, transpose_b))
+
+
+batch_mat_mul_impl = _PyboostBatchMatMulPrim()
+
+
+class _PyboostBatchNormGradExtPrim(BatchNormGradExtPrim_):
+    def __call__(self, dout, input, weight, running_mean, running_var, saved_mean, saved_rstd, training, eps):
+
+        return _convert_stub(super().__call__(dout, input, weight, running_mean, running_var, saved_mean, saved_rstd, training, eps))
+
+
+batch_norm_grad_ext_impl = _PyboostBatchNormGradExtPrim()
+
+
+class _PyboostBroadcastToPrim(BroadcastToPrim_):
+    def __call__(self, input, shape):
+
+        return _convert_stub(super().__call__(input, shape))
+
+
+broadcast_to_impl = _PyboostBroadcastToPrim()
+
+
+class _PyboostConcatPrim(ConcatPrim_):
+    def __call__(self, tensors, axis):
+
+        return _convert_stub(super().__call__(tensors, axis))
+
+
+concat_impl = _PyboostConcatPrim()
+
+
+class _PyboostConvolutionGradPrim(ConvolutionGradPrim_):
+    def __call__(self, dout, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, output_mask):
+        converted_stride = to_strides(stride)
+        converted_padding = to_2d_paddings(padding)
+        converted_dilation = to_dilations(dilation)
+        converted_output_padding = to_output_padding(output_padding)
+        return _convert_stub(super().__call__(dout, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups, output_mask))
+
+
+convolution_grad_impl = _PyboostConvolutionGradPrim()
+
+
+class _PyboostConvolutionPrim(ConvolutionPrim_):
+    def __call__(self, input, weight, bias, stride, padding, dilation, transposed, output_padding, groups):
+        converted_stride = to_strides(stride)
+        converted_padding = to_2d_paddings(padding)
+        converted_dilation = to_dilations(dilation)
+        converted_output_padding = to_output_padding(output_padding)
+        return _convert_stub(super().__call__(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups))
+
+
+convolution_impl = _PyboostConvolutionPrim()
+
+
+class _PyboostFFNExtPrim(FFNExtPrim_):
+    def __call__(self, x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2, activation, inner_precise):
+        converted_activation = str_to_enum(activation)
+        return _convert_stub(super().__call__(x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2, activation, inner_precise))
+
+
+ffn_ext_impl = _PyboostFFNExtPrim()
+
+
+class _PyboostFlashAttentionScoreGradPrim(FlashAttentionScoreGradPrim_):
+    def __call__(self, query, key, value, dy, pse_shift, drop_mask, padding_mask, atten_mask, softmax_max, softmax_sum, softmax_in, attention_in, prefix, actual_seq_qlen, actual_seq_kvlen, head_num, keep_prob, scale_value, pre_tokens, next_tokens, inner_precise, input_layout, sparse_mode):
+        converted_input_layout = str_to_enum(input_layout)
+        return _convert_stub(super().__call__(query, key, value, dy, pse_shift, drop_mask, padding_mask, atten_mask, softmax_max, softmax_sum, softmax_in, attention_in, prefix, actual_seq_qlen, actual_seq_kvlen, head_num, keep_prob, scale_value, pre_tokens, next_tokens, inner_precise, input_layout, sparse_mode))
+
+
+flash_attention_score_grad_impl = _PyboostFlashAttentionScoreGradPrim()
+
+
+class _PyboostFlashAttentionScorePrim(FlashAttentionScorePrim_):
+    def __call__(self, query, key, value, real_shift, drop_mask, padding_mask, attn_mask, prefix, actual_seq_qlen, actual_seq_kvlen, head_num, keep_prob, scale_value, pre_tokens, next_tokens, inner_precise, input_layout, sparse_mode):
+        converted_input_layout = str_to_enum(input_layout)
+        return _convert_stub(super().__call__(query, key, value, real_shift, drop_mask, padding_mask, attn_mask, prefix, actual_seq_qlen, actual_seq_kvlen, head_num, keep_prob, scale_value, pre_tokens, next_tokens, inner_precise, input_layout, sparse_mode))
+
+
+flash_attention_score_impl = _PyboostFlashAttentionScorePrim()
+
+
+class _PyboostGridSampler2DGradPrim(GridSampler2DGradPrim_):
+    def __call__(self, grad, input_x, grid, interpolation_mode, padding_mode, align_corners):
+        converted_interpolation_mode = str_to_enum(interpolation_mode)
+        converted_padding_mode = str_to_enum(padding_mode)
+        return _convert_stub(super().__call__(grad, input_x, grid, interpolation_mode, padding_mode, align_corners))
+
+
+grid_sampler_2d_grad_impl = _PyboostGridSampler2DGradPrim()
+
+
+class _PyboostGridSampler2DPrim(GridSampler2DPrim_):
+    def __call__(self, input_x, grid, interpolation_mode, padding_mode, align_corners):
+        converted_interpolation_mode = str_to_enum(interpolation_mode)
+        converted_padding_mode = str_to_enum(padding_mode)
+        return _convert_stub(super().__call__(input_x, grid, interpolation_mode, padding_mode, align_corners))
+
+
+grid_sampler_2d_impl = _PyboostGridSampler2DPrim()
+
+
+class _PyboostGridSampler3DGradPrim(GridSampler3DGradPrim_):
+    def __call__(self, grad, input_x, grid, interpolation_mode, padding_mode, align_corners):
+        converted_interpolation_mode = str_to_enum(interpolation_mode)
+        converted_padding_mode = str_to_enum(padding_mode)
+        return _convert_stub(super().__call__(grad, input_x, grid, interpolation_mode, padding_mode, align_corners))
+
+
+grid_sampler_3d_grad_impl = _PyboostGridSampler3DGradPrim()
+
+
+class _PyboostGridSampler3DPrim(GridSampler3DPrim_):
+    def __call__(self, input_x, grid, interpolation_mode, padding_mode, align_corners):
+        converted_interpolation_mode = str_to_enum(interpolation_mode)
+        converted_padding_mode = str_to_enum(padding_mode)
+        return _convert_stub(super().__call__(input_x, grid, interpolation_mode, padding_mode, align_corners))
+
+
+grid_sampler_3d_impl = _PyboostGridSampler3DPrim()
+
+
+class _PyboostMatMulPrim(MatMulPrim_):
+    def __call__(self, input, mat2, transpose_a, transpose_b):
+
+        return _convert_stub(super().__call__(input, mat2, transpose_a, transpose_b))
+
+
+matmul_impl = _PyboostMatMulPrim()
+
+
+class _PyboostMaxPoolGradWithIndicesPrim(MaxPoolGradWithIndicesPrim_):
+    def __call__(self, x, grad, argmax, kernel_size, strides, pads, dilation, ceil_mode, argmax_type):
+        converted_kernel_size = to_kernel_size(kernel_size)
+        converted_strides = to_strides(strides)
+        converted_pads = to_output_padding(pads)
+        converted_dilation = to_dilations(dilation)
+        return _convert_stub(super().__call__(x, grad, argmax, kernel_size, strides, pads, dilation, ceil_mode, argmax_type))
+
+
+max_pool_grad_with_indices_impl = _PyboostMaxPoolGradWithIndicesPrim()
+
+
+class _PyboostMaxPoolGradWithMaskPrim(MaxPoolGradWithMaskPrim_):
+    def __call__(self, x, grad, mask, kernel_size, strides, pads, dilation, ceil_mode, argmax_type):
+        converted_kernel_size = to_kernel_size(kernel_size)
+        converted_strides = to_strides(strides)
+        converted_pads = to_output_padding(pads)
+        converted_dilation = to_dilations(dilation)
+        return _convert_stub(super().__call__(x, grad, mask, kernel_size, strides, pads, dilation, ceil_mode, argmax_type))
+
+
+max_pool_grad_with_mask_impl = _PyboostMaxPoolGradWithMaskPrim()
+
+
+class _PyboostMaxPoolWithIndicesPrim(MaxPoolWithIndicesPrim_):
+    def __call__(self, x, kernel_size, strides, pads, dilation, ceil_mode, argmax_type):
+        converted_kernel_size = to_kernel_size(kernel_size)
+        converted_strides = to_strides(strides)
+        converted_pads = to_output_padding(pads)
+        converted_dilation = to_dilations(dilation)
+        return _convert_stub(super().__call__(x, kernel_size, strides, pads, dilation, ceil_mode, argmax_type))
+
+
+max_pool_with_indices_impl = _PyboostMaxPoolWithIndicesPrim()
+
+
+class _PyboostMaxPoolWithMaskPrim(MaxPoolWithMaskPrim_):
+    def __call__(self, x, kernel_size, strides, pads, dilation, ceil_mode, argmax_type):
+        converted_kernel_size = to_kernel_size(kernel_size)
+        converted_strides = to_strides(strides)
+        converted_pads = to_output_padding(pads)
+        converted_dilation = to_dilations(dilation)
+        return _convert_stub(super().__call__(x, kernel_size, strides, pads, dilation, ceil_mode, argmax_type))
+
+
+max_pool_with_mask_impl = _PyboostMaxPoolWithMaskPrim()
+
+
+class _PyboostOneHotExtPrim(OneHotExtPrim_):
+    def __call__(self, tensor, num_classes, on_value, off_value, axis):
+
+        return _convert_stub(super().__call__(tensor, num_classes, on_value, off_value, axis))
+
+
+one_hot_ext_impl = _PyboostOneHotExtPrim()
+
+
+class _PyboostQuantBatchMatmulPrim(QuantBatchMatmulPrim_):
+    def __call__(self, x1, x2, scale, offset, bias, transpose_x1, transpose_x2, dtype):
+
+        return _convert_stub(super().__call__(x1, x2, scale, offset, bias, transpose_x1, transpose_x2, dtype))
+
+
+quant_batch_matmul_impl = _PyboostQuantBatchMatmulPrim()
+
+
+class _PyboostReduceAllPrim(ReduceAllPrim_):
+    def __call__(self, input, axis, keep_dims):
+
+        return _convert_stub(super().__call__(input, axis, keep_dims))
+
+
+reduce_all_impl = _PyboostReduceAllPrim()
+
+
+class _PyboostReduceAnyPrim(ReduceAnyPrim_):
+    def __call__(self, x, axis, keep_dims):
+
+        return _convert_stub(super().__call__(x, axis, keep_dims))
+
+
+reduce_any_impl = _PyboostReduceAnyPrim()
+
+
+class _PyboostReverseV2Prim(ReverseV2Prim_):
+    def __call__(self, input, axis):
+
+        return _convert_stub(super().__call__(input, axis))
+
+
+reverse_v2_impl = _PyboostReverseV2Prim()
+
+
+class _PyboostSoftmaxPrim(SoftmaxPrim_):
+    def __call__(self, input, axis):
+
+        return _convert_stub(super().__call__(input, axis))
+
+
+softmax_impl = _PyboostSoftmaxPrim()
+
+
+class _PyboostStackExtPrim(StackExtPrim_):
+    def __call__(self, tensors, dim):
+
+        return _convert_stub(super().__call__(tensors, dim))
+
+
+stack_ext_impl = _PyboostStackExtPrim()
+
+
+class _PyboostTrilPrim(TrilPrim_):
+    def __call__(self, input, diagonal):
+
+        return _convert_stub(super().__call__(input, diagonal))
+
+
+tril_impl = _PyboostTrilPrim()
+
+
+class _PyboostTriuPrim(TriuPrim_):
+    def __call__(self, input, diagonal):
+
+        return _convert_stub(super().__call__(input, diagonal))
+
+
+triu_impl = _PyboostTriuPrim()
+
+
+class _PyboostUpsampleTrilinear3DGradPrim(UpsampleTrilinear3DGradPrim_):
+    def __call__(self, dy, input_size, output_size, scales, align_corners):
+
+        return _convert_stub(super().__call__(dy, input_size, output_size, scales, align_corners))
+
+
+upsample_trilinear3d_grad_impl = _PyboostUpsampleTrilinear3DGradPrim()
+
+
+class _PyboostUpsampleTrilinear3DPrim(UpsampleTrilinear3DPrim_):
+    def __call__(self, x, output_size, scales, align_corners):
+
+        return _convert_stub(super().__call__(x, output_size, scales, align_corners))
+
+
+upsample_trilinear3d_impl = _PyboostUpsampleTrilinear3DPrim()
+
+
+class _PyboostWeightQuantBatchMatmulPrim(WeightQuantBatchMatmulPrim_):
+    def __call__(self, x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size):
+
+        return _convert_stub(super().__call__(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size))
+
+
+weight_quant_batch_matmul_impl = _PyboostWeightQuantBatchMatmulPrim()

mindspore/ops/composite/__init__.py

@@ -21,7 +21,7 @@ Pre-defined combination of operators.
 
 from __future__ import absolute_import
 from mindspore.ops.composite.base import GradOperation, _Grad, HyperMap, Map, MultitypeFuncGraph, add_flags, \
-    tail, zip_operation, _Vmap, _TaylorOperation
+    tail, zip_operation, _Vmap, _TaylorOperation, iter_converter, ms_hasnext, ms_next
 from mindspore.ops.composite.env_ops import env_get
 from mindspore.ops.function.clip_func import clip_by_global_norm
 from mindspore.ops.composite.multitype_ops.add_impl import hyper_add
@@ -65,4 +65,7 @@ __all__ = [
     'dot',
     'batch_dot',
     '_Grad',
-    '_Vmap']
+    '_Vmap',
+    'iter_converter',
+    'ms_hasnext',
+    'ms_next']

mindspore/ops/composite/base.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.
@@ -30,7 +30,8 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
     SequenceSliceGetItem_, ListSliceSetItem_, VmapOperation_, TaylorOperation_, ListPop_, \
     ListClear_, ListReverse_, ListExtend_, DictClear_, DictHasKey_, DictUpdate_, DictFromKeys_, \
     ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_, ListAdd_, DictSetItem_, \
-    HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_
+    HandleBoolTensor_, PreSetitemByTuple_, StarredGetItem_,\
+    StarredUnpack_, StarredUnpackMerge_, IterConverter_, HasNext_, Next_, MSContext
 from mindspore.common import dtype as mstype
 from mindspore.common.api import jit, _pynative_executor, _wrap_func
 from mindspore.common.api import _add_flags, _core
@@ -39,7 +40,7 @@ from mindspore.ops import signature as sig
 
 __all__ = [TupleAdd_, ListAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_,
            ListSliceSetItem_, ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_,
-           HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_]
+           HandleBoolTensor_, PreSetitemByTuple_]
 
 
 def add_flags(fn=None, **flags):
@@ -201,7 +202,7 @@ class GradOperation(GradOperation_):
             If sens_param is ``False`` , a 'ones_like(outputs)' sensitivity will be attached automatically.
             Default: ``False`` .
             If the sensor_param is ``True`` , a sensitivity (gradient with respect to output) needs to be transferred
-            through the location parameter or key-value pair parameter. If the value is transferred through
+            through the positional parameter or key-value pair parameter. If the value is transferred through
             the key-value pair parameter, the key must be sens.
 
     Returns:
@@ -374,11 +375,11 @@ class GradOperation(GradOperation_):
             @_wrap_func
             def after_grad(*args, **kwargs):
                 self._pynative_forward_run(fn, grad_, weights, args, kwargs)
-                _pynative_executor.grad(fn, grad_, weights, self.grad_position, *args, **kwargs)
-                out = _pynative_executor()
+                out = _pynative_executor.grad(fn, grad_, weights, self.grad_position, *args, **kwargs)
                 out = _grads_divided_by_device_num_if_recomputation(out)
                 return out
         else:
+            MSContext.get_instance()._set_not_convert_jit(True)
             grad_.pynative_ = True
             if not _pynative_executor.enable_grad():
                 raise RuntimeError("In no_grad context, you can not calculate gradient")
@@ -598,8 +599,7 @@ class _Grad(GradOperation_):
             @_wrap_func
             def after_grad(*args, **kwargs):
                 res = self._pynative_forward_run(fn, grad_, weights, args, kwargs)
-                _pynative_executor.grad(fn, grad_, weights, grad_position, *args, **kwargs)
-                out = _pynative_executor()
+                out = _pynative_executor.grad(fn, grad_, weights, grad_position, *args, **kwargs)
                 out = _grads_divided_by_device_num_if_recomputation(out)
                 if self.return_ids and out:
                     out = _combine_with_ids(grad_position, weights, out)
@@ -609,6 +609,7 @@ class _Grad(GradOperation_):
                     return out, res[1:]
                 return out
         else:
+            MSContext.get_instance()._set_not_convert_jit(True)
             if not _pynative_executor.enable_grad():
                 raise RuntimeError("In no_grad context, you can not calculate gradient")
             grad_.pynative_ = True
@@ -738,11 +739,14 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         """Initialize MultitypeFuncGraph."""
         MultitypeFuncGraph_.__init__(self, name)
         self.entries = list()
+        self.default_func = None
         if read_value:
             self.set_signatures((
                 sig.make_sig('args', sig.sig_rw.RW_READ, sig.sig_kind.KIND_VAR_POSITIONAL),))
 
     def __call__(self, *args):
+        if callable(self.default_func):
+            return self.default_func(*args)
         for arg in args:
             if isinstance(arg, np.ndarray):
                 raise TypeError("For 'MultitypeFuncGraph', the input can not be numpy.ndarray")
@@ -788,6 +792,13 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
 
         return deco
 
+    def register_default(self):
+        def deco(fn):
+            self.default_func = fn
+            return fn
+
+        return deco
+
     # pylint: disable=missing-docstring
     def set_doc_url(self, doc_url):
         self.set_doc_url_(doc_url)
@@ -804,11 +815,11 @@ class HyperMap(HyperMap_):
     from `mindspore.ops.Map`, the `HyperMap` supports to apply on nested structure.
 
     Args:
-        ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
+        ops (Union[MultitypeFuncGraph, None], optional): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default is None.
-        reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
-          general users please ignore. `reverse` is the flag to decide if apply the operation reversely.
-          Only supported in graph mode. Default is False.
+        reverse (bool, optional): The optimizer needs to be inverted in some scenarios to improve parallel
+            performance, general users please ignore. `reverse` is the flag to decide if apply
+            the operation reversely. Only supported in graph mode. Default is False.
 
     Inputs:
         - **args** (Tuple[sequence]) -
@@ -822,10 +833,10 @@ class HyperMap(HyperMap_):
 
     Outputs:
         Sequence or nested sequence, the sequence of output after applying the function.
-        e.g. `operation(args[0][i], args[1][i])`.
+        e.g. `operation(args[0][i], args[1][i])`, `operation` is the function assigned by `ops`.
 
     Raises:
-        TypeError: If `ops` is neither MultitypeFuncGraph nor None.
+        TypeError: If `ops` is neither :class:`mindspore.ops.MultitypeFuncGraph` nor None.
         TypeError: If `args` is not a Tuple.
 
     Supported Platforms:
@@ -887,15 +898,15 @@ class Map(Map_):
         ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default: ``None`` .
         reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
-          general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
-          Only supported in graph mode. Default is ``False`` .
+            general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
+            Only supported in graph mode. Default is ``False`` .
 
     Inputs:
         - **args** (Tuple[sequence]) - If `ops` is not `None`, all the inputs should be the same length sequences,
           and each row of the sequences. e.g. If the length of args is 2, and for `i` in length of each sequence
           `(args[0][i], args[1][i])` will be the input of the operation.
 
-          If `ops` is `None`, the first input is the operation, and the other is inputs.
+          If `ops` is `None`, the first input is the operation, and the other is the sequence.
 
     Outputs:
         Sequence, the sequence of output after applying the ops function. e.g. `ops(args[0][i], args[1][i])`.
@@ -1181,3 +1192,93 @@ class _ZipOperation(ZipOperation_):
 
 zip_operation = _ZipOperation('zip_operation')
 """`zip_operation` will generate a tuple of zip iterations of inputs."""
+
+
+class _StarredGetItem(StarredGetItem_):
+    """Generates a list of starred get_item for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredGetItem."""
+        StarredGetItem_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_get_item = _StarredGetItem('starred_get_item')
+"""`starred_get_item` will generate a list of starred get_item for inputs."""
+
+
+class _StarredUnpack(StarredUnpack_):
+    """Generates a tuple of starred unpack for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredUnpack."""
+        StarredUnpack_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_unpack = _StarredUnpack('starred_unpack')
+"""`starred_unpack` will generate a tuple of starred unpack for inputs."""
+
+
+class _StarredUnpackMerge(StarredUnpackMerge_):
+    """Generates a tuple of starred unpack merge for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredUnpackMerge."""
+        StarredUnpackMerge_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_unpack_merge = _StarredUnpackMerge('starred_unpack_merge')
+"""`starred_unpack_merge` will generate a tuple of starred unpack merge for inputs."""
+
+
+class _IterConverter(IterConverter_):
+    """Convert input to interable object"""
+
+    def __init__(self, name):
+        """Initialize _IterConverter."""
+        IterConverter_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+iter_converter = _IterConverter('iter_converter')
+"""`iter_converter` will convert input to ietrable object"""
+
+
+class _HasNext(HasNext_):
+    """Check whether the input has next value"""
+
+    def __init__(self, name):
+        """Initialize _HasNext."""
+        HasNext_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+ms_hasnext = _HasNext('has_next')
+"""`ms_hasnext` will check whether the input has next value"""
+
+
+class _Next(Next_):
+    """Get next element and res elements for input"""
+
+    def __init__(self, name):
+        """Initialize _Next."""
+        Next_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+ms_next = _Next('next')
+"""`ms_next` will get next element and res elements for input"""