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

msprobe/pytorch/debugger/precision_debugger.py

@@ -1,181 +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.
-
-from torch.utils.data import dataloader
-
-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
-from msprobe.core.debugger.precision_debugger import BasePrecisionDebugger
-from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.common.utils import check_save_param, is_torch_nn_module
-from msprobe.pytorch.debugger.debugger_config import DebuggerConfig
-from msprobe.pytorch.dump.module_dump.module_dump import ModuleDumper
-from msprobe.pytorch.grad_probe.grad_monitor import GradientMonitor
-from msprobe.pytorch.pytorch_service import PytorchService
-from msprobe.pytorch.pt_config import parse_task_config
-
-
-class PrecisionDebugger(BasePrecisionDebugger):
-
-    def __init__(
-        self,
-        config_path=None,
-        task=None,
-        dump_path=None,
-        level=None,
-        model=None,
-        step=None
-    ):
-        if self.initialized:
-            return
-        super().__init__(config_path, task, dump_path, level, step)
-        self.model = model
-        if self.task == Const.GRAD_PROBE:
-            self.gm = GradientMonitor(self.common_config, self.task_config)
-            return
-        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 = {}
-        self.enable_dataloader = self.config.enable_dataloader
-        self._param_warning()
-
-    @staticmethod
-    def _get_task_config(task, json_config):
-        return parse_task_config(task, json_config)
-
-    @staticmethod
-    def _iter_tracer(func):
-        def func_wrapper(*args, **kwargs):
-            debugger_instance = PrecisionDebugger._instance
-            if not debugger_instance:
-                raise MsprobeException(
-                    MsprobeException.INTERFACE_USAGE_ERROR,
-                    f"PrecisionDebugger must be instantiated before executing the dataloader iteration"
-                )
-
-            debugger_instance.enable_dataloader = False
-            if not debugger_instance.service.first_start:
-                debugger_instance.stop()
-                debugger_instance.step()
-            result = func(*args, **kwargs)
-            debugger_instance.start()
-            debugger_instance.enable_dataloader = True
-            return result
-
-        return func_wrapper
-
-    @classmethod
-    @ThreadSafe.synchronized
-    def start(cls, model=None, token_range=None):
-        instance = cls._get_instance()
-        if instance is None:
-            return
-
-        check_token_range(token_range)
-        instance.config.check_model(instance, model, token_range)
-
-        if instance.enable_dataloader:
-            logger.warning_on_rank_0("DataLoader is enabled, start() skipped.")
-        else:
-            instance.service.start(instance.model, token_range)
-
-    @classmethod
-    @ThreadSafe.synchronized
-    def stop(cls):
-        instance = cls._get_instance()
-        if instance is None:
-            return
-        if instance.enable_dataloader:
-            logger.warning_on_rank_0("DataLoader is enabled, stop() skipped.")
-        else:
-            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 monitor(cls, model):
-        if not cls._instance:
-            raise Exception(MsgConst.NOT_CREATED_INSTANCE)
-        if cls._instance.task != Const.GRAD_PROBE:
-            return
-        cls._instance.gm.monitor(model)
-
-    @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)
-
-    def _param_warning(self):
-        if self.model is not None:
-            logger.warning_on_rank_0(
-                "The 'model' parameter in the PrecisionDebugger will be deprecated in the future."
-                "It is recommended to pass the 'model' parameter in the start interface instead."
-            )
-        if self.enable_dataloader:
-            logger.warning_on_rank_0("The enable_dataloader feature will be deprecated in the future.")
-            dataloader._BaseDataLoaderIter.__next__ = self._iter_tracer(dataloader._BaseDataLoaderIter.__next__)
-
-
-@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/free_benchmark/__init__.py

@@ -1,23 +0,0 @@
-# Copyright (c) 2024-2024, 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.
-
-__all__ = ["FreeBenchmarkCheck", "UnequalRow"]
-
-from msprobe.core.common.const import Const
-from msprobe.core.common.exceptions import FreeBenchmarkException
-from msprobe.pytorch.common.log import logger
-
-from .common.params import UnequalRow
-from .main import FreeBenchmarkCheck

msprobe/pytorch/free_benchmark/common/constant.py

@@ -1,85 +0,0 @@
-# Copyright (c) 2024-2024, 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.
-
-from typing import Dict
-
-import numpy as np
-import torch
-from msprobe.pytorch.free_benchmark.common.enums import FuzzThreshold
-from msprobe.pytorch.free_benchmark.common.params import BenchmarkThd
-
-
-class CommonField:
-    DEVICE = "device"
-    META = "meta"
-    FUZZ_TENSOR = "fuzz_tensor"
-    REQUIRES_GRAD = "requires_grad"
-    HOLD_PLACE = "hold_place"
-    DISTRIBUTED_OP = "torch.distributed"
-    GRADSAVER = "grad_saver"
-
-
-class ThresholdConfig:
-    PERTURBATION_VALUE_DICT: Dict = {
-        torch.bfloat16: FuzzThreshold.BF16_THD,
-        torch.float16: FuzzThreshold.F16_THD,
-        torch.float32: FuzzThreshold.F32_THD,
-        torch.float64: FuzzThreshold.F64_THD,
-    }
-
-    ABS_TOL_VALUE_DICT: Dict = {
-        torch.bfloat16: FuzzThreshold.BF16_THD,
-        torch.float16: FuzzThreshold.F16_THD,
-        torch.float32: FuzzThreshold.F32_THD,
-        torch.float64: FuzzThreshold.F64_THD,
-    }
-
-    # bit翻转需要匹配到等长或更长的整型
-    PERTURBATION_BIT_DICT = {
-        torch.bfloat16: torch.int16,
-        torch.float16: torch.int16,
-        torch.float32: torch.int32,
-        torch.float64: torch.int64,
-    }
-
-    # 输入噪声下界
-    NOISE_INPUT_LOWER_BOUND = 1e-8
-    COMP_CONSISTENT = 1.0
-    COMP_NAN = np.nan
-    SYMBOL_FLIPPING = "symbol_flipping"
-    BACKWARD_OUTPUT_LOWER_BOUND = 1e-3
-    SMALL_VALUE = 1.0
-    # 预热初始阈值
-    PREHEAT_INITIAL_THD = 2.05
-    API_THD_STEP = 2.0
-
-    DTYPE_PER_THD = {
-        torch.float16: 1.002,
-        torch.bfloat16: 1.004,
-        torch.float32: 1.0002,
-    }
-    BENCHMARK_THD_DICT = {
-        torch.float32: BenchmarkThd(2**-14, 1.0, 2**-14, 1e-4),
-        torch.float16: BenchmarkThd(2**-11, 1.0, 2**-11, 1e-4),
-        torch.bfloat16: BenchmarkThd(2**-8, 1.0, 2**-8, 1e-4),
-    }
-
-    TENSOR_SPLIT_MAX_CHUNK = 128
-
-
-class PreheatConfig:
-    IF_PREHEAT = "if_preheat"
-    PREHEAT_STEP = "preheat_step"
-    MAX_SAMPLE = "max_sample"

msprobe/pytorch/free_benchmark/common/counter.py

@@ -1,87 +0,0 @@
-# Copyright (c) 2024-2024, 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.
-
-from collections import defaultdict
-from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
-
-
-class PreheatCounter:
-    def __init__(self) -> None:
-        self.api_called_time: dict = defaultdict(int)
-        self.api_sample_time: dict = defaultdict(int)
-        self.one_step_used_api: dict = defaultdict(int)
-        self.api_thd: dict = defaultdict(dict)
-        self.preheat_record: dict = defaultdict(dict)
-        self.dtype_map: dict = {}
-        self.if_preheat: dict = defaultdict(dict)
-        self.step = 0
-
-    def clear_step(self):
-        self.preheat_record.clear()
-        self.api_called_time.clear()
-        self.api_sample_time.clear()
-    
-    def check_step(self, current_step):
-        if current_step != self.step:
-            self.clear_step()
-            self.step = current_step
-
-    def add_api_called_time(self, api_name: str):
-        self.api_called_time[api_name] += 1
-
-    def get_api_called_time(self, api_name: str) -> int:
-        return self.api_called_time[api_name]
-    
-    def add_api_sample_time(self, api_name: str):
-        self.api_sample_time[api_name] += 1
-
-    def get_api_sample_time(self, api_name: str) -> int:
-        return self.api_sample_time[api_name]
-
-    def add_one_step_used_api(self, api_name: str):
-        self.one_step_used_api[api_name] += 1
-
-    def get_one_step_used_api(self, api_name: str):
-        return self.one_step_used_api[api_name]
-
-    def update_preheat_record(self, api_name, dtype, cmp_result):
-        # 记录预热阶段CPU标杆比对的结果
-        if str(dtype) not in self.preheat_record[api_name].keys():
-            self.preheat_record[api_name][str(dtype)] = list()
-        self.preheat_record[api_name][str(dtype)].append(cmp_result)
-        self.dtype_map[str(dtype)] = dtype
-
-    def update_api_thd(self, api_name, dtype, threshold, dthreshold):
-        self.api_thd[api_name][str(dtype)] = (
-            threshold if threshold > dthreshold else dthreshold
-        )
-
-    def get_api_thd(self, api_name, dtype):
-        if not str(dtype) in self.api_thd[api_name]:
-            self.api_thd[api_name][str(dtype)] = ThresholdConfig.PREHEAT_INITIAL_THD
-            self.dtype_map[str(dtype)] = dtype
-        return self.api_thd[api_name][str(dtype)]
-
-    def set_api_preheat(self, api_name, dtype_str, is_preheat=True):
-        # 标记cpu不一致的dtype 不再进行预热
-        self.if_preheat[api_name][dtype_str] = is_preheat
-
-    def get_api_preheat(self, api_name, dtype):
-        # 标记cpu不一致的dtype 不再进行预热
-        if str(dtype) not in self.if_preheat[api_name]:
-            return True
-        return self.if_preheat[api_name][str(dtype)]
-
-preheat_counter = PreheatCounter()

msprobe/pytorch/free_benchmark/common/enums.py

@@ -1,80 +0,0 @@
-# Copyright (c) 2024-2024, 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.
-
-from msprobe.core.common.const import Const
-
-
-class PerturbationMode:
-    ADD_NOISE = "add_noise"
-    CHANGE_VALUE = "change_value"
-    IMPROVE_PRECISION = "improve_precision"
-    NO_CHANGE = "no_change"
-    BIT_NOISE = "bit_noise"
-    TO_CPU = "to_cpu"
-
-
-class DeviceType:
-    NPU = "npu"
-    CPU = "cpu"
-
-
-class FuzzThreshold:
-    BF16_THD = 1e-4
-    F16_THD = 1e-6
-    F32_THD = 1e-8
-    F64_THD = 1e-16
-
-
-class NormType:
-    ONE_NORM = (1, "one_norm")
-    TWO_NORM = (2, "two_norm")
-    ENDLESS_NORM = (3, "endless_norm")
-
-
-class HandlerType:
-    CHECK = "check"
-    PREHEAT = "preheat"
-    FIX = "fix"
-
-
-class FuzzLevel:
-    BASE_LEVEL = "L1"
-    ADV_LEVEL = "L2"
-    REAL_LEVEL = "L3"
-
-
-class PytorchFreeBenchmarkConst:
-    PERTURBATION_MODE_LIST = [
-        PerturbationMode.ADD_NOISE,
-        PerturbationMode.CHANGE_VALUE,
-        PerturbationMode.IMPROVE_PRECISION,
-        PerturbationMode.NO_CHANGE,
-        PerturbationMode.BIT_NOISE,
-        PerturbationMode.TO_CPU,
-    ]
-    DEFAULT_MODE = PerturbationMode.IMPROVE_PRECISION
-    DEVICE_LIST = [DeviceType.NPU, DeviceType.CPU]
-    DEFAULT_DEVICE = DeviceType.NPU
-    HANDLER_LIST = [HandlerType.CHECK, HandlerType.FIX]
-    DEFAULT_HANDLER = HandlerType.CHECK
-    FUZZ_LEVEL_LIST = [FuzzLevel.BASE_LEVEL]
-    DEFAULT_FUZZ_LEVEL = FuzzLevel.BASE_LEVEL
-    FUZZ_STAGE_LIST = [Const.FORWARD, Const.BACKWARD]
-    FIX_MODE_LIST = [PerturbationMode.IMPROVE_PRECISION, PerturbationMode.TO_CPU]
-    DEFAULT_FUZZ_STAGE = Const.FORWARD
-    DEFAULT_PREHEAT_STEP = 15
-    DEFAULT_MAX_SAMPLE = 20
-    CPU_MODE_LIST = [PerturbationMode.TO_CPU]
-    FIX_STAGE_LIST = [Const.FORWARD]

msprobe/pytorch/free_benchmark/common/params.py

@@ -1,152 +0,0 @@
-# Copyright (c) 2024-2024, 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.
-
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-import torch
-from msprobe.core.common.exceptions import FreeBenchmarkException
-from msprobe.pytorch.free_benchmark import logger
-from msprobe.pytorch.free_benchmark.common.enums import (
-    DeviceType,
-    FuzzLevel,
-    PerturbationMode,
-)
-from msprobe.pytorch.free_benchmark.common.utils import Tools
-
-
-@dataclass
-class DataParams:
-    args: Optional[Tuple] = None
-    kwargs: Optional[Dict] = None
-    valid_input_index: Optional[int] = None
-    original_result: Optional[Any] = None
-    perturbed_result: Optional[Any] = None
-    is_consistent: Optional[bool] = True
-    perturbed_value: Optional[Any] = None
-    origin_func: Optional[Callable] = None
-    api_type: Optional[str] = None
-    fuzz_stage: Optional[str] = None
-
-
-@dataclass
-class HandlerParams:
-    handler_type: Optional[str] = None
-    api_name: Optional[str] = None
-    pert_mode: Optional[PerturbationMode] = None
-    step: Optional[int] = None
-    fuzz_stage: Optional[str] = None
-    fuzz_device: Optional[DeviceType] = None
-    preheat_config: Optional[Dict] = None
-    fuzz_level: Optional[str] = None
-
-
-@dataclass
-class UnequalRow:
-    rank: Optional[int] = None
-    pert_mode: Optional[PerturbationMode] = None
-    stage: Optional[str] = None
-    step: Optional[int] = None
-    api_name: Optional[str] = None
-    max_rel: Optional[float] = None
-    dtype: Optional[str] = None
-    shape: Optional[str] = None
-    output_index: Optional[int] = None
-
-
-@dataclass
-class BenchmarkThd:
-    rtol: Optional[float] = None  # 相对误差阈值
-    small_value: Optional[float] = None  # 小值域
-    small_value_atol: Optional[float] = None  # 小值域绝对阈值
-    err_balance: Optional[float] = None  # 误差均衡性
-
-
-def check_args_type(args: Tuple) -> int:
-    for i, arg in enumerate(args):
-        if torch.is_tensor(arg):
-            if arg.is_meta:
-                continue
-            if not torch.is_floating_point(arg):
-                continue
-            return i
-        if isinstance(arg, (List, Tuple, Dict)):
-            return i
-    return -1
-
-
-def data_pre_deal(name, func, args, kwargs):
-    data_params = DataParams(args=args, kwargs=kwargs, origin_func=func)
-    index = check_args_type(args)
-    data_params.valid_input_index = index
-    if index == -1:
-        logger.warning_on_rank_0(
-            f"[msprobe] Free benchmark: 无标杆工具不支持当前算子的输入类型 {name}."
-        )
-    return data_params
-
-
-def make_handler_params(name, config, step):
-    handler_params = HandlerParams()
-    handler_params.api_name = name
-    handler_params.step = step
-    handler_params.handler_type = config.handler_type
-    handler_params.fuzz_stage = config.fuzz_stage
-    handler_params.fuzz_device = config.fuzz_device
-    handler_params.preheat_config = config.preheat_config
-    handler_params.fuzz_level = config.fuzz_level
-    handler_params.pert_mode = config.pert_mode
-    return handler_params
-
-
-def make_unequal_row(
-    data_params: DataParams,
-    handle_params: HandlerParams,
-    ratio: float = None,
-    index: int = None,
-):
-    row = UnequalRow(
-        api_name=handle_params.api_name,
-        pert_mode=handle_params.pert_mode,
-        output_index=index,
-        stage=handle_params.fuzz_stage,
-        step=handle_params.step,
-    )
-    if isinstance(ratio, float):
-        row.max_rel = ratio - 1
-    if isinstance(ratio, str):
-        row.max_rel = ratio
-    origin_tensor = data_params.original_result
-    perturbed_tensor = data_params.perturbed_result
-    if index is not None:
-        if index >= len(origin_tensor) or index >= len(perturbed_tensor):
-            err_msg = f"When generating unequal results, index {index} of output is out of bounds. please check!"
-            raise FreeBenchmarkException(
-                FreeBenchmarkException.OutputIndexError,
-                error_info=err_msg,
-            )
-        origin_tensor = origin_tensor[index]
-        perturbed_tensor = perturbed_tensor[index]
-        row.output_index = index
-    if isinstance(origin_tensor, torch.Tensor):
-        row.dtype = origin_tensor.dtype
-        row.shape = origin_tensor.shape
-    row.rank = Tools.get_dist_rank()
-    # 以下暂不支持
-    if handle_params.fuzz_level == FuzzLevel.ADV_LEVEL:
-        pass
-    if handle_params.fuzz_level == FuzzLevel.REAL_LEVEL:
-        pass
-    return row