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

msprobe/pytorch/free_benchmark/common/utils.py

@@ -1,143 +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.
-
-
-import torch
-from msprobe.core.common.exceptions import FreeBenchmarkException
-from msprobe.core.common.decorator import recursion_depth_decorator
-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
-    @recursion_depth_decorator("FreeBenchmark: Tools.convert_device_and_dtype")
-    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
-    @recursion_depth_decorator("FreeBenchmark: Tools.convert_fuzz_output_to_origin")
-    def convert_fuzz_output_to_origin(origin, perturbed):
-        if isinstance(origin, torch.Tensor) and isinstance(perturbed, torch.Tensor):
-            origin.data = perturbed.to(origin.dtype).to(origin.device)
-            return origin
-        if isinstance(origin, dict) and isinstance(perturbed, dict):
-            output = dict()
-            for key, value in origin.items():
-                if key not in perturbed:
-                    err_msg = f"'{key}' not in perturbed output."
-                    raise FreeBenchmarkException(
-                        FreeBenchmarkException.InvalidPerturbedOutput,
-                        error_info=err_msg,
-                    )
-                output[key] = Tools.convert_fuzz_output_to_origin(value, perturbed[key])
-            return output
-        if isinstance(origin, (tuple, list)) and isinstance(perturbed, (tuple, list)):
-            result = list()
-            if len(perturbed) != len(origin):
-                err_msg = (
-                    f"length of perturbed output ({len(perturbed)}) is different "
-                    f"from the length of original output ({len(origin)})."
-                )
-                raise FreeBenchmarkException(
-                    FreeBenchmarkException.InvalidPerturbedOutput, error_info=err_msg
-                )
-            for index_, value in enumerate(origin):
-                result.append(
-                    Tools.convert_fuzz_output_to_origin(value, perturbed[index_])
-                )
-            return type(origin)(result)
-        err_msg = f"conversion of two outputs with types ({type(origin)}, {type(perturbed)}) is not supported."
-        raise FreeBenchmarkException(
-            FreeBenchmarkException.UnsupportedType, error_info=err_msg
-        )
-
-
-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
-    mul = torch._C._VariableFunctionsClass.mul
-    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
-    clamp = torch._C._VariableFunctionsClass.clamp
-    tensor_split = torch._C._VariableFunctionsClass.tensor_split
-    stack = torch._C._VariableFunctionsClass.stack
-    reshape = torch._C._VariableFunctionsClass.reshape
-    nan_to_num = torch._C._VariableFunctionsClass.nan_to_num
-    aminmax = torch._C._VariableFunctionsClass.aminmax

msprobe/pytorch/free_benchmark/compare/grad_saver.py

@@ -1,215 +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.
-
-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,
-    data_pre_deal,
-)
-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.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):
-        data_params = DataParams()
-        data_params.original_result = origin_grad
-        data_params.perturbed_result = perturbed_grad
-        data_params.valid_input_index = index
-        try:
-            handler.handle(data_params)
-            if not data_params.is_consistent:
-                self.is_compare = False
-                data_params.is_consistent = True
-                data_params.perturbed_result = self.perturbed_grad_input
-                data_params.original_result = self.origin_grad_input
-                handler.handle(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}"
-            )
-
-    def check_grad_input(self, origin_grad, new_grad_index):
-        if self.perturbed_grad_input is None:
-            raise FreeBenchmarkException(
-                FreeBenchmarkException.InvalidPerturbedOutput,
-                f"perturbed grad not exists for {self.api_name}.",
-            )
-        if len(self.perturbed_grad_input) <= new_grad_index:
-            raise FreeBenchmarkException(
-                FreeBenchmarkException.InvalidPerturbedOutput,
-                f"perturbed grad index {new_grad_index} is out of bounds for {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.InvalidPerturbedOutput,
-                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:
-                    if index_ >= len(inputs):
-                        err_msg = (
-                            f"[msprobe] Free benchmark: When getting input from vjp, "
-                            f" the input index ({index_}) is out of bounds ({len(inputs)})."
-                        )
-                        logger.error_log_with_exp(
-                            err_msg,
-                            FreeBenchmarkException(
-                                FreeBenchmarkException.InvalidGrad,
-                                error_info=err_msg,
-                            ),
-                        )
-                    _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
-    ):
-        data_params = data_pre_deal(
-            self.handler_params.api_name,
-            self.get_grad_input_from_vjp,
-            [need_grad_tensors, grad_output, inner_args],
-            {},
-        )
-        layer = LayerFactory.create(
-            self.handler_params.api_name,
-            self.handler_params.fuzz_device,
-            self.handler_params.pert_mode,
-        )
-        layer.handle(data_params)
-        # 确定扰动成功后，才会暂存
-        if data_params.perturbed_result:
-            self.perturbed_grad_input = tuple(
-                [x.cpu() for x in data_params.perturbed_result]
-            )

msprobe/pytorch/free_benchmark/compare/single_benchmark.py

@@ -1,121 +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.
-
-import math
-
-import torch
-from msprobe.core.common.decorator import recursion_depth_decorator
-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
-
-    @recursion_depth_decorator("FreeBenchmark: SingleCompare.compare_seq")
-    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

@@ -1,123 +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 abc import ABC
-
-import torch
-from msprobe.core.common.const import Const
-from msprobe.core.common.utils import replace_last_occurrence
-from msprobe.pytorch.free_benchmark import logger
-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):
-    grad_saver_dict = {}
-
-    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)
-
-        backward_name = replace_last_occurrence(name, Const.FORWARD, Const.BACKWARD)
-        FreeBenchmarkCheck.grad_saver_dict[backward_name] = 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)
-        perturbed_output = handler.handle(data_params)
-        return perturbed_output, handler.get_unequal_rows()
-
-    def backward(self, name, module, grad_output):
-        if not self.config.fuzz_stage == Const.BACKWARD:
-            return
-        try:
-            grad_saver = FreeBenchmarkCheck.grad_saver_dict[name]
-        except AttributeError:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free benchmark:  get grad saver failed. api_name:{name}"
-            )
-            return
-        del FreeBenchmarkCheck.grad_saver_dict[name]
-
-        _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

@@ -1,28 +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 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

@@ -1,56 +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.pytorch.free_benchmark import FreeBenchmarkException
-from msprobe.pytorch.free_benchmark.common.enums import DeviceType, PerturbationMode
-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.change_value import (
-    ChangeValueLayer,
-)
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.improve_precision import (
-    ImprovePrecisionLayer,
-)
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.no_change import NoChangeLayer
-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)