mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/operations/rl_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-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.
@@ -36,10 +36,10 @@ class BufferSample(PrimitiveWithInfer):
         batch_size (int64): The size of the sampled data, lessequal to `capacity`.
         buffer_shape (tuple(shape)): The shape of an buffer.
         buffer_dtype (tuple(type)): The type of an buffer.
-        seed (int64): Random seed for sample. Default: 0. If use the default seed, it will generate a ramdom
-        one in kernel. Set a number other than `0` to keep a specific seed. Default: 0.
+        seed (int64): Random seed for sample. Default: ``0`` . If use the default seed, it will generate a ramdom
+        one in kernel. Set a number other than `0` to keep a specific seed. Default: ``0`` .
         unique (bool): Whether the sampled data is strictly unique. Setting it to False has a better performance.
-            Default: False
+            Default: ``False`` .
 
     Inputs:
         - **data** (tuple(Parameter(Tensor))) - The tuple(Tensor) represents replaybuffer,
@@ -205,38 +205,6 @@ class BufferAppend(PrimitiveWithInfer):
         if context.get_context('device_target') == "Ascend":
             self.add_prim_attr('device_target', "CPU")
 
-    def infer_shape(self, data_shape, exp_shape, count_shape, head_shape):
-        validator.check_equal_int(len(data_shape), len(exp_shape), "exp elements", self.name)
-        exp_batch = 1
-        if len(data_shape[0]) == len(exp_shape[0]):
-            exp_batch = exp_shape[0][0]
-            for i in range(len(data_shape)):
-                if len(data_shape[i]) != len(exp_shape[i]):
-                    raise ValueError(f"For '{self.name}', the dimension of {i}th 'exp_shape' must be equal to "
-                                     f"the dimension of {i}th 'data_shape', but got the {i}th 'exp_shape': "
-                                     f"{exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
-                if data_shape[i][0] < exp_shape[i][0]:
-                    raise ValueError(f"For '{self.name}', the first dimension of {i}th 'data_shape' must be greater "
-                                     f"than or equal to the first dimension of {i}th 'exp_shape', but got the {i}th "
-                                     f"'exp_shape': {exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
-        else:
-            for i in range(len(data_shape)):
-                if data_shape[i][1:] != exp_shape[i]:
-                    raise ValueError(f"For '{self.name}', the {i}th 'exp_shape' must be equal to the {i}th 'data_shape'"
-                                     f"which excepts the first dimension. but got the {i}th 'exp_shape': "
-                                     f"{exp_shape[i]}, the {i}th 'data_shape': {data_shape[i]}.")
-        self.add_prim_attr('exp_batch', exp_batch)
-        return count_shape
-
-    def infer_dtype(self, data_type, exp_type, count_type, head_type):
-        for i in range(len(data_type)):
-            if data_type[i] != exp_type[i]:
-                raise TypeError(f"For '{self.name}', each tensor in 'exp' must has the same type with 'data', but got "
-                                f"'data_type': {data_type}, 'exp_type': {exp_type}.")
-        validator.check_type_name("count type", count_type, (mstype.int32), self.name)
-        validator.check_type_name("head type", head_type, (mstype.int32), self.name)
-        return count_type
-
 
 class BufferGetItem(PrimitiveWithInfer):
     r"""

mindspore/ops/operations/sparse_ops.py

@@ -318,7 +318,7 @@ class SetSize(Primitive):
      Number of unique elements along last dimension of input set.
 
     Args:
-        validate_indices (bool): If true, sparse tensor is transposed before multiplication. Default: True.
+        validate_indices (bool): If true, sparse tensor is transposed before multiplication. Default: ``True`` .
 
     Inputs:
         - **set_indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
@@ -434,9 +434,11 @@ class SparseToDense(Primitive):
         ValueError: If `sparse_shape`, shape of `indices` and shape of `values` don't meet the parameter description.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> indices = Tensor([[0, 1], [1, 2]])
         >>> values = Tensor([1, 2], dtype=mindspore.float32)
         >>> sparse_shape = (3, 4)
@@ -461,7 +463,7 @@ class SparseToDenseV2(Primitive):
 
     Args:
         validate_indices (bool): If true, indices are checked to make sure they are sorted in
-                                 lexicographic order and that there are no repeats. Default: True.
+                                 lexicographic order and that there are no repeats. Default: ``True`` .
 
     Inputs:
         - **indices** (Tensor) - A 0D, 1D, or 2D Tensor of type int32 or int64, represents the position
@@ -583,7 +585,7 @@ class SparseTensorDenseAdd(Primitive):
     Examples:
         >>> from mindspore import Tensor
         >>> import mindspore.ops as ops
-        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import dtype as mstype
         >>> x1_indices = Tensor([[0, 0], [0, 1]], dtype=mstype.int64)
         >>> x1_values = Tensor([1, 1], dtype=mstype.float32)
         >>> x1_shape = Tensor([3, 3], dtype=mstype.int64)
@@ -609,8 +611,8 @@ class SparseTensorDenseMatmul(Primitive):
     The rank of sparse matrix and dense matrix must be equal to `2`.
 
     Args:
-        adjoint_st (bool): If true, sparse tensor is transposed before multiplication. Default: False.
-        adjoint_dt (bool): If true, dense tensor is transposed before multiplication. Default: False.
+        adjoint_st (bool): If ``True`` , sparse tensor is transposed before multiplication. Default: ``False`` .
+        adjoint_dt (bool): If ``True`` , dense tensor is transposed before multiplication. Default: ``False`` .
 
     Inputs:
         - **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
@@ -644,7 +646,7 @@ class SparseTensorDenseMatmul(Primitive):
         >>> import mindspore
         >>> from mindspore import Tensor
         >>> from mindspore.ops import operations as ops
-        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import dtype as mstype
         >>> indices = Tensor([[0, 1], [1, 2]], dtype=mindspore.int32)
         >>> values = Tensor([1, 2], dtype=mindspore.float32)
         >>> sparse_shape = (3, 4)
@@ -668,7 +670,6 @@ class SparseTensorDenseMatmul(Primitive):
         self.add_prim_attr('adjoint_b', self.adjoint_dt)
         validator.check_value_type("adjoint_st", adjoint_st, [bool], self.name)
         validator.check_value_type("adjoint_dt", adjoint_dt, [bool], self.name)
-        self.set_const_input_indexes([2])
 
 
 class CSRSparseMatrixToSparseTensor(Primitive):
@@ -811,12 +812,12 @@ class DenseToDenseSetOperation(Primitive):
     with the same first n-1 dimensions in x1 and x2.
 
     Args:
-        set_operation (str): The type of set operation, case insensitive. Default:"a-b".
+        set_operation (str): The type of set operation, case insensitive. Default: ``"a-b"`` .
             "a-b": Get the difference set of x1 to x2.
             "b-a": Get the difference set of x2 to x1.
             "intersection": Get the intersection set of x2 to x1.
             "union": Get the union set of x2 to x1.
-        validate_indices (bool): Optional attributes for DenseToDenseSetOperation.  Default: True.
+        validate_indices (bool): Optional attributes for DenseToDenseSetOperation.  Default: ``True`` .
 
     Inputs:
         - **x1** (Tensor) - The input tensor `x1` with rank `n`. 1st `n-1` dimensions must be the same as `x2`.
@@ -1042,7 +1043,7 @@ class SparseConcat(Primitive):
     Args:
         concat_dim(Scalar) - A Scalar, decide the dimension to concatenation along.
         The value must be in range [-rank, rank), where rank is the number of dimensions in each input
-        SparseTensor. Support int32, int64. Default: 0.
+        SparseTensor. Support int32, int64. Default: ``0`` .
 
     Inputs:
         - **sp_input_indices** (Tensor) - the list of Tensor which means COOTensor indices, and Need to
@@ -1614,7 +1615,7 @@ class SparseMatrixSoftmax(Primitive):
         if not isinstance(dtype, (type(mstype.float32), type(mstype.single), type(mstype.float64),
                                   type(mstype.double))):
             raise TypeError(
-                "Only float32 and float64 type data are supported, but got {}".format(dtype))
+                f"Only float32 and float64 type data are supported, but got {dtype}")
         self.add_prim_attr("dtype", dtype)
         self.init_prim_io_names(inputs=['x_dense_shape', 'x_batch_pointers', 'x_row_pointers',
                                         'x_col_indices', 'x_values'],
@@ -1691,7 +1692,7 @@ class SparseMatrixTranspose(Primitive):
         It is assumed that all the inputs can form a legal CSR sparse matrix, otherwise this operator is not defined.
 
     Args:
-        conjugate (bool): If True, the output sparse tensor is conjugated . Default: False.
+        conjugate (bool): If ``True`` , the output sparse tensor is conjugated . Default: ``False`` .
 
     Inputs:
         - **dense_shape** (Tensor) - A 1-D Tensor, represents the shape of input sparse matrix under dense status.
@@ -1909,13 +1910,14 @@ class SparseMatrixSparseMatMul(Primitive):
     Performs a matrix multiplication of a sparse matrix x1 with sparse matrix x2; return a sparse matrix x1*x2.
     Each matrix may be transposed or adjointed (conjugated and transposed),
     according to the Boolean parameters transpose_a,adjoint_a,transpose_b and adjoint_b.
-    At most one of transpose_a or adjoint_a may be True. Similarly, at most one of transpose_b or adjoint_b may be True.
+    At most one of transpose_a or adjoint_a may be ``True`` . Similarly, at most one of transpose_b or adjoint_b may
+    be ``True`` .
 
     Args:
-        transpose_a (bool): If true, sparse tensor x1 is transposed before multiplication. Default: False.
-        transpose_b (bool): If true, dense tensor x2 is transposed before multiplication. Default: False.
-        adjoint_a (bool): If true, sparse tensor x1 is adjointed before multiplication. Default: False.
-        adjoint_b (bool): If true, dense tensor x2 is adjointed before multiplication. Default: False.
+        transpose_a (bool): If ``True`` , sparse tensor x1 is transposed before multiplication. Default: ``False`` .
+        transpose_b (bool): If ``True`` , dense tensor x2 is transposed before multiplication. Default: ``False`` .
+        adjoint_a (bool): If ``True`` , sparse tensor x1 is adjointed before multiplication. Default: ``False`` .
+        adjoint_b (bool): If ``True`` , dense tensor x2 is adjointed before multiplication. Default: ``False`` .
 
     Inputs:
         - **x1_dense_shape** (Tensor) - A 1-D Tensor, represents the shape of input sparse matrix x1 under dense status.
@@ -2033,19 +2035,19 @@ class SparseMatrixMatMul(Primitive):
     Performs a matrix multiplication of a sparse matrix x1 with dense matrix x2; return a dense matrix x1*x2.
     Each matrix may be transposed or adjointed (conjugated and transposed)
     according to the Boolean parameters transpose_x1, adjoint_x1, transpose_x2 and adjoint_x2.
-    At most one of transpose_x1 or adjoint_x1 may be True.
-    Similarly, at most one of transpose_x2 or adjoint_x2 may be True.
+    At most one of transpose_x1 or adjoint_x1 may be ``True`` .
+    Similarly, at most one of transpose_x2 or adjoint_x2 may be ``True`` .
 
     Note:
         It is assumed that all the inputs can form a legal CSR sparse matrix, otherwise this operator is not defined.
 
     Args:
-        transpose_x1 (bool): If true, sparse tensor x1 is transposed before multiplication. Default: False.
-        transpose_x2 (bool): If true, dense tensor x2 is transposed before multiplication. Default: False.
-        adjoint_x1 (bool): If true, sparse tensor x1 is adjointed before multiplication. Default: False.
-        adjoint_x2 (bool): If true, dense tensor x2 is adjointed before multiplication. Default: False.
-        transpose_output (bool): If true, output x1*x2 is tansposed. Default: False.
-        conjugate_output (bool): If true, output x1*x2 is conjugated. Default: False.
+        transpose_x1 (bool): If ``True`` , sparse tensor x1 is transposed before multiplication. Default: ``False`` .
+        transpose_x2 (bool): If ``True`` , dense tensor x2 is transposed before multiplication. Default: ``False`` .
+        adjoint_x1 (bool): If ``True`` , sparse tensor x1 is adjointed before multiplication. Default: ``False`` .
+        adjoint_x2 (bool): If ``True`` , dense tensor x2 is adjointed before multiplication. Default: ``False`` .
+        transpose_output (bool): If ``True`` , output x1*x2 is tansposed. Default: ``False`` .
+        conjugate_output (bool): If ``True`` , output x1*x2 is conjugated. Default: ``False`` .
 
     Inputs:
         - **x1_dense_shape** (Tensor) - A 1-D Tensor. It represents the dense form shape of
@@ -2200,7 +2202,7 @@ class SparseSplit(Primitive):
     `[0 : shape[split_dim] % num_split]` gets one extra dimension.
 
     Args:
-        num_split (int): An `int` that is `>= 1`. The number of ways to split. Default: 1.
+        num_split (int): An `int` that is `>= 1`. The number of ways to split. Default: ``1`` .
 
     Inputs:
         - **split_dim** (Tensor) -A 0-D Tensor of type `int64`.
@@ -2378,10 +2380,10 @@ class SparseCountSparseOutput(Primitive):
     Counts the number of times each value occurs in the input.
 
     Args:
-        binary_output (bool) - If false, output the number of occurrences of each value,
-                               if True output 1 for orresponding values. Default False
-        minlength(Scalar) - Int type minimum value to count, default -1
-        maxlength(Scalar) - Int type maximum value to count, default -1
+        binary_output (bool) - If ``False`` , output the number of occurrences of each value,
+                               if ``True`` output 1 for orresponding values. Default: ``False`` .
+        minlength(Scalar) - Int type minimum value to count, Default: ``-1`` .
+        maxlength(Scalar) - Int type maximum value to count, Default: ``-1`` .
 
     Inputs:
         - **indices** (Tensor) - Tensor representing the position of the element in the sparse
@@ -2448,12 +2450,13 @@ class DenseToSparseSetOperation(Primitive):
     duplicates are allowed but ignored.
 
     Args:
-        set_operation (str): The type of set operation, supports four kinds of inputs, case insensitive. Default: "".
+        set_operation (str): The type of set operation, supports four kinds of inputs, case insensitive.
+            Default: ``""`` .
             "a-b": Get the difference set of x1 to x2.
             "b-a": Get the difference set of x2 to x1.
             "intersection": Get the intersection set of x2 to x1.
             "union": Get the union set of x2 to x1.
-        validate_indices (bool): Optional attributes for DenseToSparseSetOperation.  Default: True.
+        validate_indices (bool): Optional attributes for DenseToSparseSetOperation.  Default: ``True`` .
 
     Inputs:
         - **x1** (Tensor) - The input tensor `x1` with rank `n`. 1st `n-1` dimensions must be the same as `x2`.
@@ -2599,6 +2602,8 @@ class RaggedTensorToTensor(Primitive):
                 raise ValueError(
                     f"For {self.name}, the each element of row_partition_types must be 'ROW_SPLITS' "
                     f"when row_splits tensor.")
+        self.num_row_partition_tensors = len(row_partition_types)
+        self.add_prim_attr("num_row_partition_tensors", self.num_row_partition_tensors)
 
 
 class SparseCross(Primitive):

mindspore/ops/operations/spectral_ops.py

@@ -30,7 +30,7 @@ class BartlettWindow(Primitive):
 
     Args:
         periodic (bool, optional): If True, returns a window to be used as periodic function.
-          If False, return a symmetric window. Default: True.
+          If False, return a symmetric window. Default: ``True``.
         dtype (mindspore.dtype, optional): The desired datatype of returned tensor.
             Only float16, float32 and float64 are allowed. Default: mstype.float32.
 
@@ -45,6 +45,8 @@ class BartlettWindow(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> window_length = Tensor(5, mstype.int32)
         >>> bartlett_window = ops.BartlettWindow(periodic=True, dtype=mstype.float32)
         >>> output = bartlett_window(window_length)
@@ -72,10 +74,10 @@ class BlackmanWindow(Primitive):
     Refer to :func:`mindspore.ops.blackman_window` for more details.
 
     Args:
-        periodic (bool, optional): If True, returns a window to be used as periodic function.
-            If False, return a symmetric window. Default: True.
+        periodic (bool, optional): If ``True`` , returns a window to be used as periodic function.
+            If ``False`` , return a symmetric window. Default: ``True`` .
         dtype (mindspore.dtype, optional): the desired data type of returned tensor.
-            Only float16, float32 and float64 is allowed. Default: mstype.float32.
+            Only float16, float32 and float64 is allowed. Default: ``mstype.float32`` .
 
     Inputs:
         - **window_length** (Tensor) - the size of returned window, with data type int32, int64.
@@ -88,6 +90,8 @@ class BlackmanWindow(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> window_length = Tensor(10, mindspore.int32)
         >>> blackman_window = ops.BlackmanWindow(periodic = True, dtype = mindspore.float32)
         >>> output = blackman_window(window_length)

mindspore/ops/primitive.py

@@ -25,7 +25,7 @@ from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
 from mindspore.common.parameter import Parameter
 from mindspore.common.api import _pynative_executor
 from mindspore.common._stub_tensor import _convert_stub
-from mindspore._c_expression import Primitive_, prim_type
+from mindspore._c_expression import Primitive_, prim_type, typing
 from mindspore import _checkparam as Validator
 from mindspore.ops import signature as sig
 
@@ -186,9 +186,9 @@ class Primitive(Primitive_):
             In other parallel modes, strategies set here will be ignored.
 
         Args:
-            in_strategy (tuple): Describe the split strategy of operator input. Default: None.
+            in_strategy (tuple): Describe the split strategy of operator input. Default: ``None`` .
             out_strategy (tuple): Describe the split strategy of operator output, it is only for certain operators,
-                                  such as MatMul. Default: None.
+                                  such as MatMul. Default: ``None`` .
 
         Examples:
             >>> from mindspore import ops
@@ -309,9 +309,6 @@ class Primitive(Primitive_):
 
     def __call__(self, *args):
         should_elim, output = self.check_elim(*args)
-        for arg in args:
-            if isinstance(arg, Parameter) and arg.has_init:
-                arg.init_data()
         if should_elim:
             return output
         return _run_op(self, self.name, args)
@@ -371,7 +368,7 @@ class Primitive(Primitive_):
             - Not supported in pynative mode
 
         Args:
-            mode (bool): Specifies whether the primitive is recomputed. Default: True.
+            mode (bool): Specifies whether the primitive is recomputed. Default: ``True`` .
 
         Examples:
             >>> import numpy as np
@@ -490,7 +487,7 @@ class PrimitiveWithCheck(Primitive):
         ...         Validator.check_int(len(input_x), 1, validator.GE, 'input_x rank', self.name)
         ...
         ...     def check_dtype(self, input_x):
-        ...         Validator.check_subclass("input_x", input_x, mstype.tensor, self.name)
+        ...         Validator.check_subclass("input_x", input_x, mstype.tensor_type, self.name)
         ...
         >>> # init a Primitive obj
         >>> add = Flatten()
@@ -749,6 +746,8 @@ def _check_contains_variable(item_dtype, item_value):
             if _check_contains_variable(item_dtype[i], element):
                 return True
     elif isinstance(item_value, dict):
+        if isinstance(item_dtype, typing.Keyword):
+            return item_value is None
         for i in range(len(item_value)):
             if _check_contains_variable(item_dtype[i], list(item_value.keys())[i]):
                 return True
@@ -759,37 +758,41 @@ def _check_contains_variable(item_dtype, item_value):
 
 
 def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=True):
-    """
-    Creates a PrimitiveWithInfer operator that can infer the value at compile time. We can use it to define a function
-    to compute constant value using the constants in the constructor.
+    """Used to calculate constant in graph copmpiling process and improve compile performance in GRAPH_MODE.
 
     Args:
-        fn (function): A `fn` use as the infer_value of the output operator. Default: None.
-        get_instance (bool): If true, return the instance of operator,
-                             otherwise return the operator class. Default: True.
-        name (str): Defines the operator name. If `name` is None, use the function name as op name. Default: None.
-        reuse_result (bool): If true, the operator will be executed once and reuse the result next time,
-                             otherwise the operator will always be executed. Default: True.
-        check (bool): If ture, the parameters will be checked
-            and the warning message will raised if the parameter is not const value. Default: True.
+        fn (function): A `fn` use as the infer_value of the output operator. Default: ``None`` .
+        get_instance (bool): If ``True`` , return the instance of operator,
+                             otherwise return the operator class. Default: ``True`` .
+        name (str): Defines the operator name. If `name` is ``None`` , use the function name as op name.
+                             Default: ``None`` .
+        reuse_result (bool): If ``True`` , the operator will be executed once and reuse the result next time,
+                             otherwise the operator will always be executed. Default: ``True`` .
+        check (bool): If ``True`` , the parameters will be checked
+            and the warning message will raised if the parameter is not const value. Default: ``True`` .
 
     Examples:
-        >>> from mindspore.ops import constexpr
-        >>> a = (1, 2)
-        >>> # make an operator to calculate tuple len
-        >>> @constexpr
-        ... def tuple_len(x):
-        ...     return len(x)
+
+        >>> import mindspore as ms
+        >>> # define a constant calculate function with for loop inside and use use constexpr to accelerate the compile
+        >>> # process.
+        >>> @ms.constexpr
+        ... def for_loop_calculate(range_num):
+        ...     out = 0
+        ...     for i in range(range_num):
+        ...         if i %2 == 0 and i % 7 != 0:
+        ...             out = out + i
+        ...     return out // range_num
         ...
-        >>> print(tuple_len(a))
-        2
-        >>> # make an operator class to calculate tuple len
-        >>> @constexpr(get_instance=False, name="TupleLen")
-        ... def tuple_len_class(x):
-        ...     return len(x)
+        >>> # construct a net and run with GRAPH_MODE.
+        >>> @ms.jit
+        ... def my_func(x):
+        ...     new_shape = for_loop_calculate(100000)
+        ...     return ms.ops.broadcast_to(x, (new_shape, ))
         ...
-        >>> print(tuple_len_class()(a))
-        2
+        >>> out = my_func(ms.Tensor([1]))
+        >>> print(out.shape)
+        >>> (21428, )
     """
 
     def deco(fn):
@@ -802,7 +805,7 @@ def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=Tr
 
             def __init__(self):
                 op_name = name if name else fn.__name__
-                PrimitiveWithInfer.__init__(self, op_name)
+                super(CompileOp, self).__init__(op_name)
                 self.set_const_prim(True)
                 self.fn = fn
                 self.add_prim_attr('constexpr_prim', True)
@@ -838,13 +841,15 @@ def _primexpr(fn=None, get_instance=True, name=None, reuse_result=True):
     _primexpr is only for internal use.
 
     Args:
-        fn (function): A `fn` use as the infer_value of the output operator. Default: None.
-        get_instance (bool): If true, return the instance of operator,
-                             otherwise return the operator class. Default: True.
-        name (str): Defines the operator name. If `name` is None, use the function name as op name. Default: None.
-        reuse_result (bool): If true, the operator will be executed once and reuse the result next time,
-                             otherwise the operator will always be executed. Default: True.
+        fn (function): A `fn` use as the infer_value of the output operator. Default: ``None`` .
+        get_instance (bool): If ``True`` , return the instance of operator,
+                             otherwise return the operator class. Default: ``True`` .
+        name (str): Defines the operator name. If `name` is ``None`` , use the function name as op name.
+                             Default: ``None`` .
+        reuse_result (bool): If ``True`` , the operator will be executed once and reuse the result next time,
+                             otherwise the operator will always be executed. Default: ``True`` .
     """
+
     def deco(fn):
         """Decorator for CompileOp."""
 
@@ -882,15 +887,32 @@ def _primexpr(fn=None, get_instance=True, name=None, reuse_result=True):
     return deco
 
 
-_RUN_OP_ASYNC = True
+class _RunOpHook:
+    """Hook for run op"""
+
+    current = None
+
+    def __init__(self, hook):
+        self.hook = hook
+        self.old = _RunOpHook.current
+
+    def __enter__(self):
+        _RunOpHook.current = self
+        return self
+
+    def __exit__(self, *err):
+        _RunOpHook.current = self.old
 
 
 def _run_op(obj, op_name, args):
     """Single op execution function supported by ge in PyNative mode."""
-    if _RUN_OP_ASYNC:
-        stub = _pynative_executor.run_op_async(obj, args)
+    if not _RunOpHook.current:
+        for arg in args:
+            if isinstance(arg, Parameter) and arg.has_init:
+                arg.init_data()
+        stub = _pynative_executor.run_op_async(obj, op_name, args)
         return _convert_stub(stub)
-    return _run_op_sync(obj, op_name, args)
+    return _RunOpHook.current.hook(obj, args)
 
 
 @_wrap_func

mindspore/ops/signature.py

@@ -31,22 +31,22 @@ def make_sig(name="var", rw=sig_rw.RW_READ,
     See `ApplyMomentum` in `mindspore.ops.operation.nn_ops` as a example.
 
     Args:
-         name (bool): Argument name. Default: "var".
+         name (bool): Argument name. Default: ``"var"`` .
          rw (:class:`mindspore.ops.signature.sig_rw`): Tag the argument attribute for write and read. Choose in
             [sig_rw.RW_READ, sig_rw.RW_WRITE, sig_rw.RW_REF]`, tag if the argument will update the input.
             `sig_rw.RW_READ` for read only argument and `sig_rw.RW_WRITE` for write only argument. `sig_rw.RW_READ`
-            for the argument both need read and write. Default: sig_rw.RW_READ.
+            for the argument both need read and write. Default: ``sig_rw.RW_READ`` .
          kind (:class:`mindspore.ops.signature.kind`): Choose in `[signature_kind.KIND_POSITIONAL_KEYWORD,
             signature_kind.KIND_VAR_POSITIONAL, signature_kind.KIND_KEYWORD_ONLY, signature_kind.KIND_VAR_KEYWARD]`.
             The meaning is the same as python argument kind, please refer to the python document.
-            Default: sig_kind.KIND_POSITIONAL_KEYWORD.
+            Default: ``sig_kind.KIND_POSITIONAL_KEYWORD`` .
          default (Any): The default value of argument or `sig_kind.KIND_EMPTY_DEFAULT_VALUE` for no default value.
-            Default: sig_kind.KIND_EMPTY_DEFAULT_VALUE.
+            Default: ``sig_kind.KIND_EMPTY_DEFAULT_VALUE`` .
          dtype (:class:`mindspore.ops.signature.sig_dtype`): Choose in `signature_dtype.T` or
             `signature_dtype.T1` to `signature_dtype.T9` or `sig_dtype.T_EMPTY_DEFAULT_VALUE` for no constraints.
             If the signature of one argument is the same as another argument, we will perform auto type convert
             between them. If any `sig_rw.RW_WRITE` argument, we will try to convert the other arguments to the
-            `sig_rw.RW_WRITE` argument. Default: sig_dtype.T_EMPTY_DEFAULT_VALUE.
+            `sig_rw.RW_WRITE` argument. Default: ``sig_dtype.T_EMPTY_DEFAULT_VALUE`` .
 
     Returns:
         :class:`mindspore.ops.signature.Signature`, signature for one argument.