mindstudio-probe 8.1.2__py3-none-any.whl → 8.2.1__py3-none-any.whl

msprobe/docs/28.debugger_save_instruction.md

@@ -1,7 +1,9 @@
 # 单点保存工具
 
 ## 简介
+
 L0, L1, mix级别的dump能力存在盲区，网络中的非API或module的输入输出不会被批量dump下来。单点保存提供类似np.save和print的功能和使用体验，可以保存指定的变量。同时针对大模型场景进行了增强，具备以下特性：
+
 - 可保存变量的反向梯度结果。
 - 能直接保存嵌套结构数据（如 list、dict），无需手动遍历。
 - 自动分 Rank 保存。
@@ -10,29 +12,32 @@ L0, L1, mix级别的dump能力存在盲区，网络中的非API或module的输
 - 可配置保存统计值（MindSpore静态图暂不支持）或者张量。
 - 支持异步保存。
 
+单点保存工具的使用过程中可能会涉及到工具跨文件使用的场景，具体使能方式见[跨文件采集数据](./05.data_dump_PyTorch.md#24-跨文件采集数据)。
+
 ## 支持场景
 
 ## 动态图场景（Pytorch&MindSpore）
 
-###  使能方式
+### 使能方式
 
 #### 配置文件说明
 
 通用配置 （细节详见[通用配置说明](./02.config_introduction.md#11-通用配置) ）：
 
-| 参数     | 解释                                       | 是否必选 |
-| -------- |-------------------------------------------| -------- |
-| task     | dump 的任务类型，str 类型。 单点保存场景仅支持传入"statistics", "tensor"。    |  是     |
-| level    | dump 级别，str 类型，根据不同级别采集不同数据。单点保存场景传入"debug"。  | 是  |
-| dump_path  | 设置 dump 数据目录路径，str 类型。 | 是       |
-| rank        | 指定对某张卡上的数据进行采集，list[Union[int, str]] 类型。  | 否       |
-| step    |   指定采集某个 Step 的数据，list[Union[int, str]] 类型。  | 否       |
-| async_dump        | 异步 dump 开关，bool 类型。  | 否       |
+| 参数       | 解释                                                                                                    | 是否必选 |
+| ---------- | ------------------------------------------------------------------------------------------------------- | -------- |
+| task       | dump 的任务类型，str 类型。 单点保存场景仅支持传入"statistics", "tensor"。                              | 是       |
+| level      | dump 级别，str 类型，根据不同级别采集不同数据。单点保存场景传入"debug"。                                | 是       |
+| dump_path  | 设置 dump 数据目录路径，str 类型。                                                                      | 是       |
+| rank       | 指定对某张卡上的数据进行采集，list[Union[int, str]] 类型。                                              | 否       |
+| step       | 指定采集某个 Step 的数据，list[Union[int, str]] 类型。                                                  | 否       |
+| async_dump | 异步 dump 开关，bool 类型。该模式下，summary_mode 不支持 md5 值，也不支持复数类型 tensor 的统计量计算。 | 否       |
 
 "statistics" 任务子配置项：
-| 参数     | 解释                                       | 是否必选 |
-| -------- |-------------------------------------------| -------- |
-| summary_mode     | 控制 dump 文件输出的模式，str 类型。支持传入"statistics", "md5"。 细节详见[statistics任务子配置项说明](./02.config_introduction.md#12-task-配置为-statistics)    |  否     |
+
+| 参数         | 解释                                                                                                                                                       | 是否必选 |
+| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| summary_mode | 控制 dump 文件输出的模式，str 类型。支持传入"statistics", "md5"。 细节详见[statistics任务子配置项说明](./02.config_introduction.md#12-task-配置为-statistics) | 否       |
 
 "tensor" 任务无子配置项。
 
@@ -41,8 +46,10 @@ L0, L1, mix级别的dump能力存在盲区，网络中的非API或module的输
 调用PrecisionDebugger.save，传入需要保存的变量，指定变量名称以及是否需要保存反向数据。接口入参说明详见[PyTorch单点保存接口](./05.data_dump_PyTorch.md#19-save)，[MindSpore单点保存接口](./06.data_dump_MindSpore.md#615-save)
 
 #### 实例
+
 （以PyTorch场景为例，MindSpore场景只需要从msprobe.mindspore模块导包即可）
 配置文件
+
 ```json
 {
     "task": "statistics",
@@ -58,6 +65,7 @@ L0, L1, mix级别的dump能力存在盲区，网络中的非API或module的输
 ```
 
 初始化
+
 ```python
 # 训练启动py脚本
 from msprobe.pytorch import PrecisionDebugger
@@ -69,6 +77,7 @@ for data, label in data_loader:
 ```
 
 初始化（无配置文件）
+
 ```python
 # 训练启动py脚本
 from msprobe.pytorch import PrecisionDebugger
@@ -79,12 +88,74 @@ for data, label in data_loader:
 
 ```
 
-调用保存接口
+调用保存接口示例（以PyTorch代码为例，MindSpore使用方法相同）
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from msprobe.pytorch import PrecisionDebugger, seed_all
+# 在模型训练开始前实例化PrecisionDebugger
+debugger = PrecisionDebugger(dump_path="dump_path", level="debug")
+
+# 定义网络
+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)
+
+    def forward(self, x):
+        x1 = self.linear_1(x)
+        x2 = self.linear_2(x1)
+        debugger.save(x2, "x2", save_backward=True)  # 调用save接口
+        r1 = F.relu(x2)
+        return r1
+
+if __name__ == "__main__":
+    module = ModuleOP()
+
+    x = torch.randn(10, 8)
+    out = module(x)
+    loss = out.sum()
+    loss.backward()
+```
+
+分step保存数据（以PyTorch代码为例，MindSpore使用方法相同）
+
 ```python
-# 训练过程中被调用py文件
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
 from msprobe.pytorch import PrecisionDebugger
-dict_variable = {"key1": "value1", "key2": [1, 2]}
-PrecisionDebugger.save(dict_variable, "dict_variable", save_backward=False)
+# 在模型训练开始前实例化PrecisionDebugger
+debugger = PrecisionDebugger(dump_path="dump_path", level="debug")
+
+# 定义网络
+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)
+
+    def forward(self, x):
+        x1 = self.linear_1(x)
+        x2 = self.linear_2(x1)
+        debugger.save(x2, "x2", save_backward=True)  # 调用save接口
+        r1 = F.relu(x2)
+        return r1
+
+if __name__ == "__main__":
+    module = ModuleOP()
+    train_iter = 10
+    for i in range(train_iter):
+        x = torch.randn(10, 8)
+        out = module(x)
+        loss = out.sum()
+        loss.backward()
+        debugger.step()  # 调用debugger.step用于区分step保存
 
 ```
 
@@ -92,94 +163,126 @@ PrecisionDebugger.save(dict_variable, "dict_variable", save_backward=False)
 
 ### 使能方式
 
-#### 接口调用说明
-工具提供两个对外接口`save`和`save_grad`，分别用于保存训练中的tensor以及tensor对应的反向数据
-| 接口名称 | 入参   | device         | MindSpore版本 |备注                                                         |
-| ------- | ------ | -------------- | --------------|--------------------------------------------------- |
-| save     | save_dir name, data    | Ascend   | >= 2.6.0   |  （主流场景）图模式下只支持Ascend，pynative下支持Ascend/GPU/CPU。         |
-| save_grad | save_dir, name, data | Ascend     | >= 2.6.0   |  （主流场景）图模式下只支持Ascend，pynative下支持Ascend/GPU/CPU。         |
-
-
-----
-> 函数原型:
-`save(save_dir:str, name:str, data)`
-- save_dir：表示要保存的目录。
-- name    ：表示要保存的文件标志名称。
-- data    ：表示数据入参，可以是`mindspore.Tensor`或者是`List`,`Tuple`,`Dict`等嵌套结构。
-
-> 函数原型：
-`save_grad(save_dir:str, name:str, data)`
-- save_dir：表示要保存的目录。
-- name    ：表示要保存的文件标志名称。
-- data    ：表示数据入参，**只能**是`mindspore.Tensor`。
+### 接口说明
 
-#### 实例
+工具提供三个对外接口用于保存训练过程中的数据：
+
+| 接口名称  | 功能描述                 | 支持设备       | MindSpore版本 | 使用场景说明                                   |
+| --------- | ------------------------ | -------------- | ------------- | ---------------------------------------------- |
+| save      | 保存正向传播的tensor数据 | Ascend/GPU/CPU | >= 2.6.0      | 图模式下仅支持Ascend，PyNative模式下支持全平台 |
+| save_grad | 保存反向传播的梯度数据   | Ascend/GPU/CPU | >= 2.6.0      | 图模式下仅支持Ascend，PyNative模式下支持全平台 |
+| step      | 更新训练步数             | Ascend/GPU/CPU | >= 2.6.0      | 控制数据保存的step目录                         |
 
-- save接口使用：
+### 详细接口定义
+
+#### 1. save 接口
 
 ```python
-# save api usage
-# **first import**
-from msprobe.mindspore import save
+save(save_dir: str, name: str, data: Union[Tensor, List, Tuple, Dict])
+```
+
+**参数说明**:
+
+- `save_dir`: 数据保存目录路径
+- `name`: 数据标识名称（将作为文件名前缀）
+- `data`: 支持多种数据类型：
+  - `mindspore.Tensor` 单个张量
+  - `List/Tuple/Dict` 嵌套结构（会自动展开保存）
 
+**使用示例**:
+
+```python
+from msprobe.mindspore import save
 
 class Net(nn.Cell):
-    def construct(self, x, y, z):
-        # **use save api**
-        save("./test_dump", 'x', x)
-        return x * y * z
-
-x = Tensor([1, 2], ms.float32)
-y = Tensor([-2, 3], ms.float32)
-z = Tensor([0, 3], ms.float32)
-net = Net()
-output = grad(net, grad_position=(1, 2))(x, y, z)
-time.sleep(1)
-
-# then will generate **./test_dump/step0/rank0/x_float32_0.npy**
+    def construct(self, x):
+        save("./dump_data", 'input', x)  # 保存输入数据
+        return x * 2
+```
+
+#### 2. save_grad 接口
+
+```python
+save_grad(save_dir: str, name: str, data: Tensor) -> Tensor
 ```
 
-- save_grad接口使用：
+**参数说明**:
+
+- `save_dir`: 梯度保存目录路径
+- `name`: 梯度标识名称（将作为文件名前缀）
+- `data`: 必须是 `mindspore.Tensor`类型
+
+**特别注意**:
+
+- 必须接收返回值并传回原计算图
+- 此操作不会影响计算精度
+
+**使用示例**:
 
 ```python
-# save_grad usage
-# **first import**
 from msprobe.mindspore import save_grad
+
 class Net(nn.Cell):
-    def construct(self, x, y, z):
-        # **use save api** the return value of save_grad must be received by origin
-        z = save_grad("./test_dump", 'z', z)
-        return x * y * z
-
-x = Tensor([1, 2], ms.float32)
-y = Tensor([-2, 3], ms.float32)
-z = Tensor([0, 3], ms.float32)
-net = Net()
-output = grad(net, grad_position=(1, 2))(x, y, z)
-time.sleep(1)
-
-# then will generate **./test_dump/step0/rank0/z_grad_float32_0.npy**
+    def construct(self, x):
+        x = save_grad("./dump_data", 'grad', x)  # 保存梯度数据
+        return x * 2
+```
+
+#### 3. step 接口
+
+```python
+step()
+```
+
+**功能说明**:
+
+- 递增训练步数计数器
+- 控制数据保存到不同的step目录（如step0/, step1/等）
+- 如果不调用，所有数据会保存到同一个step目录
+
+**使用示例**:
+
+```python
+from msprobe.mindspore import save, step
+
+# 训练循环中
+for epoch in range(epochs):
+    train_one_epoch()
+    step()  # 每个epoch后更新step
 ```
-**注意**save_grad需要将返回值回传给原tensor，此操作不会有精度影响，只会传递原值。
 
 
 ## 输出结果
+
 ### 动态图场景（Pytorch&MindSpore）
-  * **"task" 配置为 "statistics" 场景** ：在 dump 目录下会生成包含变量统计值信息的 `debug.json` 文件。
+
+* **"task" 配置为 "statistics" 场景** ：在 dump 目录下会生成包含变量统计值信息的 `debug.json` 文件。
   `debug.json` 中统计值的key命名格式为 `{variable_name}{grad_flag}.{count}.debug`。
-  * **"task" 配置为 "tensor" 场景** ：除了在 dump 目录下生成包含变量统计值信息的 `debug.json` 文件外，还会在 dump 子目录 `dump_tensor_data` 中保存张量二进制文件，文件名称格式为 `{variable_name}{grad_flag}.{count}.debug.{indexes}.{file_suffix}`。
+* **"task" 配置为 "tensor" 场景** ：除了在 dump 目录下生成包含变量统计值信息的 `debug.json` 文件外，还会在 dump 子目录 `dump_tensor_data` 中保存张量二进制文件，文件名称格式为 `{variable_name}{grad_flag}.{count}.debug.{indexes}.{file_suffix}`。
 
-    - variable_name： 传入save接口的变量名称。
-    - grad_flag： 反向数据标识，反向数据为"_grad"，正向数据为""。
-    - count： 调用计数，多次以相同变量名称调用时的计数。
-    - indexes： 索引，在保存嵌套结构数据时的索引。例如：嵌套结构为`{"key1": "value1", "key2": ["value2", "value3"]}`，"value2"的索引为"key2.0"。
-    - file_suffix：文件后缀，PyTorch场景为"pt"，MindSpore场景为"npy"。
+  - variable_name： 传入save接口的变量名称。
+  - grad_flag： 反向数据标识，反向数据为"_grad"，正向数据为""。
+  - count： 调用计数，多次以相同变量名称调用时的计数。
+  - indexes： 索引，在保存嵌套结构数据时的索引。例如：嵌套结构为 `{"key1": "value1", "key2": ["value2", "value3"]}`，"value2"的索引为"key2.0"。
+  - file_suffix：文件后缀，PyTorch场景为"pt"，MindSpore场景为"npy"。
 
 ### 静态图场景（MindSpore）
-在指定目录`save_dir`下生成`{step}/{rank}`目录，目录下生成指定`{name}`的npy文件，如果是save_grad接口调用，则会生成`{name}_grad`的npy文件。
 
-如`save("./test_dump", 'x', x)` -> `./test_dump/step0/rank0/x_float32_0.npy`。
+在指定目录 `save_dir`下生成 `{step}/{rank}`目录，目录下生成指定 `{name}`的npy文件，如果是save_grad接口调用，则会生成 `{name}_grad`的npy文件。
 
-或如`z = save_grad("./test_dump", 'z', z)` -> `./test_dump/step0/rank0/z_grad_float32_0.npy`。
+如 `save("./test_dump", 'x', x)` -> `./test_dump/step0/rank0/x_float32_0.npy`。
 
+或如 `z = save_grad("./test_dump", 'z', z)` -> `./test_dump/step0/rank0/z_grad_float32_0.npy`。
 
+结构如下：
+
+```
+./save_dir/
+    ├── step0/
+    │   ├── rank0/
+    │   │   ├── x_float32_0.npy       # save保存的正向数据
+    │   │   └── z_grad_float32_0.npy  # save_grad保存的梯度数据
+    ├── step1/
+    │   ├── rank0/
+    │   │   ├── ...
+```

msprobe/docs/29.data_dump_MSAdapter.md

@@ -4,6 +4,12 @@ MSAdapter 是一款 MindSpore 生态适配工具，可以将 PyTorch 训练脚
 
 msprobe 工具主要通过在训练脚本内添加 dump 接口、启动训练的方式采集精度数据。
 
+**注意**：
+
+- 为了正确识别 MSAdapter 场景，在导入 msprobe 工具前，需完成 torch 模块的导入。
+
+- 因 MindSpore 框架自动微分机制的限制，dump 数据中可能会缺少原地操作模块/API 及其上一个模块/API 的反向数据。
+
 本工具提供固定的 API 支持列表，若需要删除或增加 dump 的 API，可以在 msprobe/pytorch/hook_module/support_wrap_ops.yaml 文件内手动修改，如下示例：
 
 ```yaml

msprobe/docs/31.config_check.md

@@ -35,7 +35,7 @@ msprobe -f pytorch/mindspore config_check -d **.sh **.yaml -o output_path
 
 -d或--dump 代表数据采集模式，可传入启动训练的 shell 脚本路径或 yaml 配置文件路径，可选，不传入代表不采集。
 
--o或--output 代表输出路径，可选，默认为 config_check_pack.zip。
+-o或--output 代表输出路径，可选，默认为 config_check_pack.zip，必须以 `.zip` 后缀结尾。
 
 #### 动态数据采集
 
@@ -55,7 +55,7 @@ apply_patches：启动数据采集所需的各项patch，参数如下：
 在模型初始化好之后插入如下代码：
 ```
 from msprobe.core.config_check import ConfigChecker
-ConfigChecker(model, shell_path, output_zip_path, fmk)
+ConfigChecker(model=model, shell_path="", output_zip_path="./config_check_pack.zip", fmk="pytorch")
 ```
 
 说明：
@@ -103,3 +103,5 @@ msprobe -f pytorch config_check -c bench_zip_path cmp_zip_path -o output_path
 
 1. 在使用 MindSpeed-LLM 进行数据采集时，需要注意动态数据采集中的 [apply_patches](#动态数据采集) 函数需要在 MindSpeed-LLM 
 框架 pretrain_gpt.py 的 megatron_adaptor 函数导入之后执行。
+
+2. 静态数据采集功能只能获取到系统中的环境变量，shell 脚本中解析的超参不支持复杂运算的数据还原，有类似问题时建议使用[动态采集方式](#动态数据采集)。

msprobe/docs/36.calculation_result_change.md

@@ -0,0 +1,75 @@
+# 模型计算结果改变原因分析
+
+## 介绍
+在模型训练场景下，使用seed_all接口同时固定随机性和打开计算，通信确定性计算，是能够保证模型跑两次得到的loss和gnorm结果完全一样。如果出现使能工具后loss或者gnorm出现偏差，可能是以下原因导致。
+
+## 工具引入同步导致计算结果变化
+工具采集统计量数据时，会涉及到将device上的tensor计算后的统计量信息通过item的时候传到cpu侧，再落盘到json文件中，item操作是一个同步的操作，可能会导致模型的计算结果出现变化。**一般的现象就是模型计算出现了NaN，但加了工具后问题不复现了。**
+
+ASCEND_LAUNCH_BLOCKING 是一个环境变量，用于控制在 PyTorch 训练或在线推理场景中算子的执行模式。当设置为“1”时，算子将采用同步模式运行。因此如果出现加工具计算结果变化，可以设置ASCEND_LAUNCH_BLOCKING 为1，如果结果一样发生了变化，则说明是由于同步引起的结果改变。这个时候需要复现问题现象完成问题定位，推荐使用msprobe工具的异步dump功能，具体使用方式可查看[config配置](02.config_introduction.md)中的async_dump字段。
+
+## Hook机制导致计算结果变化
+
+pytorch/mindspore的hook机制会导致某些特殊场景下梯度计算的累加序产生变化，从而影响模型反向计算的gnorm结果。具体代码示例如下：
+```python
+import random, os
+import numpy as np
+import torch
+from torch import nn
+
+
+class Net(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.ln1 = nn.Linear(32, 32)
+        self.bn1 = nn.BatchNorm1d(32)
+        self.ln2 = nn.Linear(32, 32)
+
+    def forward(self, x):
+        x1 = self.ln1(x)
+
+        x2 = self.bn1(x)
+        x2 = self.ln2(x2)
+        return x1 + x2
+
+
+class BigNet(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.net1 = Net()
+        self.net2 = Net()
+
+    def forward(self, x):
+        out1 = self.net1(x)
+        out2 = self.net2(out1)
+        return out1, out2
+
+
+def my_backward_hook(module, grad_input, grad_output):
+    pass
+
+
+if __name__ == "__main__":
+    os.environ["HCCL_DETERMINISTIC"] = 'true'
+
+    seed = 1234
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    torch.manual_seed(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+
+    model = BigNet()
+    model.net2.register_full_backward_hook(my_backward_hook)
+    inputs = torch.randn(3, 32)
+
+    out1, out2 = model(inputs)
+    loss = out1.sum() + out2.sum()
+    loss.backward()
+
+    for name, param in model.named_parameters():
+        print(f"{name}: {param.grad.mean()}")
+
+```
+执行一遍以上脚本，可以打印得到模型中各层的权重梯度，注释model.net2.register_full_backward_hook(my_backward_hook)后再执行一篇，可以看出bn层的权重梯度已经发生了变化。
+
+**如果在msprobe L0，mix级别采集出现gnorm发生变化，可以尝试将采集级别改为L1，若L1级别gnorm不发生变化，则大概率是hook机制导致的梯度计算结果变化。**

msprobe/docs/FAQ.md

@@ -36,8 +36,29 @@
      该信息说明 module 挂载了被 PyTorch 框架废弃的 register_backward_hook，这与工具使用的 register_full_backward_hook 接口会产生冲突，故工具会跳过该 module 的反向数据采集。
    - 如果您希望所有 module 数据都能采集下来，可以将模型中使用的 register_backward_hook 接口改为 PyTorch 框架推荐的 register_full_backward_pre_hook 或 register_full_backward_hook 接口。
 
+5. 在vllm场景下进行数据dump时，发现报错：`RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cpu and npu:0!`
+   - 这是因为工具的debugger实例化早于LLM实例化导致的，解决方法就需要将debugger的实例化移至LLM实例化之后进行，可参考下方示例：
+   ```python
+   from vllm import LLM, SamplingParams
+   from msprobe.pytorch import PrecisionDebugger
+   prompts = [
+      "Hello, my name is",
+      "The president of the United States is",
+      "The capital of France is",
+      "The future of AI is",
+   ]
+
+   sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
+   llm = LLM(model="Qwen/Qwen2.5-0.5B-Instruct")
+   
+   debugger = PrecisionDebugger("./config.json")  # debugger实例化晚于LLM实例化
+   
+   debugger.start()
+   outputs = llm.generate(prompts, sampling_params)
+   debugger.stop()
+   ```
 
-5. 在使用 msprobe 进行 Pytorch 框架的数据采集功能时，请注意确认环境变量 NPU_ASD_ENABLE=0 ，即关闭特征值检测功能。 由于工具冲突， 在该功能开启的情况下可能导致某些 api 数据采集的缺失。
+6. 在使用 msprobe 进行 PyTorch 框架的数据采集功能时，请注意确认环境变量 NPU_ASD_ENABLE=0 ，即关闭特征值检测功能。 由于工具冲突， 在该功能开启的情况下可能导致某些 api 数据采集的缺失。
 
 # 2 精度预检(PyTorch)
 

msprobe/docs/data_dump_MindSpore/dynamic_graph_quick_start_example.md

@@ -35,7 +35,7 @@ import os
 import numpy as np
 import mindspore as ms
 from mindspore import nn, ops
-from mindspore import context
+from mindspore import context, set_device, set_deterministic
 from mindspore import Tensor
 from msprobe.mindspore import PrecisionDebugger, seed_all
 
@@ -50,7 +50,11 @@ 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)
+context.set_context(mode=ms.PYNATIVE_MODE)
+
+set_device("Ascend", 0)
+
+set_deterministic(True)
 print("Context set successfully. Please wait for the training task.")
 
 # 定义卷积层

msprobe/docs/visualization/mindspeed_llamafactoary_img/llamafactory-qwen25vl.txt

@@ -0,0 +1,59 @@
+DeepSpeedEngine(
+  (module): Qwen2_5_VLForConditionalGeneration(
+    (visual): Qwen2_5_VisionTransformerPretrainedModel(
+      (patch_embed): Qwen2_5_VisionPatchEmbed(
+        (proj): Conv3d(3, 1280, kernel_size=(2, 14, 14), stride=(2, 14, 14), bias=False)
+      )
+      (rotary_pos_emb): Qwen2_5_VisionRotaryEmbedding()
+      (blocks): ModuleList(
+        (0-15): 16 x Qwen2_5_VLVisionBlock(
+          (norm1): Qwen2RMSNorm((0,), eps=1e-06)
+          (norm2): Qwen2RMSNorm((0,), eps=1e-06)
+          (attn): Qwen2_5_VLVisionSdpaAttention(
+            (qkv): Linear(in_features=1280, out_features=3840, bias=True)
+            (proj): Linear(in_features=1280, out_features=1280, bias=True)
+          )
+          (mlp): Qwen2_5_VLMLP(
+            (gate_proj): Linear(in_features=1280, out_features=3420, bias=True)
+            (up_proj): Linear(in_features=1280, out_features=3420, bias=True)
+            (down_proj): Linear(in_features=3420, out_features=1280, bias=True)
+            (act_fn): SiLU()
+          )
+        )
+      )
+      (merger): Qwen2_5_VLPatchMerger(
+        (ln_q): Qwen2RMSNorm((0,), eps=1e-06)
+        (mlp): Sequential(
+          (0): Linear(in_features=5120, out_features=5120, bias=True)
+          (1): GELU(approximate='none')
+          (2): Linear(in_features=5120, out_features=2048, bias=True)
+        )
+      )
+    )
+    (model): Qwen2_5_VLModel(
+      (embed_tokens): Embedding(151936, 2048)
+      (layers): ModuleList(
+        (0-7): 8 x Qwen2_5_VLDecoderLayer(
+          (self_attn): Qwen2_5_VLSdpaAttention(
+            (q_proj): Linear(in_features=2048, out_features=2048, bias=True)
+            (k_proj): Linear(in_features=2048, out_features=256, bias=True)
+            (v_proj): Linear(in_features=2048, out_features=256, bias=True)
+            (o_proj): Linear(in_features=2048, out_features=2048, bias=False)
+            (rotary_emb): Qwen2_5_VLRotaryEmbedding()
+          )
+          (mlp): Qwen2MLP(
+            (gate_proj): Linear(in_features=2048, out_features=11008, bias=False)
+            (up_proj): Linear(in_features=2048, out_features=11008, bias=False)
+            (down_proj): Linear(in_features=11008, out_features=2048, bias=False)
+            (act_fn): SiLU()
+          )
+          (input_layernorm): Qwen2RMSNorm((0,), eps=1e-06)
+          (post_attention_layernorm): Qwen2RMSNorm((0,), eps=1e-06)
+        )
+      )
+      (norm): Qwen2RMSNorm((0,), eps=1e-06)
+      (rotary_emb): Qwen2_5_VLRotaryEmbedding()
+    )
+    (lm_head): Linear(in_features=2048, out_features=151936, bias=False)
+  )
+)