diff --git a/debug/accuracy_tools/msprobe/core/data_dump/data_collector.py b/debug/accuracy_tools/msprobe/core/data_dump/data_collector.py
index 3b8dc70b9e191006f4b8a6621fccc1eae122e099..50ef5052a3378503c3c608f08c531689a43cb1c5 100644
--- a/debug/accuracy_tools/msprobe/core/data_dump/data_collector.py
+++ b/debug/accuracy_tools/msprobe/core/data_dump/data_collector.py
@@ -29,7 +29,8 @@ def build_data_collector(config):
class DataCollector:
multi_output_apis = ["_sort_", "npu_flash_attention"]
- tasks_need_tensor_data = [Const.OVERFLOW_CHECK, Const.TENSOR, Const.FREE_BENCHMARK]
+ tasks_need_tensor_data = [Const.OVERFLOW_CHECK, Const.TENSOR]
+ tasks_no_need_jsons = [Const.FREE_BENCHMARK,]
level_without_construct = [Const.LEVEL_L1, Const.LEVEL_L2]
def __init__(self, config):
@@ -71,6 +72,9 @@ class DataCollector:
self.data_processor.update_api_or_module_name(api_or_module_name)
def write_json(self):
+ # 无标杆场景不处理json数据
+ if self.config.task in self.tasks_no_need_jsons:
+ return
self.data_writer.write_json()
def update_data(self, name, data_info):
@@ -85,9 +89,13 @@ class DataCollector:
self.data_writer.update_data(data_info)
def pre_forward_data_collect(self, name, module, pid, module_input_output):
- backward_name = name.replace(Const.FORWARD, Const.BACKWARD)
- if self.check_scope_and_pid(self.scope, backward_name, pid):
- self.data_processor.analyze_pre_forward(backward_name, module, module_input_output)
+ if self.config.task == Const.FREE_BENCHMARK:
+ # 无标杆场景在反向时需要在preforwardhook中进行特殊处理
+ backward_name = name.replace(Const.FORWARD, Const.BACKWARD)
+ if not self.check_scope_and_pid(self.scope, backward_name, pid):
+ return
+ self.data_processor.free_benchmark_pre_forward(backward_name, module, module_input_output)
+ return
if not self.is_inplace(module) or not self.check_scope_and_pid(self.scope, name, pid):
return
logger.info(f"API {name} is inplace.")
@@ -105,7 +113,9 @@ class DataCollector:
data_info = self.data_processor.analyze_forward_inplace(name, module_input_output)
if self.config.level == "L2":
return
- self.data_writer.update_stack(self.data_processor.analyze_api_call_stack(name))
+ if self.config.level not in self.tasks_no_need_jsons:
+ # 避免在无标杆场景采集堆栈信息
+ self.data_writer.update_stack(self.data_processor.analyze_api_call_stack(name))
self.handle_data(name, data_info, flush=self.data_processor.is_terminated)
def backward_data_collect(self, name, module, pid, module_input_output):
@@ -138,6 +148,9 @@ class DataCollector:
self.data_writer.update_construct(self.module_processor.module_node)
def handle_data(self, name, data_info, flush=False):
+ # 无标杆场景不处理json数据
+ if self.config.task in self.tasks_no_need_jsons:
+ return
if data_info:
self.update_data(name, data_info)
if not flush:
@@ -147,7 +160,8 @@ class DataCollector:
def update_dump_paths(self, *args):
self.data_writer.update_dump_paths(*args)
- self.data_writer.initialize_json_file(task=self.config.task, level=self.config.level)
+ if self.config.task not in self.tasks_no_need_jsons:
+ self.data_writer.initialize_json_file(task=self.config.task, level=self.config.level)
def update_iter(self, current_iter):
self.data_processor.update_iter(current_iter)
diff --git a/debug/accuracy_tools/msprobe/core/data_dump/data_processor/pytorch_processor.py b/debug/accuracy_tools/msprobe/core/data_dump/data_processor/pytorch_processor.py
index 4677cd30c0e92754d3a4873dc282f1b97c0890a8..c0e974952fda663adea604d3e0af2ea6d9f5b26a 100644
--- a/debug/accuracy_tools/msprobe/core/data_dump/data_processor/pytorch_processor.py
+++ b/debug/accuracy_tools/msprobe/core/data_dump/data_processor/pytorch_processor.py
@@ -22,6 +22,11 @@ import torch
from msprobe.core.common.const import Const
from msprobe.core.common.file_utils import path_len_exceeds_limit
from msprobe.core.common.log import logger
+<<<<<<< HEAD
+from msprobe.core.common.const import Const, OverflowConst, FileCheckConst
+from msprobe.core.common.utils import check_op_str_pattern_valid
+=======
+>>>>>>> origin/master
from msprobe.core.data_dump.data_processor.base import BaseDataProcessor, ModuleBackwardInputsOutputs, \
ModuleForwardInputsOutputs, TensorStatInfo
from msprobe.pytorch.common.utils import save_pt, load_pt
@@ -281,17 +286,32 @@ class FreeBenchmarkDataProcessor(PytorchDataProcessor):
def __init__(self, config, data_writer):
super().__init__(config, data_writer)
self.checker = FreeBenchmarkCheck(config=config)
+ self._backward_stack_info_dict = {}
self._return_forward_new_output = None
self._forward_new_output = None
def update_iter(self, current_iter):
super().update_iter(current_iter)
self.checker.update_iter(current_iter)
-
- def update_unequal_rows(self, unequal_rows: List[UnequalRow]):
- if not unequal_rows:
- return
+
+ def pop_backward_stack_info(self, backward_name):
+ ret = None
+ if backward_name in self._backward_stack_info_dict:
+ ret = self._backward_stack_info_dict.pop(backward_name)
+ return ret
+
+ def update_unequal_rows(self, unequal_rows: List[UnequalRow], stack_info=None):
+ if isinstance(stack_info, list):
+ for item in stack_info:
+ check_op_str_pattern_valid(item, stack=True)
+ else:
+ logger.warning(
+ f"Expected stack_info to be a list, "
+ f"but got {type(stack_info).__name__}"
+ )
+ stack_info = None
for row in unequal_rows:
+ row.update_stack_info(stack_info)
data_dict = asdict(row)
self.data_writer.write_data_to_csv(
data_dict.values(),
@@ -300,8 +320,9 @@ class FreeBenchmarkDataProcessor(PytorchDataProcessor):
)
return
- def analyze_pre_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
- self.checker.pre_forward(name, module, self, module_input_output.args, module_input_output.kwargs)
+ def free_benchmark_pre_forward(self, backward_name, module, module_input_output: ModuleForwardInputsOutputs):
+ self._backward_stack_info_dict.update(self.analyze_api_call_stack(backward_name))
+ self.checker.pre_forward(backward_name, module, self, module_input_output.args, module_input_output.kwargs)
def analyze_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
new_output, unequal_rows = self.checker.forward(
@@ -311,7 +332,9 @@ class FreeBenchmarkDataProcessor(PytorchDataProcessor):
module_input_output.kwargs,
module_input_output.output,
)
- self.update_unequal_rows(unequal_rows)
+ if unequal_rows:
+ stack_info = self.analyze_api_call_stack(name).get(name)
+ self.update_unequal_rows(unequal_rows, stack_info=stack_info)
if self.checker.if_fix():
self._return_forward_new_output = True
self._forward_new_output = new_output
diff --git a/debug/accuracy_tools/msprobe/docs/15.free_benchmarking_PyTorch.md b/debug/accuracy_tools/msprobe/docs/15.free_benchmarking_PyTorch.md
index a2bc2112c16444eb76838c0f931fc3e94b502df7..b2698f172324b81f91ea196fe3d5c3b88955bca3 100644
--- a/debug/accuracy_tools/msprobe/docs/15.free_benchmarking_PyTorch.md
+++ b/debug/accuracy_tools/msprobe/docs/15.free_benchmarking_PyTorch.md
@@ -98,9 +98,9 @@ D-->config.json配置
| 参数 | 是否必选 | 可配置项 | 适用场景 |
|---|
| pert_mode | 否 | "improve_precision" （默认） | （常用）(可做验证) 插桩算子可能在低精度下有精度问题，扰动因子会将输入的低精度向量升精度。 |
| "bit_noise" | （常用）插桩算子可能在轻微扰动下暴露精度问题，扰动因子会将输入向量最后一个比特位翻转。 |
- | "add_noise" | 插桩算子可能在轻微扰动下暴露精度问题，扰动因子会为输入向量增加一个极小。 |
- | "change_value" | 插桩算子可能存在大数吃小数问题，扰动因子会交换输入向量的首尾。 |
- | "no_change" | 插桩算子可能存在数值稳定性精度问题，扰动因子会复制原始输。 |
+ | "add_noise" | 插桩算子可能在轻微扰动下暴露精度问题，扰动因子会为输入向量增加一个极小值。 |
+ | "change_value" | 插桩算子可能存在大数吃小数问题，扰动因子会交换输入向量的首尾值。 |
+ | "no_change" | 插桩算子可能存在数值稳定性精度问题，扰动因子会复制原始输入。 |
| "to_cpu" | (可做验证) 插桩算子可能在同 CPU 精度表现不一致，扰动因子会将输入转至 CPU，需要配合 fuzz_device="cpu"使用。 |
| fuzz_device | 否 | "npu" （默认） | pert_mode 不需要to cpu操作。 |
| "cpu" | pert_mode 须配置为"to_cpu"，目前仅支持"to cpu"扰动因子。 |
@@ -147,7 +147,7 @@ debugger.step() # 在训练循环的最后需要重置工具，非循环场景
check模式下，无标杆比对在dump_path目录下将扰动前后不符合精度标准的结果输出在文件 free_benchmark.csv，如下示例：
-
+
| 字段 | 说明 |
| ------------ | ---------------------------------------------------------------------------------------- |
@@ -160,6 +160,7 @@ check模式下，无标杆比对在dump_path目录下将扰动前后不符合精
| dtype | 输入的 dtype，string 类型。 |
| shape | 输入的 shape，tuple 类型。 |
| output_index | 如果输出为列表或元组，其中一个元素检测不一致，则会有该元素的 index，否则为空，int 类型。 |
+| stack_info | 风险算子的调用栈信息 |
无标杆根据参照的精度标准如下：
| 输出dtype | 相对误差阈值 |
diff --git a/debug/accuracy_tools/msprobe/docs/img/pytorch_free_benchmark_output.png b/debug/accuracy_tools/msprobe/docs/img/pytorch_free_benchmark_output.png
new file mode 100644
index 0000000000000000000000000000000000000000..339a8393d27ba1a19dcf9d7292bebae11597d4a0
Binary files /dev/null and b/debug/accuracy_tools/msprobe/docs/img/pytorch_free_benchmark_output.png differ
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/params.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/params.py
index a6a8bfd0a3bd09f441239fed0ebbd1adc5a85322..41123af8330fbba3445bd224c1ed2403298452db 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/params.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/params.py
@@ -64,6 +64,10 @@ class UnequalRow:
dtype: Optional[str] = None
shape: Optional[str] = None
output_index: Optional[int] = None
+ stack_info: Optional[List] = None
+
+ def update_stack_info(self, stack_info):
+ self.stack_info = stack_info
@dataclass
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/utils.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/utils.py
index 5926e09539212b0b709d9d141aeb4b5ef1805740..6d7f9c031d283e0d336f95378c2c9b33808e5b20 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/utils.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/common/utils.py
@@ -90,29 +90,3 @@ class Tools:
)
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
- clamp = torch._C._VariableFunctionsClass.clamp
- tensor_split = torch._C._VariableFunctionsClass.tensor_split
- stack = torch._C._VariableFunctionsClass.stack
- reshape = torch._C._VariableFunctionsClass.reshape
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/grad_saver.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/grad_saver.py
index bc168fd0d650a6634ff8aa15872d44b034a9a715..c32334b05e7f7713588e2fa831d0d721aa3a0331 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/grad_saver.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/grad_saver.py
@@ -44,6 +44,7 @@ class GradSaver:
def register_compare_func_for_inputs(self, inputs, data_processor):
_index = 0
+ stack_info = data_processor.pop_backward_stack_info(self.api_name)
for j, obj in enumerate(inputs):
if torch.is_tensor(obj) and obj.requires_grad:
@@ -56,7 +57,7 @@ class GradSaver:
self.compare_grad_results(
handler, grad, perturbed_grad, index=input_index
)
- data_processor.update_unequal_rows(handler.get_unequal_rows())
+ data_processor.update_unequal_rows(handler.get_unequal_rows(), stack_info=stack_info)
except IndexError:
logger.warning_on_rank_0(
f"[msprobe] Free benchmark: grad index out of range. api:{self.handler_params.api_name}."
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/single_benchmark.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/single_benchmark.py
index cf4bac80333671f5a24ec06ed65da03cd1b1e3f1..aed949618bce35dff5fcfeefb3645b92ea761eac 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/single_benchmark.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/compare/single_benchmark.py
@@ -18,7 +18,6 @@ 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:
@@ -30,15 +29,15 @@ class SingleCompare:
@staticmethod
def filter_overflow(tensor) -> int:
- inf_num = TorchC.sum(TorchC.isinf(tensor))
- nan_num = TorchC.sum(TorchC.isnan(tensor))
+ inf_num = torch.sum(torch.isinf(tensor))
+ nan_num = torch.sum(torch.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()
+ finite_mask = torch.isfinite(tensor)
+ inf_or_nan_mask = torch.logical_not(finite_mask)
+ inf_or_nan_num = torch.sum(inf_or_nan_mask).item()
if inf_or_nan_num > 0:
tensor[inf_or_nan_mask] = 1
return tensor
@@ -100,20 +99,20 @@ class SingleCompare:
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)
+ diff_value = torch.subtract(actual, golden)
+ diff_abs = torch.abs(diff_value)
+ golden_abs = torch.abs(golden)
# 使用绝对误差的元素
- self.absolute_err = TorchC.max(TorchC.where(
- TorchC.lt(TorchC.abs(actual), self.threshold.small_value), diff_abs, 0
+ self.absolute_err = torch.max(torch.where(
+ torch.abs(actual) < self.threshold.small_value, diff_abs, 0
))
- diff_rel = TorchC.div(diff_abs, golden_abs)
+ diff_rel = torch.div(diff_abs, golden_abs)
# 使用相对误差的元素
- self.relative_err = TorchC.max(TorchC.where(
- TorchC.ge(TorchC.abs(actual), self.threshold.small_value), diff_rel, 0
+ self.relative_err = torch.max(torch.where(
+ torch.abs(actual) >= self.threshold.small_value, diff_rel, 0
))
# 获取误差均衡性
- divided = TorchC.where(
- TorchC.ge(TorchC.abs(golden), self.threshold.small_value), golden_abs, 1
+ divided = torch.where(
+ torch.abs(golden) >= self.threshold.small_value, golden_abs, 1
)
- self.eb = TorchC.mean(TorchC.div(diff_value, divided))
+ self.eb = torch.mean(torch.div(diff_value, divided))
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/add_noise.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/add_noise.py
index 29b1de6d8f58a5e907f6156fb146dd7848e45d59..6bc0fccac5cf75fdf1fee8df5a1ac469a9faa636 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/add_noise.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/add_noise.py
@@ -18,7 +18,6 @@ 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,
)
@@ -34,9 +33,9 @@ class AddNoiseLayer(NpuBaseLayer):
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),
+ result = torch.where(
+ torch.abs(tensor_obj) > self.perturbed_value ** 0.5,
+ torch.add(noise, tensor_obj),
tensor_obj,
).to(tensor_obj.dtype)
self.is_added = True
@@ -61,7 +60,7 @@ class AddNoiseLayer(NpuBaseLayer):
def _get_noise(self, tensor_obj):
dtype = tensor_obj.dtype
device = str(tensor_obj.device)
- noise = TorchC.full(
+ noise = torch.full(
tensor_obj.shape,
self.perturbed_value,
device=device,
@@ -89,13 +88,13 @@ class AddNoiseLayer(NpuBaseLayer):
tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
)
try:
- max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
+ max_val = torch.max(torch.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()
+ max_val = torch.max(torch.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}, "
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/bit_noise.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/bit_noise.py
index 9bea9f67ca08790202f8b174346e8b2a3b4581bf..e806e492b1612f9f00460bc8abbfdac36cb18a79 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/bit_noise.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/bit_noise.py
@@ -18,7 +18,6 @@ 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,
)
@@ -27,7 +26,7 @@ from msprobe.pytorch.free_benchmark.perturbed_layers.npu.npu_base_layser import
class BitNoiseLayer(NpuBaseLayer):
def __init__(self, api_name):
super().__init__(api_name)
- self.bit_mode = TorchC.bitwise_xor
+ self.bit_mode = torch.bitwise_xor
self.bit_tail: int = 1
self.bit_type = None
@@ -42,15 +41,15 @@ class BitNoiseLayer(NpuBaseLayer):
if not self.pre_check(tensor_obj):
return tensor_obj
sub_normal = torch.finfo(tensor_obj.dtype).smallest_normal
- noise = TorchC.full(
+ noise = torch.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),
+ result = torch.where(
+ torch.abs(tensor_obj) > sub_normal,
self.bit_mode(result, noise),
result,
).view(tensor_obj.dtype)
@@ -94,13 +93,13 @@ class BitNoiseLayer(NpuBaseLayer):
tensor_obj.dtype, ThresholdConfig.NOISE_INPUT_LOWER_BOUND
)
try:
- max_val = TorchC.max(TorchC.abs(tensor_obj)).item()
+ max_val = torch.max(torch.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()
+ max_val = torch.max(torch.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}, "
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/change_value.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/change_value.py
index e2e0c8aa012a6ff57169cfd47c4728bd70a2563a..cb42c7eda29f2de6ef2f8191d4b6b480af3442ab 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/change_value.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/perturbed_layers/npu/change_value.py
@@ -17,7 +17,6 @@ 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,
)
@@ -34,15 +33,15 @@ class ChangeValueLayer(NpuBaseLayer):
交换张量首尾
"""
if isinstance(tensor_obj, torch.Tensor) and self.pre_check(tensor_obj):
- new_tensor = TorchC.clone(tensor_obj)
+ new_tensor = torch.clone(tensor_obj)
if new_tensor.ndim == 1:
- temp_first = TorchC.clone(new_tensor[self.head])
- temp_last = TorchC.clone(new_tensor[self.tail])
+ temp_first = torch.clone(new_tensor[self.head])
+ temp_last = torch.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])
+ temp_first = torch.clone(new_tensor[self.head][self.head])
+ temp_last = torch.clone(new_tensor[self.tail][self.tail])
new_tensor[self.head][self.head] = temp_last
new_tensor[self.tail][self.tail] = temp_first
diff --git a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/result_handlers/base_handler.py b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/result_handlers/base_handler.py
index 4b343d6d4f0c1c9238746f9f9729d57c5267b59a..2e8912d8cde0d5bede2450b2e546cc4c0df8f5ee 100644
--- a/debug/accuracy_tools/msprobe/pytorch/free_benchmark/result_handlers/base_handler.py
+++ b/debug/accuracy_tools/msprobe/pytorch/free_benchmark/result_handlers/base_handler.py
@@ -32,7 +32,7 @@ from msprobe.pytorch.free_benchmark.common.params import (
HandlerParams,
make_unequal_row,
)
-from msprobe.pytorch.free_benchmark.common.utils import Tools, TorchC
+from msprobe.pytorch.free_benchmark.common.utils import Tools
class FuzzHandler(ABC):
@@ -80,11 +80,11 @@ class FuzzHandler(ABC):
chunks = 2**chunks_exp
chunks = max(chunks, 1)
chunks = min(chunks, ThresholdConfig.TENSOR_SPLIT_MAX_CHUNK)
- origin_output_chunks = TorchC.tensor_split(
- TorchC.reshape(origin_output, (-1,)), chunks
+ origin_output_chunks = torch.tensor_split(
+ torch.reshape(origin_output, (-1,)), chunks
)
- perturbed_output_chunks = TorchC.tensor_split(
- TorchC.reshape(perturbed_output, (-1,)), chunks
+ perturbed_output_chunks = torch.tensor_split(
+ torch.reshape(perturbed_output, (-1,)), chunks
)
return origin_output_chunks, perturbed_output_chunks
@@ -120,24 +120,24 @@ class FuzzHandler(ABC):
if chunk_origin.nelement() == 0:
break
chunk_perturbed = perturbed_output_chunks[i]
- ratio_tensor1 = TorchC.where(
- TorchC.abs(chunk_perturbed) > abs_tol,
- TorchC.div(
- TorchC.clamp(chunk_origin, min=abs_tol),
- TorchC.clamp(chunk_perturbed, min=abs_tol),
+ ratio_tensor1 = torch.where(
+ torch.abs(chunk_perturbed) > abs_tol,
+ torch.div(
+ torch.clamp(chunk_origin, min=abs_tol),
+ torch.clamp(chunk_perturbed, min=abs_tol),
),
1,
)
- ratio_tensor2 = TorchC.where(
- TorchC.abs(chunk_origin) > abs_tol,
- TorchC.div(
- TorchC.clamp(chunk_perturbed, min=abs_tol),
- TorchC.clamp(chunk_origin, min=abs_tol),
+ ratio_tensor2 = torch.where(
+ torch.abs(chunk_origin) > abs_tol,
+ torch.div(
+ torch.clamp(chunk_perturbed, min=abs_tol),
+ torch.clamp(chunk_origin, min=abs_tol),
),
1,
)
- norm_values = TorchC.stack(
- [TorchC.max(ratio_tensor1), TorchC.max(ratio_tensor2)]
+ norm_values = torch.stack(
+ [torch.max(ratio_tensor1), torch.max(ratio_tensor2)]
)
max_ratio1, max_ratio2 = norm_values.tolist()
norm1 = max(norm1, self.convert_overflow_ratio_to_consistent(max_ratio1))