mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/compare/npy_compare.py

@@ -0,0 +1,244 @@
+import abc
+import numpy as np
+from msprobe.core.common.utils import format_value
+from msprobe.core.common.const import Const, CompareConst
+from msprobe.pytorch.common.log import logger
+
+
+def  handle_inf_nan(n_value, b_value):
+    """处理inf和nan的数据"""
+    n_inf = np.isinf(n_value)
+    b_inf = np.isinf(b_value)
+    n_nan = np.isnan(n_value)
+    b_nan = np.isnan(b_value)
+    n_invalid = np.any(n_inf) or np.any(n_nan)
+    b_invalid = np.any(b_inf) or np.any(b_nan)
+    if n_invalid or b_invalid:
+        if np.array_equal(n_inf, b_inf) and np.array_equal(n_nan, b_nan):
+            n_value[n_inf] = 0
+            b_value[b_inf] = 0
+            n_value[n_nan] = 0
+            b_value[b_nan] = 0
+        else:
+            return CompareConst.NAN, CompareConst.NAN
+    return n_value, b_value
+
+
+def get_error_type(n_value, b_value, error_flag):
+    """判断数据是否有异常并返回异常的n_value, b_value，同时返回error_flag"""
+    if error_flag:
+        return CompareConst.READ_NONE, CompareConst.READ_NONE, True
+    if n_value.size == 0:  # 判断读取到的数据是否为空
+        return CompareConst.NONE, CompareConst.NONE, True
+    if n_value.shape != b_value.shape:  # 判断NPU和bench的数据结构是否一致
+        return CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH, True
+    if not n_value.shape:  # 判断数据是否为标量
+        return n_value, b_value, False
+
+    n_value, b_value = handle_inf_nan(n_value, b_value)  # 判断是否有nan/inf数据
+    if n_value is CompareConst.NAN or b_value is CompareConst.NAN:
+        return CompareConst.NAN, CompareConst.NAN, True
+    return n_value, b_value, False
+
+
+def reshape_value(n_value, b_value):
+    """返回reshape后的数据"""
+    if not n_value.shape:  # 判断数据是否为标量
+        if n_value.dtype == bool:
+            n_value = n_value.astype(float)
+            b_value = b_value.astype(float)
+        return n_value, b_value
+
+    n_value = n_value.reshape(-1).astype(float)
+    b_value = b_value.reshape(-1).astype(float)
+    return n_value, b_value
+
+
+def get_error_message(n_value, b_value, op_name, error_flag, error_file=None):
+    """获取异常情况的错误信息"""
+    if error_flag:
+        if n_value == CompareConst.READ_NONE:
+            if error_file:
+                return "Dump file: {} not found.".format(error_file)
+            return CompareConst.NO_BENCH
+        if n_value == CompareConst.NONE:
+            return "This is empty data, can not compare."
+        if n_value == CompareConst.SHAPE_UNMATCH:
+            return "Shape of NPU and bench Tensor do not match. Skipped."
+        if n_value == CompareConst.NAN:
+            return "The position of inf or nan in NPU and bench Tensor do not match."
+    else:
+        if not n_value.shape:
+            return "This is type of scalar data, can not compare."
+        if n_value.dtype != b_value.dtype:
+            logger.warning("Dtype of NPU and bench Tensor do not match: {}".format(op_name))
+            return "Dtype of NPU and bench Tensor do not match."
+    return ""
+
+
+class TensorComparisonBasic(abc.ABC):
+    """NPU和bench中npy数据的比较模板"""
+    @abc.abstractmethod
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        raise NotImplementedError
+
+
+class GetCosineSimilarity(TensorComparisonBasic):
+    """计算cosine相似度"""
+    @staticmethod
+    def correct_data(result):
+        if result == CompareConst.NAN:
+            return result
+        if float(result) > CompareConst.COSINE_THRESHOLD:
+            return 1.0
+        return result
+
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        if error_flag:
+            if n_value == CompareConst.READ_NONE:
+                return CompareConst.NONE, ''
+            if n_value == CompareConst.NONE:
+                return CompareConst.UNSUPPORTED, ''
+            if n_value == CompareConst.SHAPE_UNMATCH:
+                return CompareConst.SHAPE_UNMATCH, ''
+            if n_value == CompareConst.NAN:
+                return "N/A", ''
+
+        if not n_value.shape:
+            return CompareConst.UNSUPPORTED, ''
+
+        with np.errstate(divide='ignore', invalid='ignore'):
+            if len(n_value) == 1:
+                return CompareConst.UNSUPPORTED, "This tensor is scalar."
+            num = n_value.dot(b_value)
+            a_norm = np.linalg.norm(n_value)
+            b_norm = np.linalg.norm(b_value)
+
+            if a_norm <= Const.FLOAT_EPSILON and b_norm <= Const.FLOAT_EPSILON:
+                return 1.0, ''
+            if a_norm <= Const.FLOAT_EPSILON:
+                return CompareConst.NAN, 'Cannot compare by Cosine Similarity, All the data is Zero in npu dump data.'
+            if b_norm <= Const.FLOAT_EPSILON:
+                return CompareConst.NAN, 'Cannot compare by Cosine Similarity, All the data is Zero in Bench dump data.'
+
+            cos = num / (a_norm * b_norm)
+            if np.isnan(cos):
+                return CompareConst.NAN, 'Cannot compare by Cosine Similarity, the dump data has NaN.'
+            result = format_value(cos)
+            result = self.correct_data(result)
+        return 1.0 if float(result) > 0.99999 else result, ''
+
+
+class GetMaxAbsErr(TensorComparisonBasic):
+    """计算最大绝对误差"""
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        if error_flag:
+            if n_value == CompareConst.READ_NONE:
+                return CompareConst.NONE, ""
+            if n_value == CompareConst.NONE:
+                return 0, ""
+            if n_value == CompareConst.SHAPE_UNMATCH:
+                return CompareConst.SHAPE_UNMATCH, ""
+            if n_value == CompareConst.NAN:
+                return "N/A", ""
+
+        temp_res = n_value - b_value
+        max_value = np.max(np.abs(temp_res))
+        return format_value(max_value), ""
+
+
+def get_relative_err(n_value, b_value):
+    """计算相对误差"""
+    with np.errstate(divide='ignore', invalid='ignore'):
+        if b_value.dtype not in CompareConst.FLOAT_TYPE:
+            n_value, b_value = n_value.astype(float), b_value.astype(float)
+        zero_mask = (b_value == 0)
+        b_value[zero_mask] += np.finfo(b_value.dtype).eps
+        n_value[zero_mask] += np.finfo(b_value.dtype).eps
+        relative_err = np.divide((n_value - b_value), b_value)
+    return np.abs(relative_err)
+
+
+class GetMaxRelativeErr(TensorComparisonBasic):
+    """计算最大相对误差"""
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        if error_flag:
+            if n_value == CompareConst.READ_NONE:
+                return CompareConst.NONE, ''
+            if n_value == CompareConst.NONE:
+                return 0, ''
+            if n_value == CompareConst.SHAPE_UNMATCH:
+                return CompareConst.SHAPE_UNMATCH, ''
+            if n_value == CompareConst.NAN:
+                return "N/A", ''
+
+        if relative_err is None:
+            relative_err = get_relative_err(n_value, b_value)
+        max_relative_err = np.max(np.abs(relative_err))
+        if np.isnan(max_relative_err):
+            message = 'Cannot compare by MaxRelativeError, the data contains nan in dump data.'
+            return CompareConst.NAN, message
+        return format_value(max_relative_err), ''
+
+
+class GetThousandErrRatio(TensorComparisonBasic):
+    """计算相对误差小于千分之一的比例"""
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        if error_flag:
+            if n_value == CompareConst.READ_NONE:
+                return CompareConst.NONE, ""
+            if n_value == CompareConst.NONE:
+                return 0, ""
+            if n_value == CompareConst.SHAPE_UNMATCH:
+                return CompareConst.SHAPE_UNMATCH, ""
+            if n_value == CompareConst.NAN:
+                return "N/A", ""
+
+        if not n_value.shape:
+            return CompareConst.NAN, ""
+        if relative_err is None:
+            relative_err = get_relative_err(n_value, b_value)
+        if not np.size(relative_err):
+            return CompareConst.NAN, ""
+        return format_value(np.sum(relative_err < CompareConst.THOUSAND_RATIO_THRESHOLD) / np.size(relative_err)), ""
+
+
+class GetFiveThousandErrRatio(TensorComparisonBasic):
+    """计算相对误差小于千分之五的比例"""
+    def apply(self, n_value, b_value, error_flag, relative_err=None):
+        if error_flag:
+            if n_value == CompareConst.READ_NONE:
+                return CompareConst.NONE, ""
+            if n_value == CompareConst.NONE:
+                return 0, ""
+            if n_value == CompareConst.SHAPE_UNMATCH:
+                return CompareConst.SHAPE_UNMATCH, ""
+            if n_value == CompareConst.NAN:
+                return "N/A", ""
+
+        if not n_value.shape:
+            return CompareConst.NAN, ""
+        if relative_err is None:
+            relative_err = get_relative_err(n_value, b_value)
+        if not np.size(relative_err):
+            return CompareConst.NAN, ""
+        return format_value(np.sum(relative_err < CompareConst.FIVE_THOUSAND_RATIO_THRESHOLD) / np.size(relative_err)), ""
+
+
+class CompareOps:
+    compare_ops = {
+        "cosine_similarity": GetCosineSimilarity(),
+        "max_abs_error": GetMaxAbsErr(),
+        "max_relative_error": GetMaxRelativeErr(),
+        "one_thousand_err_ratio": GetThousandErrRatio(),
+        "five_thousand_err_ratio": GetFiveThousandErrRatio()
+    }
+
+
+def compare_ops_apply(n_value, b_value, error_flag, err_msg, relative_err=None):
+    result_list = []
+    for op in CompareOps.compare_ops.values():
+        result, msg = op.apply(n_value, b_value, error_flag, relative_err=relative_err)
+        err_msg += msg
+        result_list.append(result)
+    return result_list, err_msg

msprobe/pytorch/debugger/debugger_config.py

@@ -0,0 +1,86 @@
+from msprobe.pytorch.common import seed_all
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.const import Const
+
+
+class DebuggerConfig:
+    def __init__(self, common_config, task_config, task, dump_path, level):
+        self.dump_path = dump_path if dump_path else common_config.dump_path
+        self.task = task or common_config.task or Const.STATISTICS
+        self.rank = common_config.rank if common_config.rank else []
+        self.step = common_config.step if common_config.step else []
+        self.level = level or common_config.level or "L1"
+        self.seed = common_config.seed if common_config.seed else 1234
+        self.is_deterministic = common_config.is_deterministic
+        self.enable_dataloader = common_config.enable_dataloader
+        self.scope = task_config.scope if task_config.scope else []
+        self.list = task_config.list if task_config.list else []
+        self.data_mode = task_config.data_mode if task_config.data_mode else ["all"]
+        self.backward_input_list = task_config.backward_input if task_config.backward_input else []
+        self.backward_input = {}
+        self.acl_config = common_config.acl_config if common_config.acl_config else ""
+        self.is_forward_acl_dump = True
+        self.summary_mode = task_config.summary_mode if task_config.summary_mode else Const.STATISTICS
+        self.overflow_num = task_config.overflow_num if task_config.overflow_num else 1
+        self.framework = Const.PT_FRAMEWORK
+
+        if self.task == Const.FREE_BENCHMARK:
+            self.fuzz_device = task_config.fuzz_device if task_config.fuzz_device else 'npu'
+            self.handler_type = task_config.handler_type if task_config.handler_type else 'check'
+            self.pert_mode = task_config.pert_mode if task_config.pert_mode else 'improve_precision'
+            self.fuzz_level = task_config.fuzz_level if task_config.fuzz_level else 'L1'
+            self.fuzz_stage = task_config.fuzz_stage if task_config.fuzz_stage else 'forward'
+            self.preheat_config = {
+                "if_preheat": task_config.if_preheat if task_config.if_preheat is not None else True, 
+                "preheat_step": task_config.preheat_step if task_config.preheat_step else 15, 
+                "max_sample": task_config.max_sample if task_config.max_sample else 20, 
+            }
+            
+        self.check()
+        if self.step:
+            self.step.sort()
+        if self.level == "L2":
+            if not self.scope or not isinstance(self.scope, list) or len(self.scope) != 1:
+                raise ValueError("scope must be configured as a list with one api name")
+            if isinstance(self.scope[0], str) and Const.BACKWARD in self.scope[0] and not self.backward_input_list:
+                raise ValueError("backward_input must be configured when scope contains 'backward'")
+            if Const.BACKWARD in self.scope[0]:
+                self.is_forward_acl_dump = False
+                for index, scope_spec in enumerate(self.scope):
+                    self.scope[index] = scope_spec.replace(Const.BACKWARD, Const.FORWARD)
+                    self.backward_input[self.scope[index]] = self.backward_input_list[index]
+        seed_all(self.seed, self.is_deterministic)
+
+    def check_kwargs(self):
+        if self.task and self.task not in Const.TASK_LIST:
+            raise Exception("task is invalid")
+        if self.level and self.level not in Const.LEVEL_LIST:
+            raise Exception("level is invalid")
+        if not self.dump_path:
+            raise Exception("Invalid dump path, please check your config")
+
+    def check(self):
+        self.check_kwargs()
+        self._check_rank()
+        self._check_step()
+        return True
+
+    def check_model(self, model):
+        if self.level in ["L0", "mix"] and not model:
+            raise Exception(
+                f"For level {self.level}, PrecisionDebugger must receive a model argument."
+            )
+
+    def _check_rank(self):
+        if self.rank:
+            for rank_id in self.rank:
+                if not isinstance(rank_id, int) or rank_id < 0:
+                    raise ValueError(f"rank {self.rank} must be an integer and greater than or equal to 0.")
+            else:
+                logger.warning_on_rank_0(f"Rank argument is provided. Only rank {self.rank} data will be dumpped.")
+
+    def _check_step(self):
+        if self.step:
+            for s in self.step:
+                if not isinstance(s, int) or s < 0:
+                    raise ValueError(f"step element {s} must be an integer and greater than or equal to 0.")

msprobe/pytorch/debugger/precision_debugger.py

@@ -0,0 +1,95 @@
+import torch
+from torch.utils.data import dataloader
+from msprobe.pytorch.debugger.debugger_config import DebuggerConfig
+from msprobe.pytorch.service import Service
+from msprobe.pytorch.common.log import logger
+from msprobe.pytorch.pt_config import parse_json_config
+from msprobe.core.common.exceptions import MsaccException
+
+
+class PrecisionDebugger:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(PrecisionDebugger, cls).__new__(cls)
+            cls._instance.config = None
+            cls._instance.enable_dataloader = False
+        return cls._instance
+
+    def __init__(
+        self,
+        config_path=None,
+        task=None,
+        dump_path=None,
+        level=None,
+        model=None,
+        step=None,
+    ):
+        if not hasattr(self, "initialized"):
+            self.initialized = True
+            self.model = self.check_model_valid(model)
+            common_config, task_config = parse_json_config(config_path, task)
+            if step:
+                common_config.step = step
+            self.config = DebuggerConfig(
+                common_config, task_config, task, dump_path, level
+            )
+            self.config.check_model(self.model)
+            self.service = Service(self.config)
+            self.enable_dataloader = self.config.enable_dataloader
+            if self.enable_dataloader:
+                logger.warning_on_rank_0("The enable_dataloader feature will be deprecated in the future.")
+                dataloader._BaseDataLoaderIter.__next__ = iter_tracer(dataloader._BaseDataLoaderIter.__next__)
+
+    @property
+    def instance(self):
+        return self._instance
+
+    @staticmethod
+    def check_model_valid(model):
+        if not model or isinstance(model, torch.nn.Module):
+            return model
+        raise MsaccException(
+            MsaccException.INVALID_PARAM_ERROR, "model 参数必须是torch.nn.Module类型。"
+        )
+
+    @classmethod
+    def start(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception("No instance of PrecisionDebugger found.")
+        if instance.enable_dataloader:
+            logger.warning_on_rank_0("DataLoader is enabled, start() skipped.")
+        else:
+            instance.service.start(instance.model)
+
+    @classmethod
+    def stop(cls):
+        instance = cls._instance
+        if not instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        if instance.enable_dataloader:
+            logger.warning_on_rank_0("DataLoader is enabled, stop() skipped.")
+        else:
+            instance.service.stop()
+
+    @classmethod
+    def step(cls):
+        if not cls._instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        cls._instance.service.step()
+
+
+def iter_tracer(func):
+    def func_wrapper(*args, **kwargs):
+        debugger_instance = PrecisionDebugger.instance
+        debugger_instance.enable_dataloader = False
+        if not debugger_instance.service.first_start:
+            debugger_instance.stop()
+            debugger_instance.step()
+        result = func(*args, **kwargs)
+        debugger_instance.start()
+        debugger_instance.enable_dataloader = True
+        return result
+    return func_wrapper

msprobe/pytorch/doc/FAQ.md

@@ -0,0 +1,193 @@
+# 精度预检工具
+
+1. 预检工具在dump和run_ut的过程中，是否需要同时开启或关闭jit编译（jit_compile）？
+
+   答：是。
+
+2. 预检工具对于type_as这类涉及数据类型转换操作的API，是否具有参考性？
+
+   由于这类API在CPU侧存在精度先提升后下降的操作，因此这类API的有效性的参考价值有限。
+
+3. run ut过程中出现报错：ERROR:Got unsupported ScalarType BFloat16
+
+   答：请使用最新版本的工具。
+
+4. Dropout算子，CPU和NPU的随机应该不一样，为什么结果比对是一致的？
+
+   答：这个结果是正常的，工具对该算子有特殊处理，只判定位置为0的位置比例大约和设定p值相当。
+
+5. 为什么浮点型数据bench和CPU的dtype不一致？
+
+   答：对于fp16的数据，CPU会上升一个精度fp32去计算，这是和算子那边对齐的精度结论，CPU用更高精度去计算会更接近真实值。
+
+6. 添加预检工具后截取操作报错：`IndexError: too many indices for tensor of dimension x` 或 `TypeError: len() of a 0-d tensor`。
+
+   答：注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中Tensor:下的`- __getitem__`，工具会跳过dump该API。如果是需要dump的关键位置API也可以考虑根据报错堆栈信息注释引发报错的类型检查。
+
+7. 添加预检工具后F.gelu触发ValueError报错：`activation_func must be F.gelu`等。
+
+   答：注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中functional:下的的`- gelu`，工具会跳过dump该API。如果是需要dump的关键位置API也可以考虑根据报错堆栈信息注释引发报错的类型检查。
+
+8. 添加预检工具后触发AsStrided算子相关的报错，或者编译相关的报错，如：`Failed to compile Op [AsStrided]`。
+
+   答：注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中Tensor:下的`- t`和`- transpose`。
+
+9. Tensor 魔法函数具体对应什么操作？
+
+   答：
+
+   | Tensor魔法函数  | 具体操作         |
+   | --------------- | ---------------- |
+   | `__add__`       | +                |
+   | `__and__`       | &                |
+   | `__bool__`      | 返回Tensor布尔值 |
+   | `__div__`       | /                |
+   | `__eq__`        | ==               |
+   | `__ge__`        | >=               |
+   | `__gt__`        | >                |
+   | `__iadd__`      | +=               |
+   | `__iand__`      | &=               |
+   | `__idiv__`      | /=               |
+   | `__ifloordiv__` | //=              |
+   | `__ilshift__`   | <<=              |
+   | `__imod__`      | %=               |
+   | `__imul__`      | *=               |
+   | `__ior__`       | \|=              |
+   | `__irshift__`   | >>=              |
+   | `__isub__`      | -=               |
+   | `__ixor__`      | ^=               |
+   | `__lshift__`    | <<               |
+   | `__matmul__`    | 矩阵乘法         |
+   | `__mod__`       | %                |
+   | `__mul__`       | *                |
+   | `__nonzero__`   | 同`__bool__`     |
+   | `__or__`        | \|               |
+   | `__radd__`      | +（反向）        |
+   | `__rmul__`      | *（反向）        |
+   | `__rshift__`    | >>               |
+   | `__sub__`       | -                |
+   | `__truediv__`   | 同`__div__`      |
+   | `__xor__`       | ^                |
+
+# 精度比对工具
+
+## 工具使用
+
+### dump指定融合算子
+
+dump指定操作当前支持dump指定融合算子的输入输出，需要在mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml中添加，比如以下代码段调用的softmax融合算子
+
+```
+def npu_forward_fused_softmax(self, input_, mask):
+    resl = torch_npu.npu_scaled_masked_softmax(input_, mask, self.scale, False)
+    return resl
+```
+
+如果需要dump其中调用的npu_scaled_masked_softmax算子的输入输出信息，需要在support_wrap_ops.yaml中的torch_npu: 中自行添加该融合算子即可：
+
+```
+- npu_scaled_masked_softmax
+```
+
+（npu_scaled_masked_softmax融合算子工具已支持dump，本例仅供参考）
+
+## 常见问题
+
+### 1. 在同一个目录多次执行dump会冲突吗？
+
+会，同一个目录多次dump，会覆盖上一次结果，可以使用dump_path参数修改dump目录。
+
+### 2. 如何dump算子级的数据？
+
+需要配置level为L2模式。
+
+### 3. 工具比对发现NPU和标杆数据的API无法完全对齐？
+
+torch版本和硬件差异属于正常情况。
+
+## 异常情况
+
+### 2. HCCL 报错： error code: EI0006
+
+**故障现象**
+
+使用msprobe工具时，报错： error code: EI0006。
+
+**故障原因**
+
+CANN软件版本较低导致不兼容。
+
+**故障处理**
+
+升级新版CANN软件版本。
+
+### 3. torch_npu._C._clear_overflow_npu() RuntimeError NPU error，error code is 107002
+
+如果运行溢出检测功能遇到这个报错，采取以下解决方法：
+如果是单卡运行，添加如下代码，0是卡号，选择自己空闲的卡号。
+
+```
+torch.npu.set_device('npu:0')
+```
+
+如果多卡运行，请在代码中修改对应卡号，比如进程使用卡号为{rank}时可以添加如下代码：
+
+```
+torch.npu.set_device(f'npu:{rank}')
+```
+
+如果运行精度比对功能遇到这个报错，尝试安装最新版本的msprobe。
+
+### 4. dump得到的VF_lstm_99_forward_input.1.0.npy、VF_lstm_99_forward_input.1.1.npy类似的数据是否正常？
+
+带1.0/1.1/1.2后缀的npy是正常现象，例如当输入数据为[[tensor1, tensor2, tensor3]]会生成这样的后缀。
+
+### 5. 进行compare报错：The current file contains stack information, please turn on the stack_mode
+
+在比对脚本中，设置stack_mode=True，例如：
+
+```
+from msprobe.pytorch import compare
+dump_result_param={
+"npu_json_path": "./npu_dump/dump.json",
+"bench_json_path": "./gpu_dump/dump.json",
+"stack_json_path": "./npu_dump/stack.json",
+"is_print_compare_log": True
+}
+compare(dump_result_param, output_path="./output", stack_mode=True)
+```
+
+### 6. dump指定反向API的kernel级别的数据报错：NameError：name 'torch_npu' is not defined
+
+- 如果是npu环境，请安装torch_npu；
+- 如果是gpu环境，暂不支持dump指定API的kernel级别的数据
+
+### 7. 配置dump_path后，使用工具报错：[ERROR]The file path /home/xxx/dump contains special characters
+
+- 请检查你设置的dump绝对路径是否包含特殊字符，确保路径名只包含大小写字母、数字、下划线、斜杠、点和短横线
+- 注意，如果执行脚本的路径为/home/abc++/，设置的dump_path="./dump"，工具实际校验的路径为绝对路径/home/abc++/dump，++为特殊字符，会引发本条报错
+
+### 8. 无法dump matmul权重的反向梯度数据
+
+- matmul期望的输入是二维，当输入不是二维时，会将输入通过view操作展成二维，再进行matmul运算，因此在反向求导时，backward_hook能拿到的是UnsafeViewBackward这步操作里面数据的梯度信息，取不到MmBackward这步操作里面数据的梯度信息，即权重的反向梯度数据。
+- 典型的例子有，当linear的输入不是二维，且无bias时，会调用output = input.matmul(weight.t()),因此拿不到linear层的weight的反向梯度数据。
+
+### 9. dump.json文件中的某些api的dtype类型为float16，但是读取此api的npy文件显示的dtype类型为float32
+
+- msprobe工具在dump数据时需要将原始数据从npu to cpu上再转换为numpy类型，npu to cpu的逻辑和gpu to cpu是保持一致的，都存在dtype可能从float16变为float32类型的情况，如果出现dtype不一致的问题，最终dump数据的dtype以pkl文件为准。
+
+### 10. 使用dataloader后raise异常Exception("msprobe: exit after iteration {}". format(max(self.config.step))
+
+- 正常现象，dataloader通过raise结束程序，堆栈信息可忽略。
+
+### 11. 添加msprobe工具后截取操作报错：`IndexError: too many indices for tensor of dimension x` 或 `TypeError: len() of a 0-d tensor`。
+
+- 注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中Tensor:下的`- __getitem__`，工具会跳过dump该API。如果是需要dump的关键位置API也可以考虑根据报错堆栈信息注释引发报错的类型检查。
+
+### 12. 添加msprobe工具后F.gelu触发ValueError报错：`activation_func must be F.gelu`等。
+
+- 注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中functional:下的的`- gelu`，工具会跳过dump该API。如果是需要dump的关键位置api也可以考虑根据报错堆栈信息注释引发报错的类型检查。
+
+### 13. 添加msprobe工具后触发AsStrided算子相关的报错，或者编译相关的报错，如：`Failed to compile Op [AsStrided]`。
+
+- 注释工具目录mstt/debug/accuracy_tools/msprobe/pytorch/hook_module/support_wrap_ops.yaml文件中Tensor:下的`- t`和`- transpose`。