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

msprobe/docs/data_dump_MindSpore/data_dump_MindSpore_baseline.md

@@ -0,0 +1,22 @@
+# MindSpore 场景的精度数据采集基线
+
+## "tensor"模式采集数据量参考基线
+
+该基线为MindSpore框架下，使用"tensor"模式采集数据量参考基线。本基线测试了38B语言大模型在不同采集模式下，不同global_batch_size下，单卡和8卡下，数据量的变化。
+
+### 38B语言大模型
+
+<table>
+    <tr><th>采集模式</th><th>global_batch_size</th><th>单卡</th><th>8卡</th></tr>
+    </td><td rowspan="3">L0</td><td>1</td><td>262GB</td><td>2.1T</td></tr>
+    <tr><td>2</td><td>480GB</td><td>3.8T</td></tr>
+    <tr><td>3</td><td>928GB</td><td>7.4T</td></tr>
+    </td><td rowspan="3">L1</td><td>1</td><td>2.1TB</td><td>17.1TB</td></tr>
+    <tr><td>2</td><td>2.8T</td><td>22.7TB</td></tr>
+    <tr><td>3</td><td>4.2T</td><td>34.3TB</td></tr>
+    </td><td rowspan="3">mix</td><td>1</td><td>2.4T</td><td>19.2TB</td></tr>
+    <tr><td>2</td><td>3.3TB</td><td>26.6TB</td></tr>
+    <tr><td>3</td><td>5.1TB</td><td>41.4TB</td></tr>
+
+</table>
+

msprobe/docs/data_dump_MindSpore/dynamic_graph_quick_start_example.md

@@ -0,0 +1,211 @@
+# 动态图精度数据采集快速入门示例
+
+本示例将展示如何在 MindSpore 动态图模式下使用 msprobe 工具进行精度数据采集。
+
+## 1. 配置文件
+
+请在当前目录下创建一个名为 `config.json` 的配置文件，内容如下：
+
+```json
+{
+    "task": "statistics",
+    "dump_path": "./output",
+    "rank": [],
+    "step": ["0-2"],
+    "level": "L1",
+    "statistics": {
+        "scope": [],
+        "list": [],
+        "data_mode": [
+            "all"
+        ],
+        "summary_mode": "statistics"
+    }
+}
+
+```
+以上配置参数详细介绍和使用请参见[《config.json 配置文件介绍》](../02.config_introduction.md)和[《config.json 配置示例》](../03.config_examples.md#3-mindspore-动态图场景) 中的“MindSpore动态图场景”。
+
+## 2. 模型脚本
+
+在当前目录下创建一个 Python 脚本文件，例如 `alexnet_model.py`，将以下代码粘贴进去：
+
+```python
+import os
+import numpy as np
+import mindspore as ms
+from mindspore import nn, ops
+from mindspore import context
+from mindspore import Tensor
+from msprobe.mindspore import PrecisionDebugger, seed_all
+
+# 设置随机种子以确保结果可重现
+seed_all(seed=1234, mode=False, rm_dropout=True)
+
+# 配置文件路径
+script_dir = os.path.dirname(os.path.abspath(__file__))
+config_path = os.path.join(script_dir, 'config.json')
+
+# 初始化精度调试器
+debugger = PrecisionDebugger(config_path=config_path)
+
+# 设置 MindSpore 设备上下文
+context.set_context(mode=ms.PYNATIVE_MODE, device_target="Ascend", device_id=0)
+
+# 定义卷积层
+def conv_layer(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode="valid", has_bias=True):
+    return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding,
+                     has_bias=has_bias, pad_mode=pad_mode)
+
+# 定义全连接层
+def fc_layer(input_channels, out_channels, has_bias=True):
+    return nn.Dense(input_channels, out_channels, has_bias=has_bias)
+
+
+class AlexNet(nn.Cell):
+    """
+    AlexNet 模型定义
+
+    参数:
+    - num_classes: 分类数量
+    - channel: 输入通道数（图像的颜色通道数）
+    - phase: 模型运行阶段（'train' 或 'test'）
+    - include_top: 是否包含全连接层的顶部（最后的分类层）
+    """
+    def __init__(self, num_classes=10, channel=3, phase='train', include_top=True):
+        super(AlexNet, self).__init__()
+
+        # 卷积层
+        self.conv1 = conv_layer(channel, 64, 11, stride=4, pad_mode="same")
+        self.conv2 = conv_layer(64, 128, 5, pad_mode="same")
+        self.conv3 = conv_layer(128, 192, 3, pad_mode="same")
+        self.conv4 = conv_layer(192, 256, 3, pad_mode="same")
+        self.conv5 = conv_layer(256, 256, 3, pad_mode="same")
+
+        # 激活函数和池化层
+        self.relu = nn.ReLU()
+        self.max_pool2d = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='valid')
+
+        # 如果包括顶部（全连接层）
+        self.include_top = include_top
+        if self.include_top:
+            self.flatten = nn.Flatten()
+            self.fc1 = fc_layer(256 * 28 * 28, 4096)
+            self.fc2 = fc_layer(4096, 4096)
+            self.fc3 = fc_layer(4096, num_classes)
+
+        # 数学操作
+        self.add = ops.Add()
+        self.mul = ops.Mul()
+
+    def construct(self, x):
+        """定义前向传播过程"""
+
+        x = self.conv1(x)
+        x = self.add(x, 0.1)  # 偏置加法
+        x = self.mul(x, 2.0)  # 乘法操作
+        x = self.relu(x)  # ReLU 激活函数
+        x = ops.celu(x) 
+        x = x + 2
+
+        # 打印每层输出形状，调试时可使用
+        print(f"After Conv1: {x.shape}")
+
+        x = self.max_pool2d(x)  # Max pooling 操作
+        print(f"After MaxPool: {x.shape}")  # 打印池化后的形状
+
+        x = self.conv2(x)
+        x = self.relu(x)
+
+        x = self.conv3(x)
+        x = self.relu(x)
+
+        x = self.conv4(x)
+        x = self.relu(x)
+
+        x = self.conv5(x)
+        x = self.relu(x)
+
+        # 打印卷积层后的形状，调试时使用
+        print(f"After Conv5: {x.shape}")
+
+        # 可选的全连接层部分
+        if self.include_top:
+            x = self.flatten(x)
+            x = self.fc1(x)
+            x = self.fc2(x)
+            x = self.fc3(x)
+
+        return x
+
+# 前向函数
+def forward_fn(data, label):
+    out = net(data)
+    loss = criterion(out, label)
+    return loss
+
+# 训练步骤
+def train_step(data, label):
+    loss, grads = grad_fn(data, label)
+    optimizer(grads)
+    return loss
+
+# 测试模型
+if __name__ == "__main__":
+    net = AlexNet()
+    optimizer = nn.SGD(net.trainable_params(), learning_rate=0.01)
+    criterion = nn.MSELoss()
+
+    grad_fn = ms.value_and_grad(forward_fn, None, optimizer.parameters)
+
+    # 生成数据和标签
+    batch_size = 1
+    num_classes = 10
+    data = np.random.normal(1, 1, (batch_size, 3, 227, 227)).astype(np.float32)
+    label = np.random.randint(0, num_classes, (batch_size,)).astype(np.float32)  # 注意此处类型应为 float32
+
+    # 转换为 MindSpore 张量
+    data = Tensor(data)
+    label = Tensor(label)
+
+    steps = 5
+    for i in range(steps):
+        debugger.start(net)  # 启动调试器
+        loss = train_step(data, label)  # 执行训练步骤
+        print(f"Step {i}, Loss: {loss}")
+        debugger.stop()  # 停止调试器
+        debugger.step()  # 计数步数
+```
+
+## 3. 运行训练脚本
+
+在命令行中执行以下命令：
+
+```bash
+python alexnet_model.py
+```
+
+## 4. 查看采集结果
+
+执行训练命令后，工具会将模型训练过程中的精度数据采集下来。
+
+日志中打印出现如下信息表示数据采集成功，即可手动停止模型训练查看采集数据。
+
+```markdown
+****************************************************************************
+*                        msprobe ends successfully.                        *
+****************************************************************************
+```
+
+## 5. 数据分析
+
+在 `dump_path` 参数指定的路径下（本例中为 `./output`），会出现如下目录结构，后续精度数据分析操作可使用 msprobe 工具的精度预检和精度比对等功能，详细流程请参见[《msprobe使用手册》](../../README.md#2-精度预检)。：
+
+```bash
+output/
+└── step0
+    └── rank
+        ├── construct.json             # level为L0时，保存Cell的层级关系信息。当前场景为空
+        ├── dump.json                  # 保存API前反向输入输出数据的统计量信息
+        └── stack.json                 # 保存API的调用栈
+```

msprobe/docs/visualization/layer_mapping_example.md

@@ -0,0 +1,132 @@
+# 模型分级可视化如何配置layer mapping映射文件
+
+## 1.使用场景
+同框架跨套件比对（例如PyTorch DeepSpeed vs Megatron），或者跨框架比对（例如PyTorch vs MindSpore），**由于代码实现的差异，导致一些模型层级和层级命名有所不同无法进行匹配**，需要进行layer层名称映射，才能够比对。
+
+## 2.模块命名说明
+
+由于有些节点的名称比较长，例如Module.module.module.language_model.embedding.Embedding.forward.0，在图节点上由于字符串过长无法完整显示，forward或backward信息被省略，**因此节点中显示的名称字符串去掉了Module前缀，并将forward或backward信息提取到名称字符串的第二位展示**。
+
+![module_name.png](./module_name.png)
+
+![module_name1.png](./module_name1.png)
+
+### 2.1 命名格式
+
+**{Module}.{module_name}.{class_name}.{forward/backward}.{调用次数}**
+
+**layer mapping主要是针对module_name的映射**
+
+#### 2.1.1 命名示例
+
+- **Module.module.Float16Module.forward.0** -----> Module{**Module**}.module{**module_name**}.Float16Module{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.GPTModel.forward.0** -----> Module{**Module**}.module.module{**module_name**}.GPTModel{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.language_model.TransformerLanguageModel.forward.0** -----> Module{**Module**}.module.module.language_model{**module_name**}.TransformerLanguageModel{**class_name**}.forward.0{**调用次数**}
+- **Module.module.module.language_model.embedding.Embedding.forward.0** -----> Module{**Module**}.module.module.language_model.embedding{**module_name**}.Embedding{**class_name**}.forward.0{**调用次数**}
+
+可以看到，module_name随着模型层级的深入在变长，**embedding层module_name拼接了它的上层language_model、上上层module和顶层module**。
+
+## 3.示例
+
+如图所示，左边为NPU模型，右边为GPU模型，由于代码实现上的差异，导致模型层级和层级命名有所不同，导致节点无法匹配，**图上节点显示为灰色，表示节点未匹配**。
+
+![no_mapping.png](./no_mapping.png)
+
+### 3.1 看图分析
+
+同一模型使用了不同套件或者框架，虽然两个模型的层级关系和层级命名可能有所不同，但也可以从图上的**节点名称**看出一些匹配关系，例如同是embedding层，代码里也是会命名为xxx_embedding，不会命名为xxx_norm，体现在节点名称上也是带有embedding的信息，并且层级关系也是大致相同的。
+
+![no_mapping_analyze.png](./no_mapping_analyze.png)
+
+分析可知，节点匹配关系如下：
+
+**注意，仅需关注module_name的差异**
+
+| NPU节点名称           | GPU节点名称                                                        | module_name差异                        |
+|-------------------|----------------------------------------------------------------|---------------------------|
+| Module.module.Float16Module.forward.0 | Module.model.FloatModule.forward.0                                 | NPU为module，GPU为model      |
+| Module.module.module.GPTModel.forward.0 | Module.model.module.GPT2Model.forward.0                            | NPU为module，GPU为module，无差异 |
+| Module.module.module.language_model.TransformerLanguageModel.forward.0 | 无                                                              | NPU多了一层                   |
+| Module.module.module.language_model.embedding.Embedding.forward.0 | Module.module.module.embedding.LanguageModelEmbedding.forward.0  | NPU为language_model.embedding，GPU为embedding           |
+| Module.module.module.language_model.rotary_pos_emb.RotaryEmbedding.forward.0 | Module.module.module.rotary_pos_emb.RotaryEmbedding.forward.0    | NPU为language_model.rotary_pos_emb，GPU为rotary_pos_emb |
+| Module.module.module.language_model.encoder.ParallelTransformer.forward.0 | Module.module.module.decoder.TransformerBlock.forward.0          | NPU为language_model.encoder，GPU为decoder               |
+| Module.module.module.language_model.encoder.layers.0.ParallelTransformerLayer.forward.0 | Module.module.module.decoder.layers.0.TransformerLayer.forward.0 | 父层级有差异，本层级NPU和GPU都叫layers，无差异                        |
+
+### 3.2 构建layer_mapping配置文件
+准备一个命名为mapping.yaml文件，建立**module_name**的映射关系
+
+#### 3.2.1 顶层模块映射
+NPU和GPU侧的模块Module.module.Float16Module.forward.0和Module.model.FloatModule.forward.0处于图的顶层，需要进行如下配置：
+
+![top_layer.png](./top_layer.png)
+
+```yaml
+TopLayer:
+  module: model
+```
+
+#### 3.2.2 其他模块映射
+配置module下的子模块，虽然两边的class_name不同（NPU侧为GPTModel，GPU侧为GPT2Model），**但是仅需取NPU侧也就是左边图的class_name进行配置，无需关心右边图的class_name叫什么**。
+
+**这里涉及到跨层级的配置，NPU多了一层language_model层**，将language_model作为embedding层、rotary_pos_emb层和encoder层的前缀，进行如下配置：
+
+![GPTModel.png](./GPTModel.png)
+
+```yaml
+GPTModel:
+    language_model.embedding: embedding
+    language_model.rotary_pos_emb: rotary_pos_emb
+    language_model.encoder: decoder
+```
+然后看Module.module.module.language_model.encoder.ParallelTransformer.forward.0层下的子模块：
+
+此层下的若干个层，NPU和GPU的层名都叫layers，**当前层名称相同，则不用进行配置**。
+
+### 3.3 查看效果
+
+执行命令，指定-lm：
+```
+msprobe -f pytorch graph -i ./compare.json -o ./output -lm ./mapping.yaml
+```
+或
+```
+msprobe -f mindspore graph -i ./compare.json -o ./output -lm ./mapping.yaml
+```
+可以看到，除了language_model层（NPU多的一层，GPU没有层与其匹配），其余在mapping.yaml文件配置的层均匹配上了。
+
+![mapping.png](./mapping.png)
+
+### 3.4 继续配置
+
+展开节点过程中，如果发现还有未匹配节点，则继续配置mapping.yaml
+
+![no_mapping1.png](./no_mapping1.png)
+
+按前一章过程进行分析配置，分析可知，节点匹配关系如下：
+
+| NPU节点名称           | GPU节点名称                                                          | 差异                                          |
+|-------------------|------------------------------------------------------------------|---------------------------------------------|
+| Module.module.module.language_model.encoder.layers.0.mlp.dense_h_to_4h.ColumnParallelLinear.forward.0 | Module.module.module.decoder.layers.0.mlp.linear_fc1.TELayerNormColumnParallelLinear.forward.0      | NPU为dense_h_to_4h，GPU为linear_fc1            |
+| Module.module.module.language_model.encoder.layers.0.mlp.dense_4h_to_h.RowParallelLinear.forward.0 | Module.module.module.decoder.layers.0.mlp.linear_fc2.TERowParallelLinear.forward.0  | NPU为dense_4h_to_h，GPU为linear_fc2 |
+
+![ParallelMLP.png](./ParallelMLP.png)
+
+追加mapping.yaml配置：
+
+```yaml
+TopLayer:
+  module: model
+
+GPTModel:
+    language_model.embedding: embedding
+    language_model.rotary_pos_emb: rotary_pos_emb
+    language_model.encoder: decoder
+
+ParallelMLP:
+    dense_h_to_4h: linear_fc1
+    dense_4h_to_h: linear_fc2
+```
+
+执行命令，查看效果，可以看到节点已成功匹配上。
+
+![mapping1.png](./mapping1.png)

msprobe/mindspore/__init__.py

@@ -1,2 +1,27 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+try:
+    from msprobe.lib import _msprobe_c
+    os.environ["MS_HOOK_ENABLE"] = "on"
+    os.environ["HOOK_TOOL_PATH"] = _msprobe_c.__file__
+except ImportError:
+    from .common.log import logger
+    logger.info("Module _msprobe_c has not been installed. L2-Dump may not work normally.")
+
 from msprobe.mindspore.debugger.precision_debugger import PrecisionDebugger
 from msprobe.mindspore.common.utils import seed_all