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

msprobe/pytorch/parse_tool/lib/utils.py

@@ -1,299 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# 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
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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.
-
-import os
-import re
-import subprocess
-import sys
-import time
-import zlib
-from collections import namedtuple
-
-import numpy as np
-from msprobe.core.common.const import FileCheckConst
-from msprobe.core.common.file_utils import change_mode, check_other_user_writable, \
-    check_path_executable, check_path_owner_consistent
-from msprobe.core.common.file_utils import check_file_or_directory_path, remove_path, check_file_type, os_walk_for_files
-from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.parse_tool.lib.config import Const
-from msprobe.pytorch.parse_tool.lib.file_desc import DumpDecodeFileDesc, FileDesc
-from msprobe.pytorch.parse_tool.lib.parse_exception import ParseException
-
-try:
-    from rich.traceback import install
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich import print as rich_print
-    from rich.columns import Columns
-except ImportError as err:
-    install = None
-    Panel = None
-    Table = None
-    Columns = None
-    rich_print = None
-    logger.warning(
-        "Failed to import rich, Some features may not be available. Please run 'pip install rich' to fix it.")
-
-
-class Util:
-    def __init__(self):
-        self.ms_accu_cmp = None
-        self.log = logger
-        self.python = sys.executable
-
-    @staticmethod
-    def print(content):
-        rich_print(content)
-
-    @staticmethod
-    def path_strip(path):
-        return path.strip("'").strip('"')
-
-    @staticmethod
-    def check_executable_file(path):
-        check_path_owner_consistent(path)
-        check_other_user_writable(path)
-        check_path_executable(path)
-
-    @staticmethod
-    def get_subdir_count(directory):
-        subdir_count = 0
-        check_file_or_directory_path(directory, isdir=True)
-        for _, dirs, _ in os.walk(directory):
-            subdir_count += len(dirs)
-            break
-        return subdir_count
-
-    @staticmethod
-    def get_subfiles_count(directory):
-        files = os_walk_for_files(directory, Const.MAX_TRAVERSAL_DEPTH)
-        return len(files)
-
-    @staticmethod
-    def get_sorted_subdirectories_names(directory):
-        subdirectories = []
-        for item in os.listdir(directory):
-            item_path = os.path.join(directory, item)
-            if os.path.isdir(item_path):
-                subdirectories.append(item)
-        return sorted(subdirectories)
-
-    @staticmethod
-    def get_sorted_files_names(directory):
-        files = []
-        for item in os.listdir(directory):
-            item_path = os.path.join(directory, item)
-            if os.path.isfile(item_path):
-                files.append(item)
-        return sorted(files)
-
-    @staticmethod
-    def check_npy_files_valid_in_dir(dir_path):
-        for file_name in os.listdir(dir_path):
-            file_path = os.path.join(dir_path, file_name)
-            check_file_or_directory_path(file_path)
-            _, file_extension = os.path.splitext(file_path)
-            if not file_extension == '.npy':
-                return False
-        return True
-
-    @staticmethod
-    def get_md5_for_numpy(obj):
-        np_bytes = obj.tobytes()
-        md5_crc = zlib.crc32(np_bytes)
-        return f"{md5_crc:08x}"
-
-    @staticmethod
-    def deal_with_dir_or_file_inconsistency(output_path):
-        logger.warning(f"Trying to delete {output_path}")
-        remove_path(output_path)
-        raise ParseException("Inconsistent directory structure or file.")
-
-    @staticmethod
-    def deal_with_value_if_has_zero(data):
-        if data.dtype in Const.FLOAT_TYPE:
-            zero_mask = (data == 0)
-            # 给0的地方加上eps防止除0
-            data[zero_mask] += np.finfo(data.dtype).eps
-        else:
-            # int type + float eps 会报错，所以这里要强转
-            data = data.astype(float)
-            zero_mask = (data == 0)
-            data[zero_mask] += np.finfo(float).eps
-        return data
-
-    @staticmethod
-    def dir_contains_only(path, endfix):
-        files = os_walk_for_files(path, Const.MAX_TRAVERSAL_DEPTH)
-        for file in files:
-            if not file['file'].endswith(endfix):
-                return False
-        return True
-
-    @staticmethod
-    def localtime_str():
-        return time.strftime("%Y%m%d%H%M%S", time.localtime())
-
-    @staticmethod
-    def change_filemode_safe(path):
-        change_mode(path, FileCheckConst.DATA_FILE_AUTHORITY)
-
-    @staticmethod
-    def _gen_npu_dump_convert_file_info(name, match, dir_path):
-        return DumpDecodeFileDesc(name, dir_path, int(match.groups()[-4]), op_name=match.group(2),
-                                  op_type=match.group(1), task_id=int(match.group(3)), anchor_type=match.groups()[-3],
-                                  anchor_idx=int(match.groups()[-2]))
-
-    @staticmethod
-    def _gen_numpy_file_info(name, math, dir_path):
-        return FileDesc(name, dir_path)
-
-    def execute_command(self, cmd):
-        if not cmd:
-            self.log.error("Commond is None")
-            return -1
-        self.log.info("[RUN CMD]: %s" % cmd)
-        cmd = cmd.split(" ")
-        complete_process = subprocess.run(cmd, shell=False)
-        return complete_process.returncode
-
-    def print_panel(self, content, title='', fit=True):
-        if not Panel:
-            self.print(content)
-            return
-        if fit:
-            self.print(Panel.fit(content, title=title))
-        else:
-            self.print(Panel(content, title=title))
-
-    def check_msaccucmp(self, target_file):
-        if os.path.split(target_file)[-1] != Const.MS_ACCU_CMP_FILE_NAME:
-            self.log.error(
-                "Check msaccucmp failed in dir %s. This is not a correct msaccucmp file" % target_file)
-            raise ParseException(ParseException.PARSE_MSACCUCMP_ERROR)
-        result = subprocess.run(
-            [self.python, target_file, "--help"], stdout=subprocess.PIPE, shell=False)
-        if result.returncode == 0:
-            self.log.info("Check [%s] success." % (target_file))
-        else:
-            self.log.error("Check msaccucmp failed in dir %s" % target_file)
-            self.log.error("Please specify a valid msaccucmp.py path or install the cann package")
-            raise ParseException(ParseException.PARSE_MSACCUCMP_ERROR)
-        return target_file
-
-    def gen_npy_info_txt(self, source_data):
-        (shape, dtype, max_data, min_data, mean) = \
-            self.npy_info(source_data)
-        return \
-                '[Shape: %s] [Dtype: %s] [Max: %s] [Min: %s] [Mean: %s]' % (shape, dtype, max_data, min_data, mean)
-
-    def list_convert_files(self, path, external_pattern=""):
-        return self.list_file_with_pattern(
-            path, Const.OFFLINE_DUMP_CONVERT_PATTERN, external_pattern, self._gen_npu_dump_convert_file_info
-        )
-
-    def list_numpy_files(self, path, extern_pattern=''):
-        return self.list_file_with_pattern(path, Const.NUMPY_PATTERN, extern_pattern,
-                                           self._gen_numpy_file_info)
-
-    def create_columns(self, content):
-        if not Columns:
-            self.log.error("No module named rich, please install it")
-            raise ParseException(ParseException.PARSE_NO_MODULE_ERROR)
-        return Columns(content)
-
-    def create_table(self, title, columns):
-        if not Table:
-            self.log.error("No module named rich, please install it and restart parse tool")
-            raise ParseException(ParseException.PARSE_NO_MODULE_ERROR)
-        table = Table(title=title)
-        for column_name in columns:
-            table.add_column(column_name, overflow='fold')
-        return table
-
-    def check_path_valid(self, path):
-        path = self.path_strip(path)
-        if not path or not os.path.exists(path):
-            self.log.error("The path does not exist.")
-            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
-        isdir = check_file_type(path) == FileCheckConst.DIR
-        check_file_or_directory_path(path, isdir=isdir)
-        return True
-
-    def check_files_in_path(self, path):
-        if os.path.isdir(path) and len(os.listdir(path)) == 0:
-            self.log.error("No files found in path.")
-            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
-
-    def npy_info(self, source_data):
-        if isinstance(source_data, np.ndarray):
-            data = source_data
-        else:
-            self.log.error("Invalid data, data is not ndarray")
-            raise ParseException(ParseException.PARSE_INVALID_DATA_ERROR)
-        if data.dtype == 'object':
-            self.log.error("Invalid data, data is object.")
-            raise ParseException(ParseException.PARSE_INVALID_DATA_ERROR)
-        if np.size(data) == 0:
-            self.log.error("Invalid data, data is empty")
-            raise ParseException(ParseException.PARSE_INVALID_DATA_ERROR)
-        npu_info_result = namedtuple('npu_info_result', ['shape', 'dtype', 'max', 'min', 'mean'])
-        res = npu_info_result(data.shape, data.dtype, data.max(), data.min(), data.mean())
-        return res
-
-    def list_file_with_pattern(self, path, pattern, extern_pattern, gen_info_func):
-        self.check_path_valid(path)
-        file_list = {}
-        re_pattern = re.compile(pattern)
-        files = os_walk_for_files(path, Const.MAX_TRAVERSAL_DEPTH)
-        for file in files:
-            name = file["file"]
-            match = re_pattern.match(name)
-            if not match:
-                continue
-            if extern_pattern != '' and re_pattern.match(extern_pattern) and not name.startswith(extern_pattern):
-                continue
-            file_list[name] = gen_info_func(name, match, file["root"])
-        return file_list
-
-    def check_file_path_format(self, path, suffix):
-        if os.path.isfile(path):
-            if not path.endswith(suffix):
-                self.log.error("%s is not a %s file." % (path, suffix))
-                raise ParseException(ParseException.PARSE_INVALID_FILE_FORMAT_ERROR)
-        elif os.path.isdir(path):
-            self.log.error("Please specify a single file path")
-            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
-        else:
-            self.log.error("The file path %s is invalid" % path)
-            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
-
-    def check_str_param(self, param):
-        if len(param) > Const.FILE_NAME_LENGTH:
-            self.log.error('The parameter length exceeds limit')
-            raise ParseException(ParseException.PARSE_INVALID_PARAM_ERROR)
-        if not re.match(Const.FILE_PATTERN, param):
-            self.log.error('The parameter {} contains special characters.'.format(param))
-            raise ParseException(ParseException.PARSE_INVALID_PARAM_ERROR)
-
-    def is_subdir_count_equal(self, dir1, dir2):
-        dir1_count = self.get_subdir_count(dir1)
-        dir2_count = self.get_subdir_count(dir2)
-        return dir1_count == dir2_count
-
-    def check_positive(self, value):
-        if value <= 0.0:
-            self.log.error("Invalid value. It must be greater than 0.")
-            raise ParseException(ParseException.PARSE_INVALID_DATA_ERROR)

msprobe/pytorch/parse_tool/lib/visualization.py

@@ -1,85 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# 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
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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.
-
-import json
-
-import numpy as np
-from msprobe.core.common.file_utils import FileOpen, load_npy, save_npy_to_txt
-from msprobe.pytorch.parse_tool.lib.config import Const
-from msprobe.pytorch.parse_tool.lib.parse_exception import ParseException
-from msprobe.pytorch.parse_tool.lib.utils import Util
-
-
-class Visualization:
-    def __init__(self):
-        self.util = Util()
-
-    def print_npy_summary(self, target_file):
-        np_data = load_npy(target_file)
-        table = self.util.create_table('', ['Index', 'Data'])
-        flatten_data = np_data.flatten()
-        tablesize = 8
-        for i in range(min(16, int(np.ceil(flatten_data.size / tablesize)))):
-            last_idx = min(flatten_data.size, i * tablesize + tablesize)
-            table.add_row(str(i * tablesize), ' '.join(flatten_data[i * tablesize: last_idx].astype('str').tolist()))
-        summary = ['[yellow]%s[/yellow]' % self.util.gen_npy_info_txt(np_data), 'Path: %s' % target_file,
-                   "TextFile: %s.txt" % target_file]
-        self.util.print_panel(self.util.create_columns([table, "\n".join(summary)]), target_file)
-        save_npy_to_txt(np_data, target_file + ".txt")
-
-    def print_npy_data(self, file_name):
-        file_name = self.util.path_strip(file_name)
-        self.util.check_path_valid(file_name)
-        self.util.check_file_path_format(file_name, Const.NPY_SUFFIX)
-        return self.print_npy_summary(file_name)
-
-    def parse_pkl(self, path, api_name):
-        path = self.util.path_strip(path)
-        self.util.check_path_valid(path)
-        self.util.check_file_path_format(path, Const.PKL_SUFFIX)
-        self.util.check_str_param(api_name)
-        with FileOpen(path, "r") as pkl_handle:
-            title_printed = False
-            while True:
-                pkl_line = pkl_handle.readline()
-                if pkl_line == '\n':
-                    continue
-                if len(pkl_line) == 0:
-                    break
-                try:
-                    msg = json.loads(pkl_line)
-                except json.JSONDecodeError as e:
-                    self.util.log.error("%s %s in line %s" % ("JSONDecodeError", str(e), pkl_line))
-                    self.util.log.warning("Please check the pkl file")
-                    raise ParseException(ParseException.PARSE_JSONDECODE_ERROR) from e
-                if not isinstance(msg, list) or len(msg) == 0:
-                    break
-                info_prefix = msg[0]
-                if not info_prefix.startswith(api_name):
-                    continue
-                if info_prefix.find("stack_info") != -1 and len(msg) == 2:
-                    self.util.log.info("\nTrace back({}):".format(msg[0]))
-                    if msg[1] and len(msg[1]) > 4:
-                        for item in reversed(msg[1]):
-                            self.util.log.info("  File \"{}\", line {}, in {}".format(item[0], item[1], item[2]))
-                            self.util.log.info("    {}".format(item[3]))
-                        continue
-                if len(msg) > 5 and len(msg[5]) >= 3:
-                    summery_info = "  [{}][dtype: {}][shape: {}][max: {}][min: {}][mean: {}]" \
-                        .format(msg[0], msg[3], msg[4], msg[5][0], msg[5][1], msg[5][2])
-                    if not title_printed:
-                        self.util.log.info("\nStatistic Info:")
-                        title_printed = True
-                    self.util.log.info(summery_info)

msprobe/pytorch/pt_config.py

@@ -1,299 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# 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
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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.
-
-import os
-import re
-
-from msprobe.core.common.const import Const, FileCheckConst
-from msprobe.core.common.exceptions import MsprobeException
-from msprobe.core.common.file_utils import FileOpen, load_json, check_file_or_directory_path, FileChecker
-from msprobe.core.common.log import logger
-from msprobe.core.common.utils import is_int
-from msprobe.core.common_config import BaseConfig, CommonConfig
-from msprobe.core.grad_probe.constant import level_adp
-from msprobe.core.grad_probe.utils import check_bounds
-from msprobe.pytorch.free_benchmark.common.enums import (
-    DeviceType,
-    HandlerType,
-    PytorchFreeBenchmarkConst,
-)
-from msprobe.pytorch.hook_module.utils import get_ops
-
-
-class TensorConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.check_config()
-        self._check_summary_mode()
-        self._check_file_format()
-
-
-    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 OverflowCheckConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.overflow_nums = json_config.get("overflow_nums")
-        self.check_mode = json_config.get("check_mode")
-        self.check_overflow_config()
-
-    def check_overflow_config(self):
-        if self.overflow_nums is not None and not is_int(self.overflow_nums):
-            raise Exception("overflow_num is invalid")
-        if self.overflow_nums is not None and self.overflow_nums != -1 and self.overflow_nums <= 0:
-            raise Exception("overflow_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 FreeBenchmarkCheckConfig(BaseConfig):
-
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.fuzz_device = json_config.get("fuzz_device", PytorchFreeBenchmarkConst.DEFAULT_DEVICE)
-        self.pert_mode = json_config.get("pert_mode", PytorchFreeBenchmarkConst.DEFAULT_MODE)
-        self.handler_type = json_config.get("handler_type", PytorchFreeBenchmarkConst.DEFAULT_HANDLER)
-        self.fuzz_level = json_config.get("fuzz_level", PytorchFreeBenchmarkConst.DEFAULT_FUZZ_LEVEL)
-        self.fuzz_stage = json_config.get("fuzz_stage", PytorchFreeBenchmarkConst.DEFAULT_FUZZ_STAGE)
-        self.list = json_config.get("list")
-        self.if_preheat = json_config.get("if_preheat", False)
-        self.preheat_step = json_config.get("preheat_step", PytorchFreeBenchmarkConst.DEFAULT_PREHEAT_STEP)
-        self.max_sample = json_config.get("max_sample", PytorchFreeBenchmarkConst.DEFAULT_PREHEAT_STEP)
-        self.check_freebenchmark_config()
-
-    def check_freebenchmark_config(self):
-        self._check_pert_mode()
-        self._check_fuzz_device()
-        self._check_handler_type()
-        self._check_fuzz_stage()
-        self._check_fuzz_level()
-        self._check_if_preheat()
-        if self.handler_type == HandlerType.FIX:
-            self._check_fix_config()
-        if self.if_preheat:
-            self._check_preheat_config()
-
-    def _check_pert_mode(self):
-        if self.pert_mode not in PytorchFreeBenchmarkConst.PERTURBATION_MODE_LIST:
-            msg = (
-                f"pert_mode is invalid, it should be one of"
-                f" {PytorchFreeBenchmarkConst.PERTURBATION_MODE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_fuzz_device(self):
-        if self.fuzz_device not in PytorchFreeBenchmarkConst.DEVICE_LIST:
-            msg = (
-                f"fuzz_device is invalid, it should be one of"
-                f" {PytorchFreeBenchmarkConst.DEVICE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if (self.fuzz_device == DeviceType.CPU) ^ (
-                self.pert_mode in PytorchFreeBenchmarkConst.CPU_MODE_LIST
-        ):
-            msg = (
-                f"You need to and can only set fuzz_device as {DeviceType.CPU} "
-                f"when pert_mode in {PytorchFreeBenchmarkConst.CPU_MODE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_handler_type(self):
-        if self.handler_type not in PytorchFreeBenchmarkConst.HANDLER_LIST:
-            msg = (
-                f"handler_type is invalid, it should be one of"
-                f" {PytorchFreeBenchmarkConst.HANDLER_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_fuzz_stage(self):
-        if self.fuzz_stage not in PytorchFreeBenchmarkConst.FUZZ_STAGE_LIST:
-            msg = (
-                f"fuzz_stage is invalid, it should be one of"
-                f" {PytorchFreeBenchmarkConst.FUZZ_STAGE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if self.fuzz_stage == Const.BACKWARD and not self.list:
-            raise MsprobeException(
-                MsprobeException.INVALID_PARAM_ERROR,
-                f"When fuzz_stage is set to {Const.BACKWARD}, the parameters list must not be empty."
-            )
-
-    def _check_fuzz_level(self):
-        if self.fuzz_level not in PytorchFreeBenchmarkConst.FUZZ_LEVEL_LIST:
-            msg = (
-                f"fuzz_level is invalid, it should be one of"
-                f" {PytorchFreeBenchmarkConst.FUZZ_LEVEL_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_if_preheat(self):
-        if not isinstance(self.if_preheat, bool):
-            msg = "if_preheat is invalid, it should be a boolean"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_preheat_config(self):
-        if not is_int(self.preheat_step):
-            msg = "preheat_step is invalid, it should be an integer"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if self.preheat_step <= 0:
-            msg = "preheat_step must be greater than 0"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if not is_int(self.max_sample):
-            msg = "max_sample is invalid, it should be an integer"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if self.max_sample <= 0:
-            msg = "max_sample must be greater than 0"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-    def _check_fix_config(self):
-        if self.if_preheat:
-            msg = f"Preheating is not supported for {HandlerType.FIX} handler type"
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if self.fuzz_stage not in PytorchFreeBenchmarkConst.FIX_STAGE_LIST:
-            msg = (
-                f"The fuzz_stage when opening {HandlerType.FIX} handler must be one of "
-                f"{PytorchFreeBenchmarkConst.FIX_STAGE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-        if self.pert_mode not in PytorchFreeBenchmarkConst.FIX_MODE_LIST:
-            msg = (
-                f"The pert_mode when opening {HandlerType.FIX} handler must be one of "
-                f"{PytorchFreeBenchmarkConst.FIX_MODE_LIST}"
-            )
-            logger.error_log_with_exp(
-                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
-            )
-
-
-class RunUTConfig(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_run_ut_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_run_ut_config(self):
-        RunUTConfig.check_filter_list_config(Const.WHITE_LIST, self.white_list)
-        RunUTConfig.check_filter_list_config(Const.BLACK_LIST, self.black_list)
-        RunUTConfig.check_error_data_path_config(self.error_data_path)
-
-
-class GradToolConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-        self.grad_level = json_config.get("grad_level", "L1")
-        self.param_list = json_config.get("param_list", [])
-        self.bounds = json_config.get("bounds", [-1, 0, 1])
-        self._check_config()
-
-    def _check_config(self):
-        if self.grad_level not in level_adp.keys():
-            raise Exception(f"grad_level must be one of {level_adp.keys()}")
-        if not isinstance(self.param_list, list):
-            raise Exception(f"param_list must be a list")
-        check_bounds(self.bounds)
-
-
-class StructureConfig(BaseConfig):
-    def __init__(self, json_config):
-        super().__init__(json_config)
-
-
-TaskDict = {
-    Const.TENSOR: TensorConfig,
-    Const.STATISTICS: StatisticsConfig,
-    Const.OVERFLOW_CHECK: OverflowCheckConfig,
-    Const.FREE_BENCHMARK: FreeBenchmarkCheckConfig,
-    Const.RUN_UT: RunUTConfig,
-    Const.GRAD_PROBE: GradToolConfig,
-    Const.STRUCTURE: StructureConfig
-}
-
-
-def parse_task_config(task, json_config):
-    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