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

mindspore/ops/function/vmap_func.py

@@ -27,8 +27,9 @@ def vmap(fn, in_axes=0, out_axes=0):
     Vmap is pioneered by Jax and it removes the restriction of batch dimension on the operator, and provides a
     more convenient and unified operator expression. Moreover, it allows users to composite with other functional
     modules such as :func:`mindspore.grad`, to improve the development efficiency, please refer to the
-    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/tutorials/experts/en/master/vmap/vmap.html>`_ tutorial
-    for more detail. In addition, the vectorizing map does not execute loops outside the function, but sinks loops
+    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/docs/en/master/model_train/train_process/optimize/vmap.html>`_
+    tutorial for more detail.
+    In addition, the vectorizing map does not execute loops outside the function, but sinks loops
     into the primitive operations of the function for better performance. When combined with `Graph Kernel Fusion`,
     operational efficiency would be further improved.
 

mindspore/ops/functional.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-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.
@@ -19,7 +19,7 @@
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
-from mindspore.ops.function.array_func import narrow, flatten
+from mindspore.ops.function.array_func import chunk_ext, zero_
 from mindspore.ops.function.math_func import all, argmax_ext
 from mindspore.ops.function.random_func import uniform_ext
 from mindspore.ops import operations as P
@@ -34,14 +34,15 @@ from mindspore.ops.operations.math_ops import Roll
 from mindspore.ops.composite.math_ops import mm
 from mindspore.ops.function.math_func import dot
 from mindspore.ops import auto_generate
+from mindspore.ops.auto_generate import cast
 from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum
-from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul,\
-    scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow,\
+from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul, \
+    scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow, \
     scalar_uadd, scalar_usub, flash_attention_score
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
-cast = P.Cast()
+_cast = P.Cast()
 dtype = P.DType()
 isconstant = _inner_ops.IsConstant()
 isconstant.set_const_prim(True)
@@ -116,7 +117,8 @@ reduced_shape = Primitive("reduced_shape")
 # shape_mul:input must be shape multiply elements in tuple(shape)
 shape_mul = _sequence_ops.shape_mul()
 
-setattr(tensor_operator_registry, 'tuple_to_tensor', _sequence_ops.TupleToTensor)
+setattr(tensor_operator_registry, 'tuple_to_tensor',
+        _sequence_ops.TupleToTensor)
 setattr(tensor_operator_registry, 'add', add)
 setattr(tensor_operator_registry, 'softmax', softmax)
 setattr(tensor_operator_registry, 'addr', addr)
@@ -136,6 +138,7 @@ setattr(tensor_operator_registry, 'rsqrt', rsqrt)
 setattr(tensor_operator_registry, 'bincount', bincount)
 setattr(tensor_operator_registry, 'slogdet', slogdet)
 setattr(tensor_operator_registry, 'trace', trace)
+setattr(tensor_operator_registry, 'tracev2', auto_generate.trace_v2_op)
 setattr(tensor_operator_registry, 'tril', tril)
 setattr(tensor_operator_registry, 'chunk', chunk)
 setattr(tensor_operator_registry, 'count_nonzero', count_nonzero)
@@ -210,7 +213,8 @@ setattr(tensor_operator_registry, 'dot', dot)
 setattr(tensor_operator_registry, 'outer', outer)
 setattr(tensor_operator_registry, 'log1p', log1p)
 setattr(tensor_operator_registry, 'logdet', logdet)
-setattr(tensor_operator_registry, 'log_matrix_determinant', log_matrix_determinant)
+setattr(tensor_operator_registry,
+        'log_matrix_determinant', log_matrix_determinant)
 setattr(tensor_operator_registry, 'matrix_determinant', matrix_determinant)
 setattr(tensor_operator_registry, 'ceil', ceil)
 setattr(tensor_operator_registry, 'fillv2', P.FillV2)
@@ -223,6 +227,7 @@ setattr(tensor_operator_registry, 'vsplit', vsplit)
 setattr(tensor_operator_registry, 'hsplit', hsplit)
 setattr(tensor_operator_registry, 'dsplit', dsplit)
 setattr(tensor_operator_registry, 'zeros_like', zeros_like)
+setattr(tensor_operator_registry, 'zero_', zero_)
 setattr(tensor_operator_registry, 'scalar_to_tensor', scalar_to_tensor)
 setattr(tensor_operator_registry, 'stop_gradient', stop_gradient)
 setattr(tensor_operator_registry, 'masked_fill', masked_fill)
@@ -264,6 +269,7 @@ setattr(tensor_operator_registry, 'tanh', tanh)
 setattr(tensor_operator_registry, 'exp', exp)
 setattr(tensor_operator_registry, 'addbmm', addbmm)
 setattr(tensor_operator_registry, 'addmm', addmm)
+setattr(tensor_operator_registry, 'addmm_', auto_generate.inplace_addmm_op)
 setattr(tensor_operator_registry, 'addmv', addmv)
 setattr(tensor_operator_registry, 'adjoint', adjoint)
 setattr(tensor_operator_registry, 'asinh', asinh)
@@ -314,7 +320,7 @@ setattr(tensor_operator_registry, 'unsqueeze', unsqueeze)
 setattr(tensor_operator_registry, 'expand_dims', expand_dims)
 setattr(tensor_operator_registry, 'contiguous', auto_generate.contiguous)
 # support GE backend for no compare operators
-setattr(tensor_operator_registry, 'cast', cast)
+setattr(tensor_operator_registry, 'cast', _cast)
 setattr(tensor_operator_registry, 'shape_mul', shape_mul)
 setattr(tensor_operator_registry, 'concatenate', concat)
 setattr(tensor_operator_registry, 'fill', fill)
@@ -392,12 +398,13 @@ setattr(tensor_operator_registry, 'argwhere', argwhere)
 setattr(tensor_operator_registry, 'coo_add', coo_add)
 setattr(tensor_operator_registry, 'topk', topk)
 setattr(tensor_operator_registry, 'isfinite', isfinite)
-setattr(tensor_operator_registry, 'to', cast)
-setattr(tensor_operator_registry, 'bool', cast)
-setattr(tensor_operator_registry, 'float', cast)
-setattr(tensor_operator_registry, 'half', cast)
-setattr(tensor_operator_registry, 'int', cast)
-setattr(tensor_operator_registry, 'long', cast)
+setattr(tensor_operator_registry, 'to', _cast)
+setattr(tensor_operator_registry, 'bool', _cast)
+setattr(tensor_operator_registry, 'float', _cast)
+setattr(tensor_operator_registry, 'half', _cast)
+setattr(tensor_operator_registry, 'int', _cast)
+setattr(tensor_operator_registry, 'long', _cast)
+setattr(tensor_operator_registry, 'byte', _cast)
 setattr(tensor_operator_registry, 'cholesky', cholesky)
 setattr(tensor_operator_registry, 'cholesky_inverse', cholesky_inverse)
 setattr(tensor_operator_registry, 'cholesky_solve', cholesky_solve)
@@ -440,6 +447,9 @@ setattr(tensor_operator_registry, 'imag', imag)
 setattr(tensor_operator_registry, 'repeat_interleave', repeat_interleave)
 setattr(tensor_operator_registry, 'rad2deg', rad2deg)
 setattr(tensor_operator_registry, 'deg2rad', deg2rad)
+setattr(tensor_operator_registry, 'copy_', auto_generate.copy_ext)
+setattr(tensor_operator_registry, 'add_', auto_generate.inplace_add_ext)
+setattr(tensor_operator_registry, 'adds_', auto_generate.inplace_adds_ext)
 setattr(tensor_operator_registry, 'copysign', copysign)
 setattr(tensor_operator_registry, 'roll', Roll)
 setattr(tensor_operator_registry, 'rot90', rot90)

mindspore/ops/op_info_register.py

@@ -82,7 +82,7 @@ class _CustomInstaller:
         for dir_name in dir_names:
             if not os.path.isdir(dir_name):
                 try:
-                    os.makedirs(dir_name, exist_ok=True)
+                    os.makedirs(dir_name, mode=0o700, exist_ok=True)
                 except OSError as err:
                     if err.errno == 17:  # File exists
                         pass
@@ -121,7 +121,7 @@ class _CustomInstaller:
 
     def _find_ai_cpu_so_path(self, so_file):
         """find the absolute path of so"""
-        current_path = os.path.dirname(os.path.abspath(__file__))
+        current_path = os.path.dirname(os.path.realpath(__file__))
         search_paths = [current_path + "/../lib", current_path + "/../lib/plugin/ascend"]
         for path in search_paths:
             so_path = os.path.join(path, so_file)
@@ -235,7 +235,7 @@ class _CustomInstaller:
             # generate and copy reg info file
             op_info = self._gen_ai_core_reg_info(imply_path, self.func.__name__)
             self._copy_file(imply_path, self.ai_core_impl_dir)
-            for arc_name in ["ascend910", "ascend910b", "ascend910c", "ascend310p"]:
+            for arc_name in ["ascend910", "ascend910b", "ascend910_93", "ascend310p"]:
                 arc_dir = os.path.join(self.ai_core_config_dir, arc_name)
                 _CustomInstaller._create_dir(arc_dir)
                 self._save_op_info(arc_dir, "aic-{}-ops-info.json".format(arc_name), op_info)

mindspore/ops/operations/__init__.py

@@ -55,7 +55,7 @@ from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborE
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
                        _VirtualOutput, _VirtualDiv, _GetTensorSlice, _VirtualAdd, _VirtualAssignAdd, _VirtualAccuGrad,
                        _HostAllGather, _HostReduceScatter, _MirrorMicroStepOperator, _MicroStepAllGather,
-                       _VirtualPipelineEnd, AlltoAllV, ReduceScatter)
+                       _VirtualPipelineEnd, AlltoAllV, ReduceScatter, _VirtualAssignKvCache)
 from .control_ops import GeSwitch, Merge
 from .custom_ops import (Custom)
 from .debug_ops import (ImageSummary, InsertGradientOf, HookBackward, ScalarSummary,
@@ -96,7 +96,7 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      InstanceNorm,
                      GeLU, FastGeLU, Elu, CeLU,
                      GetNext, L2Normalize, LayerNorm, L2Loss, CTCLoss, CTCLossV2, CTCLossV2Grad, CTCGreedyDecoder,
-                     LogSoftmax, MaxPool3D, AvgPool3D,
+                     LogSoftmax, LogSoftmaxExt, MaxPool3D, AvgPool3D,
                      MaxPool, DataFormatDimMap,
                      AvgPool, Conv2DBackpropInput, ComputeAccidentalHits,
                      MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6,
@@ -136,6 +136,7 @@ from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax, DropoutGen
                           TensorAdd, InplaceUpdate, ScatterNonAliasingAdd,
                           BatchToSpaceND, Unpack, GatherV2, DynamicShape, ScalarToArray, Pack)
 from .manually_defined._inner import ScalarCast
+from .manually_defined import WhileLoop, Scan, ForiLoop
 from .reshard_ops import (Reshard)
 
 __all__ = [
@@ -203,6 +204,7 @@ __all__ = [
     'Softmax',
     'Softsign',
     'LogSoftmax',
+    'LogSoftmaxExt',
     'SoftmaxCrossEntropyWithLogits',
     'BCEWithLogitsLoss',
     'ROIAlign',
@@ -337,6 +339,9 @@ __all__ = [
     'TupleToArray',
     'GeSwitch',
     'Merge',
+    'WhileLoop',
+    'Scan',
+    'ForiLoop',
     'CheckValid',
     'BartlettWindow',
     'BlackmanWindow',

mindspore/ops/operations/_grad_ops.py

@@ -35,8 +35,8 @@ from ..auto_generate import (AbsGrad, ACosGrad, LogitGrad, AcoshGrad, AsinGrad,
                              SigmoidGrad, HSwishGrad, NLLLossGrad, AtanGrad, GridSampler3DGrad, GridSampler2DGrad,
                              ResizeBicubicGrad, HSigmoidGrad, CholeskyGrad, ResizeNearestNeighborGrad, LayerNormGrad,
                              HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad, RmsNormGrad,
-                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad,
-                             BinaryCrossEntropyGrad)
+                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad, MaskedSelectGrad,
+                             BinaryCrossEntropyGrad, SoftShrinkGrad, SeluGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -1658,35 +1658,6 @@ class SoftMarginLossGrad(Primitive):
         self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
 
 
-class StridedSliceV2Grad(Primitive):
-    """
-    Performs grad of StridedSliceV2 operation.
-
-    Inputs:
-        - **shapex** (Tensor) - StridedSliceV2 shape of input
-        - **begin** (tuple[int]) - A tuple which represents the location where to start. Only
-          constant value is allowed.
-        - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
-          Only constant value is allowed.
-        - **strides** (tuple[int]) - A tuple which represents the stride is continuously added
-          before reaching the maximum location. Only constant value is allowed.
-        - **dy** (Tensor) - The output of StridedSliceV2
-
-    Outputs:
-        Tensor, the shape same as the input of StridedSliceV2
-    """
-
-    @prim_attr_register
-    def __init__(self,
-                 begin_mask=0,
-                 end_mask=0,
-                 ellipsis_mask=0,
-                 new_axis_mask=0,
-                 shrink_axis_mask=0):
-        """Initialize StridedSliceV2Grad"""
-        self.init_prim_io_names(inputs=['shapex', 'begin', 'end', 'strides', 'dy'], outputs=['output'])
-
-
 class StridedSliceGrad(Primitive):
     """
     Performs grad of StridedSlice operation.
@@ -1991,51 +1962,6 @@ class MvlgammaGrad(Primitive):
         self.p = validator.check_value_type('p', p, [int], self.name)
 
 
-class MaskedSelectGrad(PrimitiveWithInfer):
-    """Computes gradient for MaskedSelect."""
-
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-    def infer_shape(self, x, mask, grad):
-        return x
-
-    def infer_dtype(self, x, mask, grad):
-        return x
-
-
-class SoftShrinkGrad(Primitive):
-    r"""
-          Gradients for SoftShrink operation.
-
-          Args:
-              lambd – The \lambdaλ (must be no less than zero) value for the Softshrink formulation. Default: 0.5.
-
-          Inputs:
-              - **input_grad** (Tensor) - The input gradient.
-              - **input_x** (Tensor) - The input of SoftShrink with data type of float16 or float32.
-                Any number of additional dimensions.
-
-          Outputs:
-              output - Tensor, has the same shape and data type as input_x.
-
-          Raises:
-              TypeError: If lambd is not a float.
-              TypeError: If dtype of input_x is neither float16 nor float32.
-              ValueError: If lambd is less than to 0.
-
-          Supported Platforms:
-              ``Ascend``
-      """
-
-    @prim_attr_register
-    def __init__(self, lambd=0.5):
-        self.init_prim_io_names(inputs=['input_grad', 'input_x'], outputs=['output'])
-        validator.check_value_type("lambd", lambd, [float], self.name)
-        validator.check_number("lambd", lambd, 0, validator.GE, self.name)
-
-
 class CdistGrad(Primitive):
     """Computes gradient for Cdist."""
 

mindspore/ops/operations/_infer_ops.py

@@ -16,4 +16,4 @@
 """Operator of infer net"""
 # pylint: disable=unused-import
 from ..auto_generate import (QuantV2, DynamicQuantExt, QuantBatchMatmul, WeightQuantBatchMatmul, KVCacheScatterUpdate,
-                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting)
+                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse)

mindspore/ops/operations/_inner_ops.py

@@ -17,6 +17,7 @@
 from types import FunctionType, MethodType
 from collections.abc import Iterable
 import os
+import weakref
 import numpy as np
 
 from mindspore.common import Tensor
@@ -29,7 +30,7 @@ from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, \
     _run_op, _check_contains_variable
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore._c_expression import typing
+from mindspore._c_expression import typing, HookType
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
@@ -1535,7 +1536,7 @@ class CellBackwardHook(PrimitiveWithInfer):
         ...     print(grad)
         ...
         >>> hook = inner.CellBackwardHook()
-        >>> hook_fn_key = hook.register_backward_hook(hook_fn)
+        >>> hook_fn_key = hook.register_backward_hook()
         >>> def hook_test(x, y):
         ...     z = x * y
         ...     z = hook(z)
@@ -1556,16 +1557,19 @@ class CellBackwardHook(PrimitiveWithInfer):
         (Tensor(shape=[], dtype=Float32, value= 4), Tensor(shape=[], dtype=Float32, value= 4))
     """
 
-    def __init__(self, cell_id=""):
+    def __init__(self, cell_id="", cell=None, hook_dict=None):
         """Initialize CellBackwardHook"""
         super(CellBackwardHook, self).__init__(self.__class__.__name__)
         self.cell_id = cell_id
+        self.cell = cell
+        self.hook_dict = weakref.ref(hook_dict)
         self.add_prim_attr("cell_id", cell_id)
-        self.init_attrs["cell_id"] = cell_id
+        self.grad_output = None
 
-    def __call__(self, args):
-        if not isinstance(args, tuple):
-            args = (args,)
+    def __call__(self, *args):
+        # If args is empty, just return.
+        if not args:
+            return args
         return _run_op(self, self.name, args)
 
     def infer_shape(self, *inputs_shape):
@@ -1578,51 +1582,76 @@ class CellBackwardHook(PrimitiveWithInfer):
             return inputs_type[0]
         return inputs_type
 
-    def register_backward_hook(self, hook_fn):
-        r"""
-        This function is used to register backward hook function. Note that this function is only supported in pynative
-        mode.
-
-        Note:
-            The 'hook_fn' must be defined as the following code.
-            `cell_id` is the information of registered cell. `grad_input` is the gradient passed to the cell.
-            `grad_output` is the gradient computed and passed to the next cell or primitive, which may be modified by
-            returning a new output gradient.
-            The 'hook_fn' should have the following signature:
-            hook_fn(cell_id, grad_input, grad_output) -> New output gradient or none.
-            The 'hook_fn' is executed in the python environment.
+    def register_backward_hook(self):
+        """
+        Register the backward hook function.
 
         Args:
-            hook_fn (Function): Python function. Backward hook function.
+            None
 
         Returns:
-            - **key** (int) - The key of 'hook_fn'.
+            None
 
-        Raises:
-            TypeError: If the `hook_fn` is not a function of python.
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
         """
-        if not isinstance(hook_fn, (FunctionType, MethodType)):
-            raise TypeError(f"When using 'register_backward_hook(hook_fn)', the type of 'hook_fn' must be python "
-                            f"function, but got {type(hook_fn)}.")
-        key = self.add_backward_hook_fn(hook_fn)
-        return key
 
-    def remove_backward_hook(self, key):
-        r"""
-        This function is used to remove backward hook function. Note that this operation is only supported in pynative
-        mode.
-
-        Note:
-            The 'key' is the object returned by 'register_backward_hook' function of the same CellBackwardHook
-            operator.
+        def hook_backward_grad(grad):
+            if self.grad_output is None:
+                self.grad_output = grad
+                # Indicates the first time of call backward hook, and need to wait for the second time call
+                return self.cell_id
+            backward_hook_grad_input = grad
+            if self.hook_dict():
+                backward_hooks = self.hook_dict().values()
+                for hook in backward_hooks:
+                    res = hook(self.cell, backward_hook_grad_input, self.grad_output)
+                    if res is None:
+                        continue
+                    if not isinstance(res, tuple):
+                        res = (res,)
+                    if len(res) != len(grad):
+                        raise TypeError(
+                            "The backward hook return value size is {} not equal to expect grad input size {}".format(
+                                len(res), len(grad)))
+                    backward_hook_grad_input = res
+            self.grad_output = None
+            return backward_hook_grad_input
+
+        self.set_hook_fn(hook_backward_grad, HookType.BackwardHook)
+
+    def register_backward_pre_hook(self):
+        """
+        Register the backward pre hook function.
 
         Args:
-            key (int): The key corresponding to the 'hook_fn'.
+            None
 
         Returns:
-            None.
+            None
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
         """
-        self.remove_backward_hook_fn(key)
+
+        def hook_backward_pre_grad(grad):
+            backward_pre_hook_grad = grad
+            if self.hook_dict():
+                backward_pre_hooks = self.hook_dict().values()
+                for hook in backward_pre_hooks:
+                    res = hook(self.cell, backward_pre_hook_grad)
+                    if res is None:
+                        continue
+                    if not isinstance(res, tuple):
+                        res = (res,)
+                    if len(res) != len(grad):
+                        raise TypeError(
+                            "The backward pre hook return value size is {} not equal to expect output size {}".format(
+                                len(res), len(grad)))
+                    backward_pre_hook_grad = res
+            return backward_pre_hook_grad
+
+        self.set_hook_fn(hook_backward_pre_grad, HookType.BackwardPreHook)
 
 
 class Format(PrimitiveWithInfer):
@@ -2478,60 +2507,6 @@ class FFN(Primitive):
         validator.check_value_type("inner_precise", inner_precise, [int], cls_name)
 
 
-class _MirrorSilentCheck(PrimitiveWithInfer):
-    """
-    The operator _MirrorSilentCheck implements accuracy-sensitive detection on the tensor input in backpropagator.
-    Call _MirrorSilentCheck in method __call__ of derived class to implement accuracy-sensitive detection.
-
-    Inputs:
-        - **input** (Tensor) : The tensor used for detection.
-          Its data type must be mindspore.float16, mindspore.float32 or mindspore.bfloat16.
-        - **pre_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **min_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **max_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **cnt** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-          After each invocation of _MirrorSilentCheck, increment the value of cnt by one.
-
-    Outputs:
-        - **output** (Tensor) - Same shape, type and value as `input`.
-    """
-    @prim_attr_register
-    def __init__(self, min_steps=8):
-        upper_thresh, sigma_thresh = self.get_thresh()
-        self.min_steps = min_steps
-        self.thresh_l1 = upper_thresh[0]
-        self.coeff_l1 = sigma_thresh[0]
-        self.thresh_l2 = upper_thresh[1]
-        self.coeff_l2 = sigma_thresh[1]
-        self.add_prim_attr('side_effect_mem', True)
-
-    def parse_thresh(self, env_var_name, default_value, min_value):
-        env_var = os.environ.get(env_var_name, default=default_value)
-        thresh = [value.strip() for value in env_var.split(",")]
-        if len(thresh) != 2 or not all(value.isdigit() for value in thresh):
-            thresh = default_value.split(",")
-        thresh = [float(max(int(value), min_value)) for value in thresh]
-        if thresh[0] <= thresh[1]:
-            thresh = [float(value) for value in default_value.split(",")]
-
-        return thresh
-
-    def get_thresh(self):
-        upper_thresh = self.parse_thresh("NPU_ASD_UPPER_THRESH", "1000000,10000", 3)
-        sigma_thresh = self.parse_thresh("NPU_ASD_SIGMA_THRESH", "100000,5000", 3)
-        return upper_thresh, sigma_thresh
-
-    def infer_shape(self, x_shape, pre_shape, min_shape, max_shape, n_step, loss_scale_shape):
-        return x_shape
-
-    def infer_dtype(self, x_dtype, pre_dtype, min_dtype, max_dtype, n_dtype, loss_scale_dtype):
-        return x_dtype
-
-
 class _VirtualConverterEnd(PrimitiveWithInfer):
     """
     Auto parallel virtual operator.
@@ -2560,6 +2535,8 @@ class _VirtualConverterBegin(PrimitiveWithInfer):
         self.output_nums = output_nums
 
     def infer_shape(self, arg):
+        if self.output_nums == 0:
+            return ValueError("output_nums can\'t be zero.")
         new_arg = (arg[0] / self.output_nums,) + tuple(arg[1:])
         return (new_arg,) * self.output_nums