mindstudio-probe 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

msprobe/docs/05.data_dump_PyTorch.md

@@ -2,6 +2,8 @@
 
 msprobe 工具主要通过在训练脚本内添加 dump 接口、启动训练的方式采集精度数据。
 
+dump的'tensor'模式采集数据量大小，可以参考[数据量基线](./26.data_dump_PyTorch_baseline.md)。
+
 本工具提供固定的 API 支持列表，若需要删除或增加 dump 的 API，可以在 msprobe/pytorch/hook_module/support_wrap_ops.yaml 文件内手动修改，如下示例：
 
 ```yaml
@@ -25,8 +27,12 @@ functional:  # functional为算子类别，找到对应的类别，在该类别
 PrecisionDebugger(config_path=None, task=None, dump_path=None, level=None, model=None, step=None)
 ```
 
-1. config_path：指定 dump 配置文件路径；model：指定具体的 torch.nn.Module，默认未配置，level 配置为"L0"或"mix"时，必须在该接口或 **start** 接口中配置该参数。其他参数均在 [config.json](../config.json) 文件中可配，详细配置可见 [config.json 介绍](./02.config_introduction.md)。
-2. 此接口的参数均不是必要，且优先级高于 [config.json](../config.json) 文件中的配置，但可配置的参数相比 config.json 较少。
+1. config_path：指定 dump 配置文件路径；
+2. model：指定需要采集 Module 级数据的模型，支持传入 torch.nn.Module 或 list[torch.nn.Module] 类型，默认未配置。
+level 配置为"L0"或"mix"时，必须在该接口或 **start** 接口中配置该参数。该参数在将来会从该接口移除，建议在 **start** 接口中配置该参数。
+3. 其他参数均在 [config.json](../config.json) 文件中可配，详细配置可见 [config.json 介绍](./02.config_introduction.md)。
+
+此接口的参数均不是必要，且优先级高于 [config.json](../config.json) 文件中的配置，但可配置的参数相比 config.json 较少。
 
 ### 1.2 start
 
@@ -38,12 +44,16 @@ PrecisionDebugger(config_path=None, task=None, dump_path=None, level=None, model
 debugger.start(model=None)
 ```
 
-1.  model：指定具体的 torch.nn.Module，默认未配置，level 配置为"L0"或"mix"时，必须在该接口或 **PrecisionDebugger** 接口中配置该参数。
+1. model：指定需要采集 Module 级数据的模型，支持传入 torch.nn.Module 或 list[torch.nn.Module] 类型，默认未配置。
+level 配置为"L0"或"mix"时，必须在该接口或 **PrecisionDebugger** 接口中配置该参数。
 本接口中的 model 比 PrecisionDebugger 中 model 参数优先级更高，会覆盖 PrecisionDebugger 中的 model 参数。
 
 ### 1.3 stop
 
-**功能说明**：停止精度数据采集。在 **start** 函数之后的任意位置添加。若需要 dump 反向数据，则需要添加在反向计算代码（如，loss.backward）之后。使用示例可参见 [2.1 快速上手](#21-快速上手)和 [2.2 采集完整的前反向数据](#22-采集完整的前反向数据)。
+**功能说明**：停止精度数据采集。在 **start** 函数之后的任意位置添加。
+若 **stop** 函数添加在反向计算代码（如loss.backward）之后，则会采集 **start** 和该函数之间的前反向数据。
+若 **stop** 函数添加在反向计算代码之前，则需要将 **step** 函数添加到反向计算代码之后，才能采集 **start** 和该函数之间的前反向数据。
+**step** 函数详细介绍见1.5章节。使用示例可参见 [2.1 快速上手](#21-快速上手) 和 [2.2 采集完整的前反向数据](#22-采集完整的前反向数据)。
 
 **原型**：
 
@@ -53,7 +63,8 @@ debugger.stop()
 
 ### 1.4 forward_backward_dump_end
 
-**功能说明**：停止精度数据采集。用于 dump 指定代码的前反向数据。在 **start** 函数之后，反向计算代码（如，loss.backward）之前的任意位置添加，可以采集 **start** 函数和该函数之间的前反向数据，可以通过调整 **start** 函数与该函数的位置，来指定需要 dump 的代码块。要求 **stop** 函数添加在反向计算代码（如，loss.backward）之后，此时该函数与 **stop** 函数之间的代码不会被 dump。使用示例可参见 [2.3 采集指定代码块的前反向数据](#23-采集指定代码块的前反向数据)
+**功能说明**：停止精度数据采集。与 **stop** 函数功能相同，该函数在将来会被移除，建议使用 **stop** 函数。
+使用示例可参见 [2.3 采集指定代码块的前反向数据](#23-采集指定代码块的前反向数据)。
 
 **原型**：
 
@@ -63,7 +74,8 @@ forward_backward_dump_end()
 
 ### 1.5 step
 
-**功能说明**：更新 dump 参数。在最后一个 **stop** 函数后或一个 step 结束的位置添加。需要与 **start** 函数一起添加在 for 循环内。
+**功能说明**：结束一个 step 的数据采集，完成所有数据落盘并更新 dump 参数。在一个 step 结束的位置添加，且必须在 **stop** 函数之后的位置调用。
+该函数需要配合 **start** 和 **stop** 函数使用，尽量添加在反向计算代码（如loss.backward）之后，否则可能会导致反向数据丢失。使用示例可参见[2.2 采集完整的前反向数据](#22-采集完整的前反向数据)。
 
 **原型**：
 
@@ -103,13 +115,18 @@ module_dump_end()
 
 **原型**：
 ```python
-seed_all(seed=1234, mode=False)
+seed_all(seed=1234, mode=False, rm_dropout=True)
 ```
 
 **参数说明**:
 
 1. seed: 随机性种子。参数示例: seed=1000。默认值：1234。非必选
 2. mode：确定性计算模式。可配置True或False。参数示例：mode=True。默认为False。非必选（注意：确定性计算会导致API执行性能降低，建议在发现模型多次执行结果不同的情况下开启）
+3. rm_dropout：控制dropout失效的开关。可配置 True 或 False，默认值：True，非必选。参数示例：rm_dropout=True。
+该参数设置为 True 后， 工具会自动将 `torch.nn.functional.dropout`、`torch.nn.functional.dropout2d`、`torch.nn.functional.dropout3d`、`torch.nn.Dropout`、`torch.nn.Dropout2d`、`torch.nn.Dropout3d` 
+的接口参数 p 置为0，以避免因随机dropout造成的网络随机性。 注意：通过rm_dropout控制dropout失效或生效需要在初始化dropout实例前调用才能生效。
+
+当前工具 dump 默认不会固定随机性和使 dropout 失效，若希望每次采集的数据保持一致，建议在 dump 数据前调用 seed_all 接口。
 
 seed_all 函数可固定随机数的范围如下表。
 
@@ -128,29 +145,30 @@ seed_all 函数可固定随机数的范围如下表。
 | torch.backends.cudnn.enable=False        | 关闭 cuDNN                   |
 | torch.backends.cudnn.benchmark=False     | cuDNN 确定性地选择算法       |
 | torch.backends.cudnn.deterministic=True  | cuDNN 仅使用确定性的卷积算法 |
+| torch.nn.functional.dropout              | 将 dropout 的接口参数 p 置为0 |
+| torch.nn.functional.dropout2d            | 将 dropout2d 的接口参数 p 置为0 |
+| torch.nn.functional.dropout3d            | 将 dropout3d 的接口参数 p 置为0 |
+| torch.nn.Dropout                         | 将 Dropout 的接口参数 p 置为0 |
+| torch.nn.Dropout2d                       | 将 Dropout2d 的接口参数 p 置为0 |
+| torch.nn.Dropout3d                       | 将 Dropout3d 的接口参数 p 置为0 |
 
 需要保证 CPU 或 GPU 以及 NPU 的模型输入完全一致，dump 数据的比对才有意义，seed_all 并不能保证模型输入完全一致，如下表所示场景需要保证输入的一致性。
 
 | 场景            | 固定方法      |
 | --------------- | ------------- |
 | 数据集的 shuffle | 关闭 shuffle。 |
-| dropout         | 关闭 dropout。 |
 
 关闭 shuffle 示例：
 
 ```python
 train_loader = torch.utils.data.DataLoader(
-train_dataset,
-batch_size = batch_size,
-shuffle = False,
-num_workers = num_workers
+    train_dataset,
+    batch_size=batch_size,
+    shuffle=False,
+    num_workers=num_workers
 )
 ```
 
-关闭 dropout：
-
-在使用 `from msprobe.pytorch import PrecisionDebugger` 后，工具会自动将 `torch.nn.functional.dropout`、`torch.nn.functional.dropout2d`、`torch.nn.functional.dropout3d`、`torch.nn.Dropout`、`torch.nn.Dropout2d`、`torch.nn.Dropout3d` 的接口参数 p 置为0.
-
 ## 2 示例代码
 
 ### 2.1 快速上手
@@ -161,38 +179,43 @@ num_workers = num_workers
 # 根据需要import包
 import torch
 import torch.nn as nn
-import torch_npu  # 需安装 torch_npu
 import torch.nn.functional as F
+
+# 导入工具的数据采集接口
 from msprobe.pytorch import PrecisionDebugger, seed_all
+
 # 在模型训练开始前固定随机性
 seed_all()
+# 在模型训练开始前实例化PrecisionDebugger
+debugger = PrecisionDebugger(config_path='./config.json')
 
-torch.npu.set_device("npu:0")
 # 定义网络
 class ModuleOP(nn.Module):
     def __init__(self) -> None:
         super().__init__()
-        self.linear_1 = nn.Linear(in_features=8,out_features=4)
-        self.linear_2 = nn.Linear(in_features=4,out_features=2)
+        self.linear_1 = nn.Linear(in_features=8, out_features=4)
+        self.linear_2 = nn.Linear(in_features=4, out_features=2)
 
-    def forward(self,x):
+    def forward(self, x):
         x1 = self.linear_1(x)
         x2 = self.linear_2(x1)
         r1 = F.relu(x2)
         return r1
 
 if __name__ == "__main__":
-	module = ModuleOP()
-	# 注册工具
-	debugger = PrecisionDebugger('./config.json', model=module)
-	debugger.start()
-	x = torch.randn(10,8)
-	out = module(x)
-	loss = out.sum()
-	loss.backward()
-	debugger.stop()
+    module = ModuleOP()
+    # 开启数据 dump
+    debugger.start(model=module)
 
+    x = torch.randn(10, 8)
+    out = module(x)
+    loss = out.sum()
+    loss.backward()
+
+    # 关闭数据 dump
+    debugger.stop()
 ```
+
 ### 2.2 采集完整的前反向数据
 
 ```Python
@@ -205,19 +228,20 @@ debugger = PrecisionDebugger(config_path="./config.json", dump_path="./dump_path
 # ...
 # 数据集迭代的位置一般为模型训练开始的位置
 for data, label in data_loader:
-	debugger.start() # 开启数据dump
-	# 如下是模型每个step执行的逻辑
+    debugger.start()  # 开启数据dump
+    # 如下是模型每个step执行的逻辑
     output = model(data)
     #...
     loss.backward()
-	debugger.stop() # 关闭数据dump
-	debugger.step() # 结束一个step的dump
+    debugger.stop()  # 关闭数据dump
+    debugger.step()  # 结束一个step的dump
 ```
 
 ### 2.3 采集指定代码块的前反向数据
 
 ```Python
 from msprobe.pytorch import PrecisionDebugger, seed_all
+
 # 在模型训练开始前固定随机性
 seed_all()
 # 请勿将PrecisionDebugger的初始化流程插入到循环代码中
@@ -227,14 +251,14 @@ debugger = PrecisionDebugger(config_path="./config.json", dump_path="./dump_path
 # ...
 # 数据集迭代的位置一般为模型训练开始的位置
 for data, label in data_loader:
-	debugger.start() # 开启数据dump
-	# 如下是模型每个step执行的逻辑
+    debugger.start()  # 开启数据dump
+    # 如下是模型每个step执行的逻辑
     output = model(data)
-    debugger.forward_backward_dump_end() # 插入该函数到start函数之后，只dump start函数到该函数之间代码的前反向数据，本函数到stop函数之间的数据则不dump
-    #...
+    
+    debugger.forward_backward_dump_end()  # 插入该函数到start函数之后，只dump start函数到该函数之间的前反向数据。
+    # ...
     loss.backward()
-	debugger.stop() # 关闭数据dump
-	debugger.step() # 结束一个step的dump
+    debugger.step()  # 结束一个step的dump
 ```
 
 ### 2.4 采集函数模块化数据
@@ -243,11 +267,14 @@ for data, label in data_loader:
 # 根据需要import包
 import torch
 import torch.nn as nn
-import torch_npu  # 需安装 torch_npu
 import torch.nn.functional as F
+
+# 导入工具的数据采集接口
 from msprobe.pytorch import PrecisionDebugger, module_dump, module_dump_end
 
-torch.npu.set_device("npu:0")
+# 在模型训练开始前实例化PrecisionDebugger
+debugger = PrecisionDebugger(config_path='./config.json')
+
 # 定义网络
 class ModuleOP(nn.Module):
     def __init__(self) -> None:
@@ -263,37 +290,37 @@ class ModuleOP(nn.Module):
 
 if __name__ == "__main__":
     module = ModuleOP()
-    # 注册工具
-    debugger = PrecisionDebugger(config_path='./config.json')
-    debugger.start()                   # 开启数据dump
-    
-    x = torch.randn(10, 8)             
+    # 开启数据dump
+    debugger.start()
+    x = torch.randn(10, 8)
     # ...                              # start和module_dump接口之间的数据正常dump
     module_dump(module, "MyModuleOP")  # 开启模块级精度数据dump
-    out = module(x)                    # module内部的child modules或API不会被dump
+    out = module(x)                    # module内部的child modules或API将不会被dump
     module_dump_end()                  # 关闭模块级精度数据dump
     loss = out.sum()                   # module_dump_end和stop接口之间的数据正常dump
-    loss.backward()          
-
-    debugger.stop()                    # 关闭数据dump
+    loss.backward()
+    # 关闭数据dump
+    debugger.stop()  
 ```
 
 ## 3 dump 结果文件介绍
 
 训练结束后，工具将 dump 的数据保存在 dump_path 参数指定的目录下。目录结构示例如下：
 
-```Python
+```lua
 ├── dump_path
 │   ├── step0
 │   |   ├── rank0
 │   |   │   ├── dump_tensor_data
 |   |   |   |    ├── Tensor.permute.1.forward.pt
-|   |   |   |    ├── MyModule.0.forward.input.pt        # 开启模块级精度数据dump时存在模块级的dump数据文件
+|   |   |   |    ├── Module.conv1.Conv2d.forward.0.input.0.pt   # 命名格式为{Module}.{module_name}.{class_name}.{forward/backward}.{调用次数}.{input/output}.{参数序号}, 其中，“参数序号”表示该Module的第n个参数，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该Module的第1个参数的第1个元素。
+|   |   |   |    ├── Module.conv1.Conv2D.forward.0.parameters.bias.pt  # 模块参数数据：命名格式为{Module}.{module_name}.{class_name}.forward.{调用次数}.parameters.{parameter_name}。
+|   |   |   |    ├── Module.conv1.Conv2D.parameters_grad.weight.pt  # 模块参数梯度数据：命名格式为{Module}.{module_name}.{class_name}.parameters_grad.{parameter_name}。因为同一模块的参数使用同一梯度进行更新，所以参数梯度文件名不包含调用次数。
 |   |   |   |    ...
-|   |   |   |    └── Fcuntion.linear.5.backward.output.pt
-│   |   |   ├── dump.json        # 保存前反向算子、算子的统计量信息或溢出算子信息。包含dump数据的API名称（命名格式为：`{api_type}_{api_name}_{API调用次数}_{前向反向}_{input/output}.{参数序号}`）、dtype、 shape、各数据的max、min、mean、L2norm统计信息以及当配置summary_mode="md5"时的CRC-32数据。其中，“参数序号”表示该API下的第n个参数，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该API的第1个参数的第1个子参数；L2norm表示L2范数（平方根）
-│   |   |   ├── stack.json        # 算子调用栈信息
-│   |   |   └── construct.json        # 分层分级结构
+|   |   |   |    └── Functional.linear.5.backward.output.pt    # 命名格式为{api_type}.{api_name}.{API调用次数}.{forward/backward}.{input/output}.{参数序号}, 其中，“参数序号”表示该API的第n个输入或输出，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该API的第1个参数的第1个元素。
+│   |   |   ├── dump.json       
+│   |   |   ├── stack.json        
+│   |   |   └── construct.json        
 │   |   ├── rank1
 |   |   |   ├── dump_tensor_data
 |   |   |   |   └── ...
@@ -306,7 +333,13 @@ if __name__ == "__main__":
 │   ├── step1
 │   |   ├── ...
 │   ├── step2
-```
+```  
+* `rank`：设备 ID，每张卡的数据保存在对应的 `rank{ID}` 目录下。非分布式场景下没有 rank ID，目录名称为 rank。
+* `dump_tensor_data`：保存采集到的张量数据。
+* `dump.json`： 保存API或Module前反向数据的统计量信息。包含dump数据的API名称或Module名称，各数据的dtype、 shape、max、min、mean、L2norm（L2范数，平方根）统计信息以及当配置summary_mode="md5"时的CRC-32数据。具体介绍可参考[dump.json文件说明](./27.dump_json_instruction.md#1-dumpjson文件介绍pytorch)。
+* `stack.json`：API/Module的调用栈信息。
+* `construct.json`：分层分级结构，level为L1时，construct.json内容为空。  
+
 
 dump 过程中，pt 文件在对应算子或者模块被执行后就会落盘，而 json 文件则需要在正常执行 PrecisionDebugger.stop() 后才会写入完整数据，异常的程序终止会保存终止前被执行算子的相关 npy 文件，可能会导致 json 文件中数据丢失。
 
@@ -323,6 +356,3 @@ pt 文件保存的前缀和 PyTorch 对应关系如下：
 | VF          | torch._VF           |
 | Aten        | torch.ops.aten      |
 | Distributed | torch.distributed   |
-
-
-

msprobe/docs/06.data_dump_MindSpore.md

@@ -20,12 +20,13 @@
 
 以下通过一个简单的示例，展示如何在 MindSpore 中使用 msprobe 工具进行精度数据采集。
 
-您可以参考 [动态图快速入门示例](./data_dump_Mindspore/dynamic_graph_quick_start_example.md)  了解详细步骤。
+您可以参考 [动态图快速入门示例](data_dump_MindSpore/dynamic_graph_quick_start_example.md)  了解详细步骤。
 
 ## 4. 概述
 
 msprobe 工具通过在训练脚本中添加 `PrecisionDebugger` 接口并启动训练的方式，采集模型在运行过程中的精度数据。该工具支持对MindSpore的静态图和动态图场景进行不同Level等级的精度数据采集。
 
+dump 的"tensor"模式采集数据量大小，可以参考[数据量基线](data_dump_MindSpore/data_dump_MindSpore_baseline.md)。
 
 ## 5. 场景介绍 
 
@@ -43,7 +44,7 @@ msprobe 工具通过在训练脚本中添加 `PrecisionDebugger` 接口并启动
 - **未使用高阶 API** ： 
   - 手动在训练循环中调用 `start`、`stop`、`step` 等接口，适用于 **L0** 、**L1** 、**mix** 、**L2** 数据采集。
 
-采集方式请参见[示例代码 > 动态图场景](#72-动态图场景-)。
+采集方式请参见[示例代码 > 动态图场景](#72-动态图场景)。
 
 > **注意** ：动态图模式下，使用 `PSJit` 或 `PIJit` 装饰的部分实际以静态图模式执行，此时的 **Kernel 级（L2 Level）**  数据采集方式与静态图场景相同。 
 - **L0 Level（Cell 级）** ：采集 `Cell` 对象的数据，适用于需要分析特定网络模块的情况。
@@ -65,12 +66,15 @@ msprobe 工具通过在训练脚本中添加 `PrecisionDebugger` 接口并启动
 **原型**：
 
 ```Python
-PrecisionDebugger(config_path=None)
+PrecisionDebugger(config_path=None, task=None, dump_path=None, level=None, step=None)
 ```
 
 **参数说明**:
 
 1. config_path：指定 dump 配置文件路径，string 类型。参数示例："./config.json"。未配置该路径时，默认使用 [config.json](../config.json) 文件的默认配置，配置选项含义可见 [config.json 介绍](./02.config_introduction.md)。
+2. 其他参数均在 [config.json](../config.json) 文件中可配，详细配置可见 [config.json 介绍](./02.config_introduction.md)。
+
+此接口的参数均不是必要，且优先级高于 [config.json](../config.json) 文件中的配置，但可配置的参数相比 config.json 较少。
 
 #### 6.1.1 start
 
@@ -88,7 +92,9 @@ start(model=None)
 
 #### 6.1.2 stop
 
-**功能说明**：停止数据采集。在 **start** 函数之后的任意位置添加。需要与 start 函数一起添加在 for 循环内。若需要 dump 反向数据，则需要添加在反向计算代码之后。**仅未使用 Model 高阶 API 的动态图场景支持。**
+**功能说明**：停止精度数据采集。在 **start** 函数之后的任意位置添加。若 **stop** 函数添加在反向计算代码之后，则会采集 **start** 和该函数之间的前反向数据。
+若 **stop** 函数添加在反向计算代码之前，则需要将 **step** 函数添加到反向计算代码之后，才能采集 **start** 和该函数之间的前反向数据。
+**step** 函数详细介绍见6.1.3章节。**仅未使用 Model 高阶 API 的动态图场景支持。**
 
 **原型**：
 
@@ -98,7 +104,9 @@ stop()
 
 #### 6.1.3 step
 
-**功能说明**：在最后一个 **stop** 函数后或一个 step 训练结束的位置添加。**仅未使用 Model 高阶 API 的动态图场景支持。**
+**功能说明**：结束一个 step 的数据采集，完成所有数据落盘并更新 dump 参数。在一个 step 结束的位置添加，且必须在 **stop** 函数之后的位置调用。
+该函数需要配合 **start** 和 **stop** 函数使用，尽量添加在反向计算代码之后，否则可能会导致反向数据丢失。
+**仅未使用 Model 高阶 API 的动态图场景支持。**
 
 **原型**：
 
@@ -108,9 +116,7 @@ step()
 
 #### 6.1.4 forward_backward_dump_end
 
-**功能说明**：在 **start** 函数和在 **stop** 函数之间调用，表示采集 **start** 到 **forward_backward_dump_end**之间的L1级别的正反向数据。
-
-**仅支持L1级别数据采集场景。**
+**功能说明**：停止精度数据采集。与 **stop** 函数功能相同，该函数在将来会被移除，建议使用 **stop** 函数。
 
 **L1级别数据中的jit数据采集行为不受此接口影响。**
 
@@ -173,7 +179,7 @@ debugger.start()
 
 ```
 
-### 7.2 动态图场景 
+### 7.2 动态图场景
 
 #### 7.2.1 L0 ,L1, mix 级别
 
@@ -273,7 +279,37 @@ trainer.train(1, train_dataset)
 
 ### 8.1 静态图场景
 
-训练结束后，数据将保存在 `dump_path` 指定的目录下，目录结构请参见 MindSpore 官方文档中的[数据对象目录](https://www.mindspore.cn/docs/zh-CN/r2.4.0/model_train/debug/dump.html)。
+训练结束后，数据将保存在 `dump_path` 指定的目录下。
+
+若jit_level=O2，且使用mindstudio-probe发布包或源码编包时添加了`--include-mod=adump`选项，目录结构示例如下：
+```
+├── dump_path
+│   ├── rank_0
+│   |   ├── {timestamp}
+│   |   │   ├── step_0
+|   |   |   |    ├── AssignAdd.Default_network-TrainOneStepCell_optimzer-Gsd_AssignAdd-op0.0.10.1735011096403740.input.0.ND.INT32.npy
+|   |   |   |    ├── Cast.Default_network-TrainOneStepCell_network-WithLossCell__backbone-Net_Cast-op0.9.10.1735011096426349.input.0.ND.FLOAT.npy
+|   |   |   |    ├── GetNext.Default_GetNext-op0.0.11.17350110964032987.output.0.ND.FLOAT.npy
+|   |   |   |    ...
+|   |   |   |    ├── RefDAata.accum_bias1.6.10.1735011096424907.output.0.ND.FLOAT.npy
+|   |   |   |    ├── Sub.Default_network-TrainOneStepCell_network-WithLossCell__backbone-Net_Sub-op0.10.10.1735011096427368.input.0.ND.BF16
+|   |   |   |    └── mapping.csv
+│   |   │   ├── step_1
+|   |   |   |    ├── ...
+|   |   |   ├── ...
+|   |   ├── ...
+|   |
+│   ├── ...
+|   |
+│   └── rank_7
+│       ├── ...
+```
+**说明**
+1. 若配置文件中指定落盘npy格式，但是实际数据格式不在npy支持范围内(如bf16、int4等)，则该tensor会以原始码流落盘，并不会转换为npy格式。
+2. 若原始文件全名长度超过255个字符，则文件基础名会被转换为长度为32位的随机数字字符串，原始文件名与转换后文件名的对应关系会保存在同目录下的`mapping.csv`文件中。
+
+
+其他场景请参见 MindSpore 官方文档中的[数据对象目录](https://www.mindspore.cn/docs/zh-CN/r2.4.0/model_train/debug/dump.html)。
 
 ### 8.2 动态图场景
 
@@ -286,15 +322,17 @@ dump 结果目录结构示例如下：
 │   |   │   ├── dump_tensor_data
 |   |   |   |    ├── MintFunctional.relu.0.backward.input.0.npy
 |   |   |   |    ├── Mint.abs.0.forward.input.0.npy
-|   |   |   |    ├── Functional.split.0.forward.input.0.npy
+|   |   |   |    ├── Functional.split.0.forward.input.0.npy       # 命名格式为{api_type}.{api_name}.{API调用次数}.{forward/backward}.{input/output}.{参数序号}, 其中，“参数序号”表示该API的第n个输入或输出，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该API的第1个参数的第1个元素。   
 |   |   |   |    ├── Tensor.__add__.0.forward.output.0.npy
 |   |   |   |    ...
 |   |   |   |    ├── Jit.AlexNet.0.forward.input.0.npy
 |   |   |   |    ├── Primitive.conv2d.Conv2D.0.forward.input.0.npy
-|   |   |   |    └── Cell.relu.ReLU.forward.0.input.0.npy        
-│   |   |   ├── dump.json        # 保存前反向API、API的统计量信息或溢出API信息。包含dump数据的API名称或Cell名称（Api命名格式为：{api_type}_{api_name}_{API调用次数}_{前向反向}_{input/output}.{参数序号}，Cell命名格式为：{Cell}_{cell_name}_{class_name}_{前向反向}.{index}.{input/output}.{参数序号}）、dtype、 shape、各数据的max、min、mean、L2norm统计信息以及当配置summary_mode="md5"时的CRC-32数据。其中，“参数序号”表示该API或Cell下的第n个参数，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该API或Cell的第1个参数的第1个子参数；L2norm表示L2范数（平方根）。
-│   |   |   ├── stack.json        # API 调用栈信息
-│   |   |   └── construct.json        # 分层分级结构，level为L1时，construct.json内容为空
+|   |   |   |    ├── Cell.conv1.Conv2D.forward.0.parameters.weight.npy    # 模块参数数据：命名格式为{Cell}.{cell_name}.{class_name}.forward.{调用次数}.parameters.{parameter_name}。
+|   |   |   |    ├── Cell.conv1.Conv2D.parameters_grad.weight.npy   # 模块参数梯度数据：命名格式为{Cell}.{cell_name}.{class_name}.parameters_grad.{parameter_name}。因为同一模块的参数使用同一梯度进行更新，所以参数梯度文件名不包含调用次数。
+|   |   |   |    └── Cell.relu.ReLU.forward.0.input.0.npy        # 命名格式为{Cell}.{cell_name}.{class_name}.{forward/backward}.{调用次数}.{input/output}.{参数序号}, 其中，“参数序号”表示该Cell的第n个参数，例如1，则为第一个参数，若该参数为list格式，则根据list继续排序，例如1.1，表示该Cell的第1个参数的第1个元素。   
+│   |   |   ├── dump.json
+│   |   |   ├── stack.json
+│   |   |   └── construct.json
 │   |   ├── rank1
 |   |   |   ├── dump_tensor_data
 |   |   |   |   └── ...
@@ -311,9 +349,9 @@ dump 结果目录结构示例如下：
 
 * `rank`：设备 ID，每张卡的数据保存在对应的 `rank{ID}` 目录下。非分布式场景下没有 rank ID，目录名称为 rank。
 * `dump_tensor_data`：保存采集到的张量数据。
-* `dump.json`：记录模块或 API 的统计信息。
-* `stack.json`：API调用栈信息。
-* `construct.json`：分层分级结构信息。
+* `dump.json`： 保存API或Cell前反向数据的统计量信息。包含dump数据的API名称或Cell名称，各数据的dtype、 shape、max、min、mean、L2norm（L2范数，平方根）统计信息以及当配置summary_mode="md5"时的CRC-32数据。具体介绍可参考[dump.json文件说明](./27.dump_json_instruction.md#2-dumpjson文件示例mindspore)。
+* `stack.json`：API/Cell的调用栈信息。
+* `construct.json`：分层分级结构，level为L1时，construct.json内容为空。  
 
 dump 过程中，npy 文件在对应API或者模块被执行后就会落盘，而 json 文件则需要在正常执行 PrecisionDebugger.stop() 后才会写入完整数据，因此，程序异常终止时，被执行API对应的 npy 文件已被保存，但 json 文件中的数据可能丢失。
 
@@ -332,6 +370,7 @@ npy文件名的前缀含义如下：
 | Primitive      | mindspore.ops.Primitive API数据      |
 | Mint           | mindspore.mint API数据              |
 | MintFunctional | mindspore.mint.nn.functional API数据 |
+| Distributed    | mindspore.communication.comm_func API数据     |
 | Jit            | 被"jit"装饰的模块或函数数据                |
 | Cell           | mindspore.nn.Cell 类（模块）数据           |
 
@@ -349,4 +388,3 @@ ops:
   - adaptive_avg_pool2d
   - adaptive_avg_pool3d
 ```
-

msprobe/docs/07.accuracy_checker_PyTorch.md

@@ -31,7 +31,7 @@ run_ut 预检操作包括以下两种方式：
 将 API 信息输入到 run_ut 模块进行精度检测并比对，运行如下命令： 
 
 ```bash
-msprobe -f pytorch run_ut -api_info ./dump.json
+msprobe -f pytorch run_ut -api_info ./dump_path/step{step_number}/rank{rank_number}/dump.json
 ```
 
    | 参数名称                     | 解释                                                         | 是否必选                           |
@@ -50,7 +50,7 @@ run_ut 执行结果包括 `accuracy_checking_result_{timestamp}.csv` 和 `accura
 如果需要保存比对不达标的输入和输出数据，可以在 run_ut 执行命令结尾添加 `-save_error_data`，例如：
 
 ```bash
-msprobe -f pytorch run_ut -api_info ./dump.json -save_error_data
+msprobe -f pytorch run_ut -api_info ./dump_path/step{step_number}/rank{rank_number}/dump.json -save_error_data
 ```
 
 数据默认会存盘到 './ut_error_data{timestamp}' 路径下，如有需要，用户可以通过 error_data_path 参数来配置保存路径，error_data_path 参数在 [config.json](../config.json) 文件或 [config.yaml](../pytorch/api_accuracy_checker/config.yaml) 文件配置，config.json 文件需要在 run_ut 操作时通过 -config 参数指定。
@@ -98,7 +98,7 @@ msprobe -f pytorch run_ut -api_info ./dump.json -save_error_data
 multi_run_ut 脚本，可以并行执行多个 run_ut 操作，从而减少预检耗时。示例如下：
 
 ```bash
-msprobe -f pytorch multi_run_ut -api_info ./dump.json -n 32 -d 0 1 2 3
+msprobe -f pytorch multi_run_ut -api_info ./dump_path/step{step_number}/rank{rank_number}/dump.json -n 32 -d 0 1 2 3
 ```
 
 | 参数名称                     | 解释                                                         | 是否必选                           |
@@ -117,7 +117,7 @@ msprobe -f pytorch multi_run_ut -api_info ./dump.json -n 32 -d 0 1 2 3
 断点续检操作通过如下命令执行：
 
 ```bash
-msprobe -f pytorch run_ut -api_info ./dump.json -csv_path /home/xxx/ut/accuracy_checking_result_{timestamp}.csv
+msprobe -f pytorch run_ut -api_info ./dump_path/step{step_number}/rank{rank_number}/dump.json -csv_path /home/xxx/ut/accuracy_checking_result_{timestamp}.csv
 ```
 
 精度预检 run_ut 过程中，若因环境、数据量过大等原因导致预检进程中断，那么当用户解决这些问题后，重新执行 run_ut 操作，可以通过断点续检操作继续前面未完成的预检，会在 -csv_path 指定的 `accuracy_checking_result_{timestamp}.csv` 文件以及对应的 `accuracy_checking_details_{timestamp}.csv` 文件中继续写入后续的结果，不会重新创建结果文件。
@@ -194,15 +194,15 @@ Forward Test Success 和 Backward Test Success 是否通过测试是由 `accurac
 
    判定为小值的阈值：
 
-   - torch.float32：e-6
-   - torch.float16：e-3
-   - torch.bfloat16：e-3
+   - torch.float32：2**-20
+   - torch.float16：2**-10
+   - torch.bfloat16：2**-10
 
    小值域的绝对误差阈值：
 
-   - torch.float32：e-9
-   - torch.float16：e-5
-   - torch.bfloat16：e-5
+   - torch.float32：2**-30
+   - torch.float16：2**-16
+   - torch.bfloat16：2**-16
 
 ## 5 预检结果比对
 
@@ -229,8 +229,8 @@ msprobe -f pytorch api_precision_compare -npu /home/xxx/npu/accuracy_checking_de
 | 字段                  | 含义                                                         |
 | --------------------- | ------------------------------------------------------------ |
 | API name              | API 名称。                                                   |
-| Forward Test Success  | 前向 API 是否通过测试。pass 为通过；warning 为待观察；error 为错误；SKIP 表示跳过该 API 的计算，跳过原因在 Message 字段中提示，包括：该 API 的数据类型不支持使用新精度标准进行比对（如 float64），或该 API 不支持精度预检，或该 API 被黑名单过滤或不在白名单上，或运行错误等。 |
-| Backward Test Success | 反向 API 是否通过测试。pass 为通过；warning 为待观察；error 为错误；如果是空白的话代表该 API 没有反向输出；SKIP 表示该 API 的数据类型不支持使用新精度标准进行比对（如 float64）。 |
+| Forward Test Success  | 前向 API 是否通过测试。pass 为通过；error 为错误；SKIP 表示跳过该 API 的计算，跳过原因在 Message 字段中提示，包括：该 API 的数据类型不支持使用新精度标准进行比对（如 float64），或该 API 不支持精度预检，或该 API 被黑名单过滤或不在白名单上，或运行错误等。 |
+| Backward Test Success | 反向 API 是否通过测试。pass 为通过；error 为错误；如果是空白的话代表该 API 没有反向输出；SKIP 表示该 API 的数据类型不支持使用新精度标准进行比对（如 float64）。 |
 | Message               | 提示信息。                                                   |
 
 Forward Test Success 和 Backward Test Success 是否通过测试是由 `api_precision_compare_details_{timestamp}.csv` 中的各个指标判定结果决定的。需要注意的是 `api_precision_compare_details_{timestamp}.csv` 中可能存在一个 API 的前向（反向）有多个输出，那么每个输出记录一行，而在 `api_precision_compare_result_{timestamp}.csv` 中的结果需要该 API 的所有结果均为 pass 才能标记为 pass，只要存在一个 error 则标记 error，仅存在 warning 和 pass 且不存在 error 标记 warning。
@@ -243,15 +243,15 @@ Forward Test Success 和 Backward Test Success 是否通过测试是由 `api_pre
 | ------------------------ | ------------------------------------------------------------ |
 | API name                 | NPU 或 GPU 下的 API 名称。        |
 | 小值域错误比值           | NPU 与 CPU 的小值域的错误比率 / GPU 与 CPU 的小值域的错误比率。标杆比对法指标。 |
-| 小值域错误判定结果       | 小值域错误比值小于等于 1 标记为 pass，1 ~ 2 之间标记为 warning，大于 2 标记为 error。 |
+| 小值域错误判定结果       | 小值域错误比值小于等于 2 标记为 pass，大于 2 标记为 error。 |
 | 均方根误差比值           | NPU 与 CPU 的均方根误差 / GPU 与 CPU 的均方根误差。标杆比对法指标。  |
-| 均方根误差判定结果       | 均方根误差比值小于等于 1 标记为 pass，1~2 之间标记为 warning，大于 2 标记为 error。 |
+| 均方根误差判定结果       | 均方根误差比值小于等于 2 标记为 pass，大于 2 标记为 error。 |
 | 相对误差最大值比值       | NPU 与 CPU 的相对误差最大值 / GPU 与 CPU 的相对误差最大值。标杆比对法指标。 |
-| 相对误差最大值判定结果   | 相对误差最大值比值小于等于 1 标记为 pass，1 ~ 10 之间标记为 warning，大于 10 标记为 error。 |
+| 相对误差最大值判定结果   | 相对误差最大值比值小于等于 10 标记为 pass，大于 10 标记为 error。 |
 | 相对误差平均值比值       | NPU 与 CPU 的相对误差的平均值 / GPU 与 CPU 的相对误差的平均值。标杆比对法指标。 |
-| 相对误差平均值判定结果   | 相对误差平均值比值小于等于 1 标记为 pass，1 ~ 2 之间标记为 warning，大于 2 标记为 error。 |
+| 相对误差平均值判定结果   | 相对误差平均值比值小于等于 2 标记为 pass，大于 2 标记为 error。 |
 | 误差均衡性比值           | NPU 与 CPU 的误差均衡性 / GPU 与 CPU 的误差均衡性。标杆比对法指标。  |
-| 误差均衡性判定结果       | 误差均衡性比值小于等于 1 标记为 pass，1 ~ 2 之间标记为 warning，大于 2 标记为 error。该字段暂不参与 api_precision_compare_result 的结果判定。 |
+| 误差均衡性判定结果       | 误差均衡性比值小于等于 2 标记为 pass，大于 2 标记为 error。该字段暂不参与 api_precision_compare_result 的结果判定。 |
 | inf / nan 错误率            | NPU 与标杆 inf / nan 计算不一致的元素个数占总元素的个数比例。绝对阈值法指标。 |
 | inf / nan 判定结果          | inf / nan 错误率判定结果，等于 0 标记为 pass，其余情况标记为 error。 |
 | 相对误差错误率           | NPU 与标杆的正常值计算相对误差，其大于错误阈值的元素个数占正常值元素个数的比例。绝对阈值法指标。 |
@@ -286,7 +286,7 @@ a：误差比对法指标。
 
 - npu_linear
 
-- npu_fusion_attention（该算子在 GPU 上预检时，需要额外安装 flash_attn，请用户自行安装。）
+- npu_fusion_attention（该算子在 GPU 上预检时，需要额外安装 flash_attn，请用户自行安装,建议安装2.1以上版本。）
 
 - npu_rms_norm
 

msprobe/docs/09.accuracy_checker_MindSpore.md

@@ -29,7 +29,7 @@ msprobe -f mindspore run_ut -api_info ./dump.json -o ./checker_result
 
 | 参数名称     | 说明                                                                                                                                                                              |参数类型    | 是否必选     |
 | ---------------------------- |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------- | ---------------------------------- |
-| -api_info 或 --api_info_file   | 指定 API 信息文件 dump.json。对其中的mint api以及部分Tensor api进行预检                                                                                                                                           |  str      | 是      |
+| -api_info 或 --api_info_file   | 指定 API 信息文件 dump.json。对其中的mint api以及部分Tensor api进行预检，预检支持的Tensor api列表详见 [ 预检支持列表](../mindspore/api_accuracy_checker/checker_support_api.yaml)。            |  str      | 是      |
 | -o 或 --out_path    | 指定预检结果存盘路径，默认“./”。                                                                                                                                                              |   str   | 否      |
 | -csv_path 或 --result_csv_path | 指定本次运行中断时生成的 `accuracy_checking_result_{timestamp}.csv` 文件路径，执行 run_ut 中断时，若想从中断处继续执行，配置此参数即可。需要指定为上次中断的 `accuracy_checking_result_{timestamp}.csv` 文件。详见 [3.3 断点续检](#33-断点续检)。  |  str   | 否      |
 
@@ -45,12 +45,12 @@ msprobe -f mindspore multi_run_ut -api_info ./dump.json -d 0 1 2 3
 
 | 参数名称     | 说明                                                                                                                                                                              |参数类型    | 是否必选     |
 | ---------------------------- |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------- | ---------------------------------- |
-| -api_info 或 --api_info_file   | 指定 API 信息文件 dump.json。对其中的mint api以及部分Tensor api进行预检                                                                                                                                   |  str      | 是      |
+| -api_info 或 --api_info_file   | 指定 API 信息文件 dump.json。对其中的mint api以及部分Tensor api进行预检，预检支持的Tensor api列表详见 [ 预检支持列表](../mindspore/api_accuracy_checker/checker_support_api.yaml)。                                   |  str      | 是      |
 | -o 或 --out_path    | 指定预检结果存盘路径，默认“./”。                                                                                                                                                              |   str   | 否      |
 | -csv_path 或 --result_csv_path | 指定本次运行中断时生成的 `accuracy_checking_result_{timestamp}.csv` 文件路径，执行 run_ut 中断时，若想从中断处继续执行，配置此参数即可。需要指定为上次中断的 `accuracy_checking_result_{timestamp}.csv` 文件。详见 [3.3 断点续检](#33-断点续检)。 |  str   | 否      |
-| -d 或 --device                 | 指定 Device ID，选择 UT 代码运行所在的卡，默认值为 0，支持同时指定 0 ~ Device数量的N - 1 ，例如 0 1 2 3 4                                  |                                      List[int]  | 否      |
-
+| -d 或 --device                 | 指定 Device ID，选择 UT 代码运行所在的卡，默认值为 0，支持同时指定 0 ~ Device数量 - 1 ，例如 0 1 2 3 4。                                 |                                      List[int]  | 否      |
 
+在不同卡数下，使用38B语言大模型的预检耗时基线参考 [multi_run_ut耗时基线](accuracy_checker_MindSpore/accuracy_checker_MindSpore_baseline.md)
 
 
 ### 3.3 断点续检