mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.4__py3-none-any.whl

msprobe/pytorch/free_benchmark/perturbed_layers/npu/add_noise.py

@@ -1,90 +1,90 @@
-import torch
-from msprobe.pytorch.free_benchmark import logger
-from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
-from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
-from msprobe.pytorch.free_benchmark.common.params import DataParams
-from msprobe.pytorch.free_benchmark.common.utils import TorchC
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
-    NpuBaseLayer,
-)
-
-
-class AddNoiseLayer(NpuBaseLayer):
-
-    def add_noise(self, tensor_obj):
-        if isinstance(tensor_obj, torch.Tensor):
-            self.perturbed_value = ThresholdConfig.PERTURBATION_VALUE_DICT.get(
-                tensor_obj.dtype
-            )
-            if not self.pre_check(tensor_obj):
-                return tensor_obj
-            noise = self._get_noise(tensor_obj)
-            result = TorchC.where(
-                TorchC.gt(TorchC.abs(tensor_obj), self.perturbed_value ** 0.5),
-                TorchC.add(noise, tensor_obj),
-                tensor_obj,
-            ).to(tensor_obj.dtype)
-            self.is_added = True
-            return result
-        if isinstance(tensor_obj, dict):
-            return {key: self.add_noise(value) for key, value in tensor_obj.items()}
-        if isinstance(tensor_obj, (tuple, list)):
-            return type(tensor_obj)([self.add_noise(value) for value in tensor_obj])
-        return tensor_obj
-
-    def handle(self, params: DataParams) -> torch.Any:
-        """
-        对输入添加扰动并返回
-        """
-        logger.info_on_rank_0(
-            f"[msprobe] Free benchmark: Perturbation is "
-            f"{PerturbationMode.ADD_NOISE} of {self.api_name}."
-        )
-        params.perturbed_value = self.add_noise(params.args[params.valid_input_index])
-        return self.perturbed_result(params)
-
-    def _get_noise(self, tensor_obj):
-        dtype = tensor_obj.dtype
-        device = str(tensor_obj.device)
-        noise = TorchC.full(
-            tensor_obj.shape,
-            self.perturbed_value,
-            device=device,
-            dtype=dtype,
-        )
-        return noise
-
-    def _check_details(self, tensor_obj):
-        """
-        判断是否需要添加扰动
-        """
-        if not self.perturbed_value:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"dtype unsupported. Cancel perturbation."
-            )
-            return False
-        if tensor_obj.numel() == 0:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free benchmark: For {self.api_name}, tensor shape must > 0."
-                f" Cancel adding noise."
-            )
-            return False
-        abs_tol = ThresholdConfig.ABS_TOL_VALUE_DICT.get(
-            tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
-        )
-        try:
-            max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
-        except Exception:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"when calculate maximun value, tensor is changed to float32."
-            )
-            max_val = TorchC.max(TorchC.abs(tensor_obj.to(torch.float32))).item()
-        if max_val < abs_tol:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"Maximun value is less than the  minimun threshold. Cancel add noise."
-            )
-            return False
-        return True
+import torch
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
+from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+from msprobe.pytorch.free_benchmark.common.utils import TorchC
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
+    NpuBaseLayer,
+)
+
+
+class AddNoiseLayer(NpuBaseLayer):
+
+    def add_noise(self, tensor_obj):
+        if isinstance(tensor_obj, torch.Tensor):
+            self.perturbed_value = ThresholdConfig.PERTURBATION_VALUE_DICT.get(
+                tensor_obj.dtype
+            )
+            if not self.pre_check(tensor_obj):
+                return tensor_obj
+            noise = self._get_noise(tensor_obj)
+            result = TorchC.where(
+                TorchC.gt(TorchC.abs(tensor_obj), self.perturbed_value ** 0.5),
+                TorchC.add(noise, tensor_obj),
+                tensor_obj,
+            ).to(tensor_obj.dtype)
+            self.is_added = True
+            return result
+        if isinstance(tensor_obj, dict):
+            return {key: self.add_noise(value) for key, value in tensor_obj.items()}
+        if isinstance(tensor_obj, (tuple, list)):
+            return type(tensor_obj)([self.add_noise(value) for value in tensor_obj])
+        return tensor_obj
+
+    def handle(self, params: DataParams):
+        """
+        对输入添加扰动并返回
+        """
+        logger.info_on_rank_0(
+            f"[msprobe] Free benchmark: Perturbation is "
+            f"{PerturbationMode.ADD_NOISE} of {self.api_name}."
+        )
+        params.perturbed_value = self.add_noise(params.args[params.valid_input_index])
+        return self.perturbed_result(params)
+
+    def _get_noise(self, tensor_obj):
+        dtype = tensor_obj.dtype
+        device = str(tensor_obj.device)
+        noise = TorchC.full(
+            tensor_obj.shape,
+            self.perturbed_value,
+            device=device,
+            dtype=dtype,
+        )
+        return noise
+
+    def _check_details(self, tensor_obj):
+        """
+        判断是否需要添加扰动
+        """
+        if not self.perturbed_value:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"dtype unsupported. Cancel perturbation."
+            )
+            return False
+        if tensor_obj.numel() == 0:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free benchmark: For {self.api_name}, tensor shape must > 0."
+                f" Cancel adding noise."
+            )
+            return False
+        abs_tol = ThresholdConfig.ABS_TOL_VALUE_DICT.get(
+            tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
+        )
+        try:
+            max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
+        except Exception:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"when calculate maximun value, tensor is changed to float32."
+            )
+            max_val = TorchC.max(TorchC.abs(tensor_obj.to(torch.float32))).item()
+        if max_val < abs_tol:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"Maximun value is less than the  minimun threshold. Cancel add noise."
+            )
+            return False
+        return True

msprobe/pytorch/free_benchmark/perturbed_layers/npu/bit_noise.py

@@ -1,104 +1,104 @@
-import torch
-from msprobe.pytorch.free_benchmark import logger
-from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
-from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
-from msprobe.pytorch.free_benchmark.common.params import DataParams
-from msprobe.pytorch.free_benchmark.common.utils import TorchC
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
-    NpuBaseLayer,
-)
-
-
-class BitNoiseLayer(NpuBaseLayer):
-    def __init__(self, api_name):
-        super().__init__(api_name)
-        self.bit_mode = TorchC.bitwise_xor
-        self.bit_tail: int = 1
-        self.bit_type = None
-
-    def add_bit_noise(self, tensor_obj):
-        """
-        对输入添加噪声
-        """
-        # finfo应该列入黑名单
-
-        if isinstance(tensor_obj, torch.Tensor):
-            self._set_perturbation_bit(tensor_obj)
-            if not self.pre_check(tensor_obj):
-                return tensor_obj
-            sub_normal = torch.finfo(tensor_obj.dtype).smallest_normal
-            noise = TorchC.full(
-                tensor_obj.shape,
-                self.bit_tail,
-                device=tensor_obj.device,
-                dtype=self.bit_type,
-            )
-            result = tensor_obj.view(self.bit_type)
-            result = TorchC.where(
-                TorchC.gt(TorchC.abs(tensor_obj), sub_normal),
-                self.bit_mode(result, noise),
-                result,
-            ).view(tensor_obj.dtype)
-
-            self.is_added = True
-            return result
-        if isinstance(tensor_obj, dict):
-            return {key: self.add_bit_noise(value) for key, value in tensor_obj.items()}
-        if isinstance(tensor_obj, (tuple, list)):
-            return type(tensor_obj)([self.add_bit_noise(value) for value in tensor_obj])
-        return tensor_obj
-
-    def handle(self, params: DataParams) -> torch.Any:
-        """
-        对输入添加扰动并返回
-        """
-        logger.info_on_rank_0(
-            f"[msprobe] Free benchmark: Perturbation is "
-            f"{PerturbationMode.BIT_NOISE} of {self.api_name}."
-        )
-        params.perturbed_value = self.add_bit_noise(params.args[params.valid_input_index])
-        return self.perturbed_result(params)
-
-    def _check_details(self, tensor_obj):
-        """
-        判断是否需要添加扰动,  bit翻转
-        """
-        if not self.bit_type:
-            logger.info_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"dtype unsupported. Cancel perturbation."
-            )
-            return False
-        if tensor_obj.numel() == 0:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free benchmark: For {self.api_name}, tensor shape must > 0"
-                f" Cancel adding noise."
-            )
-            return False
-        abs_tol = ThresholdConfig.ABS_TOL_VALUE_DICT.get(
-            tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
-        )
-        try:
-            max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
-        except Exception:
-            logger.warning_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"when calculate maximun value, tensor is changed to float32."
-            )
-            max_val = TorchC.max(TorchC.abs(tensor_obj.to(torch.float32))).item()
-        if max_val < abs_tol:
-            logger.info_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"Maximun value is less than the  minimun threshold. Cancel add noise."
-            )
-            return False
-        return True
-
-    def _set_perturbation_bit(self, tensor_obj):
-        """
-        根据不同浮点数确定不同位数扰动值
-        """
-        bit_len_type = ThresholdConfig.PERTURBATION_BIT_DICT.get(tensor_obj.dtype)
-        if bit_len_type:
-            self.bit_tail = 1
-            self.bit_type = bit_len_type
+import torch
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
+from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+from msprobe.pytorch.free_benchmark.common.utils import TorchC
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
+    NpuBaseLayer,
+)
+
+
+class BitNoiseLayer(NpuBaseLayer):
+    def __init__(self, api_name):
+        super().__init__(api_name)
+        self.bit_mode = TorchC.bitwise_xor
+        self.bit_tail: int = 1
+        self.bit_type = None
+
+    def add_bit_noise(self, tensor_obj):
+        """
+        对输入添加噪声
+        """
+        # finfo应该列入黑名单
+
+        if isinstance(tensor_obj, torch.Tensor):
+            self._set_perturbation_bit(tensor_obj)
+            if not self.pre_check(tensor_obj):
+                return tensor_obj
+            sub_normal = torch.finfo(tensor_obj.dtype).smallest_normal
+            noise = TorchC.full(
+                tensor_obj.shape,
+                self.bit_tail,
+                device=tensor_obj.device,
+                dtype=self.bit_type,
+            )
+            result = tensor_obj.view(self.bit_type)
+            result = TorchC.where(
+                TorchC.gt(TorchC.abs(tensor_obj), sub_normal),
+                self.bit_mode(result, noise),
+                result,
+            ).view(tensor_obj.dtype)
+
+            self.is_added = True
+            return result
+        if isinstance(tensor_obj, dict):
+            return {key: self.add_bit_noise(value) for key, value in tensor_obj.items()}
+        if isinstance(tensor_obj, (tuple, list)):
+            return type(tensor_obj)([self.add_bit_noise(value) for value in tensor_obj])
+        return tensor_obj
+
+    def handle(self, params: DataParams):
+        """
+        对输入添加扰动并返回
+        """
+        logger.info_on_rank_0(
+            f"[msprobe] Free benchmark: Perturbation is "
+            f"{PerturbationMode.BIT_NOISE} of {self.api_name}."
+        )
+        params.perturbed_value = self.add_bit_noise(params.args[params.valid_input_index])
+        return self.perturbed_result(params)
+
+    def _check_details(self, tensor_obj):
+        """
+        判断是否需要添加扰动,  bit翻转
+        """
+        if not self.bit_type:
+            logger.info_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"dtype unsupported. Cancel perturbation."
+            )
+            return False
+        if tensor_obj.numel() == 0:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free benchmark: For {self.api_name}, tensor shape must > 0"
+                f" Cancel adding noise."
+            )
+            return False
+        abs_tol = ThresholdConfig.ABS_TOL_VALUE_DICT.get(
+            tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
+        )
+        try:
+            max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
+        except Exception:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"when calculate maximun value, tensor is changed to float32."
+            )
+            max_val = TorchC.max(TorchC.abs(tensor_obj.to(torch.float32))).item()
+        if max_val < abs_tol:
+            logger.info_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"Maximun value is less than the  minimun threshold. Cancel add noise."
+            )
+            return False
+        return True
+
+    def _set_perturbation_bit(self, tensor_obj):
+        """
+        根据不同浮点数确定不同位数扰动值
+        """
+        bit_len_type = ThresholdConfig.PERTURBATION_BIT_DICT.get(tensor_obj.dtype)
+        if bit_len_type:
+            self.bit_tail = 1
+            self.bit_type = bit_len_type

msprobe/pytorch/free_benchmark/perturbed_layers/npu/change_value.py

@@ -1,63 +1,63 @@
-import torch
-from msprobe.pytorch.free_benchmark import logger
-from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
-from msprobe.pytorch.free_benchmark.common.params import DataParams
-from msprobe.pytorch.free_benchmark.common.utils import TorchC
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
-    NpuBaseLayer,
-)
-
-
-class ChangeValueLayer(NpuBaseLayer):
-    def __init__(self, api_name):
-        super().__init__(api_name)
-        self.head: int = 0
-        self.tail: int = -1
-
-    def change_value(self, tensor_obj):
-        """
-        交换张量首尾
-        """
-        if isinstance(tensor_obj, torch.Tensor) and self.pre_check(tensor_obj):
-            new_tensor = TorchC.clone(tensor_obj)
-            if new_tensor.ndim == 1:
-                temp_first = TorchC.clone(new_tensor[self.head])
-                temp_last = TorchC.clone(new_tensor[self.tail])
-                new_tensor[self.head] = temp_last
-                new_tensor[self.tail] = temp_first
-            else:
-                temp_first = TorchC.clone(new_tensor[self.head][self.head])
-                temp_last = TorchC.clone(new_tensor[self.tail][self.tail])
-                new_tensor[self.head][self.head] = temp_last
-                new_tensor[self.tail][self.tail] = temp_first
-
-            self.is_added = True
-            return new_tensor
-        if isinstance(tensor_obj, dict):
-            return {key: self.change_value(value) for key, value in tensor_obj.items()}
-        if isinstance(tensor_obj, (tuple, list)):
-            return type(tensor_obj)([self.change_value(value) for value in tensor_obj])
-        return tensor_obj
-
-    def handle(self, params: DataParams) -> torch.Any:
-        """
-        对输入添加扰动并返回
-        """
-        logger.info_on_rank_0(
-            f"[msprobe] Free benchmark: Perturbation is "
-            f"{PerturbationMode.CHANGE_VALUE} of {self.api_name}."
-        )
-        params.perturbed_value = self.change_value(params.args[params.valid_input_index])
-        return self.perturbed_result(params)
-
-    def _check_details(self, tensor_obj):
-        """
-        判断是否需要添加扰动,  首尾值交换
-        """
-        if tensor_obj.size(0) < 2:
-            logger.info_on_rank_0(
-                f"[msprobe] Free Benchmark: For {self.api_name}, "
-                f"size 0 must greater than 1. Cancel change value."
-            )
-            return False
-        return True
+import torch
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.enums import PerturbationMode
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+from msprobe.pytorch.free_benchmark.common.utils import TorchC
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
+    NpuBaseLayer,
+)
+
+
+class ChangeValueLayer(NpuBaseLayer):
+    def __init__(self, api_name):
+        super().__init__(api_name)
+        self.head: int = 0
+        self.tail: int = -1
+
+    def change_value(self, tensor_obj):
+        """
+        交换张量首尾
+        """
+        if isinstance(tensor_obj, torch.Tensor) and self.pre_check(tensor_obj):
+            new_tensor = TorchC.clone(tensor_obj)
+            if new_tensor.ndim == 1:
+                temp_first = TorchC.clone(new_tensor[self.head])
+                temp_last = TorchC.clone(new_tensor[self.tail])
+                new_tensor[self.head] = temp_last
+                new_tensor[self.tail] = temp_first
+            else:
+                temp_first = TorchC.clone(new_tensor[self.head][self.head])
+                temp_last = TorchC.clone(new_tensor[self.tail][self.tail])
+                new_tensor[self.head][self.head] = temp_last
+                new_tensor[self.tail][self.tail] = temp_first
+
+            self.is_added = True
+            return new_tensor
+        if isinstance(tensor_obj, dict):
+            return {key: self.change_value(value) for key, value in tensor_obj.items()}
+        if isinstance(tensor_obj, (tuple, list)):
+            return type(tensor_obj)([self.change_value(value) for value in tensor_obj])
+        return tensor_obj
+
+    def handle(self, params: DataParams):
+        """
+        对输入添加扰动并返回
+        """
+        logger.info_on_rank_0(
+            f"[msprobe] Free benchmark: Perturbation is "
+            f"{PerturbationMode.CHANGE_VALUE} of {self.api_name}."
+        )
+        params.perturbed_value = self.change_value(params.args[params.valid_input_index])
+        return self.perturbed_result(params)
+
+    def _check_details(self, tensor_obj):
+        """
+        判断是否需要添加扰动,  首尾值交换
+        """
+        if tensor_obj.size(0) < 2:
+            logger.info_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.api_name}, "
+                f"size 0 must greater than 1. Cancel change value."
+            )
+            return False
+        return True

msprobe/pytorch/free_benchmark/perturbed_layers/npu/improve_precision.py

@@ -1,68 +1,68 @@
-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 PerturbationMode
-from msprobe.pytorch.free_benchmark.common.params import DataParams
-from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
-    NpuBaseLayer,
-)
-
-
-class ImprovePrecisionLayer(NpuBaseLayer):
-
-    def improve_tensor_precision(self, tensor_obj):
-        if (
-            isinstance(tensor_obj, torch.Tensor)
-            and torch.is_floating_point(tensor_obj)
-            and tensor_obj.dtype not in [torch.float32, torch.float64]
-        ):
-            self._set_improve_valus(tensor_obj)
-            tensor_obj = self._change_dtype(tensor_obj)
-            self.is_added = True
-            return tensor_obj
-        if isinstance(tensor_obj, dict):
-            return {
-                key: self.improve_tensor_precision(value)
-                for key, value in tensor_obj.items()
-            }
-        if isinstance(tensor_obj, (tuple, list)):
-            return type(tensor_obj)(
-                [self.improve_tensor_precision(value) for value in tensor_obj]
-            )
-        return tensor_obj
-
-    def handle(self, params: DataParams) -> torch.Any:
-        logger.info_on_rank_0(
-            f"[msprobe] Free benchmark: Perturbation is "
-            f"{PerturbationMode.IMPROVE_PRECISION} of {self.api_name}."
-        )
-        new_args = self.improve_tensor_precision(params.args)
-        if params.fuzz_stage == Const.BACKWARD:
-            new_kwargs = {}
-        else:
-            new_kwargs = self.improve_tensor_precision(params.kwargs)
-        # 如果输入中全为高精度、应跳过二次执行、减少多余显存引用
-        if not self.is_added:
-            return params.perturbed_result
-        if "inplace" in new_kwargs:
-            new_kwargs["inplace"] = False
-        params.perturbed_result = params.origin_func(*new_args, **new_kwargs)
-        return params.perturbed_result
-
-    def _set_improve_valus(self, inputs):
-        if inputs.dtype in [torch.float16, torch.bfloat16]:
-            self.perturbed_value = torch.float32
-
-    def _change_dtype(self, inputs):
-        if hasattr(inputs, CommonField.DEVICE):
-            device = inputs.device
-            if device is CommonField.META:
-                new_inputs = inputs.to(
-                    device=CommonField.META, dtype=self.perturbed_value
-                )
-            else:
-                new_inputs = inputs.to(dtype=self.perturbed_value).to(device)
-        else:
-            new_inputs = inputs.to(dtype=self.perturbed_value)
-        return new_inputs
+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 PerturbationMode
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import (
+    NpuBaseLayer,
+)
+
+
+class ImprovePrecisionLayer(NpuBaseLayer):
+
+    def improve_tensor_precision(self, tensor_obj):
+        if (
+            isinstance(tensor_obj, torch.Tensor)
+            and torch.is_floating_point(tensor_obj)
+            and tensor_obj.dtype not in [torch.float32, torch.float64]
+        ):
+            self._set_improve_values(tensor_obj)
+            tensor_obj = self._change_dtype(tensor_obj)
+            self.is_added = True
+            return tensor_obj
+        if isinstance(tensor_obj, dict):
+            return {
+                key: self.improve_tensor_precision(value)
+                for key, value in tensor_obj.items()
+            }
+        if isinstance(tensor_obj, (tuple, list)):
+            return type(tensor_obj)(
+                [self.improve_tensor_precision(value) for value in tensor_obj]
+            )
+        return tensor_obj
+
+    def handle(self, params: DataParams):
+        logger.info_on_rank_0(
+            f"[msprobe] Free benchmark: Perturbation is "
+            f"{PerturbationMode.IMPROVE_PRECISION} of {self.api_name}."
+        )
+        new_args = self.improve_tensor_precision(params.args)
+        if params.fuzz_stage == Const.BACKWARD:
+            new_kwargs = {}
+        else:
+            new_kwargs = self.improve_tensor_precision(params.kwargs)
+        # 如果输入中全为高精度、应跳过二次执行、减少多余显存引用
+        if not self.is_added:
+            return params.perturbed_result
+        if "inplace" in new_kwargs:
+            new_kwargs["inplace"] = False
+        params.perturbed_result = params.origin_func(*new_args, **new_kwargs)
+        return params.perturbed_result
+
+    def _set_improve_values(self, inputs):
+        if inputs.dtype in [torch.float16, torch.bfloat16]:
+            self.perturbed_value = torch.float32
+
+    def _change_dtype(self, inputs):
+        if hasattr(inputs, CommonField.DEVICE):
+            device = inputs.device
+            if device is CommonField.META:
+                new_inputs = inputs.to(
+                    device=CommonField.META, dtype=self.perturbed_value
+                )
+            else:
+                new_inputs = inputs.to(dtype=self.perturbed_value).to(device)
+        else:
+            new_inputs = inputs.to(dtype=self.perturbed_value)
+        return new_inputs