mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

msprobe/mindspore/compare/ms_to_pt_api.yaml

@@ -0,0 +1,399 @@
+Functional.abs: Torch.abs
+Functional.absolute: Torch.absolute
+Functional.acos: Torch.acos
+Functional.acosh: Torch.acosh
+Functional.adaptive_avg_pool2d: Functional.adaptive_avg_pool2d
+Functional.adaptive_avg_pool3d: Functional.adaptive_avg_pool3d
+Functional.adaptive_max_pool2d: Functional.adaptive_max_pool2d
+Functional.add: Torch.add
+Functional.addbmm: Torch.addbmm
+Functional.addcdiv: Torch.addcdiv
+Functional.addcmul: Torch.addcmul
+Functional.addmm: Torch.addmm
+Functional.addmv: Torch.addmv
+Functional.affine_grid: Functional.affine_grid
+Functional.angle: Torch.angle
+Functional.arange: Torch.arange
+Functional.arccos: Torch.arccos
+Functional.arccosh: Torch.arccosh
+Functional.arcsinh: Torch.arcsinh
+Functional.arctan: Torch.arctan
+Functional.arctanh: Torch.arctanh
+Functional.argmax: Torch.argmax
+Functional.asin: Torch.asin
+Functional.asinh: Torch.asinh
+Functional.atan: Torch.atan
+Functional.atan2: Torch.atan2
+Functional.atanh: Torch.atanh
+Functional.baddbmm: Torch.baddbmm
+Functional.bartlett_window: Torch.bartlett_window
+Functional.bidense: Functional.bilinear
+Functional.bincount: Torch.bincount
+Functional.bitwise_and: Torch.bitwise_and
+Functional.bitwise_or: Torch.bitwise_or
+Functional.bitwise_xor: Torch.bitwise_xor
+Functional.blackman_window: Torch.blackman_window
+Functional.ceil: Torch.ceil
+Functional.cholesky_solve: Torch.cholesky_solve
+Functional.clamp: Torch.clamp
+Functional.clip: Torch.clip
+Functional.column_stack: Torch.column_stack
+Functional.conj: Torch.conj
+Functional.conv1d: Functional.conv1d
+Functional.conv2d: Functional.conv2d
+Functional.conv3d: Functional.conv3d
+Functional.cosh: Torch.cosh
+Functional.cosine_embedding_loss: Functional.cosine_embedding_loss
+Functional.cosine_similarity: Functional.cosine_similarity
+Functional.cross: Torch.cross
+Functional.cross_entropy: Functional.cross_entropy
+Functional.ctc_loss: Functional.ctc_loss
+Functional.cumprod: Torch.cumprod
+Functional.dense: Functional.linear
+Functional.diag_embed: Torch.diag_embed
+Functional.diagflat: Torch.diagflat
+Functional.diagonal: Torch.diagonal
+Functional.digamma: Torch.digamma
+Functional.dist: Torch.dist
+Functional.div: Torch.div
+Functional.divide: Torch.divide
+Functional.einsum: Torch.einsum
+Functional.equal: Torch.eq
+Functional.erf: Torch.erf
+Functional.erfc: Torch.erfc
+Functional.exp: Torch.exp
+Functional.exp2: Torch.exp2
+Functional.expm1: Torch.expm1
+Functional.eye: Torch.eye
+Functional.flip: Torch.flip
+Functional.fliplr: Torch.fliplr
+Functional.flipud: Torch.flipud
+Functional.floor_divide: Torch.floor_divide
+Functional.fmax: Torch.fmax
+Functional.fmod: Torch.fmod
+Functional.full: Torch.full
+Functional.full_like: Torch.full_like
+Functional.gcd: Torch.gcd
+Functional.geqrf: Torch.geqrf
+Functional.greater: Torch.greater
+Functional.greater_equal: Torch.greater_equal
+Functional.gumbel_softmax: Functional.gumbel_softmax
+Functional.hamming_window: Torch.hamming_window
+Functional.hann_window: Torch.hann_window
+Functional.hardsigmoid: Functional.hardsigmoid
+Functional.hardtanh: Functional.hardtanh
+Functional.heaviside: Torch.heaviside
+Functional.hinge_embedding_loss: Functional.hinge_embedding_loss
+Functional.histc: Torch.histc
+Functional.hsplit: Torch.hsplit
+Functional.hstack: Torch.hstack
+Functional.hypot: Torch.hypot
+Functional.i0: Torch.i0
+Functional.igamma: Torch.igamma
+Functional.igammac: Torch.igammac
+Functional.imag: Torch.imag
+Functional.inner: Torch.inner
+Functional.inverse: Torch.inverse
+Functional.is_nonzero: Torch.is_nonzero
+Functional.is_tensor: Torch.is_tensor
+Functional.isinf: Torch.isinf
+Functional.isneginf: Torch.isneginf
+Functional.isposinf: Torch.isposinf
+Functional.isreal: Torch.isreal
+Functional.kaiser_window: Torch.kaiser_window
+Functional.kron: Torch.kron
+Functional.l1_loss: Functional.l1_loss
+Functional.lcm: Torch.lcm
+Functional.lerp: Torch.lerp
+Functional.log1p: Torch.log1p
+Functional.logaddexp: Torch.logaddexp
+Functional.logaddexp2: Torch.logaddexp2
+Functional.logdet: Torch.logdet
+Functional.logical_and: Torch.logical_and
+Functional.logical_not: Torch.logical_not
+Functional.logical_or: Torch.logical_or
+Functional.logical_xor: Torch.logical_xor
+Functional.logit: Torch.logit
+Functional.logspace: Torch.logspace
+Functional.lt: Torch.lt
+Functional.lu_solve: Torch.lu_solve
+Functional.lu_unpack: Torch.lu_unpack
+Functional.margin_ranking_loss: Functional.margin_ranking_loss
+Functional.masked_select: Torch.masked_select
+Functional.matmul: Torch.matmul
+Functional.max_pool3d: Functional.max_pool3d
+Functional.max_unpool1d: Functional.max_unpool1d
+Functional.max_unpool2d: Functional.max_unpool2d
+Functional.max_unpool3d: Functional.max_unpool3d
+Functional.mm: Torch.mm
+Functional.moveaxis: Torch.moveaxis
+Functional.movedim: Torch.movedim
+Functional.mse_loss: Functional.mse_loss
+Functional.msort: Torch.msort
+Functional.mul: Torch.mul
+Functional.multi_margin_loss: Functional.multi_margin_loss
+Functional.multilabel_margin_loss: Functional.multilabel_margin_loss
+Functional.multilabel_soft_margin_loss: Functional.multilabel_soft_margin_loss
+Functional.multiply: Torch.multiply
+Functional.nan_to_num: Torch.nan_to_num
+Functional.nansum: Torch.nansum
+Functional.neg: Torch.neg
+Functional.negative: Torch.negative
+Functional.nextafter: Torch.nextafter
+Functional.nll_loss: Functional.nll_loss
+Functional.nonzero: Torch.nonzero
+Functional.not_equal: Torch.not_equal
+Functional.numel: Torch.numel
+Functional.ones_like: Torch.ones_like
+Functional.orgqr: Torch.orgqr
+Functional.outer: Torch.outer
+Functional.pdist: Functional.pdist
+Functional.permute: Torch.permute
+Functional.pixel_shuffle: Functional.pixel_shuffle
+Functional.pixel_unshuffle: Functional.pixel_unshuffle
+Functional.polar: Torch.polar
+Functional.pow: Torch.pow
+Functional.rand: Torch.rand
+Functional.rand_like: Torch.rand_like
+Functional.randn: Torch.randn
+Functional.randn_like: Torch.randn_like
+Functional.ravel: Torch.ravel
+Functional.real: Torch.real
+Functional.reciprocal: Torch.reciprocal
+Functional.relu: Functional.relu
+Functional.remainder: Torch.remainder
+Functional.reshape: Torch.reshape
+Functional.roll: Torch.roll
+Functional.rot90: Torch.rot90
+Functional.round: Torch.round
+Functional.row_stack: Torch.row_stack
+Functional.rsqrt: Torch.rsqrt
+Functional.searchsorted: Torch.searchsorted
+Functional.sgn: Torch.sgn
+Functional.sigmoid: Functional.sigmoid
+Functional.sign: Torch.sign
+Functional.signbit: Torch.signbit
+Functional.sin: Torch.sin
+Functional.sinc: Torch.sinc
+Functional.sinh: Torch.sinh
+Functional.slogdet: Torch.slogdet
+Functional.smooth_l1_loss: Functional.smooth_l1_loss
+Functional.soft_margin_loss: Functional.soft_margin_loss
+Functional.square: Torch.square
+Functional.subtract: Torch.subtract
+Functional.sum: Torch.sum
+Functional.swapaxes: Torch.transpose
+Functional.swapdims: Torch.swapdims
+Functional.t: Torch.t
+Functional.tan: Torch.tan
+Functional.tanh: Functional.tanh
+Functional.tanhshrink: Functional.tanhshrink
+Functional.topk: Torch.topk
+Functional.trace: Torch.trace
+Functional.trapz: Torch.trapz
+Functional.tril: Torch.tril
+Functional.tril_indices: Torch.tril_indices
+Functional.triu_indices: Torch.triu_indices
+Functional.true_divide: Torch.true_divide
+Functional.trunc: Torch.trunc
+Functional.unbind: Torch.unbind
+Functional.unfold: Functional.unfold
+Functional.unsqueeze: Torch.unsqueeze
+Functional.vander: Torch.vander
+Functional.view_as_real: Torch.view_as_real
+Functional.vsplit: Torch.vsplit
+Functional.where: Torch.where
+Functional.xlogy: Torch.xlogy
+Functional.zeros_like: Torch.zeros_like
+Tensor.H: Tensor.H
+Tensor.T: Tensor.T
+Tensor.abs: Tensor.abs
+Tensor.absolute: Tensor.absolute
+Tensor.acos: Tensor.acos
+Tensor.acosh: Tensor.acosh
+Tensor.add: Tensor.add
+Tensor.addbmm: Tensor.addbmm
+Tensor.addcdiv: Tensor.addcdiv
+Tensor.addcmul: Tensor.addcmul
+Tensor.addmm: Tensor.addmm
+Tensor.addr: Tensor.addr
+Tensor.angle: Tensor.angle
+Tensor.arccos: Tensor.arccos
+Tensor.arccosh: Tensor.arccosh
+Tensor.arcsin: Tensor.arcsin
+Tensor.arcsinh: Tensor.arcsinh
+Tensor.arctan: Tensor.arctan
+Tensor.arctanh: Tensor.arctanh
+Tensor.asin: Tensor.asin
+Tensor.asinh: Tensor.asinh
+Tensor.asnumpy: Tensor.numpy
+Tensor.atan: Tensor.atan
+Tensor.atan2: Tensor.atan2
+Tensor.atanh: Tensor.atanh
+Tensor.baddbmm: Tensor.baddbmm
+Tensor.bincount: Tensor.bincount
+Tensor.bitwise_and: Tensor.bitwise_and
+Tensor.bitwise_or: Tensor.bitwise_or
+Tensor.bitwise_xor: Tensor.bitwise_xor
+Tensor.cauchy: Tensor.cauchy_
+Tensor.ceil: Tensor.ceil
+Tensor.cholesky: Tensor.cholesky
+Tensor.cholesky_solve: Tensor.cholesky_solve
+Tensor.chunk: Tensor.chunk
+Tensor.clamp: Tensor.clamp
+Tensor.clip: Tensor.clip
+Tensor.conj: Tensor.conj
+Tensor.contiguous: Tensor.contiguous
+Tensor.copysign: Tensor.copysign
+Tensor.cos: Tensor.cos
+Tensor.cosh: Tensor.cosh
+Tensor.cross: Tensor.cross
+Tensor.cumprod: Tensor.cumprod
+Tensor.cumsum: Tensor.cumsum
+Tensor.deg2rad: Tensor.deg2rad
+Tensor.diagflat: Tensor.diagflat
+Tensor.diagonal: Tensor.diagonal
+Tensor.digamma: Tensor.digamma
+Tensor.div: Tensor.div
+Tensor.divide: Tensor.divide
+Tensor.equal: Tensor.eq
+Tensor.erf: Tensor.erf
+Tensor.erfc: Tensor.erfc
+Tensor.erfinv: Tensor.erfinv
+Tensor.exp: Tensor.exp
+Tensor.expm1: Tensor.expm1
+Tensor.fill_diagonal: Tensor.fill_diagonal_
+Tensor.fliplr: Tensor.fliplr
+Tensor.flipud: Tensor.flipud
+Tensor.float: Tensor.float
+Tensor.floor: Tensor.floor
+Tensor.fmax: Tensor.fmax
+Tensor.fmod: Tensor.fmod
+Tensor.gather_elements: Tensor.gather
+Tensor.geqrf: Tensor.geqrf
+Tensor.greater: Tensor.greater
+Tensor.greater_equal: Tensor.greater_equal
+Tensor.half: Tensor.half
+Tensor.hardshrink: Tensor.hardshrink
+Tensor.heaviside: Tensor.heaviside
+Tensor.histc: Tensor.histc
+Tensor.hypot: Tensor.hypot
+Tensor.i0: Tensor.i0
+Tensor.igamma: Tensor.igamma
+Tensor.igammac: Tensor.igammac
+Tensor.imag: Tensor.imag
+Tensor.index_add: Tensor.index_add
+Tensor.index_fill: Tensor.index_fill
+Tensor.index_put: Tensor.index_put
+Tensor.int: Tensor.int
+Tensor.inverse: Tensor.inverse
+Tensor.is_complex: Tensor.is_complex
+Tensor.is_contiguous: Tensor.is_contiguous
+Tensor.is_floating_point: Tensor.is_floating_point
+Tensor.is_signed: Tensor.is_signed
+Tensor.isfinite: Tensor.isfinite
+Tensor.isinf: Tensor.isinf
+Tensor.isnan: Tensor.isnan
+Tensor.isneginf: Tensor.isneginf
+Tensor.isposinf: Tensor.isposinf
+Tensor.isreal: Tensor.isreal
+Tensor.lcm: Tensor.lcm
+Tensor.ldexp: Tensor.ldexp
+Tensor.le: Tensor.le
+Tensor.lerp: Tensor.lerp
+Tensor.less: Tensor.less
+Tensor.less_equal: Tensor.less_equal
+Tensor.log: Tensor.log
+Tensor.log10: Tensor.log10
+Tensor.log1p: Tensor.log1p
+Tensor.log2: Tensor.log2
+Tensor.log_normal: Tensor.log_normal
+Tensor.logaddexp: Tensor.logaddexp
+Tensor.logaddexp2: Tensor.logaddexp2
+Tensor.logcumsumexp: Tensor.logcumsumexp
+Tensor.logdet: Tensor.logdet
+Tensor.logical_and: Tensor.logical_and
+Tensor.logical_not: Tensor.logical_not
+Tensor.logical_or: Tensor.logical_or
+Tensor.logical_xor: Tensor.logical_xor
+Tensor.logit: Tensor.logit
+Tensor.long: Tensor.long
+Tensor.lt: Tensor.lt
+Tensor.lu_solve: Tensor.lu_solve
+Tensor.mH: Tensor.mH
+Tensor.mT: Tensor.mT
+Tensor.masked_fill: Tensor.masked_fill
+Tensor.masked_select: Tensor.masked_select
+Tensor.matmul: Tensor.matmul
+Tensor.maximum: Tensor.maximum
+Tensor.minimum: Tensor.minimum
+Tensor.mm: Tensor.mm
+Tensor.movedim: Tensor.movedim
+Tensor.msort: Tensor.msort
+Tensor.mul: Tensor.mul
+Tensor.multiply: Tensor.multiply
+Tensor.mvlgamma: Tensor.mvlgamma
+Tensor.nan_to_num: Tensor.nan_to_num
+Tensor.nanmedian: Tensor.nanmedian
+Tensor.nansum: Tensor.nansum
+Tensor.ndim: Tensor.ndim
+Tensor.ndimension: Tensor.ndimension
+Tensor.ne: Tensor.ne
+Tensor.neg: Tensor.neg
+Tensor.negative: Tensor.negative
+Tensor.nelement: Tensor.nelement
+Tensor.new_ones: Tensor.new_ones
+Tensor.new_zeros: Tensor.new_zeros
+Tensor.nextafter: Tensor.nextafter
+Tensor.nonzero: Tensor.nonzero
+Tensor.not_equal: Tensor.not_equal
+Tensor.numel: Tensor.numel
+Tensor.orgqr: Tensor.orgqr
+Tensor.ormqr: Tensor.ormqr
+Tensor.outer: Tensor.outer
+Tensor.permute: Tensor.permute
+Tensor.rad2deg: Tensor.rad2deg
+Tensor.ravel: Tensor.ravel
+Tensor.real: Tensor.real
+Tensor.reciprocal: Tensor.reciprocal
+Tensor.remainder: Tensor.remainder
+Tensor.repeat_interleave: Tensor.repeat_interleave
+Tensor.reshape: Tensor.reshape
+Tensor.reshape_as: Tensor.reshape_as
+Tensor.roll: Tensor.roll
+Tensor.rot90: Tensor.rot90
+Tensor.round: Tensor.round
+Tensor.rsqrt: Tensor.rsqrt
+Tensor.sgn: Tensor.sgn
+Tensor.shape: Tensor.shape
+Tensor.short: Tensor.short
+Tensor.sigmoid: Tensor.sigmoid
+Tensor.sign: Tensor.sign
+Tensor.signbit: Tensor.signbit
+Tensor.sin: Tensor.sin
+Tensor.sinc: Tensor.sinc
+Tensor.sinh: Tensor.sinh
+Tensor.slogdet: Tensor.slogdet
+Tensor.sort: Tensor.sort
+Tensor.sqrt: Tensor.sqrt
+Tensor.square: Tensor.square
+Tensor.squeeze: Tensor.squeeze
+Tensor.storage_offset: Tensor.storage_offset
+Tensor.stride: Tensor.stride
+Tensor.subtract: Tensor.subtract
+Tensor.sum_to_size: Tensor.sum_to_size
+Tensor.swapaxes: Tensor.transpose
+Tensor.swapdims: Tensor.swapdims
+Tensor.t: Tensor.t
+Tensor.tan: Tensor.tan
+Tensor.tanh: Tensor.tanh
+Tensor.topk: Tensor.topk
+Tensor.trace: Tensor.trace
+Tensor.tril: Tensor.tril
+Tensor.true_divide: Tensor.true_divide
+Tensor.trunc: Tensor.trunc
+Tensor.unbind: Tensor.unbind
+Tensor.unsqueeze: Tensor.unsqueeze
+Tensor.view: Tensor.view
+Tensor.view_as: Tensor.view_as
+Tensor.where: Tensor.where

msprobe/mindspore/debugger/debugger_config.py

@@ -1,33 +1,49 @@
 import os
+from pathlib import Path
 
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.core.common.file_check import FileChecker, FileCheckConst, check_path_before_create
 
-class DebuggerConfig:
-    convert_map = {
-        "L0": "cell",
-        "L1": "api",
-        "L2": 'kernel'
-    }
 
+class DebuggerConfig:
     def __init__(self, common_config, task_config):
+        self.execution_mode = None
         self.dump_path = common_config.dump_path
         self.task = common_config.task
         self.rank = [] if not common_config.rank else common_config.rank
         self.step = [] if not common_config.step else common_config.step
-        if not common_config.level:
-            common_config.level = "L1"
-        self.level = DebuggerConfig.convert_map[common_config.level]
+        common_config.level = Const.LEVEL_L1 if not common_config.level else common_config.level
+        self.level = MsConst.TOOL_LEVEL_DICT.get(common_config.level, MsConst.API)
+        self.level_ori = common_config.level
         self.list = [] if not task_config.list else task_config.list
-        self.data_mode =  [] if not task_config.data_mode else task_config.data_mode
+        self.scope = [] if not task_config.scope else task_config.scope
+        self.data_mode = [] if not task_config.data_mode else task_config.data_mode
         self.file_format = task_config.file_format
+        self.overflow_nums = 1 if not task_config.overflow_nums else task_config.overflow_nums
         self.check_mode = task_config.check_mode
-
+        self.framework = Const.MS_FRAMEWORK
+        self.summary_mode = task_config.summary_mode
         self.check()
+        self._make_dump_path_if_not_exists()
+
+        if self.task == Const.FREE_BENCHMARK:
+            self.pert_type = (FreeBenchmarkConst.DEFAULT_PERT_TYPE
+                              if not task_config.pert_mode else task_config.pert_mode)
+            self.handler_type = (FreeBenchmarkConst.DEFAULT_HANDLER_TYPE
+                                 if not task_config.handler_type else task_config.handler_type)
+            if self.handler_type == FreeBenchmarkConst.FIX_HANDLER_MODE and \
+               self.pert_type != FreeBenchmarkConst.DEFAULT_PERT_TYPE:
+                raise ValueError("pert_mode must be improve_precision or empty when handler_type is fix, "
+                                 f"but got {self.pert_type}.")
+            self.dump_level = FreeBenchmarkConst.DEFAULT_DUMP_LEVEL
+            self.stage = FreeBenchmarkConst.DEFAULT_STAGE
 
     def check(self):
         if not self.dump_path:
             raise Exception("Dump path is empty.")
-        if not os.path.isabs(self.dump_path):
-            raise Exception("Dump path must be absolute path.")
+        self.dump_path = os.path.abspath(self.dump_path)
         if not self.task:
             self.task = "statistics"
         if not self.level:
@@ -47,5 +63,12 @@ class DebuggerConfig:
 
     def _check_step(self):
         for s in self.step:
-            if not isinstance(s, int):
-                raise ValueError(f"step element {s} should be int")
+            if not isinstance(s, int) or s < 0:
+                raise ValueError(f"step element {s} must be a positive integer.")
+
+    def _make_dump_path_if_not_exists(self):
+        check_path_before_create(self.dump_path)
+        if not os.path.exists(self.dump_path):
+            Path(self.dump_path).mkdir(mode=FileCheckConst.DATA_DIR_AUTHORITY, exist_ok=True)
+        file_check = FileChecker(self.dump_path, FileCheckConst.DIR)
+        file_check.common_check()

msprobe/mindspore/debugger/precision_debugger.py

@@ -1,32 +1,107 @@
 import os
+
+import mindspore as ms
+
+from msprobe.mindspore.service import Service
 from msprobe.mindspore.ms_config import parse_json_config
 from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
 from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.runtime import Runtime
+
+from msprobe.mindspore.grad_probe.grad_monitor import GradientMonitor
 
 
 class PrecisionDebugger:
     _instance = None
+    task_not_need_service = [Const.GRAD_PROBE]
 
-    def __new__(cls, config_path=None):
+    def __new__(cls, config_path=None, opt=None):
         if not cls._instance:
             cls._instance = super().__new__(cls)
             cls._instance.initialized = False
             cls._instance.config = None
+            cls.service = None
+            cls.first_start = False
         return cls._instance
 
     def __init__(self, config_path=None):
         if self.initialized:
             return
+        self.initialized = True
         if not config_path:
             config_path = os.path.join(os.path.dirname(__file__), "../../config/config.json")
         common_config, task_config = parse_json_config(config_path)
+        self.task = common_config.task
+        if self.task == Const.GRAD_PROBE:
+            self.gm = GradientMonitor(common_config, task_config)
+            return
         self.config = DebuggerConfig(common_config, task_config)
-        self.initialized = True
+
+        Runtime.step_count = 0
+        Runtime.is_running = False
+
+    @staticmethod
+    def _get_execution_mode():
+        if ms.get_context("mode") == ms.GRAPH_MODE:
+            if ms.context.get_jit_config().get("jit_level") == "O2" or ms.get_context("jit_level") == "O2":
+                return MsConst.GRAPH_GE_MODE
+            else:
+                return MsConst.GRAPH_KBYK_MODE
+        else:
+            return MsConst.PYNATIVE_MODE
 
     @classmethod
     def start(cls, target=None):
         instance = cls._instance
         if not instance:
             raise Exception("No instance of PrecisionDebugger found.")
-        handler = TaskHandlerFactory.create(instance.config)
-        handler.handle()
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+
+        instance.config.execution_mode = instance._get_execution_mode()
+        if instance.config.execution_mode == MsConst.PYNATIVE_MODE and instance.config.task != Const.FREE_BENCHMARK and instance.config.level != "kernel":
+            if not instance.service:
+                instance.service = Service(instance.config)
+            instance.service.start(target)
+        else:
+            if not instance.first_start:
+                handler = TaskHandlerFactory.create(instance.config)
+                handler.handle()
+
+        instance.first_start = True
+        Runtime.is_running = True
+
+    @classmethod
+    def stop(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        if instance.task == Const.GRAD_PROBE:
+            instance.gm.stop()
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+        if instance.service:
+            instance.service.stop()
+        Runtime.is_running = False
+
+    @classmethod
+    def step(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+        if instance.service:
+            instance.service.step()
+        Runtime.step_count += 1
+
+    @classmethod
+    def monitor(cls, opt):
+        instance = cls._instance
+        if not instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        if instance.task != Const.GRAD_PROBE:
+            return
+        instance.gm.monitor(opt)

msprobe/mindspore/doc/compare.md

@@ -0,0 +1,58 @@
+# 精度比对工具
+msprobe精度比对工具主要通过对同一个模型，在两个不同的MindSpore环境下，输入相同的训练数据，在分别得到dump数据后，对这两个dump数据进行全量自动对比，从而快速定位不同版本之间的精度问题。
+
+执行精度比对操作需要安装msprobe工具。详见《[MindStudio精度调试工具](../../README.md)》的“工具安装”章节。
+
+## 命令行方式比对
+
+精度比对工具目前使用方式为命令行形式，对MindSpore的dump数据仅支持单卡。
+
+请先参见《[精度数据采集](./dump.md)》完成不同环境下MindSpore精度数据的采集。
+
+### 操作步骤
+
+1. 使用MindSpore进行dump，得到不同框架版本的dump数据。
+
+2. 创建比对文件，文件内容及示例请参见“**比对文件**”。
+
+3. 执行如下示例命令进行比对：
+
+   ```shell
+   msprobe -f mindspore compare -i ./compare.json -o ./output -s
+   ```
+
+   **完整参数说明**
+
+   | 参数名               | 说明                                                                                                                                                                                                 | 是否必选 |
+   |-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -------- |
+   | -i或--input_path   | 指定比对文件路径。比对文件内容及示例请参见“**比对文件**”。                                                                                                                                                                   | 是       |
+   | -o或--output_path  | 配置比对结果文件存盘目录。文件名称基于时间戳自动生成，格式为：`compare_result_{timestamp}.xlsx`。                                                                                                                                  | 是       |
+   | -s或--stack_mode   | 配置stack_mode的开关。仅当**比对文件**配置"stack_path"需要开启。通过直接配置该参数开启，默认未配置，表示关闭。                                                                                                                               | 否       |
+   | -c或--compare_only | 仅比对开关。未配置默认关闭仅比对，使用自动精度分析，工具自动针对比对结果进行分析，识别到第一个精度不达标节点（在比对结果文件中的“Accuracy Reached or Not”列显示为No），并给出问题可能产生的原因（打屏展示并生成advisor_{timestamp}.txt文件）。该参数默认未配置，使用自动精度分析，通过配置该参数开启仅比对，关闭自动精度分析，仅输出比对结果表格。 | 否       |
+   | -f或--fuzzy_match  | 模糊匹配。开启后，对于网络中同一层级且命名仅调用次数不同的API，可匹配并进行比对。通过直接配置该参数开启，默认未配置，表示关闭。                                                                                                                                  | 否       |
+
+4. 查看比对结果，请详见PyTorch目录下的《[精度比对工具](../../pytorch/doc/ptdbg_ascend_compare.md)》的“比对结果分析”章节。
+
+### 比对文件
+
+以在当前目录创建./compare.json为例，单卡场景示例如下：
+
+
+  ```json
+  {
+  "npu_path": "./npu_dump/dump.json",
+  "bench_path": "./bench_dump/dump.json",
+  "stack_path": "./npu_dump/stack.json",
+  "is_print_compare_log": true
+  }
+  ```
+
+
+**参数说明**
+
+| 参数名               | 说明                                                         | 是否必选           |
+| -------------------- | ------------------------------------------------------------ | ------------------ |
+| npu_path             | 配置NPU环境下的dump.json文件（单卡场景）。数据类型：str。 | 是                 |
+| bench_path           | 配置CPU、GPU或NPU环境下的dump.json文件（单卡场景）。数据类型：str。 | 是                 |
+| stack_path           | 配置NPU dump目录下的stack.json文件。数据类型：str。          | 是|
+| is_print_compare_log | 配置是否开启日志打屏。可取值True或False，默认为True。数据类型：bool      | 否                 |