mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/_vmap/vmap_nn_ops.py

@@ -325,9 +325,10 @@ def get_bce_with_logits_loss_vamp_rule(prim, axis_size):
         # If rank is larger than 1, we need to reduce result when reduction != 'none'
         if max_rank > 1:
             reduce_indexes = tuple(range(1, max_rank))
-        if logits_dim == label_dim and F.shape(logits) == F.shape(label) \
-                and logits_dim == weight_dim and F.shape(logits) == F.shape(weight) \
-                and logits_dim == pos_weight_dim and F.shape(logits) == F.shape(pos_weight):
+        logits_dim_ok = logits_dim == label_dim and logits_dim == weight_dim and logits_dim == pos_weight_dim
+        shape = F.shape(logits)
+        shape_ok = shape == F.shape(label) and shape == F.shape(weight) and shape == F.shape(pos_weight)
+        if logits_dim_ok and shape_ok:
             if prim_reduction == 'none':
                 output = prim(logits, label, weight, pos_weight)
             elif prim_reduction in ('mean', 'sum'):
@@ -798,7 +799,8 @@ def get_instance_norm_rule(prim, axis_size):
             output_x, updated_moving_mean, updated_moving_variance = prim(input_x, gamma, beta, mean, variance, u_monad)
             return (output_x, None), (updated_moving_mean, None), (updated_moving_variance, None)
 
-        if gamma_dim != 0 or beta_dim != gamma_dim or mean_dim != gamma_dim or variance_dim != gamma_dim:
+        precondition = gamma_dim != 0 or beta_dim != gamma_dim or mean_dim != gamma_dim or variance_dim != gamma_dim
+        if precondition:
             # pylint: disable=too-many-format-args
             raise ValueError(
                 "For `{}`, the source axis of `var` must be equal to `accum` and `accum_update`, and not equal to 0, "
@@ -1309,6 +1311,61 @@ def get_apply_adam_with_amsgrad_rule(prim, axis_size):
     return vmap_rule
 
 
+@vmap_rules_getters.register(P.ApplyAdamWithAmsgradV2)
+def get_apply_adam_with_amsgrad_v2_rule(prim, axis_size):
+    """VmapRule for `ApplyAdamWithAmsgradV2` operation"""
+    if hasattr(prim, "batch_rank"):
+        batch_rank = prim.batch_rank + 1
+    else:
+        batch_rank = 1
+    prim_name = prim.name
+    batch_prim = _vmap_clone_prim(prim)
+    batch_prim.add_prim_attr("batch_rank", batch_rank)
+
+    def vmap_rule(var_bdim, m_bdim, v_bdim, vhat_bdim, beta1_power_bdim, beta2_power_bdim, lr_bdim, beta1_bdim,
+                  beta2_bdim, epsilon_bdim, grad_bdim, u_monad):
+        var, var_dim = var_bdim
+        m, m_dim = m_bdim
+        v, v_dim = v_bdim
+        vhat, vhat_dim = vhat_bdim
+        beta1_power, beta1_power_dim = beta1_power_bdim
+        beta2_power, beta2_power_dim = beta2_power_bdim
+        lr, lr_dim = lr_bdim
+        beta1, beta1_dim = beta1_bdim
+        beta2, beta2_dim = beta2_bdim
+        epsilon, epsilon_dim = epsilon_bdim
+        grad, grad_dim = grad_bdim
+
+        if var_dim is None:
+            if any(dim is not None for dim in [m_dim, v_dim, vhat_dim, beta1_power_dim,
+                                               beta2_power_dim, lr_dim, beta1_dim, beta2_dim, grad_dim]):
+                raise ValueError("The source axis of `var` is None, "
+                                 "but the source axis of `m/v/vhat/beta1_power/beta2_power/lr/beta1/beta2/grad` is not "
+                                 "None. The execution of operator `{}` cannot be guaranteed.".format(prim_name))
+            out_var, out_m, out_v, out_vhat = prim(var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2, epsilon,
+                                                   grad, u_monad)
+            return (out_var, None), (out_m, None), (out_v, None), (out_vhat, None)
+
+        if any(dim != 0 for dim in [var_dim, m_dim, v_dim, vhat_dim]):
+            raise ValueError("For `{}`, the source axis of `var/m/v/vhat` must be 0, "
+                             "but get `var`: {}, `m`: {}, `v`: {}, `vhat`: {}".format(prim_name, var_dim,
+                                                                                      m_dim, v_dim, vhat_dim))
+
+        beta1_power = _bdim_at_front(beta1_power, beta1_power_dim, axis_size)
+        beta2_power = _bdim_at_front(beta2_power, beta2_power_dim, axis_size)
+        lr = _bdim_at_front(lr, lr_dim, axis_size)
+        beta1 = _bdim_at_front(beta1, beta1_dim, axis_size)
+        beta2 = _bdim_at_front(beta2, beta2_dim, axis_size)
+        epsilon = _bdim_at_front(epsilon, epsilon_dim, axis_size)
+        grad = _bdim_at_front(grad, grad_dim, axis_size)
+
+        out_var, out_m, out_v, out_vhat = batch_prim(var, m, v, vhat, beta1_power, beta2_power, lr, beta1, beta2,
+                                                     epsilon, grad, u_monad)
+        return (out_var, 0), (out_m, 0), (out_v, 0), (out_vhat, 0)
+
+    return vmap_rule
+
+
 @vmap_rules_getters.register(P.Adam)
 def get_adam_rule(prim, axis_size):
     """VmapRule for `Adam` operation"""
@@ -1624,7 +1681,8 @@ def get_rmsprop_vmap_rule(prim, axis_size):
             res = prim(var, mean_square, moment, lr, grad, decay, momentum, epsilon,
                        u_monad)  # low dimensional operator;
             return (res, None)
-        if var_dim != 0 or var_dim != mean_square_dim or var_dim != moment_dim or var_dim != grad_dim:
+        precondition = var_dim != 0 or var_dim != mean_square_dim or var_dim != moment_dim or var_dim != grad_dim
+        if precondition:
             raise ValueError(
                 f"For '{prim_name}', the source axis of 'var' must be equal to 'mean_square_dim' "
                 f"and 'moment_dim' and 'grad_dim' and not equal to 0, "
@@ -1680,8 +1738,8 @@ def get_apply_centered_rmsprop_vmap_rule(prim, axis_size):
             var = prim(var, mean_grad, mean_square,
                        mom, grad, lr, rho, momentum, eps, u_monad)
             return (var, None)
-
-        if var_dim != 0 or var_dim != mean_grad_dim or var_dim != mean_square_dim or var_dim != mom_dim:
+        precondition = var_dim != 0 or var_dim != mean_grad_dim or var_dim != mean_square_dim or var_dim != mom_dim
+        if precondition:
             raise ValueError(
                 f"For '{prim_name}', the source axis of 'var' must be equal to 'mean_grad_dim' "
                 f"and 'mean_square_dim' and 'mom_dim' and not equal to 0, "
@@ -1748,6 +1806,7 @@ def get_max_pool_vmap_rule(prim, axis_size):
 @vmap_rules_getters.register(P.LayerNorm)
 def get_layernorm_vmap_rule(prim, axis_size):
     """VmapRule for `LayerNorm` operation."""
+
     @constexpr
     def process_attr_axis(prim_attr_axis):
         if prim_attr_axis < 0:
@@ -1794,6 +1853,7 @@ def get_layernorm_vmap_rule(prim, axis_size):
         output = F.add(F.mul(output_tmp, g), b)
 
         return (output, 0), (mean, 0), (var, 0)
+
     return vmap_rule
 
 
@@ -1828,6 +1888,7 @@ def get_grid_sampler_vmap_rule(prim, axis_size):
         return_shape = input_x_shape[:non_batch_dim_index] + out_shape[non_batch_dim_index:]
         out = F.reshape(out, return_shape)
         return out, 0
+
     return vmap_rule
 
 
@@ -1837,21 +1898,31 @@ def get_upsample_nearest_3d_vmap_rule(prim, axis_size):
     """VmapRule for `UpsampleNearest3D` and `UpsampleTrilinear3D`."""
     cdhw_reverse_index = -4
 
-    def vmap_rule(x_bdim):
-        is_all_none, result = vmap_general_preprocess(prim, x_bdim)
+    def vmap_rule(x_bdim, size_bdim, scales_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, x_bdim, size_bdim,
+                                                      scales_bdim)
         if is_all_none:
             return result
 
         x, x_dim = x_bdim
         x = _bdim_at_front(x, x_dim, axis_size)
+        size, size_dim = size_bdim
+        scales, scales_dim = scales_bdim
+        if size_dim is not None or scales_dim is not None:
+            _raise_value_error(
+                "The source axis of `output_size` and `scales` must be None, but got {0} and {1}."
+                .format(size_dim, scales_dim))
+
         x_shape = F.shape(x)
         input_shape = (-1,) + x_shape[cdhw_reverse_index:]
         x = F.reshape(x, input_shape)
-        out = prim(x)
+        out = prim(x, size, scales)
         out_shape = F.shape(out)
-        return_shape = x_shape[:cdhw_reverse_index] + out_shape[cdhw_reverse_index:]
+        return_shape = x_shape[:cdhw_reverse_index] + out_shape[
+            cdhw_reverse_index:]
         out = F.reshape(out, return_shape)
         return out, 0
+
     return vmap_rule
 
 
@@ -1889,6 +1960,7 @@ def get_sparse_apply_adagrad_vmap_rule(prim, axis_size):
 
         var, accum = batch_prim(var, accum, grad, indices, u_monad)
         return (var, 0), (accum, 0)
+
     return vmap_rule
 
 
@@ -1927,6 +1999,58 @@ def get_sparse_apply_ftrl_vmap_rule(prim, axis_size):
 
         var, accum, linear = batch_prim(var, accum, linear, grad, indices, u_monad)
         return (var, 0), (accum, 0), (linear, 0)
+
+    return vmap_rule
+
+
+@vmap_rules_getters.register(P.Dense)
+def get_dense_vmap_rule(prim, axis_size):
+    """VmapRule for `Dense` operation."""
+    if isinstance(prim, str):
+        prim = Primitive(prim)
+
+    batch_matmul = P.BatchMatMul(transpose_b=True)
+
+    @_primexpr
+    def get_start_mid_end(x_shape):
+        start = x_shape[0]
+        mid = 1
+        for shp in x_shape[1:-1]:
+            mid *= shp
+        end = x_shape[-1]
+        return start, mid, end
+
+    def vmap_rule(x_bdim, w_bdim, b_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, x_bdim, w_bdim, b_bdim)
+        if is_all_none:
+            return result
+
+        x, x_dim = x_bdim
+        w, w_dim = w_bdim
+        b, b_dim = b_bdim
+        x = _bdim_at_front(x, x_dim, axis_size)
+        w = _bdim_at_front(w, w_dim, axis_size)
+        if b is not None:
+            b = _bdim_at_front(b, b_dim, axis_size)
+
+        x_shape = x.shape
+        start, mid, end = get_start_mid_end(x_shape)
+
+        x = x.reshape(start, mid, end)
+
+        out = batch_matmul(x, w)
+        out_shape = tuple(x_shape[:-1]) + (out.shape[-1],)
+        out = out.reshape(out_shape)
+
+        if b is not None:
+            b_shape = b.shape
+            b_shape = (start,) + (1,) * (len(out_shape) - 2) + (b_shape[-1],)
+            b = b.reshape(b_shape)
+
+            out = out + b
+
+        return out, 0
+
     return vmap_rule
 
 

mindspore/ops/arg_dtype_cast.py

@@ -0,0 +1,54 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2023-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.
+# 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.
+# ============================================================================
+"""Operator argument data type cast function."""
+from enum import Enum
+
+
+class TypeCastKind(Enum):
+    INT_TO_TUPLE = 1
+    INT_OR_TUPLE_TO_LIST = 2
+
+
+def type_it(src_data, cast_type):
+    """
+    cast operator argument data type.
+    """
+    if cast_type == TypeCastKind.INT_TO_TUPLE:
+        if isinstance(src_data, tuple):
+            return src_data
+
+        if isinstance(src_data, int):
+            return (src_data,)
+
+        raise TypeError(f'{src_data} is the wrong data type.')
+
+    if cast_type == TypeCastKind.INT_OR_TUPLE_TO_LIST:
+        if isinstance(src_data, list):
+            return src_data
+
+        if isinstance(src_data, int):
+            return [
+                src_data,
+            ]
+
+        if isinstance(src_data, tuple):
+            dst_list = [item for item in src_data]
+            return dst_list
+
+        raise TypeError(f'{src_data} is the wrong data type.')
+
+    raise TypeError("Unsupported type cast")

mindspore/ops/composite/__init__.py

@@ -28,7 +28,8 @@ from mindspore.ops.composite.multitype_ops.add_impl import hyper_add
 from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.function.random_func import normal, laplace, uniform, gamma, poisson, multinomial
-from mindspore.ops.composite.math_ops import count_nonzero, tensor_dot, dot, batch_dot, matmul, cummin, mm
+from mindspore.ops.composite.math_ops import matmul, cummin, mm
+from mindspore.ops.function.math_func import count_nonzero, tensor_dot, vecdot, dot, batch_dot
 from mindspore.ops.function.array_func import repeat_interleave, repeat_elements, sequence_mask
 from mindspore.ops.function.vmap_func import _VmapGeneralPreprocess, _VmapGeneralRule
 from mindspore.ops.function.clip_func import clip_by_value
@@ -52,15 +53,16 @@ __all__ = [
     'gamma',
     'poisson',
     'multinomial',
-    'count_nonzero',
     'cummin',
-    'tensor_dot',
-    'dot',
-    'batch_dot',
     'repeat_elements',
     'repeat_interleave',
     'sequence_mask',
     'matmul',
     'mm',
+    'count_nonzero',
+    'tensor_dot',
+    'vecdot',
+    'dot',
+    'batch_dot',
     '_Grad',
     '_Vmap']

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-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,6 +20,7 @@ from __future__ import absolute_import
 from functools import partial
 
 from types import FunctionType, MethodType
+import numpy as np
 import mindspore as ms
 from mindspore import context
 from mindspore.common.parameter import Parameter, ParameterTuple
@@ -28,14 +29,17 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
     TupleAdd_, UnpackCall_, ZipOperation_, ListAppend_, TupleGetItemTensor_, ListInsert_, \
     SequenceSliceGetItem_, ListSliceSetItem_, VmapOperation_, TaylorOperation_, ListPop_, \
     ListClear_, ListReverse_, ListExtend_, DictClear_, DictHasKey_, DictUpdate_, DictFromKeys_, \
-    ZerosLike_
+    ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_, ListAdd_, DictSetItem_, \
+    HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_
 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
 from mindspore.ops.primitive import Primitive
 from mindspore.ops import signature as sig
 
-__all__ = [TupleAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_, ListSliceSetItem_, ZerosLike_]
+__all__ = [TupleAdd_, ListAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_,
+           ListSliceSetItem_, ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_,
+           HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_]
 
 
 def add_flags(fn=None, **flags):
@@ -46,8 +50,8 @@ def add_flags(fn=None, **flags):
         Only supports bool value.
 
     Args:
-        fn (Function): Function or cell to add flag. Default: None.
-        flags (dict): Flags use kwargs. Default: None.
+        fn (Function): Function or cell to add flag. Default: ``None`` .
+        flags (dict): Flags use kwargs. Default: ``None`` .
 
     Returns:
         Function, the function with added flags.
@@ -70,9 +74,9 @@ def core(fn=None, **flags):
     set flag to a graph.
 
     Args:
-        fn (Function, optional): Function to add flag. Default: None.
+        fn (Function, optional): Function to add flag. Default: ``None`` .
         flags (dict, optional): The following flags can be set core, which indicates that this is a core function or
-                      other flag. Default: None.
+                      other flag. Default: ``None`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -187,16 +191,16 @@ class GradOperation(GradOperation_):
         - Return an empty tuple for no result.
 
     Args:
-        get_all (bool): If True, get all the gradients with respect to inputs. Default: False.
-        get_by_list (bool): If True, get all the gradients with respect to Parameter free variables.
-            If get_all and get_by_list are both False, get the gradient with respect to first input.
-            If get_all and get_by_list are both True, get the gradients with respect to inputs and
+        get_all (bool): If ``True`` , get all the gradients with respect to inputs. Default: ``False`` .
+        get_by_list (bool): If ``True`` , get all the gradients with respect to Parameter free variables.
+            If get_all and get_by_list are both ``False`` , get the gradient with respect to first input.
+            If get_all and get_by_list are both ``True`` , get the gradients with respect to inputs and
             Parameter free variables at the same time in the form of ("gradients with respect to inputs",
-            "gradients with respect to parameter free variables"). Default: False.
+            "gradients with respect to parameter free variables"). Default: ``False`` .
         sens_param (bool): Whether to append sensitivity (gradient with respect to output) as input.
-            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
+            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
             the key-value pair parameter, the key must be sens.
 
@@ -210,6 +214,10 @@ class GradOperation(GradOperation_):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import Tensor, ops, nn, Parameter
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -329,7 +337,7 @@ class GradOperation(GradOperation_):
         self.get_all = get_all
         self.get_by_list = get_by_list
         self.sens_param = sens_param
-        GradOperation_.__init__(self, 'grad', get_all, get_by_list, sens_param, False, False, False, False)
+        GradOperation_.__init__(self, 'grad', get_all, get_by_list, sens_param, False, False, False, False, False)
         self.grad_fn = None
         self.fn = None
         self.weights_id = None
@@ -360,6 +368,9 @@ class GradOperation(GradOperation_):
                 def after_grad(*args, **kwargs):
                     return grad_(fn)(*args, **kwargs)
         elif self.pynative_:
+            if not _pynative_executor.enable_grad():
+                raise RuntimeError("In no_grad context, you can not calculate gradient")
+
             @_wrap_func
             def after_grad(*args, **kwargs):
                 self._pynative_forward_run(fn, grad_, weights, args, kwargs)
@@ -369,6 +380,8 @@ class GradOperation(GradOperation_):
                 return out
         else:
             grad_.pynative_ = True
+            if not _pynative_executor.enable_grad():
+                raise RuntimeError("In no_grad context, you can not calculate gradient")
             # after_grad of this branch can't use @jit, just directly call grad_
             if self.get_by_list:
                 def after_grad(*args, **kwargs):
@@ -501,8 +514,8 @@ class _Grad(GradOperation_):
     A higher-order function which is used to generate the gradient function by position for the input function.
     """
 
-    def __init__(self, get_by_list=False, sens_param=False, get_by_position=False, has_aux=False, get_value=False,
-                 return_ids=False):
+    def __init__(self, get_all=False, get_by_list=False, sens_param=False, get_by_position=False, has_aux=False,
+                 get_value=False, return_ids=False, merge_forward=False):
         """Initialize _Grad."""
         if not isinstance(get_by_position, bool):
             raise TypeError(f"For '_Grad', the 'get_by_position' should be bool, "
@@ -522,14 +535,16 @@ class _Grad(GradOperation_):
         if not isinstance(return_ids, bool):
             raise TypeError(f"For '_Grad', the 'return_ids' should be bool, "
                             f"but got {type(return_ids).__name__}")
+        self.get_all = get_all
         self.get_by_position = get_by_position
         self.get_by_list = get_by_list
         self.sens_param = sens_param
         self.has_aux = has_aux
         self.get_value = get_value
         self.return_ids = return_ids
-        GradOperation_.__init__(self, 'grad', False, get_by_list, sens_param, get_by_position, has_aux, get_value,
-                                return_ids)
+        self.merge_forward = merge_forward
+        GradOperation_.__init__(self, 'grad', get_all, get_by_list, sens_param, get_by_position, has_aux, get_value,
+                                return_ids, merge_forward)
         self.grad_fn = None
         self.fn = None
         self.pynative_ = False
@@ -552,8 +567,8 @@ class _Grad(GradOperation_):
                 res += (stop_gradient(item),)
             return res
 
-        grad_ = _Grad(self.get_by_list, self.sens_param, self.get_by_position, self.has_aux, self.get_value,
-                      self.return_ids)
+        grad_ = _Grad(self.get_all, self.get_by_list, self.sens_param, self.get_by_position, self.has_aux,
+                      self.get_value, self.return_ids, self.merge_forward)
         # If calling Grad in GRAPH_MODE or calling Grad in functions decorated with 'jit', do grad in GRAPH_MODE
         # If calling Grad in pure PYNATIVE_MODE do grad in PYNATIVE_MODE
         #   In pure PYNATIVE_MODE the out layer after_grad just used to set pynative flag for inner GradOperation.
@@ -577,6 +592,9 @@ class _Grad(GradOperation_):
                     def after_grad(*args):
                         return grad_(fn)(*args)
         elif self.pynative_:
+            if not _pynative_executor.enable_grad():
+                raise RuntimeError("In no_grad context, you can not calculate gradient")
+
             @_wrap_func
             def after_grad(*args, **kwargs):
                 res = self._pynative_forward_run(fn, grad_, weights, args, kwargs)
@@ -591,6 +609,8 @@ class _Grad(GradOperation_):
                     return out, res[1:]
                 return out
         else:
+            if not _pynative_executor.enable_grad():
+                raise RuntimeError("In no_grad context, you can not calculate gradient")
             grad_.pynative_ = True
             fn_ = fn
             if self.has_aux:
@@ -682,8 +702,7 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
     Args:
         name (str): Operator name.
         read_value (bool, optional): If the registered function do not need to set value on Parameter,
-            and all inputs will pass by value, set `read_value` to True. Default: False.
-        doc_url (str, optional): The official document link corresponding to the registered function. Default:"".
+            and all inputs will pass by value, set `read_value` to ``True`` . Default: ``False`` .
 
     Raises:
         ValueError: If failed to find a matching function for the given arguments.
@@ -715,15 +734,18 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         [0.2 1.2 2.4]
     """
 
-    def __init__(self, name, read_value=False, doc_url=""):
+    def __init__(self, name, read_value=False):
         """Initialize MultitypeFuncGraph."""
-        MultitypeFuncGraph_.__init__(self, name, doc_url)
+        MultitypeFuncGraph_.__init__(self, name)
         self.entries = list()
         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):
+        for arg in args:
+            if isinstance(arg, np.ndarray):
+                raise TypeError("For 'MultitypeFuncGraph', the input can not be numpy.ndarray")
         if len(self.entries) == 1:
             output = self.entries[0][1](*args)
             return output
@@ -766,6 +788,13 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
 
         return deco
 
+    # pylint: disable=missing-docstring
+    def set_doc_url(self, doc_url):
+        self.set_doc_url_(doc_url)
+
+    def set_need_raise(self):
+        self.set_need_raise_()
+
 
 class HyperMap(HyperMap_):
     """
@@ -856,10 +885,10 @@ class Map(Map_):
 
     Args:
         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
+            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.
+          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,
@@ -869,7 +898,7 @@ class Map(Map_):
           If `ops` is `None`, the first input is the operation, and the other is inputs.
 
     Outputs:
-        Sequence, the sequence of output after applying the function. e.g. `operation(args[0][i], args[1][i])`.
+        Sequence, the sequence of output after applying the ops function. e.g. `ops(args[0][i], args[1][i])`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -922,11 +951,7 @@ class _ListAppend(ListAppend_):
     Args:
         name (str): The name of the metafuncgraph object.
     """
-
-    def __init__(self, name):
-        """Initialize _ListAppend."""
-        ListAppend_.__init__(self, name)
-
+    # `__init__` method removed entirely
     def __call__(self, *args):
         pass
 
@@ -1029,6 +1054,25 @@ class _ListExtend(ListExtend_):
 _extend = _ListExtend("extend")
 
 
+class _DictSetItem(DictSetItem_):
+    """
+    A metafuncgraph class that setitem for the dict.
+
+    Args:
+        name (str): The name of the metafuncgraph object.
+    """
+
+    def __init__(self, name):
+        """Initialize _DictClear."""
+        DictSetItem_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_dict_setitem = _DictSetItem("setitem")
+
+
 class _DictClear(DictClear_):
     """
     A metafuncgraph class that clear the dict.