mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.4__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,51 +1,66 @@
-import os
-
-
-class DebuggerConfig:
-    convert_map = {
-        "L0": "cell",
-        "L1": "api",
-        "L2": 'kernel'
-    }
-
-    def __init__(self, common_config, task_config):
-        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]
-        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.file_format = task_config.file_format
-        self.check_mode = task_config.check_mode
-
-        self.check()
-
-    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.")
-        if not self.task:
-            self.task = "statistics"
-        if not self.level:
-            raise Exception("level must be L0, L1 or L2")
-        if not self.file_format:
-            self.file_format = "npy"
-        if not self.check_mode:
-            self.check_mode = "all"
-        self._check_rank()
-        self._check_step()
-        return True
-
-    def _check_rank(self):
-        for rank_id in self.rank:
-            if not isinstance(rank_id, int) or rank_id < 0:
-                raise ValueError(f"rank {self.rank} must be a positive integer.")
-
-    def _check_step(self):
-        for s in self.step:
-            if not isinstance(s, int):
-                raise ValueError(f"step element {s} should be int")
+import os
+
+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_utils import create_directory
+
+
+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
+        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.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()
+        create_directory(self.dump_path)
+
+        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)
+            self.stage = FreeBenchmarkConst.DEFAULT_STAGE if not task_config.fuzz_stage else task_config.fuzz_stage
+            if self.handler_type == FreeBenchmarkConst.FIX 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
+
+    def check(self):
+        if not self.dump_path:
+            raise Exception("Dump path is empty.")
+        self.dump_path = os.path.abspath(self.dump_path)
+        if not self.task:
+            self.task = "statistics"
+        if not self.level:
+            raise Exception("level must be L0, L1 or L2")
+        if not self.file_format:
+            self.file_format = "npy"
+        if not self.check_mode:
+            self.check_mode = "all"
+        self._check_rank()
+        self._check_step()
+        return True
+
+    def _check_rank(self):
+        for rank_id in self.rank:
+            if not isinstance(rank_id, int) or rank_id < 0:
+                raise ValueError(f"rank {self.rank} must be a positive integer.")
+
+    def _check_step(self):
+        for s in self.step:
+            if not isinstance(s, int) or s < 0:
+                raise ValueError(f"step element {s} must be a positive integer.")

msprobe/mindspore/debugger/precision_debugger.py

@@ -1,32 +1,126 @@
-import os
-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
-
-
-class PrecisionDebugger:
-    _instance = None
-
-    def __new__(cls, config_path=None):
-        if not cls._instance:
-            cls._instance = super().__new__(cls)
-            cls._instance.initialized = False
-            cls._instance.config = None
-        return cls._instance
-
-    def __init__(self, config_path=None):
-        if self.initialized:
-            return
-        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.config = DebuggerConfig(common_config, task_config)
-        self.initialized = True
-
-    @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()
+import os
+
+import mindspore as ms
+from mindspore._c_expression import MSContext
+
+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, 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.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)
+
+        Runtime.step_count = 0
+        Runtime.is_running = False
+
+    @staticmethod
+    def _get_execution_mode():
+        jit_level = ms.context.get_jit_config().get(MsConst.JIT_LEVEL)
+        jit_level = jit_level if jit_level else ms.get_context(MsConst.JIT_LEVEL)
+        if not jit_level:
+            if MSContext.get_instance().get_ascend_soc_version() == MsConst.ASCEND_910A:
+                jit_level = MsConst.JIT_LEVEL_O2
+            else:
+                jit_level = MsConst.JIT_LEVEL_O0
+
+        if ms.get_context("mode") == ms.GRAPH_MODE:
+            if jit_level == MsConst.JIT_LEVEL_O2:
+                return MsConst.GRAPH_GE_MODE
+            else:
+                return MsConst.GRAPH_KBYK_MODE
+        else:
+            return MsConst.PYNATIVE_MODE
+
+    @classmethod
+    def start(cls, model=None):
+        instance = cls._instance
+        if not instance:
+            raise Exception("No instance of PrecisionDebugger found.")
+        if instance.task in PrecisionDebugger.task_not_need_service:
+            return
+
+        instance.config.execution_mode = instance._get_execution_mode()
+        if cls._need_service():
+            if not instance.service:
+                instance.service = Service(instance.config)
+            instance.service.start(model)
+        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)
+
+    @classmethod
+    def _need_service(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception("No instance of PrecisionDebugger found.")
+        if instance.config.execution_mode != MsConst.PYNATIVE_MODE:
+            return False
+        else:
+            return instance.config.task != Const.FREE_BENCHMARK and instance.config.level != MsConst.KERNEL