mindstudio-probe 8.3.0__py3-none-any.whl → 8.3.1__py3-none-any.whl

msprobe/visualization/builder/graph_merger.py

@@ -146,6 +146,7 @@ class BaseGraphMerger:
                                                                           GraphConst.APIS_BETWEEN_MODULES_ALL_RANKS,
                                                                           id_accumulation=True)
                 all_collection_node = main_graph_result.graph.get_node(all_collection_node_id)
+                all_collection_node.upnode = main_graph_result.graph.root
                 new_main_root_sub_nodes.append(all_collection_node)
                 # Apis_Between_Modules.0 --> Apis_Between_Modules_Rank0.0
                 origin_main_node_id = main_node.id
@@ -377,6 +378,12 @@ class PPMerger(BaseGraphMerger):
             logger.info('Unable to get pp groups based on Distributed Api (batch_isend_irecv, send, or isend), '
                         'generate pp groups using parallel param "rank_size", "tp" and "pp".')
             _, pp_groups = self.get_default_groups()
+        elif len(pp_groups[0]) != self.parallel_param.pp:
+            logger.warning(f'Based on Distributed Api (atch_isend_irecv, send, or isend), '
+                           f'the resulting pp groups={pp_groups}, '
+                           f'its length is not equal to the parallel param "pp"({self.parallel_param.pp}) you defined, '
+                           f'generate pp groups using parallel param "rank_size", "tp" and "pp".')
+            _, pp_groups = self.get_default_groups()
         logger.info(f'{self.log_prefix} All pp groups is {pp_groups}.')
         return pp_groups
 
@@ -657,6 +664,12 @@ class TPMerger(BaseGraphMerger):
             logger.info('Unable to get tp groups based on Distributed Api (reduce_scatter or all_reduce), '
                         'generate tp groups using parallel param "rank_size", "tp" and "pp".')
             tp_groups, _ = self.get_default_groups()
+        elif len(tp_groups[0]) != self.parallel_param.tp:
+            logger.warning(f'Based on Distributed Api (reduce_scatter or all_reduce), '
+                           f'the resulting tp groups={tp_groups}, '
+                           f'its length is not equal to the parallel param "tp"({self.parallel_param.tp}) you defined, '
+                           f'generate tp groups using parallel param "rank_size", "tp" and "pp".')
+            tp_groups, _ = self.get_default_groups()
         logger.info(f'{self.log_prefix} All tp groups is {tp_groups}.')
         return tp_groups
 

msprobe/visualization/graph/graph.py

@@ -126,21 +126,25 @@ class Graph:
 
     def get_sorted_nodes(self):
         """
-        通过深度优先遍历graph，获得排过序的node列表
+        通过深度优先遍历graph，获得排过序的node列表，使用栈实现避免超出递归深度问题
         """
         visited = set()
         order = []
+        stack = [(self.root, False)]
 
-        @recursion_depth_decorator('msprobe.visualization.graph.graph.Graph.get_nodes_order.visit', max_depth=500)
-        def visit(node):
+        while stack:
+            node, processed = stack.pop()
             if node.id in visited:
-                return
-            visited.add(node.id)
-            for sub_node in node.subnodes:
-                visit(sub_node)
-            order.append(node)
+                continue
+            if processed:
+                visited.add(node.id)
+                order.append(node)
+            else:
+                stack.append((node, True))
+                for sub_node in reversed(node.subnodes):
+                    if sub_node.id not in visited:
+                        stack.append((sub_node, False))
 
-        visit(self.root)
         return order
 
     def add_node(self, node_op, node_id, up_node=None, id_accumulation=False):

msprobe/docs/08.accuracy_checker_online_PyTorch.md

@@ -1,295 +0,0 @@
-# PyTorch 场景的在线精度预检
-
-## 1 简介
-
-为了应对大模型场景下，通过离线预检方式 dump API 输入输出数据导致的存储资源紧张问题，提供在线精度预检功能。本功能实现在执行 NPU 训练操作的过程中，通过 TCP/IP 协议在 NPU
-Host 与 GPU Host 设备间建立连接，将 NPU 上对应 API 的输入数据在 GPU 设备上运行，将两份输出数据进行比对，得到预检比对结果，从而减少数据 dump 的步骤，降低存储资源的占用。针对偏差较大的算子，两方比对（NPU vs. GPU）的方法缺少裁判进行裁定。 参考离线预检，在线预检场景同时支持两方比对和三方比对方式，按照 api 的精度标准要求，选择两方比对或三方比对。
-
-## 2 在线精度预检流程
-
-在线精度预检当前支持**局域网场景**和**共享存储场景**，请根据不同的场景选择对应的配置。
-
-在线精度预检操作流程如下：
-
-1. 准备 GPU 和 NPU 可正常运行的训练环境，PyTorch 版本大于等于2.0，并保证两台 Host 在同一局域网内可正常通信或能通过共享存储进行通信。
-2. GPU 和 NPU Host 设备上同时安装msprobe工具，详见[ msprobe 安装](./01.installation.md)章节，其中在线预检要安装 twisted、pyOpenSSL，这些包为 Python 模块。
-3. 分别配置 GPU 侧、NPU 侧的 config.json 文件。
-4. 在 GPU 侧运行 `msprobe -f pytorch run_ut -config ./config.json`。
-5. 在 NPU 侧配置训练脚本。
-6. 在 NPU 侧执行训练。
-
-## 3 在线精度预检操作指导
-
-### 3.1 配置 config.json 文件
-
-预检工具安装完成后，需要在 GPU 和 NPU 环境下分别配置 config.json。其中需要重点关注文件中的 is_online、is_benchmark_device、host 和 port 参数的配置，保障在线预检时 GPU 和 NPU 两台设备间的通信正常。
-
-#### 3.1.1 GPU 侧在线预检配置说明
-
-| 参数名称            | 说明           | 是否必选 |
-|-----------------|--------------|------|
-| task            | 任务名称，str 类型，配置为 run_ut 表示预检任务。通过其他字段 is_online 判断离线预检、在线预检任务。          | 是    |
-| white_list      | 预检的 API 白名单，list[str] 类型。<br/>**配置示例**：white_list=["conv1d", "conv2d"]。默认未配置白名单，即预检全量 API 数据。       | 否    |
-| black_list      | 预检的 API 黑名单，list[str] 类型。<br/>**配置示例**：white_list=["conv1d", "conv2d"]。默认未配置黑名单，即预检全量 API 数据。         | 否    |
-| error_data_path | 配置保存精度未达标的 API 输入输出数据路径，str 类型。在线预检模式下该参数不生效。         | 否    |
-| is_online       | 在线预检模式开关，bool 类型，可取值 True（开启）、False（关闭），默认关闭。              | 是    |
-| nfs_path        | 在线预检模式共享存储目录路径，str 类型，用于 GPU 设备和 NPU 设备间进行通信。配置该参数后 host、port 和 tls_path 不生效。   | 否    |
-| host            | 在线预检模式局域网场景信息接收端 IP，str 类型，用于 GPU 设备和 NPU 设备间进行通信，GPU 侧配置为本机地址 127.0.0.1 或本机局域网 IP。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。            | 否    |
-| port            | 在线预检模式局域网场景信息接收端端口号，int 类型，用于 GPU 设备和 NPU 设备间进行通信，GPU 侧配置为本机可用端口。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。        | 否    |
-| rank_list       | 指定在线预检的 Rank ID，默认值为 [0]，list[int] 类型，应配置为大于等于 0 的整数，且须根据实际卡的 Rank ID 配置，若所配置的值大于实际训练所运行的卡的 Rank ID，则在线预检输出数据为空。GPU 和 NPU 须配置一致。 | 是    |
-| tls_path        | 在线预检模式局域网场景 SSL 证书路径，该路径下包含私钥 server.key、证书 server.crt、自建CA证书 ca.crt、CRL吊销证书 crl.pem，str 类型，未配置该参数时默认取值当前路径。tls_path配置为空字符串时，采用TCP协议明文传输api数据；当配置为路径时，采用TLS1.2协议加密传输数据，加密传输时安全性较高，传输速率较低。其中 crl.pem 为非必需文件，仅当用户存在吊销记录时使用。 | 否    |
-
-
-#### 3.1.2 NPU 侧在线预检配置说明
-
-| 参数名称             | 说明           | 是否必选 |
-|------------------|-------------|------|
-| task             | 任务名称，str 类型，配置为 tensor 表示 dump API 统计信息和完全复刻整网的 API 运行情况的真实数据。通过字段 online_run_ut 判断是否使用在线预检功能。      | 是    |
-| dump_path        | dump 路径，str 类型，配置为合法路径即可，兼容 tensor 任务静态检查。       | 是    |
-| level            | dump 级别，str 类型，在线预检时配置为 L1，表示 dump API 级精度数据。在线预检可不配置，默认取值 L1。                                               | 是    |
-| rank             | 指定对某张卡上的数据进行 dump，list[int] 类型，默认未配置(表示 dump所有卡的数据)，需要与 GPU 侧配置项 rank_list 保持一致。   | 否    |
-| step             | 指定 dump 某个 step 的数据，list[int] 类型，默认未配置，表示 dump 所有 step 的数据。dump 特定 step 时，须指定为训练脚本中存在的 step。   | 否    |
-| scope            | dump 范围，list[str] 类型，默认未配置（list 也未配置时表示 dump 所有 api 的数据），配置方式参考 [config.json 配置介绍](./02.config_introduction.md)。    | 否    |
-| list             | dump 范围，list[str] 类型，默认未配置（scope 也未配置时表示 dump 所有 api 的数据），配置方式参考 [config.json 配置介绍](./02.config_introduction.md)。 | 否    |
-| online_run_ut    | 在线预检模式开关，bool 类型，可取值 True（开启）、False（关闭），默认关闭。        | 是    |
-| nfs_path         | 在线预检模式共享存储目录路径，str 类型，用于 GPU 设备和 NPU 设备间进行通信。配置该参数后 host 和 port 不生效。     | 否    |
-| host             | 在线预检模式局域网场景信息接收端 IP，str 类型，用于 GPU 设备和 NPU 设备间进行通信，NPU 侧须配置为 GPU 侧的局域网 IP 地址。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。     | 否    |
-| port             | 在线预检模式局域网场景信息接收端端口号，int 类型，用于 GPU 设备和 NPU 设备间进行通信，NPU 侧须配置为 GPU 侧的端口号。局域网场景时，不能配置 nfs_path 参数，否则局域网场景不生效。        | 否    |
-| tls_path         | 在线预检模式局域网场景 SSL 证书路径，该路径下包含私钥 client.key、证书 client.crt、自建CA证书 ca.crt、CRL吊销证书 crl.pem，str 类型，未配置该参数时默认取值当前路径。tls_path配置为空字符串时，采用TCP协议明文传输api数据；当配置为路径时，采用TLS1.2协议加密传输数据，加密传输时安全性较高，传输速率较低。其中 crl.pem 为非必需文件，仅当用户存在吊销记录时使用。 | 否    |
-| online_run_ut_recompute | 模型训练是否使用重计算机制，bool类型，默认为False，表示模型没有使用重计算。在线预检暂不支持重计算机制下反向算子的预检，当模型训练使用重计算时，跳过反向算子预检，默认模型关闭重计算。 | 否    |
-
-#### 3.1.3 局域网场景配置示例
-
-若采用 TLS1.2 协议加密传输 api 数据，需配置 SSL 证书，可参考如下生成自签名证书方法。
-
-以下秘钥生成方法仅为简单示例，客户应使用与自己需求相符的秘钥生成和存储机制并保证秘钥安全性与机密性，必要时可采用分层秘钥机制。
-以下示例中加密口令仅供参考，使用时请更换为复杂口令，并保护口令安全。
-```shell
-# 生成CA证书的根私钥和证书签名请求，其中ca_password为CA私钥加密口令，仅作演示，请更换使用
-openssl req -new -newkey rsa:3072 -passout pass:ca_password -subj "/CN=*ca.com/O=ca.Inc./C=CN/ST=Zhejiang/L=Hangzhou" -keyout ca.key -out ca.csr
-# 自签发根证书
-openssl x509 -req -days 365 -in ca.csr -signkey ca.key -passin pass:ca_password -out ca.crt -extensions v3_ca -extfile <(cat <<-EOF
-[v3_ca]
-basicConstraints = critical,CA:true
-keyUsage = critical, keyCertSign, cRLSign
-EOF
-)
-
-# 生成client公私钥，其中client_password为私钥加密口令，仅作演示，请更换使用
-openssl genrsa -aes256 -passout pass:client_password -out client.key 3072
-# 基于client公私钥生成签名请求
-openssl req -new -key client.key -passin pass:client_password -subj "/CN=*example.com/O=Test, Inc./C=CN/ST=Zhejiang/L=Hangzhou" -out client.csr
-# 利用自签发的根证书，签发client证书
-openssl x509 -req -days 180 -CA ca.crt -CAkey ca.key -passin pass:ca_password -in client.csr -out client.crt -CAcreateserial -extfile <(cat <<-EOF
-[v3_server]
-basicConstraints = CA:FALSE
-keyUsage = critical, digitalSignature, keyEncipherment
-extendedKeyUsage = serverAuth
-EOF
-)
-
-# 生成server公私钥，其中server_password为私钥加密口令，仅作演示，请更换使用
-openssl genrsa -aes256 -passout pass:server_password -out server.key 3072
-# 基于server公私钥生成签名请求
-openssl req -new -key server.key -passin pass:server_password -subj "/CN=*example.com/O=Test, Inc./C=CN/ST=Zhejiang/L=Hangzhou" -out server.csr
-# 利用自签发的根证书，签发server证书
-openssl x509 -req -days 180 -CA ca.crt -CAkey ca.key -passin pass:ca_password -in server.csr -out server.crt -CAcreateserial -extfile <(cat <<-EOF
-[v3_server]
-basicConstraints = CA:FALSE
-keyUsage = critical, digitalSignature, keyEncipherment
-extendedKeyUsage = serverAuth
-EOF
-)
-
-```
-
-当需要吊销已创建的SSL证书时，通过openssl命令生成CRL证书 crl.pem，示例如下：
-```shell
-# 创建证书信息的文本数据库，空文件即可
-touch index.txt
-
-# 创建ca配置文件ca.cnf，内容如下，用于吊销证书使用
-[ca]
-default_ca = CA_default
-[CA_default]
-database = ./index.txt
-default_md = sha256
-
-# 吊销证书 client.crt，其中ca_password为CA私钥加密口令，与CA创建时保持一致
-openssl ca -revoke client.crt -config ca.cnf -cert ca.crt -keyfile ca.key -passin pass:ca_password
-# 生成CRL文件
-openssl ca -gencrl -config ca.cnf -cert ca.crt -keyfile ca.key -passin pass:ca_password -out crl.pem -crldays 30
-# 查看生成的CRL文件内容：
-openssl工具的命令： openssl crl -inform PEM -in crl.pem -text
-
-```
-
-注意：配置TLS协议时，传输性能受机器环境和网络质量的影响，可能触发NPU超时中断模型训练，为避免训练和预检中断，丢弃长时间未传输的api数据，同时NPU侧配置HCCL环境变量，配置方式如下：
-
-a) 调整HCCL环境变量，关闭看门狗，避免WorkHCCL超时中断模型训练:
-```shell
-export HCCL_DESYNC_DEBUG=0
-export HCCL_ASYNC_ERROR_HANDLING=0
-```
-b) 调整通信算子超时设置（以1800s举例）：
-```shell
-export HCCL_CONNECT_TIMEOUT=1800
-export HCCL_EXEC_TIMEOUT=1800
-```
-
-GPU 侧：
-
-```json
-{
-  "task": "run_ut",
-  "run_ut": {
-    "white_list": [],
-    "black_list": [],
-    "error_data_path": "./",
-    "is_online": true,
-    "nfs_path": "",
-    "host": "127.0.0.1",
-    "port": 59208,
-    "rank_list": [0],
-    "tls_path": ""
-  }
-}
-```
-
-NPU 侧：
-
-```json
-{
-  "task": "tensor",
-  "dump_path": "./dump_path",
-  "rank": [0],
-  "step": [0],
-  "level": "L1",
-  "tensor": {
-    "scope": [],
-    "list": [],
-    "online_run_ut": true,
-    "nfs_path": "",
-    "host": "xx.xx.xx.x",
-    "port": 59208,
-    "tls_path": ""
-  }
-}
-```
-
-#### 3.1.4 共享存储场景配置示例
-
-GPU 侧：
-
-```json
-{
-  "task": "run_ut",
-  "run_ut": {
-    "white_list": [],
-    "black_list": [],
-    "error_data_path": "./",
-    "is_online": true,
-    "nfs_path": "/nfs/xxx/data",
-    "host": "",
-    "port": -1,
-    "rank_list": [0],
-    "tls_path": ""
-  }
-}
-```
-
-NPU 侧：
-
-```json
-{
-  "task": "tensor",
-  "dump_path": "./dump_path",
-  "rank": [0],
-  "step": [0],
-  "level": "L1",
-  "tensor": {
-    "scope": [],
-    "list": [],
-    "online_run_ut": true,
-    "nfs_path": "/nfs/xxx/data",
-    "host": "",
-    "port": -1,
-    "tls_path": ""
-  }
-}
-```
-
-### 3.2 在 GPU 侧运行 run_ut
-
-由于 GPU 侧为通信接收端，需先于 NPU 侧执行 run_ut 操作，命令如下：
-
-```bash
-msprobe -f pytorch run_ut -config ./config.json
-```
-
-GPU 侧配置好 config.json 文件后执行 run_ut 命令，此时 GPU 处于预检等待状态：
-
-- 局域网场景：当 NPU 侧启动训练后将预检的 API 输入和输出数据发送到 GPU 侧时，GPU 启动预检操作。
-- 共享存储场景：当 NPU 侧启动训练后将预检的 API 输入和输出数据发送到共享存储时，GPU 启动预检操作。
-
-### 3.3 在 NPU 侧配置训练脚本
-
-在 NPU 训练脚本中添加如下代码以获取 run_ut 操作的预检 API 输入和输出数据：
-
-```python
-from msprobe.pytorch import PrecisionDebugger
-
-debugger = PrecisionDebugger("config.json")
-...
-
-debugger.start()
-
-...
-
-debugger.stop()
-debugger.step()
-```
-
-### 3.4 在 NPU 侧执行训练脚本
-
-配置完 NPU 侧训练脚本后即可执行训练脚本，命令示例如下：
-
-```bash
-bash train.sh
-```
-
-训练脚本执行完毕后，在GPU侧dump_path目录下生成比对结果文件，`accuracy_checking_result_{timestamp}_rank{rank_id}.csv`和`accuracy_checking_details_{timestamp}_rank{rank_id}.csv`记录两方比对结果，`api_precision_compare_result_{timestamp}_rank{rank_id}.csv`和`api_precision_compare_details_{timestamp}_rank{rank_id}.csv`记录三方比对结果。详细介绍请参见[离线精度预检中的 **4 预检结果**](./07.accuracy_checker_PyTorch.md#4-预检结果)。
-
-## 4 支持的融合算子列表
-
-预检工具当前支持的融合算子如下：
-
-- npu_apply_adam_w
-
-- npu_confusion_transpose
-
-- fast_gelu
-
-- npu_layer_norm_eval
-
-- npu_linear
-
-- npu_fusion_attention（该算子在 GPU 上预检时，需要额外安装 flash_attn，请用户自行安装。）
-
-- npu_rms_norm
-
-- npu_rotary_mul
-
-- npu_scaled_masked_softmax
-
-- npu_swiglu
-
-- npu_apply_adam
-
-- npu_group_norm_silu
-
-- npu_mish
-
-- npu_moe_gating_top_k_softmax
-
-- npu_sort_v2

msprobe/pytorch/api_accuracy_checker/tensor_transport_layer/attl.py

@@ -1,205 +0,0 @@
-# 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 glob
-import os.path
-import time
-from multiprocessing import Queue
-from typing import Optional, Union, Dict, Any
-from dataclasses import dataclass
-
-import torch
-
-from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
-from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.client import TCPClient
-from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.server import TCPServer
-from msprobe.core.common.file_utils import remove_path
-from msprobe.pytorch.common.utils import logger, save_api_data, load_api_data, save_pkl, load_pkl
-from msprobe.core.common.decorator import recursion_depth_decorator
-
-BufferType = Union[ApiData, Dict[str, Any], str]  # Union[Tensor, Tuple[Optional[Tensor]]]
-
-
-@dataclass
-class ATTLConfig:
-    is_benchmark_device: bool
-    connect_ip: str
-    connect_port: int
-    # storage_config
-    nfs_path: str = None
-    tls_path: str = None
-    check_sum: bool = True
-    queue_size: int = 50
-
-
-class ATTL:
-    def __init__(self, session_id: str, session_config: ATTLConfig, need_dump=True) -> None:
-        self.session_id = session_id
-        self.session_config = session_config
-        self.logger = logger
-        self.socket_manager = None
-        self.data_queue = Queue(maxsize=50)
-        self.dequeue_list = []
-        self.message_end = False
-        self.kill_progress = False
-        self.nfs_path = None
-        if self.session_config.nfs_path:
-            self.nfs_path = self.session_config.nfs_path
-        elif self.session_config.is_benchmark_device:
-
-            self.socket_manager = TCPServer(self.session_config.connect_port,
-                                            self.data_queue,
-                                            self.session_config.check_sum,
-                                            self.session_config.tls_path)
-            self.socket_manager.start()
-        elif need_dump:
-            self.socket_manager = TCPClient(self.session_config.connect_ip,
-                                            self.session_config.connect_port,
-                                            self.session_config.check_sum,
-                                            self.session_config.tls_path)
-            self.socket_manager.start()
-
-    def stop_serve(self):
-        if isinstance(self.socket_manager, TCPServer):
-            self.socket_manager.stop()
-
-    def send(self, buffer: BufferType) -> None:
-        """
-        npu major in 'send' (client)
-        """
-
-        # if tcp connection lost,
-        if self.socket_manager.signal_exit:
-            raise ConnectionError(f"Failed to connect to {self.session_config.connect_ip}.")
-
-        # know receiver receive and go next
-        if isinstance(buffer, ApiData):
-            buffer = move2target_device(buffer, torch.device('cpu'))
-
-        if 'device' in buffer.kwargs:
-            buffer.kwargs.pop('device')
-        rank = buffer.rank if hasattr(buffer, "rank") and buffer.rank is not None else 0
-        step = buffer.step if hasattr(buffer, "step") else 0
-        try:
-            io_buff = save_api_data(buffer)
-        except Exception as e:
-            self.logger.info(f"{buffer.name} can not be saved, skip: {e}")
-            return
-        data = io_buff.getvalue()
-        self.socket_manager.add_to_sending_queue(data, rank=rank, step=step)
-
-    def recv(self, timeout_ms=0) -> Optional[BufferType]:
-        buffer = ''
-        while not buffer:
-            if timeout_ms > 0:
-                time.sleep(timeout_ms / 1000.0)
-            if not buffer and not self.data_queue.empty():
-                buffer = self.data_queue.get()
-                break
-            if not buffer and timeout_ms > 0:  # timeout is the only case we give up and return None
-                break
-            if self.message_end and self.data_queue.empty():
-                buffer = b"KILL_CONFIRM"
-                self.kill_progress = True
-                break
-            time.sleep(0.1)  # waiting outside the lock before next attempt
-        if not buffer:
-            # this is a result of a timeout
-            self.logger.info(f"RECEIVE API DATA TIMED OUT")
-        else:
-            if buffer == b"STOP_":
-                return "STOP_"
-            if buffer == b"KILL_":
-                self.message_end = True
-                return "STOP_"
-            if buffer == b"KILL_CONFIRM":
-                self.kill_progress = True
-                return "KILL_"
-            try:
-                buffer = load_api_data(buffer)
-            except Exception as e:
-                self.logger.warning("there is something error. please check it. %s", e)
-            if isinstance(buffer, bytes):
-                return ''
-            if isinstance(buffer, str):
-                return buffer
-
-        return buffer
-
-    def upload(self, buffer: BufferType):
-        if isinstance(buffer, ApiData):
-            buffer = move2target_device(buffer, torch.device('cpu'))
-            file_path = os.path.join(self.session_config.nfs_path, buffer.name + ".pt")
-        else:
-            file_path = os.path.join(self.session_config.nfs_path, buffer + f"_{int(time.time())}")
-
-        try:
-            save_pkl(buffer, file_path)
-        except Exception as e:
-            self.logger.warning("there is something error in save_pt. please check it. %s", e)
-
-    def download(self):
-        buffer = None
-        cur_file = None
-        for file_type in ("start*", "*.pt", "end*"):
-            pattern = os.path.join(self.nfs_path, file_type)
-            files = glob.glob(pattern)
-            if len(files) > 0:
-                cur_file = files[0]
-                break
-
-        if cur_file is not None:
-            try:
-                buffer = load_pkl(cur_file)
-            except Exception as e:
-                self.logger.warning("there is something error. please check it. %s", e)
-            remove_path(cur_file)
-        return buffer
-
-
-@recursion_depth_decorator("move2device_exec")
-def move2device_exec(obj, device):
-    if isinstance(obj, (tuple, list)):
-        data_list = [move2device_exec(val, device) for val in obj]
-        return data_list if isinstance(obj, list) else tuple(data_list)
-    if isinstance(obj, dict): 
-        return {key: move2device_exec(val, device) for key, val in obj.items()}
-    elif isinstance(obj, torch.Tensor):
-        obj = obj.detach()
-        if obj.device.type != device:
-            obj = obj.to(device)
-        return obj
-    elif "return_types" in str(type(obj)):
-        return move2device_exec(tuple(obj), device)
-    elif isinstance(obj, torch._C.device):
-        return torch.device(device)
-    else:
-        return obj
-
-
-def move2target_device(buffer: ApiData, target_device):
-    # handle args
-    new_args = move2device_exec(buffer.args, target_device)
-
-    # handle kwargs
-    new_kwargs = move2device_exec(buffer.kwargs, target_device)
-
-    # handle result
-    new_results = move2device_exec(buffer.result, target_device)
-
-    if target_device == torch.device('cpu') or target_device == "cpu":
-        return ApiData(buffer.name, tuple(new_args), new_kwargs, new_results, buffer.step, buffer.rank)
-    else:
-        return ApiData(buffer.name, tuple(new_args), new_kwargs, buffer.result, buffer.step, buffer.rank)