mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/pytorch/dump/debugger/precision_debugger.py

@@ -0,0 +1,130 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+from msprobe.core.dump.debugger.precision_debugger import BasePrecisionDebugger
+from msprobe.pytorch.dump.debugger.debugger_config import DebuggerConfig
+from msprobe.pytorch.dump.pt_config import parse_task_config
+from msprobe.pytorch.dump.pytorch_service import PytorchService
+
+from msprobe.core.common.const import Const, MsgConst
+from msprobe.core.common.exceptions import MsprobeException
+from msprobe.core.common.utils import check_token_range, ThreadSafe, check_rank_id
+from msprobe.pytorch.common.utils import check_save_param, is_torch_nn_module
+from msprobe.pytorch.dump.module_dump.module_dump import ModuleDumper
+
+
+class PrecisionDebugger(BasePrecisionDebugger):
+
+    def __init__(
+        self,
+        config_path=None,
+        task=None,
+        dump_path=None,
+        level=None,
+        step=None
+    ):
+        if self.initialized:
+            return
+        super().__init__(config_path, task, dump_path, level, step)
+        self.config = DebuggerConfig(
+            self.common_config,
+            self.task_config,
+            task,
+            dump_path,
+            level
+        )
+        self.service = PytorchService(self.config)
+        self.module_dumper = ModuleDumper(self.service)
+        self.ori_customer_func = {}
+
+    @staticmethod
+    def _get_task_config(task, json_config):
+        return parse_task_config(task, json_config)
+
+    @classmethod
+    @ThreadSafe.synchronized
+    def start(cls, model=None, token_range=None, rank_id=None):
+        instance = cls._get_instance()
+        if instance is None:
+            return
+
+        check_token_range(token_range)
+        check_rank_id(rank_id)
+        instance.config.check_model(model, token_range)
+        instance.service.start(model, token_range, rank_id)
+
+    @classmethod
+    @ThreadSafe.synchronized
+    def stop(cls):
+        instance = cls._get_instance()
+        if instance is None:
+            return
+        instance.service.stop()
+
+    @classmethod
+    @ThreadSafe.synchronized
+    def step(cls):
+        instance = cls._get_instance()
+        if instance is None:
+            return
+        cls._instance.service.step()
+
+    @classmethod
+    @ThreadSafe.synchronized
+    def save(cls, variable, name, save_backward=True):
+        instance = cls._instance
+        if not instance:
+            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.task not in [Const.TENSOR, Const.STATISTICS] or instance.config.level != Const.LEVEL_DEBUG:
+            return
+        try:
+            check_save_param(variable, name, save_backward)
+        except ValueError:
+            return
+        instance.service.save(variable, name, save_backward)
+
+
+@ThreadSafe.synchronized
+def module_dump(module, dump_name):
+    if not is_torch_nn_module(module):
+        raise MsprobeException(
+            MsprobeException.INVALID_PARAM_ERROR,
+            f"the module argument in module_dump must be a torch.nn.Module type, "
+            f"but currently there is an unsupported {type(module)} type."
+        )
+    if not isinstance(dump_name, str):
+        raise MsprobeException(
+            MsprobeException.INVALID_PARAM_ERROR,
+            f"the dump_name argument in module_dump must be a str type"
+        )
+    instance = PrecisionDebugger._instance
+    if not instance:
+        raise MsprobeException(
+            MsprobeException.INTERFACE_USAGE_ERROR,
+            f"PrecisionDebugger must be instantiated before using module_dump interface"
+        )
+    instance.module_dumper.start_module_dump(module, dump_name)
+
+
+@ThreadSafe.synchronized
+def module_dump_end():
+    instance = PrecisionDebugger._instance
+    if not instance:
+        raise MsprobeException(
+            MsprobeException.INTERFACE_USAGE_ERROR,
+            f"PrecisionDebugger must be instantiated before using module_dump_end interface"
+        )
+    instance.module_dumper.stop_module_dump()

msprobe/pytorch/{function_factory.py → dump/function_factory.py}

@@ -1,17 +1,18 @@
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from msprobe.pytorch.bench_functions.apply_adam_w import npu_apply_adam_w
 from msprobe.pytorch.bench_functions.confusion_transpose import npu_confusion_transpose, \

msprobe/pytorch/dump/module_dump/hook_wrapper.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2025-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from functools import wraps
 from typing import Any, Callable
@@ -22,14 +23,17 @@ from torch.utils.hooks import BackwardHook
 from msprobe.core.common.const import Const
 from msprobe.core.common.decorator import recursion_depth_decorator
 from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.hook_module.api_register import get_api_register
+from msprobe.pytorch.common.utils import is_float8_tensor
+from msprobe.pytorch.dump.api_dump.api_register import get_api_register
 
 torch_version_above_or_equal_2 = torch.__version__.split('+')[0] >= '2.0'
 
 
 def wrap_setup_backward_hook(func):
     def requires_clone(tensor, need_check_leaf=False):
-        need_clone = isinstance(tensor, torch.Tensor) and tensor.requires_grad and torch.is_grad_enabled()
+        if not isinstance(tensor, torch.Tensor):
+            return False
+        need_clone = torch.is_grad_enabled() and tensor.requires_grad and not is_float8_tensor(tensor)
         if need_check_leaf:
             need_clone &= tensor.grad_fn is not None
         return need_clone

msprobe/pytorch/dump/module_dump/module_dump.py

@@ -1,21 +1,22 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.dump.module_dump.module_processer import ModuleProcesser
-from msprobe.pytorch.hook_module.api_register import get_api_register
+from msprobe.pytorch.dump.module_dump.module_processor import ModuleProcessor
+from msprobe.pytorch.dump.api_dump.api_register import get_api_register
 
 
 class ModuleDumper:
@@ -28,7 +29,7 @@ class ModuleDumper:
             logger.info_on_rank_0("The init dump is enabled, and the module dump function will not be available.")
             return
 
-        ModuleProcesser.enable_module_dump = True
+        ModuleProcessor.enable_module_dump = True
         self.api_register.restore_all_api()
         if not hasattr(module, 'msprobe_module_dump'):
             self.service.module_processor.register_module_hook(module, self.service.build_hook,
@@ -36,5 +37,5 @@ class ModuleDumper:
             setattr(module, 'msprobe_module_dump', True)
 
     def stop_module_dump(self):
-        ModuleProcesser.enable_module_dump = False
+        ModuleProcessor.enable_module_dump = False
         self.api_register.register_all_api()

msprobe/pytorch/dump/module_dump/{module_processer.py → module_processor.py}

@@ -1,17 +1,18 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import sys
 import threading
@@ -24,7 +25,7 @@ from msprobe.core.common.const import Const
 from msprobe.core.common.megatron_utils import wrap_megatron_step, get_micro_step, is_megatron
 from msprobe.core.common.runtime import Runtime
 from msprobe.core.common.utils import ModuleQueue, ThreadSafe
-from msprobe.core.data_dump.scope import BaseScope, ModuleRangeScope, MixRangeScope
+from msprobe.core.dump.data_dump.scope import BaseScope, ModuleRangeScope, MixRangeScope
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.common.utils import is_torch_nn_module, register_forward_pre_hook
 from msprobe.pytorch.dump.module_dump.hook_wrapper import (
@@ -63,9 +64,9 @@ def wrap_forward_with_hook_safety(module):
         except _StopRecomputationError as e:
             exception_output = None
             if len(module._forward_hooks.values()) > 0:
-                # 仅执行msprobe的forward_hook, hook名称必然包含'ModuleProcesser.'
+                # 仅执行msprobe的forward_hook, hook名称必然包含'ModuleProcessor.'
                 for hook_fn in module._forward_hooks.values():
-                    if 'ModuleProcesser' in str(hook_fn):
+                    if 'ModuleProcessor' in str(hook_fn):
                         hook_fn(module, args, kwargs, exception_output)
                         break
             raise e
@@ -74,7 +75,7 @@ def wrap_forward_with_hook_safety(module):
         module.forward = wrapped_forward
 
 
-class ModuleProcesser:
+class ModuleProcessor:
     module_queue = ModuleQueue()
     module_count = {}
     module_stack = {}
@@ -83,6 +84,7 @@ class ModuleProcesser:
     module_bw_hook_kernels = {}
     module_with_backward_hook = {}
     enable_module_dump = False
+    is_megatron_module = False
 
     def __init__(self, scope):
         self.scope = scope if isinstance(scope, (ModuleRangeScope, MixRangeScope)) else None
@@ -109,11 +111,11 @@ class ModuleProcesser:
 
     @staticmethod
     def set_and_get_calls_number(module_name):
-        if module_name not in ModuleProcesser.module_count:
-            ModuleProcesser.module_count[module_name] = 0
+        if module_name not in ModuleProcessor.module_count:
+            ModuleProcessor.module_count[module_name] = 0
         else:
-            ModuleProcesser.module_count[module_name] += 1
-        return ModuleProcesser.module_count[module_name]
+            ModuleProcessor.module_count[module_name] += 1
+        return ModuleProcessor.module_count[module_name]
 
     @staticmethod
     def has_register_backward_hook(module):
@@ -137,6 +139,15 @@ class ModuleProcesser:
                 [(module_names[0], models)]
         return modules_and_names_with_index
 
+    @staticmethod
+    def check_is_megatron_module(models):
+        if isinstance(models, (list, tuple)):
+            for model in models:
+                if "megatron" in type(model).__module__:
+                    return True
+        else:
+            return "megatron" in type(models).__module__
+
     @classmethod
     def reset_module_stats(cls):
         cls.module_queue = ModuleQueue()
@@ -151,16 +162,17 @@ class ModuleProcesser:
         if module_names is None:
             module_names = []
 
+        ModuleProcessor.is_megatron_module = self.check_is_megatron_module(models)
         modules_and_names_with_index = self.get_modules_and_names(models, recursive, module_names)
         for index, modules_and_names in modules_and_names_with_index.items():
             model = models if index == "-1" else models[int(index)]
-
+            
             model_list = []
             for name, module in modules_and_names:
                 model_list.append((name, module))
-                
+            
             is_verl = "verl" in sys.modules
-            for idx, (name, module) in enumerate(model_list): 
+            for idx, (name, module) in enumerate(model_list):
                 if recursive and module == model:
                     continue
                 if not is_torch_nn_module(module):
@@ -177,7 +189,7 @@ class ModuleProcesser:
                     logger.warning(f"The module {name} is the first or last layer in verl scenario, "
                                    f"the data dump for this module will be skipped.")
                     continue
-
+                
                 setattr(module, 'msprobe_hook', True)
                 module_index = (index + Const.SEP) if index != "-1" else ""
                 prefix_name = f'{BaseScope.Module_Type_Module}{Const.SEP}{module_index}{name}{Const.SEP}' + \
@@ -190,7 +202,7 @@ class ModuleProcesser:
                         f"The {prefix_name[:-1]} has registered deprecated register_backward_hook,"
                         f"which may cause abnormal data dump. The backward data dump for this module will be skipped."
                     )
-                    ModuleProcesser.module_with_backward_hook[prefix_name] = True
+                    ModuleProcessor.module_with_backward_hook[prefix_name] = True
                 wrap_forward_with_hook_safety(module)
                 register_forward_pre_hook(module, forward_pre_hook)
 
@@ -206,7 +218,7 @@ class ModuleProcesser:
             if hasattr(module, 'msprobe_module_dump') and not self.enable_module_dump:
                 return (args, kwargs) if torch_version_above_or_equal_2 else args
 
-            index = ModuleProcesser.set_and_get_calls_number(module_name)
+            index = ModuleProcessor.set_and_get_calls_number(module_name)
             full_forward_name = f'{module_name}{Const.FORWARD}{Const.SEP}{index}'
             full_backward_name = f'{module_name}{Const.BACKWARD}{Const.SEP}{index}'
 
@@ -241,14 +253,14 @@ class ModuleProcesser:
 
                 return backward_hook_fn
 
-            if not ModuleProcesser.module_with_backward_hook.get(module_name):
+            if not ModuleProcessor.module_with_backward_hook.get(module_name):
                 backward_pre_hook = get_backward_pre_hook(full_backward_name)
                 backward_hook = get_backward_hook(hook_set.backward_hook, full_backward_name)
                 if torch_version_above_or_equal_2:
                     bw_hook = BackwardHook(module, [backward_hook], [backward_pre_hook])
                 else:
                     bw_hook = BackwardHook(module, [backward_hook])
-                ModuleProcesser.module_bw_hook_kernels[full_forward_name] = bw_hook
+                ModuleProcessor.module_bw_hook_kernels[full_forward_name] = bw_hook
                 args = bw_hook.setup_input_hook(args)
             return (args, kwargs) if torch_version_above_or_equal_2 else args
 
@@ -257,7 +269,7 @@ class ModuleProcesser:
             if hasattr(module, 'msprobe_module_dump') and not self.enable_module_dump:
                 return output_or_kwargs if torch_version_above_or_equal_2 else kwargs_or_output
 
-            index = ModuleProcesser.module_count.get(module_name)
+            index = ModuleProcessor.module_count.get(module_name)
             full_name = f'{module_name}{Const.FORWARD}{Const.SEP}{index}'
 
             hook_set = build_data_hook(BaseScope.Module_Type_Module, full_name)
@@ -269,7 +281,7 @@ class ModuleProcesser:
             else:
                 result = output_or_kwargs if torch_version_above_or_equal_2 else kwargs_or_output
 
-            bw_hook = ModuleProcesser.module_bw_hook_kernels.get(full_name)
+            bw_hook = ModuleProcessor.module_bw_hook_kernels.get(full_name)
             if bw_hook:
                 result = bw_hook.setup_output_hook(result)
 
@@ -280,35 +292,35 @@ class ModuleProcesser:
     def set_construct_info_in_pre_hook(self, full_name):
         tid = threading.get_ident()
         if tid not in self.module_stack:
-            ModuleProcesser.module_stack[tid] = []
+            ModuleProcessor.module_stack[tid] = []
 
         if self.module_stack[tid]:
-            ModuleProcesser.module_node[full_name] = self.module_stack[tid][-1] if not is_megatron() \
+            ModuleProcessor.module_node[full_name] = self.module_stack[tid][-1] if not is_megatron() \
                 else [self.module_stack[tid][-1], get_micro_step()]
         else:
-            parent_name = ModuleProcesser.module_queue.find_last(full_name)
-            ModuleProcesser.module_node[full_name] = parent_name if not is_megatron() \
+            parent_name = ModuleProcessor.module_queue.find_last(full_name)
+            ModuleProcessor.module_node[full_name] = parent_name if not is_megatron() \
                 else [parent_name, get_micro_step()]
 
-        ModuleProcesser.module_queue.add_name(full_name)
-        ModuleProcesser.module_stack[tid].append(full_name)
-        ModuleProcesser.api_parent_node[tid] = full_name if not is_megatron() else [full_name, get_micro_step()]
+        ModuleProcessor.module_queue.add_name(full_name)
+        ModuleProcessor.module_stack[tid].append(full_name)
+        ModuleProcessor.api_parent_node[tid] = full_name if not is_megatron() else [full_name, get_micro_step()]
         if self.scope:
             self.scope.begin_module(full_name)
 
     def set_construct_info_in_hook(self, full_name, is_forward=True):
         tid = threading.get_ident()
         if torch_version_above_or_equal_2 or is_forward:
-            ModuleProcesser.module_queue.remove_name(full_name)
-            ModuleProcesser.api_parent_node[tid] = None if not is_megatron() else [None, get_micro_step()]
+            ModuleProcessor.module_queue.remove_name(full_name)
+            ModuleProcessor.api_parent_node[tid] = None if not is_megatron() else [None, get_micro_step()]
             if self.module_stack.get(tid):
-                ModuleProcesser.module_stack[tid].pop()
+                ModuleProcessor.module_stack[tid].pop()
             if self.module_stack.get(tid):
-                ModuleProcesser.api_parent_node[tid] = ModuleProcesser.module_stack[tid][-1] if not is_megatron() \
-                    else [ModuleProcesser.module_stack[tid][-1], get_micro_step()]
+                ModuleProcessor.api_parent_node[tid] = ModuleProcessor.module_stack[tid][-1] if not is_megatron() \
+                    else [ModuleProcessor.module_stack[tid][-1], get_micro_step()]
             if self.scope:
                 self.scope.end_module(full_name)
         else:
             if self.scope:
                 self.scope.begin_module(full_name)
-            ModuleProcesser.api_parent_node[tid] = full_name if not is_megatron() else [full_name, get_micro_step()]
+            ModuleProcessor.api_parent_node[tid] = full_name if not is_megatron() else [full_name, get_micro_step()]

msprobe/pytorch/dump/pt_config.py

@@ -0,0 +1,128 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+import os
+
+from msprobe.core.common.const import Const
+from msprobe.core.common.file_utils import load_json
+from msprobe.core.dump.common_config import BaseConfig, CommonConfig
+from msprobe.pytorch.dump.api_dump.utils import get_ops
+from msprobe.core.common.utils import is_int
+
+
+class TensorConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.check_config()
+        self._check_summary_mode()
+        self._check_file_format()
+        self.bench_path = json_config.get("bench_path")
+
+    def _check_file_format(self):
+        if self.file_format is not None and self.file_format not in ["npy", "bin"]:
+            raise Exception("file_format is invalid")
+
+
+class StatisticsConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.check_config()
+        self._check_summary_mode()
+
+        self.tensor_list = json_config.get("tensor_list", [])
+        self._check_str_list_config(self.tensor_list, "tensor_list")
+
+
+class ACCCheckConfig(BaseConfig):
+    WrapApi = get_ops()
+
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.white_list = json_config.get("white_list", Const.DEFAULT_LIST)
+        self.black_list = json_config.get("black_list", Const.DEFAULT_LIST)
+        self.error_data_path = json_config.get("error_data_path", Const.DEFAULT_PATH)
+
+        self.check_acc_check_config()
+
+    @classmethod
+    def check_filter_list_config(cls, key, filter_list):
+        if not isinstance(filter_list, list):
+            raise Exception("%s must be a list type" % key)
+        if not all(isinstance(item, str) for item in filter_list):
+            raise Exception("All elements in %s must be string type" % key)
+        invalid_api = [item for item in filter_list if item not in cls.WrapApi]
+        if invalid_api:
+            raise Exception("Invalid api in %s: %s" % (key, invalid_api))
+
+    @classmethod
+    def check_error_data_path_config(cls, error_data_path):
+        if not os.path.exists(error_data_path):
+            raise Exception("error_data_path: %s does not exist" % error_data_path)
+
+    def check_acc_check_config(self):
+        ACCCheckConfig.check_filter_list_config(Const.WHITE_LIST, self.white_list)
+        ACCCheckConfig.check_filter_list_config(Const.BLACK_LIST, self.black_list)
+        ACCCheckConfig.check_error_data_path_config(self.error_data_path)
+
+
+class DiffCheckConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.diff_nums = json_config.get("diff_nums")
+        self.check_mode = json_config.get("check_mode")
+        self.check_diff_config()
+
+    def check_diff_config(self):
+        if self.diff_nums is not None and not is_int(self.diff_nums):
+            raise Exception("diff_num is invalid")
+        if self.diff_nums is not None and self.diff_nums != -1 and self.diff_nums <= 0:
+            raise Exception("diff_nums should be -1 or positive integer")
+        if self.check_mode is not None and self.check_mode not in ["all", "aicore", "atomic"]:
+            raise Exception("check_mode is invalid")
+
+
+class StructureConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+
+
+TaskDict = {
+    Const.TENSOR: TensorConfig,
+    Const.STATISTICS: StatisticsConfig,
+    Const.DIFF_CHECK: DiffCheckConfig,
+    Const.STRUCTURE: StructureConfig,
+    Const.ACC_CHECK: ACCCheckConfig
+}
+
+
+def parse_task_config(task, json_config):
+    if task not in Const.TORCH_TASK_LIST:
+        raise Exception(f"task <{task}> is invalid, it is not in the {Const.TORCH_TASK_LIST}.")
+    task_map = json_config.get(task, dict())
+    return TaskDict.get(task)(task_map)
+
+
+def parse_json_config(json_file_path, task):
+    if not json_file_path:
+        config_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        json_file_path = os.path.join(config_dir, "../../config.json")
+    json_config = load_json(json_file_path)
+    common_config = CommonConfig(json_config)
+    if task:
+        task_config = parse_task_config(task, json_config)
+    else:
+        task_config = parse_task_config(common_config.task, json_config)
+    return common_config, task_config