mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/free_benchmark/common/params.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import torch
+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
+    grad_unequal_flag: Optional[bool] = True
+
+
+@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
+    origin_tensor = data_params.original_result
+    perturbed_tensor = data_params.perturbed_result
+    if index:
+        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

msprobe/pytorch/free_benchmark/common/utils.py

@@ -0,0 +1,98 @@
+import torch
+from msprobe.pytorch.free_benchmark.common.enums import DeviceType
+
+
+class Tools:
+
+    @staticmethod
+    def is_float_tensor(tensor) -> bool:
+        if isinstance(tensor, torch.Tensor) and torch.is_floating_point(tensor):
+            return True
+        if isinstance(tensor, (list, tuple)):
+            for value in tensor:
+                if isinstance(value, torch.Tensor) and torch.is_floating_point(value):
+                    return True
+        return False
+
+    @staticmethod
+    def get_dist_rank():
+        try:
+            return torch.distributed.get_rank()
+        except RuntimeError:
+            return 0
+
+    @staticmethod
+    def get_first_tensor_dtype(tensor_seq):
+        if isinstance(tensor_seq, torch.Tensor):
+            return tensor_seq.dtype
+        if isinstance(tensor_seq, (list, tuple)):
+            for object_ in tensor_seq:
+                if isinstance(object_, torch.Tensor):
+                    return object_.dtype
+        raise RuntimeError("The sequence does not contain tensors.")
+
+    @staticmethod
+    def get_pure_api_name(api_name: str):
+        return api_name.rsplit(".", 2)[0]
+
+    @staticmethod
+    def convert_device_and_dtype(
+        tensor_seq, device: str = DeviceType.CPU, change_dtype: bool = False
+    ):
+        if isinstance(tensor_seq, torch.Tensor):
+            if change_dtype and tensor_seq.dtype in [torch.float16, torch.bfloat16]:
+                return tensor_seq.detach().to(device).to(torch.float32)
+            return tensor_seq.detach().to(device)
+        if isinstance(tensor_seq, dict):
+            return {
+                key: Tools.convert_device_and_dtype(value, device, change_dtype)
+                for key, value in tensor_seq.items()
+            }
+        if isinstance(tensor_seq, (tuple, list)):
+            return type(tensor_seq)(
+                [
+                    Tools.convert_device_and_dtype(value, device, change_dtype)
+                    for value in tensor_seq
+                ]
+            )
+        return tensor_seq
+
+    @staticmethod
+    def convert_fuzz_output_to_origin(origin, perturbed):
+        if isinstance(origin, torch.Tensor):
+            origin.data = perturbed.to(origin.dtype).to(origin.device)
+            return origin
+        if isinstance(origin, dict):
+            output = dict()
+            for key, value in origin.items():
+                output[key] = Tools.convert_fuzz_output_to_origin(value, perturbed[key])
+            return output
+        if isinstance(origin, (tuple, list)):
+            result = list()
+            for index_, value in enumerate(origin):
+                result.append(
+                    Tools.convert_fuzz_output_to_origin(value, perturbed[index_])
+                )
+            return type(origin)(result)
+        return origin
+    
+class TorchC:
+    sum = torch._C._VariableFunctionsClass.sum
+    isinf = torch._C._VariableFunctionsClass.isinf
+    isfinite = torch._C._VariableFunctionsClass.isfinite
+    isnan = torch._C._VariableFunctionsClass.isnan
+    logical_not = torch._C._VariableFunctionsClass.logical_not
+    subtract = torch._C._VariableFunctionsClass.subtract
+    abs = torch._C._VariableFunctionsClass.abs
+    where = torch._C._VariableFunctionsClass.where
+    div = torch._C._VariableFunctionsClass.div
+    max = torch._C._VariableFunctionsClass.max
+    min = torch._C._VariableFunctionsClass.min
+    gt = torch._C._VariableFunctionsClass.gt
+    ge = torch._C._VariableFunctionsClass.ge
+    lt = torch._C._VariableFunctionsClass.lt
+    mean = torch._C._VariableFunctionsClass.mean
+    full = torch._C._VariableFunctionsClass.full
+    add = torch._C._VariableFunctionsClass.add
+    bitwise_xor = torch._C._VariableFunctionsClass.bitwise_xor
+    clone = torch._C._VariableFunctionsClass.clone

msprobe/pytorch/free_benchmark/compare/grad_saver.py

@@ -0,0 +1,183 @@
+import torch
+from msprobe.core.common.exceptions import FreeBenchmarkException
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import CommonField
+from msprobe.pytorch.free_benchmark.common.params import DataParams, HandlerParams
+from msprobe.pytorch.free_benchmark.perturbed_layers.layer_factory import LayerFactory
+from msprobe.pytorch.free_benchmark.result_handlers.handler_factory import (
+    FuzzHandlerFactory,
+)
+
+
+class GradSaver:
+
+    def __init__(self, origin_func, handler_params: HandlerParams):
+
+        self.handler_params = handler_params
+        self.api_name = handler_params.api_name
+        self.origin_func = origin_func
+        self.data_params = DataParams()
+        self.is_compare = True
+        self.kwargs = dict()
+        self.perturbed_grad_input = tuple()
+        self.origin_grad_input = tuple()
+        self.need_grad_flag = list()
+        self.backward_input = tuple()
+
+    def register_compare_func_for_inputs(self, inputs, data_processor):
+        _index = 0
+        for j, obj in enumerate(inputs):
+            if torch.is_tensor(obj) and obj.requires_grad:
+
+                def compare_func(grad, new_grad_index=_index, input_index=j):
+                    if not self.is_compare:
+                        return grad
+                    try:
+                        perturbed_grad = self.check_grad_input(grad, new_grad_index)
+                        handler = FuzzHandlerFactory.create(self.handler_params)
+                        self.compare_grad_results(
+                            handler, grad, perturbed_grad, index=input_index
+                        )
+                        data_processor.update_unequal_rows(handler.get_unequal_rows())
+                    except IndexError:
+                        logger.warning_on_rank_0(
+                            f"[msprobe] Free benchmark: grad index out of range. api:{self.handler_params.api_name}."
+                            f"index:{new_grad_index}, perturbation grad len {len(self.perturbed_grad_input)}"
+                        )
+                        return grad
+                    except FreeBenchmarkException as e:
+                        logger.warning_on_rank_0(
+                            f"[msprobe] Free benchmark: grad input check error: {e}"
+                        )
+                        return grad
+                    except Exception as e:
+                        logger.warning_on_rank_0(
+                            f"[msprobe] Free benchmark: grad compare error: {e}"
+                        )
+                        return grad
+                    return grad
+
+                obj.register_hook(compare_func)
+                _index += 1
+
+    def compare_grad_results(self, handler, origin_grad, perturbed_grad, index):
+        # TODO get dtype?
+        self.data_params.original_result = origin_grad
+        self.data_params.perturbed_result = perturbed_grad
+        self.data_params.grad_unequal_flag = False
+        self.data_params.valid_input_index = index
+        try:
+            handler.handle(self.data_params)
+            if not self.data_params.is_consistent:
+                self.is_compare = False
+                self.data_params.grad_unequal_flag = True
+                self.data_params.is_consistent = True
+                self.data_params.perturbed_result = self.perturbed_grad_input
+                self.data_params.original_result = self.origin_grad_input
+                handler.handle(self.data_params)
+        except Exception as e:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free benchmark: compare two vjp failed: api:{self.handler_params.api_name}."
+                f"{e}"
+            )
+        # 在扰动前后输出对比后释放输出的引用
+        self.data_params.perturbed_result = None
+        self.data_params.original_result = None
+
+    def check_grad_input(self, origin_grad, new_grad_index):
+        if self.perturbed_grad_input is None:
+            raise FreeBenchmarkException(
+                FreeBenchmarkException.InvalidGrad,
+                f"grad not exists : {self.api_name}."
+            )
+        with torch.no_grad():
+            perturbed_grad = self.perturbed_grad_input[new_grad_index].to(
+                origin_grad.device
+            )
+        if origin_grad.shape != perturbed_grad.shape:
+            raise FreeBenchmarkException(
+                FreeBenchmarkException.InvalidGrad,
+                f"grad shapes are inconsistent. api:{self.handler_params.api_name}."
+                f"origin:{origin_grad.shape}, perturbation: {perturbed_grad.shape}"
+            )
+        return perturbed_grad
+
+    def cache_backward_input(self, backward_input_list):
+        _inputs = []
+        with torch.no_grad():
+            for backward_input in backward_input_list:
+                if torch.is_tensor(backward_input):
+                    _inputs.append(
+                        {
+                            CommonField.DEVICE: backward_input.device,
+                            CommonField.FUZZ_TENSOR: backward_input.cpu(),
+                            CommonField.REQUIRES_GRAD: backward_input.requires_grad,
+                        }
+                    )
+                else:
+                    _inputs.append(backward_input)
+        self.backward_input = _inputs
+
+    def get_vjp_input(self):
+        inner_args_tmp = []
+        need_grad_tensors = []
+        for object_ in self.backward_input:
+            if isinstance(object_, dict) and CommonField.FUZZ_TENSOR in object_.keys():
+                tensor_ = torch.tensor(
+                    object_.get(CommonField.FUZZ_TENSOR).data,
+                    dtype=object_.get(CommonField.FUZZ_TENSOR).dtype,
+                    device=object_.get(CommonField.DEVICE),
+                    requires_grad=object_.get(CommonField.REQUIRES_GRAD),
+                )
+
+                if tensor_.requires_grad:
+                    inner_args_tmp.append(CommonField.HOLD_PLACE)
+                    need_grad_tensors.append(tensor_)
+                    self.need_grad_flag.append(True)
+                else:
+                    self.need_grad_flag.append(False)
+                    inner_args_tmp.append(tensor_)
+            else:
+                self.need_grad_flag.append(False)
+                inner_args_tmp.append(object_)
+
+        return need_grad_tensors, tuple(inner_args_tmp)
+
+    def get_grad_input_from_vjp(self, need_grad_tensors, grad_output, inner_args):
+        def vjp_func(*inputs):
+            _real_input = []
+            index_ = 0
+            for object_ in inner_args:
+                if object_ is CommonField.HOLD_PLACE:
+                    _real_input.append(inputs[index_])
+                    index_ += 1
+                else:
+                    _real_input.append(object_)
+            kwargs = self.kwargs.copy()
+            if 'inplace' in kwargs:
+                kwargs['inplace'] = False
+            return self.origin_func(*_real_input, **kwargs)
+
+        _, grad_input = torch.autograd.functional.vjp(
+            vjp_func, tuple(need_grad_tensors), grad_output
+        )
+        return grad_input
+
+    def calculate_perturbed_grad_input(self, grad_output, need_grad_tensors, inner_args):
+        self.data_params.args = [need_grad_tensors, grad_output, inner_args]
+        self.data_params.kwargs = {}
+        self.data_params.valid_input_index = 0
+        self.data_params.origin_func = self.get_grad_input_from_vjp
+        layer = LayerFactory.create(
+            self.handler_params.api_name,
+            self.handler_params.fuzz_device,
+            self.handler_params.pert_mode,
+        )
+        layer.handle(self.data_params)
+        # 在计算扰动输出之后，释放输入的引用
+        self.data_params.args = None
+        # 确定扰动成功后，才会暂存
+        if self.data_params.perturbed_result:
+            self.perturbed_grad_input = tuple(
+                [x.cpu() for x in self.data_params.perturbed_result]
+            )

msprobe/pytorch/free_benchmark/compare/single_benchmark.py

@@ -0,0 +1,104 @@
+import math
+
+import torch
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
+from msprobe.pytorch.free_benchmark.common.utils import TorchC
+
+
+class SingleCompare:
+    def __init__(self) -> None:
+        self.relative_err = None
+        self.absolute_err = None
+        self.eb = None
+        self.threshold = None
+
+    @staticmethod
+    def filter_overflow(tensor) -> int:
+        inf_num = TorchC.sum(TorchC.isinf(tensor))
+        nan_num = TorchC.sum(TorchC.isnan(tensor))
+        return inf_num + nan_num
+
+    @staticmethod
+    def replace_inf_or_nan(tensor):
+        finite_mask = TorchC.isfinite(tensor)
+        inf_or_nan_mask = TorchC.logical_not(finite_mask)
+        inf_or_nan_num = TorchC.sum(inf_or_nan_mask).item()
+        if inf_or_nan_num > 0:
+            tensor[inf_or_nan_mask] = 1
+        return tensor
+
+    @staticmethod
+    def compare_float_seq(actual, golden):
+        return math.isclose(actual, golden)
+
+    @staticmethod
+    def compare_other_seq(actual, golden):
+        return actual == golden
+
+    def compare_dict_seq(self, actual, golden):
+        if len(actual) != len(golden):
+            return False
+        for key, value in golden.items():
+            if not self.compare_seq(value, actual.get(key)):
+                return False
+        return True
+
+    def compare_list_seq(self, actual, golden):
+        if len(actual) != len(golden):
+            return False
+        for index_, value in enumerate(golden):
+            if not self.compare_seq(value, actual[index_]):
+                return False
+        return True
+
+    def compare_seq(self, actual, golden):
+        if isinstance(golden, torch.Tensor):
+            return self.compare_tensor_seq(actual, golden)
+        elif isinstance(golden, dict):
+            return self.compare_dict_seq(actual, golden)
+        elif isinstance(golden, (tuple, list)):
+            return self.compare_list_seq(actual, golden)
+        elif isinstance(golden, float):
+            return self.compare_float_seq(actual, golden)
+        else:
+            return self.compare_other_seq(actual, golden)
+
+    def compare_tensor_seq(self, actual, golden):
+        self.threshold = ThresholdConfig.BENCHMARK_THD_DICT.get(
+            actual.dtype, ThresholdConfig.BENCHMARK_THD_DICT.get(torch.float32)
+        )
+        if self.filter_overflow(golden) > 0:
+            logger.warning_on_rank_0("[msprobe] Free Benchmark: inf and nan"
+                                  "in golden tensor is not supported.")
+            return True
+        actual = self.replace_inf_or_nan(actual)
+        actual = actual.to(torch.float64)
+        golden = golden.to(torch.float64).to(actual.device)
+        self._cal_compare_metrics(actual, golden)
+        if self.absolute_err > self.threshold.small_value_atol:
+            return False
+        if self.relative_err > self.threshold.rtol:
+            return False
+        if self.eb > self.threshold.err_balance:
+            return False
+        return True
+
+    def _cal_compare_metrics(self, actual, golden):
+        diff_value = TorchC.subtract(actual, golden)
+        diff_abs = TorchC.abs(diff_value)
+        golden_abs = TorchC.abs(golden)
+        # 使用绝对误差的元素
+        self.absolute_err = TorchC.max(TorchC.where(
+            TorchC.lt(TorchC.abs(actual), self.threshold.small_value), diff_abs, 0
+        ))
+        diff_rel = TorchC.div(diff_abs, golden_abs)
+        # 使用相对误差的元素
+        self.relative_err = TorchC.max(TorchC.where(
+            TorchC.ge(TorchC.abs(actual), self.threshold.small_value), diff_rel, 0
+        ))
+        # 获取误差均衡性
+        divided = TorchC.where(
+            TorchC.ge(TorchC.abs(golden), self.threshold.small_value), golden_abs, 1
+        )
+        self.eb = TorchC.mean(TorchC.div(diff_value, divided))

msprobe/pytorch/free_benchmark/main.py

@@ -0,0 +1,102 @@
+from abc import ABC
+
+import torch
+from msprobe.core.common.const import Const
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import CommonField
+from msprobe.pytorch.free_benchmark.common.enums import (
+    DeviceType,
+    FuzzLevel,
+    HandlerType,
+    PerturbationMode,
+)
+from msprobe.pytorch.free_benchmark.common.params import data_pre_deal, make_handler_params
+from msprobe.pytorch.free_benchmark.compare.grad_saver import GradSaver
+from msprobe.pytorch.free_benchmark.perturbed_layers.layer_factory import LayerFactory
+from msprobe.pytorch.free_benchmark.result_handlers.handler_factory import (
+    FuzzHandlerFactory,
+)
+
+
+class FreeBenchmarkCheck(ABC):
+
+    def __init__(self, config) -> None:
+        super().__init__()
+        self.config = config
+        if self.config.pert_mode is None:
+            self.config.pert_mode = PerturbationMode.IMPROVE_PRECISION
+        if self.config.fuzz_level is None:
+            self.config.fuzz_level = FuzzLevel.BASE_LEVEL
+        if self.config.fuzz_device is None:
+            self.config.fuzz_device = DeviceType.NPU
+        self.current_iter = 0
+
+    def update_iter(self, update_iter):
+        self.current_iter = update_iter
+    
+    def if_fix(self):
+        if self.config.handler_type==HandlerType.FIX:
+            return True
+        return False
+
+    def pre_forward(self, name, module, data_processor, args, kwargs):
+        if not self.config.fuzz_stage == Const.BACKWARD:
+            return
+        origin_func = (
+            module._slow_forward if torch._C._get_tracing_state() else module.forward
+        )
+        handler_params = make_handler_params(name, self.config, self.current_iter)
+        grad_saver = GradSaver(origin_func, handler_params)
+        grad_saver.kwargs = kwargs
+        grad_saver.register_compare_func_for_inputs(args, data_processor)
+        grad_saver.cache_backward_input(args)
+        setattr(module, CommonField.GRADSAVER, grad_saver)
+
+    def forward(self, name, module, args, kwargs, output):
+        if not self.config.fuzz_stage == Const.FORWARD:
+            return output, []
+        origin_func = (
+            module._slow_forward if torch._C._get_tracing_state() else module.forward
+        )
+        data_params = data_pre_deal(name, origin_func, args, kwargs)
+        if data_params.valid_input_index == -1:
+            return output, []
+        data_params.original_result = output
+        data_params.fuzz_stage = self.config.fuzz_stage
+
+        layer = LayerFactory.create(
+            name, self.config.fuzz_device, self.config.pert_mode
+        )
+        layer.handle(data_params)
+        handler_params = make_handler_params(name, self.config, self.current_iter)
+        handler = FuzzHandlerFactory.create(handler_params)
+        handler.handle(data_params)
+        return data_params.perturbed_result, handler.get_unequal_rows()
+
+    def backward(self, name, module, grad_output):
+
+        if not self.config.fuzz_stage == Const.BACKWARD:
+            return
+        try:
+            grad_saver = getattr(module, CommonField.GRADSAVER)
+        except AttributeError:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free benchmark:  get grad saver failed. api_name:{name}"
+            )
+            return
+
+        _new_grad_output = grad_output
+        try:
+            need_grad_tensors, _inner_args = grad_saver.get_vjp_input()
+            origin_grad_input = grad_saver.get_grad_input_from_vjp(
+                tuple(need_grad_tensors), _new_grad_output, _inner_args
+            )
+            grad_saver.origin_grad_input = tuple([x.cpu() for x in origin_grad_input])
+            grad_saver.calculate_perturbed_grad_input(
+                _new_grad_output, need_grad_tensors, _inner_args
+            )
+        except Exception as e:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free benchmark: grad vjp calculate failed. api_name:{name} error: {e}"
+            )
+            return

msprobe/pytorch/free_benchmark/perturbed_layers/base_layer.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+
+
+class BaseLayer(ABC):
+    def __init__(self, api_name: str) -> None:
+        self.api_name = api_name
+
+    @abstractmethod
+    def handle(self, params: DataParams) -> Any:
+        pass

msprobe/pytorch/free_benchmark/perturbed_layers/layer_factory.py

@@ -0,0 +1,41 @@
+from msprobe.pytorch.free_benchmark import FreeBenchmarkException
+from msprobe.pytorch.free_benchmark.common.enums import DeviceType, PerturbationMode
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.improve_precision import (
+    ImprovePrecisionLayer,
+)
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.add_noise import AddNoiseLayer
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.bit_noise import BitNoiseLayer
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.no_change import NoChangeLayer
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.change_value import (
+    ChangeValueLayer,
+)
+from msprobe.pytorch.free_benchmark.perturbed_layers.run_cpu import CpuLayer
+
+
+class LayerFactory:
+    layers = {
+        DeviceType.NPU: {
+            PerturbationMode.ADD_NOISE: AddNoiseLayer,
+            PerturbationMode.CHANGE_VALUE: ChangeValueLayer,
+            PerturbationMode.NO_CHANGE: NoChangeLayer,
+            PerturbationMode.BIT_NOISE: BitNoiseLayer,
+            PerturbationMode.IMPROVE_PRECISION: ImprovePrecisionLayer,
+        },
+        DeviceType.CPU: {PerturbationMode.TO_CPU: CpuLayer},
+    }
+
+    @staticmethod
+    def create(api_name: str, device_type: str, mode: str):
+        layer = LayerFactory.layers.get(device_type)
+        if not layer:
+            raise FreeBenchmarkException(
+                FreeBenchmarkException.UnsupportedType,
+                f"无标杆工具不支持当前设备 {device_type}",
+            )
+        layer = layer.get(mode)
+        if not layer:
+            raise FreeBenchmarkException(
+                FreeBenchmarkException.UnsupportedType,
+                f"无标杆工具无法识别该扰动因子 {mode} on {device_type}",
+            )
+        return layer(api_name)