deepspeed

Deepspeed 技能

基于官方文档生成的 deepspeed 开发全面协助。

何时使用此技能

此技能应在以下情况触发：

• 使用 deepspeed 时
• 询问 deepspeed 功能或 API 时
• 实现 deepspeed 解决方案时
• 调试 deepspeed 代码时
• 学习 deepspeed 最佳实践时

快速参考

常见模式

模式 1： DeepNVMe 内容 环境要求 创建 DeepNVMe 句柄 使用 DeepNVMe 句柄 阻塞式文件写入 非阻塞式文件写入 并行文件写入 固定内存张量 综合示例 致谢 附录 高级句柄创建 性能调优 DeepNVMe API 通用 I/O API GDS 专用 API 句柄设置 API 本教程将展示如何使用 DeepNVMe 在持久化存储与位于主机或设备内存中的张量之间进行数据传输。DeepNVMe 基于非易失性内存 Express（NVMe）固态硬盘（SSD）、Linux 异步 I/O（libaio）和 NVIDIA Magnum IOTM GPUDirect® Storage（GDS）构建的强大优化，提升深度学习应用中 I/O 操作的性能和效率。环境要求 确保你的环境已正确配置以使用 DeepNVMe。首先，你需要安装 DeepSpeed 版本 >= 0.15.0。接下来，确保 DeepSpeed 安装中提供 DeepNVMe 算子。任何 DeepNVMe 功能都需要 async_io 算子，而 gds 算子仅 GDS 功能需要。你可以通过检查 ds_report 的输出来确认每个算子是否可用，检查兼容状态是否为 [OKAY]。下面是 ds_report 输出片段，确认 async_io 和 gds 算子均可用。如果 async_io 算子不可用，你需要为你的 Linux 发行版安装相应的 libaio 库二进制文件。例如，Ubuntu 用户需要运行 apt install libaio-dev。一般来说，你应该仔细检查 ds_report 输出以获取有用的提示，例如以下内容：[WARNING] async_io requires the dev libaio .so object and headers but these were not found. [WARNING] async_io: please install the libaio-dev package with apt [WARNING] If libaio is already installed (perhaps from source), try setting the CFLAGS and LDFLAGS environment variables to where it can be found. 要启用 gds 算子，你需要安装 NVIDIA GDS，请参考适用于裸金属系统或 Azure VM（即将推出）的相应指南。创建 DeepNVMe 句柄 DeepNVMe 功能可通过两种抽象访问：aio_handle 和 gds_handle。aio_handle 可用于主机和设备张量，而 gds_handle 仅适用于 CUDA 张量，但效率更高。使用 DeepNVMe 的第一步是创建所需的句柄。aio_handle 需要 async_io 算子，而 gds_handle 需要 async_io 和 gds 两个算子。以下代码片段分别展示了 aio_handle 和 gds_handle 的创建。 ### 创建 aio_handle from deepspeed.ops.op_builder import AsyncIOBuilder aio_handle = AsyncIOBuilder().load().aio_handle() ### 创建 gds_handle from deepspeed.ops.op_builder import GDSBuilder gds_handle = GDSBuilder().load().gds_handle() 为简单起见，以上示例展示了使用默认参数创建句柄。我们期望使用默认参数创建的句柄在大多数环境中都能提供良好性能。不过，你可以查看下文了解高级句柄创建。使用 DeepNVMe 句柄 aio_handle 和 gds_handle 提供相同的 API，用于将张量存储到文件或从文件加载张量。这些 API 的一个共同特点是它们接收一个张量和一个文件路径作为所需 I/O 操作的参数。为获得最佳性能，应使用固定的设备或主机张量进行 I/O 操作（详见此处）。为简洁起见，本教程将使用 aio_handle 进行说明，但请记住 gds_handle 的工作方式类似。你可以通过在 Python shell 中对 aio_handle 对象进行 tab 补全来查看可用 API。下面通过 h. 的 tab 补全进行说明。 >python Python 3.10.12 (main, Jul 29 2024, 16:56:48) [GCC 11.4.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h. h.async_pread( h.free_cpu_locked_tensor( h.get_overlap_events( h.get_single_submit( h.new_cpu_locked_tensor( h.pwrite( h.sync_pread( h.wait( h.async_pwrite( h.get_block_size( h.get_queue_depth( h.get_intra_op_parallelism( h.pread( h.read( h.sync_pwrite( h.write( 用于执行 I/O 操作的感兴趣 API 是那些名称中包含 pread 和 pwrite 子串的 API。为简洁起见，我们将重点关注文件写入 API，即 sync_pwrite、async_pwrite 和 pwrite。下面我们仅讨论 sync_pwrite 和 async_pwrite，因为它们是 pwrite 的特化。阻塞式文件写入 sync_pwrite 提供 Python 文件写入的标准阻塞语义。下面的示例展示了使用 sync_pwrite 将 1GB 的 CUDA 张量存储到本地 NVMe 文件。 >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(10243, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.sync_pwrite(t,'/local_nvme/test_1GB.pt') >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 非阻塞式文件写入 DeepNVMe 的一个重要优化是非阻塞 I/O 语义，它使 Python 线程能够将计算与 I/O 操作重叠。async_pwrite 提供文件写入的非阻塞语义。Python 线程随后可以使用 wait() 与 I/O 操作同步。async_write 还可用于提交多个连续的非阻塞 I/O 操作，之后可以通过单个 wait() 阻塞等待这些操作完成。下面的示例展示了使用 async_pwrite 将 1GB 的 CUDA 张量存储到本地 NVMe 文件。 >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(10243, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 非阻塞 I/O 操作的警告：为避免数据竞争和损坏，必须谨慎使用 .wait() 来串行化源张量的写入和目标张量的读取。例如，在非阻塞文件写入期间对 t 进行以下更新是不安全的，可能会损坏 /local_nvme/test_1GB.pt。 >>> t=torch.empty(10243, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> t += 1 # <--- Data race; avoid by preceding with h.wait() 类似的安全问题也适用于在未使用 .wait() 同步的情况下读取非阻塞文件读取的目标张量。并行文件写入 DeepNVMe 的一个重要优化是能够并行化单个 I/O 操作。此优化通过在构造 DeepNVMe 句柄时指定所需的并行度来启用。使用该句柄的后续 I/O 操作将自动在所需数量的主机或设备线程上并行化（视情况而定）。I/O 并行性可与阻塞或非阻塞 I/O API 组合使用。下面的示例展示了使用 async_pwrite 对文件写入进行 4 路并行化。注意在创建句柄时使用 intra_op_parallelism 参数指定所需的并行度。 >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(10243, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle(intra_op_parallelism=4) >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 固定内存张量 DeepNVMe 优化的一个关键部分是使用直接内存访问（DMA）进行 I/O 操作，这要求主机或设备张量被固定。要固定主机张量，你可以使用 Pytorch 或 DeepSpeed Accelerators 提供的机制。下面的示例展示了将固定的 CPU 张量写入本地 NVMe 文件。 >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(10243, dtype=torch.uint8).pin_memory() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 另一方面，gds_handle 提供 new_pinned_device_tensor() 和 pin_device_tensor() 函数用于固定 CUDA 张量。下面的示例展示了将固定的 CUDA 张量写入本地 NVMe 文件。 >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(10243, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import GDSBuilder >>> h = GDSBuilder().load().gds_handle() >>> h.pin_device_tensor(t) >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 >>> h.unpin_device_tensor(t) 综合示例 我们希望以上内容能帮助你开始使用 DeepNVMe。你还可以使用以下链接查看 DeepNVMe 在真实深度学习应用中的使用。ZeRO-Inference 和 ZeRO-Infinity 中的参数交换器。ZeRO-Infinity 中的优化器交换器。ZeRO-Infinity 中的梯度交换器。简单的文件读取和写入操作。致谢 本教程因 Guanhua Wang、Masahiro Tanaka 和 Stas Bekman 的反馈而得到显著改进。附录 高级句柄创建 要使用 DeepNVMe 实现峰值 I/O 性能，需要仔细配置句柄创建。特别是，aio_handle 和 gds_handle 构造函数的参数对性能至关重要，因为它们决定了 DeepNVMe 与底层存储子系统（即 libaio、GDS、PCIe 和 SSD）交互的效率。为方便起见，我们允许使用默认参数值创建句柄，这在大多数场景下都能提供不错的性能。然而，要在你的环境中榨取所有可用性能，很可能需要调整构造函数参数，即 block_size、queue_depth、single_submit、overlap_events 和 intra_op_parallelism。aio_handle 构造函数参数和默认值如下所示：>>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> help(AsyncIOBuilder().load().aio_handle()) Help on aio_handle in module async_io object: class aio_handle(pybind11_builtins.pybind11_object) | Method resolution order: | aio_handle | pybind11_builtins.pybind11_object | builtins.object | | Methods defined here: | | init(...) | init(self: async_io.aio_handle, block_size: int = 1048576, queue_depth: int = 128, single_submit: bool = False, overlap_events: bool = False, intra_op_parallelism: int = 1) -> None | | AIO handle constructor 性能调优 如前所述，要针对目标工作负载或环境实现 DeepNVMe 峰值性能，需要使用经过优化配置的 aio_handle 或 gds_handle 句柄。为方便配置，我们提供一个名为 ds_nvme_tune 的实用工具，用于自动发现最佳的 DeepNVMe 配置。ds_nvme_tune 自动探索用户指定或默认的配置空间，并推荐提供最佳读和写性能的选项。下面是使用 ds_nvme_tune 调优 aio_handle 在 GPU 内存与挂载在 /local_nvme 的本地 NVVMe SSD 之间数据传输的示例用法。此示例使用了 ds_nvme_tune 的默认配置空间进行调优。$ ds_nvme_tune --nvme_dir /local_nvme --gpu Running DeepNVMe performance tuning on ['/local_nvme/'] Best performance (GB/sec): read = 3.69, write = 3.18 { "aio": { "single_submit": "false", "overlap_events": "true", "intra_op_parallelism": 8, "queue_depth": 32, "block_size": 1048576 } } 上述调优在一台 Lambda 工作站上执行，该工作站配备两个 NVIDIA A6000-48GB GPU、252GB DRAM 和一块 CS3040 NVMe 2TB SSD，其峰值读写速度分别为 5.6 GB/s 和 4.3 GB/s。调优大约需要四分半钟。根据结果，通过使用如下配置的 aio_handle，可以预期实现 3.69 GB/sec 和 3.18 GB/sec 的读写传输速度。 >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle(block_size=1048576, queue_depth=32, single_submit=False, overlap_events=True, intra_op_parallelism=8) ds_nvme_tune 的完整命令行选项可以通过正常的 -h 或 --help 获取。usage: ds_nvme_tune [-h] --nvme_dir NVME_DIR [NVME_DIR ...] [--sweep_config SWEEP_CONFIG] [--no_read] [--no_write] [--io_size IO_SIZE] [--gpu] [--gds] [--flush_page_cache] [--log_dir LOG_DIR] [--loops LOOPS] [--verbose] options: -h, --help show this help message and exit --nvme_dir NVME_DIR [NVME_DIR ...] Directory in which to perform I/O tests. A writeable directory on a NVMe device. --sweep_config SWEEP_CONFIG Performance sweep configuration json file. --no_read Disable read performance measurements. --no_write Disable write performance measurements. --io_size IO_SIZE Number of I/O bytes to read/write for performance measurements. --gpu Test tensor transfers between GPU device and NVME device. --gds Run the sweep over NVIDIA GPUDirectStorage operator --flush_page_cache Page cache will not be flushed and reported read speeds may be higher than actual Requires sudo access. --log_dir LOG_DIR Output directory for performance log files. Default is ./_aio_bench_logs --loops LOOPS Count of operation repetitions --verbose Print debugging information. DeepNVMe API 为方便起见，我们提供 DeepNVMe API 的列表和简要描述。通用 I/O API 以下函数用于 aio_handle 和 gds_handle 的 I/O 操作。Function Description async_pread Non-blocking file read into tensor sync_pread Blocking file read into tensor pread File read with blocking and non-blocking options async_pwrite Non-blocking file write from tensor sync_pwrite Blocking file write from tensor pwrite File write with blocking and non-blocking options wait Wait for non-blocking I/O operations to complete GDS 专用 API 以下函数仅适用于 gds_handle Function Description new_pinned_device_tensor Allocate and pin a device tensor free_pinned_device_tensor Unpin and free a device tensor pin_device_tensor Pin a device tensor unpin_device_tensor unpin a device tensor 句柄设置 API 以下 API 可用于探测句柄配置。Function Description get_queue_depth Return queue depth setting get_single_submit Return whether single_submit is enabled get_intra_op_parallelism Return I/O parallelism degree get_block_size Return I/O block size setting get_overlap_events Return whether overlap_event is enabled 更新日期：2025 年 11 月 5 日 上一页 下一页

libaio

模式 2： 用于 NLG 模型的混合专家 目录 1. 安装 2. 训练 NLG+MoE 模型 2.1. 对模型的修改 2.2. 预训练标准 MoE 模型 2.3. 预训练 PR-MoE 模型 2.4. 训练缩减模型规模的 MoS 在本教程中，我们将介绍如何将 DeepSpeed 混合专家（MoE）应用于 NLG 模型，这可将训练成本降低 5 倍，并将 MoE 模型规模缩小 3 倍（详见我们的博客）。我们以 Megatron-LM 框架中的类 GPT-3 模型为例。在阅读本教程之前，我们建议先阅读关于混合专家和 Megatron-LM GPT 预训练的教程。1. 安装 你需要安装 DeepSpeed v0.6.0 或更高版本才能使用 MoE 功能。用于 NLG 模型的 MoE 示例位于 Megatron-DeepSpeed 仓库的 MoE 文件夹下。2. 训练 NLG+MoE 模型 2.1. 对模型的修改 为了将 MoE 应用于 GPT 风格的模型，我们在 Megatron 框架中做了若干修改，主要集中在 megatron/model/ 中，我们在模型中加入 MoE 层。2.2. 预训练标准 MoE 模型 我们在 examples_deepspeed/MoE 下提供了示例训练脚本，我们曾用这些脚本在我们的博客中开展实验。标准 MoE 模型有几个新的超参数：--num-experts：每个 MoE 层的专家数量。在我们的实验中，我们将其设置为 128。专家数量越多，往往能带来更好的收敛，但收益会递减。--moe-expert-parallel-size：MoE 专家并行的程度。换句话说，每个 GPU 上将会有 num-experts/moe-expert-parallel-size 个专家。因此，--moe-expert-parallel-size 不应超过 GPU 数量，也不应超过 --num-experts。--moe-loss-coeff：将 MoE 损失添加到模型损失时的缩放系数。在我们的实验中，我们发现 0.01 是一个不错的设置。--moe-train-capacity-factor、--moe-eval-capacity-factor、--moe-min-capacity：这些配置决定单个专家可以处理多少个 token。数值越大可能会带来更好的收敛，但也会导致训练变慢，因为不同专家之间的负载会更加不均衡。--disable-moe-token-dropping：这将完全移除单个专家可以处理多少个 token 的限制。出于与上述相同的原因，我们只建议在推理/评估期间使用它。2.3. 预训练 PR-MoE 模型 PR-MoE 是一种新设计的 MoE 模型，代表 Pyramid-Residual-MoE，与标准 MoE 相比，它将参数效率最多提高 3 倍。更多详情请参阅我们的博客。我们在 examples_deepspeed/MoE 下提供了示例训练脚本。与标准 MoE 相比，PR-MoE 模型有几个不同的超参数：--num-experts：不是提供单个数字，要启用 Pyramid-MoE，你需要提供一个列表，其长度与 MoE 层数相同。我们建议在模型的后期阶段（接近输出）使用更多专家。--mlp-type：从 [standard, residual] 中选择。当其为 residual 时，将启用 Residual-MoE。除了上述用于标准 MoE 和 PR-MoE 的新超参数外，对于 NLG+MoE 模型，我们发现与基础稠密模型相比，降低学习率并增加学习率衰减持续时间会有所帮助。我们的调优细节可在示例训练脚本中找到。关于训练数据，我们无法发布我们的内部数据，但任何用于 Megatron-LM 预训练的公开数据都可以直接用于训练 MoE 模型（需要注意的是，它可能无法提供与我们的实验完全相同的模型质量）。例如，我们针对稠密模型和 MoE 模型评估了 The Pile 数据集（pile.eleuther.ai、github.com/EleutherAI/the-pile）。下面的表 1 显示，这些公开数据提供了与我们的内部数据相似的评估结果。模型规模 LAMBADA：补全预测 PIQA：常识推理 BoolQ：阅读理解 RACE-h：阅读理解 TriviaQA：问答 WebQs：问答 稠密 NLG：350M，内部数据 0.5203 0.6931 0.5364 0.3177 0.0321 0.0157 350M，公开 Pile 0.5106 0.6589 0.5933 0.3196 0.0257 0.0064 标准 MoE NLG：350M+MoE-128，内部数据 0.6270 0.7459 0.6046 0.3560 0.1658 0.0517 350M+MoE-128，公开 Pile 0.6128 0.7323 0.6040 0.3349 0.1111 0.0335 PR-MoE NLG：350M+MoE-128，内部数据 0.6365 0.7399 0.5988 0.3569 0.1630 0.0473 PR-MoE + MoS NLG：350M+MoE-128，内部数据 0.6346 0.7334 0.5807 0.3483 0.1369 0.0522 表 1：不同稠密和 MoE NLG 模型的零样本评估结果（最后六列）。所有零样本评估结果均使用准确率指标。2.4. 训练缩减模型规模的 MoS MoS 代表 Mixture-of-Students，是一种基于分阶段蒸馏的技术，用于压缩大型 MoE 模型。MoS 进一步将模型规模缩小 12.5%，与 PR-MoE 结合使用时，相比标准 MoE 可实现高达 3.7 倍的模型规模缩减。缩减后的模型规模有助于降低推理期间的延迟和成本。要训练 MoS 模型，需要指定一些额外参数。我们将以 PR-MoE 为例：--mos：这将通过知识蒸馏启用 Mixture-of-Students。--load-teacher：这指定了教师模型检查点的路径。这是使用 MoS 的强制性参数，教师模型检查点可以通过训练标准 MoE 或 PR-MoE 获得。num-layers-teacher、--hidden-size-teacher、--hidden-size-teacher、--num-experts-teacher：除了教师模型检查点路径外，我们还需要指定教师模型的模型架构，例如其层数、隐藏维度大小以及每个 MoE 层的专家数量。对于 PR-MoE，我们还需要为教师模型提供一个专家列表，其中我们从教师模型中移除若干专家层。除了上述新参数外，我们观察到在整个训练过程中使用教师 PR-MoE 可能会对学生模型的最终准确率产生不利影响。在我们的实验中，我们使用分阶段蒸馏方法，即在训练过程早期停止蒸馏（例如，在 400K 步之后），并在剩余的训练中仅针对标准语言建模损失进行优化。我们在 examples_deepspeed/MoE 下提供了示例训练脚本。我们的参数设置细节可在示例训练脚本中找到。MoS 的性能结果可以从我们的博客文章和我们的论文中看到。更新于：2025 年 11 月 5 日 上一页 下一页

megatron/model/

模式 3： MoS 即 Mixture-of-Students，是一种基于分阶段蒸馏的技术，用于压缩大型 MoE 模型。MoS 可进一步将模型大小减少 12.5%，当与 PR-MoE 结合使用时，相比标准 MoE 最多可将模型大小减少 3.7 倍。模型大小的缩减有助于降低推理过程中的延迟和成本。要训练 MoS 模型，需要指定一些额外参数。我们以 PR-MoE 为例：

--mos

模式 4： 学习率范围测试 目录 学习率范围测试（LRRT） 前提条件 LRRT 参数 所需的模型配置更改 PyTorch 示例：针对大批量大小进行调优 本教程展示如何在 PyTorch 中使用以执行学习率范围测试。 学习率范围测试（LRRT） 学习率范围测试（LRRT）是一种用于发现可用于训练模型而不发生发散的最大学习率值的方法。数据科学家通常对此信息感兴趣，因为较大的学习率能让模型比小学习率更快收敛。此外，较大的学习率在诸如 CLR 和 1Cycle 等学习率调度中至关重要，这些调度用于以大批量大小进行有效训练。DeepSpeed 为 PyTorch 框架中的模型训练提供 LRRT。 前提条件 要使用 DeepSpeed 的 LRRT，你必须满足以下两个条件： 使用入门指南将 DeepSpeed 集成到你的训练脚本中。 将用于配置 LRRT 的参数添加到你的模型参数中。LRRT 参数定义如下。 LRRT 参数 LRRT 的工作原理是按预定义间隔将学习率线性增加预定义量。因此，LRRT 是一种学习率调度形式，因为它定义了在模型训练期间学习率应如何以及何时变化。 要配置 LRRT，你需要设置以下参数： lr_range_test_min_lr ：训练的初始学习率（float） lr_range_test_step_size：按训练步数定义的提高学习率的间隔（integer） lr_range_test_step_rate：提高学习率的缩放因子（float） lr_range_test_staircase：如果为 true，则每 lr_range_test_step_size 个训练步更改学习率，否则在每个训练步更改学习率（boolean） 所需的模型配置更改 我们将通过一个 LRRT 调度示例来说明所需的模型配置更改，该示例： 以 0.0001 的初始学习率开始训练 使用缩放率 5 使用 200 个训练步的缩放间隔 在每个训练步缩放学习率，即不使用 staircase PyTorch 对于 PyTorch 模型，LRRT 实现为学习率调度器，这是 PyTorch 1.0.1 及更新版本中可用的功能。因此，你可以向模型配置中添加一个类型为 "LRRangeTest" 的 "scheduler" 条目，如下所示： "scheduler": { "type": "LRRangeTest", "params": { "lr_range_test_min_lr": 0.0001, "lr_range_test_step_size": 200, "lr_range_test_step_rate": 5, "lr_range_test_staircase": false } } 示例：针对大批量大小进行调优 我们通过一段调优内部生产模型以在更大批量大小上高效收敛的经验片段，来说明 LRRT 如何使数据科学家受益：我们将规模从一个 GPU（批量大小 512）扩展到四个 GPU（批量大小 2048）。我们的目标是使用更大的批量大小训练模型，以便在使用相同数量的数据样本时匹配较小批量大小的性能。这里的挑战是大批量大小训练收敛缓慢这一众所周知的问题。我们的方法是在 DeepSpeed 中使用 1Cycle 调度来解决此问题，并使用 LRRT 来配置该调度。在下面的图中，我们展示了使用 LRRT 来发现可用于批量大小 2048 有效训练的最大学习率。左图显示了在训练的前 9000 个批次中，大学习率对验证损失的影响。右图显示了同一训练期间的学习率值。通过网格搜索，我们发现批量大小 2048 的最佳固定学习率为 0.0002。蓝线（lr=0.0002）表示使用该固定学习率进行训练。我们将两个 LRRT 调度与该固定学习率进行比较。橙色（lr_range_test_step_rate=5）和灰色（lr_range_test_step_rate=50）线表示使用相似 LRRT 调度进行的训练，二者仅在 lr_range_test_step_rate 值上不同。尽管这两个 LRRT 调度从相同的基准学习率开始，但灰线的学习率增长速度约为橙线的 10 倍。此外，在所示数据点中，LRRT 调度的学习率已增长到高于蓝线。我们随后分别将灰线称为“快速增长”的 LRRT 调度，将橙线称为“缓慢增长”的 LRRT 调度。 我们从这个小示例中得出以下观察结果。 较大的学习率显然有利于模型性能，直到某一点为止。快速增长的 LRRT 调度在 3000 个批次后实现了 0.46 的验证损失，而固定学习率在 9000 个批次后仍未达到该值。缓慢增长的 LRRT 直到 6000 个批次后才达到该分数，但它相对于固定学习率一直保持着不断增长的性能优势。 可用于训练模型的学习率值存在上限。快速增长的 LRRT 调度很快触及该边界并发散，而缓慢增长的 LRRT 后来也会因同样的原因发散。LRRT 帮助我们使用不到 2% 的训练数据快速发现了这些边界。这些边界是用于构建学习率调度的有用信息。 来自 LRRT 的这些观察结果帮助我们为解决问题的 1Cycle 调度配置学习率边界和周期跨度，如下所示。 "OneCycle": { "cycle_min_lr": 0.002, "cycle_max_lr": 0.005, "cycle_first_step_size": 2000, "cycle_second_step_size": 2000, ... } 根据我们的经验，这些是 1Cycle 调度最关键的四项参数。我们选择使用较慢的 LRRT 调度（lr_range_test_step_rate=5）来设置 cycle_min_lr，因为它实现了最佳损失，而较快的调度发散相当快。我们将 cycle_max_lr 设置为 0.005，尽管图中显示在略高的学习率下性能仍在提升。这是因为我们观察到，如果我们等到最大学习率，模型可能处于发散边缘且无法恢复。由于学习率达到 0.005 需要 8000 个批次，我们将 cycle_first_step_size 和（cycle_second_step_size）设置为 2000，这是四个 GPU 处理 8000 个批次所需的步数。 我们希望这个简短的示例能激发你的想象，将 LRRT 用于你自己独特的调优挑战。 更新于：2025 年 11 月 5 日 上一篇 下一篇

lr_range_test_min_lr

模式 5： 训练概览与功能 内容概览 分布式、有效且高效的轻松训练 速度 内存效率 可扩展性 通信效率 数据效率 支持长序列长度 快速收敛以提升有效性 良好的易用性 功能 混合精度分布式训练 混合精度训练 单 GPU、多 GPU 和多节点训练 流水线并行 模型并行 支持自定义模型并行 与 Megatron-LM 集成 零冗余优化器 优化器状态与梯度分区 激活分区 常量缓冲区优化（CBO） 连续内存优化（CMO） ZeRO-Offload 额外的内存与带宽优化 智能梯度累积 通信重叠 训练功能 简化的训练 API 激活检查点 API 梯度裁剪 混合精度下的自动损失缩放 训练优化器 1-bit Adam、0/1 Adam 和 1-bit LAMB 优化器，通信量最多减少 26 倍 Fused Adam 优化器及任意 torch.optim.Optimizer CPU-Adam：高性能向量化实现的 Adam 内存带宽优化的 FP16 优化器 使用 LAMB 优化器进行大批量训练 使用 ZeRO 优化器进行内存高效训练 与训练无关的检查点 高级参数搜索 学习率范围测试 1Cycle 学习率调度 简化的数据加载器 数据效率 课程学习 性能分析与调试 墙钟时间分解 激活检查点函数的计时 Flops 分析器 自动调优 监控 通信日志记录 稀疏注意力 专家混合（MoE） 概览 训练高级深度学习模型颇具挑战。除了模型设计之外，模型科学家还需要设置最先进的训练技术，例如分布式训练、混合精度、梯度累积和检查点。然而，科学家们可能仍然无法达到理想的系统性能和收敛速度。大模型规模甚至更具挑战性：大模型在纯数据并行下很容易耗尽内存，而且很难使用模型并行。DeepSpeed 应对这些挑战，以加速模型开发和训练。 分布式、有效且高效的轻松训练 DeepSpeed API 是 PyTorch 上的轻量级封装。这意味着你可以使用 PyTorch 中你所喜爱的一切，而无需学习新平台。此外，DeepSpeed 管理所有样板化的最先进训练技术，例如分布式训练、混合精度、梯度累积和检查点，以便你可以专注于模型开发。最重要的是，你可以利用 DeepSpeed 独特的效率与有效性优势，只需对 PyTorch 模型进行几行代码更改，即可提升速度和规模。 速度 DeepSpeed 通过在计算/通信/内存/IO 上的效率优化，以及在高级超参数调优和优化器上的有效性优化相结合，实现高性能和快速收敛。例如： DeepSpeed 使用 1024 个 V100 GPU（64 台 DGX-2 机器）在 44 分钟内将 BERT-large 训练到同等水平，并使用 256 个 GPU（16 台 DGX-2 机器）在 2.4 小时内完成。 BERT-large 训练时间 设备 来源 训练时间 1024 个 V100 GPU DeepSpeed 44 分钟 256 个 V100 GPU DeepSpeed 2.4 小时 64 个 V100 GPU DeepSpeed 8.68 小时 16 个 V100 GPU DeepSpeed 33.22 小时 BERT 代码和教程即将推出。 DeepSpeed 在 Azure GPU 上训练 GPT2（15 亿参数）比最先进的 NVIDIA Megatron 快 3.75 倍。阅读更多：GPT 教程 内存效率 DeepSpeed 提供内存高效的数据并行，并支持在没有模型并行的情况下训练模型。例如，DeepSpeed 可以在单个 GPU 上训练多达 130 亿参数的模型。相比之下，现有框架（例如 PyTorch 的 Distributed Data Parallel）在 14 亿参数模型上就会耗尽内存。DeepSpeed 通过一种名为零冗余优化器（ZeRO）的新颖解决方案减少训练内存占用。与在数据并行进程间复制内存状态的基本数据并行不同，ZeRO 对模型状态和梯度进行分区，以节省大量内存。此外，它还减少激活内存和碎片化内存。当前实现（ZeRO-2）相对于最先进方案最多可减少 8 倍内存。你可以在我们的论文中，以及与我们关于 ZeRO-1 和 ZeRO-2 的博客文章中阅读更多关于 ZeRO 的内容。凭借这一令人印象深刻的内存减少，DeepSpeed 的早期采用者已经生产出一个拥有超过 170 亿参数的名为 Turing-NLG 的语言模型（LM），在 LM 类别中确立了新的 SOTA。对于 GPU 资源有限的模型科学家，ZeRO-Offload 利用 CPU 和 GPU 内存来训练大模型。使用一台单 GPU 的机器，我们的用户可以运行多达 130 亿参数的模型而不会耗尽内存，比现有方法大 10 倍，同时获得有竞争力的吞吐量。这一功能使数十亿参数模型训练变得大众化，并为许多深度学习从业者打开了探索更大、更好模型的大门。 可扩展性 DeepSpeed 支持高效的数据并行、模型并行、流水线并行及其组合，我们称之为 3D 并行。DeepSpeed 的 3D 并行提供系统支持，以运行具有数万亿参数的模型，更多内容请阅读我们的新闻稿和教程。DeepSpeed 可以更高效地运行大模型，对于规模从 15 亿到数千亿的模型，速度最高可提升 10 倍。更具体地说，由 ZeRO 提供支持的数据并行是互补的，并且可以与不同类型的模型并行相结合。它允许 DeepSpeed 使用更低程度的模型并行和更高的批量大小来容纳模型，与仅使用模型并行相比，提供了显著的性能提升。阅读更多：ZeRO 论文和 GPT 教程。该图展示了 DeepSpeed（将 ZeRO 驱动的数据并行与 NVIDIA Megatron-LM 的模型并行相结合）相对于仅使用 Megatron-LM 的系统吞吐量改进。 通信效率 DeepSpeed 的流水线并行减少了分布式训练期间的通信量，这使用户能够在网络带宽有限的集群上以快 2–7 倍的速度训练数十亿参数模型。1-bit Adam、0/1 Adam 和 1-bit LAMB 将通信量最多减少 26 倍，同时实现与 Adam 相似的收敛效率，从而可以扩展到不同类型的 GPU 集群和网络。1-bit Adam 博客文章、1-bit Adam 教程、0/1 Adam 教程、1-bit LAMB 教程。 数据效率 DeepSpeed 数据效率库通过课程学习提供高效的数据采样，并通过随机逐层 token 丢弃提供高效的数据路由。该组合解决方案在 GPT-3/BERT 预训练和 GPT/ViT 微调期间可实现最多 2 倍数据和 2 倍时间节省，或在相同数据/时间下进一步提升模型质量。更多内容请参见教程。 支持长序列长度 DeepSpeed 提供稀疏注意力内核——这是一项支持长模型输入序列的关键技术，无论输入是文本、图像还是声音。与经典的稠密 Transformer 相比，它支持长一个数量级的输入序列，并在精度相当的情况下实现最高快 6 倍的执行速度。它还在执行速度上比最先进的稀疏实现快 1.5–3 倍。此外，我们的稀疏内核支持灵活稀疏格式的高效执行，并赋能用户在其自定义稀疏结构上进行创新。在此阅读更多内容。 快速收敛以提升有效性 DeepSpeed 支持高级超参数调优和大批量优化器，例如 LAMB。这些改进了模型训练的有效性，并减少了收敛到目标精度所需的样本数量。阅读更多：调优教程。 良好的易用性 只需更改几行代码，即可让 PyTorch 模型使用 DeepSpeed 和 ZeRO。与当前的模型并行库相比，DeepSpeed 不需要重新设计代码或重构模型。它也不对模型维度（例如注意力头数、隐藏层大小等）、批量大小或任何其他训练参数施加限制。对于多达 130 亿参数的模型，你可以方便地使用 ZeRO 驱动的数据并行，而无需模型并行；相比之下，标准数据并行对于超过 14 亿参数的模型将耗尽内存。此外，DeepSpeed 方便地支持 ZeRO 驱动的数据并行与自定义模型并行的灵活组合，例如 NVIDIA Megatron-LM 的张量切片。 功能 下面我们提供简要的功能列表，有关描述和用法，请参阅我们详细的功能概览。 混合精度分布式训练 16 位混合精度 单 GPU/多 GPU/多节点 模型并行 支持自定义模型并行 与 Megatron-LM 集成 流水线并行 3D 并行 零冗余优化器 优化器状态与梯度分区 激活分区 常量缓冲区优化 连续内存优化 ZeRO-Offload 利用 CPU/GPU 内存进行模型训练 支持在单个 GPU 上训练 100 亿参数模型 超高速稠密 Transformer 内核 稀疏注意力 内存和计算高效的稀疏内核 支持比稠密长 10 倍的序列 灵活支持不同的稀疏结构 1-bit Adam、0/1 Adam 和 1-bit LAMB 自定义通信集合 最多节省 26 倍通信量 额外的内存与带宽优化 智能梯度累积 通信/计算重叠 训练功能 简化的训练 API 梯度裁剪 混合精度下的自动损失缩放 训练优化器 Fused Adam 优化器及任意 torch.optim.Optimizer 内存带宽优化的 FP16 优化器 使用 LAMB 优化器进行大批量训练 使用 ZeRO 优化器进行内存高效训练 CPU-Adam 与训练无关的检查点 高级参数搜索 学习率范围测试 1Cycle 学习率调度 简化的数据加载器 数据效率 通过课程学习实现高效数据采样，并通过随机逐层 token 丢弃实现高效数据路由 在 GPT-3/BERT 预训练和 GPT/ViT 微调期间最多节省 2 倍数据和 2 倍时间 或在相同数据/时间下进一步提升模型质量 课程学习 基于课程学习的数据流水线，在训练早期呈现更容易或更简单的示例 稳定且快 3.3 倍的 GPT-2 预训练，使用大 8 倍/4 倍的批量大小/学习率，同时保持 token 级收敛速度 与许多其他 DeepSpeed 功能互补 请注意，上述数据效率库提供更通用的课程学习支持。此旧版课程学习功能仍受支持，但我们建议使用数据效率库。 渐进式层级丢弃 高效且稳健的压缩训练 预训练收敛速度最高提升 2.5 倍 性能分析与调试 专家混合（MoE） title: “功能概览” layout: single permalink: /features/ toc: true toc_label: “内容” — 混合精度分布式训练 混合精度训练 通过在 deepspeed_config JSON 中启用 16 位（FP16）训练。 "fp16": { "enabled": true, "loss_scale": 0, "loss_scale_window": 1000, "hysteresis": 2, "consecutive_hysteresis": false, "min_loss_scale": 1 } 单 GPU、多 GPU 和多节点训练 通过使用 hostfile 指定资源，可以轻松在单 GPU、单节点多 GPU 或多节点多 GPU 执行之间切换。 deepspeed --hostfile= \ <client_entry.py> \ --deepspeed --deepspeed_config ds_config.json 脚本 <client_entry.py> 将在 中指定的资源上执行。 流水线并行 DeepSpeed 提供流水线并行，以实现内存和通信高效的训练。DeepSpeed 支持数据、模型和流水线并行的混合组合，并已使用 3D 并行扩展到超过一万亿参数。流水线并行还可以提高通信效率，并在低带宽集群上将训练加速最高 7 倍。 模型并行 支持自定义模型并行 DeepSpeed 支持所有形式的模型并行，包括基于张量切片的方法，例如 Megatron-LM。它只要求模型并行框架提供一个模型并行单元（mpu），该单元实现少量簿记功能： mpu.get_model_parallel_rank() mpu.get_model_parallel_group() mpu.get_model_parallel_world_size() mpu.get_data_parallel_rank() mpu.get_data_parallel_group() mpu.get_data_parallel_world_size() 与 Megatron-LM 集成 DeepSpeed 与 Megatron 完全兼容。详情请参阅 Megatron-LM 教程。 零冗余优化器 零冗余优化器（ZeRO）是 DeepSpeed 的核心，它使大模型训练能够达到仅靠模型并行根本无法实现的规模。启用后，ZeRO 允许在没有任何模型并行的情况下训练超过 130 亿参数的模型，并在当前一代硬件上通过模型并行训练最多 2000 亿参数的模型。更多详情请参阅 ZeRO 论文、关于与 DeepSpeed 集成的 GPT 教程。 优化器状态与梯度分区 ZeRO 中的优化器状态与梯度分区通过将这些状态跨数据并行进程分区而不是复制它们，将模型状态（优化器状态、梯度和参数）的内存消耗相比标准数据并行减少 8 倍。 激活分区 激活分区是 ZeRO 中的一种内存优化，可以减少模型并行训练（MP）期间激活所消耗的内存。在 MP 中，某些激活可能被所有 MP 进程需要，导致激活在 MP GPU 之间复制。激活分区在激活于前向传播中用于计算之后，以分区状态存储这些激活。这些激活在反向传播期间再次需要之前会被 allgather 收集。通过以分区状态存储激活，DeepSpeed 中的 ZeRO 可以按 MP 程度成比例地减少激活内存占用。 常量缓冲区优化（CBO） CBO 在将内存使用限制为常量大小的同时，实现高网络和内存吞吐量。对于内存和网络受限的操作，例如归一化或 allreduce 集合通信，性能取决于操作数的大小。简单地将所有操作数融合为一个大的操作数可以实现出色的吞吐量，但代价是不必要的内存开销。DeepSpeed 中的 CBO 将较小的操作数融合到一个大致预定义大小的缓冲区中，该缓冲区足够大以实现出色性能，同时避免不必要的内存开销。 连续内存优化（CMO） CMO 减少训练期间的内存碎片，防止由于缺乏连续内存而导致的内存不足错误。内存碎片是短生命周期和长生命周期内存对象交错的结果。在前向传播期间，激活检查点是长生命周期的，但重新计算的激活是短生命周期的。类似地，在反向计算期间，激活梯度是短生命周期的，而参数梯度是长生命周期的。CMO 将激活检查点和参数梯度转移到连续缓冲区中，防止内存碎片。 ZeRO-Offload ZeRO-Offload 通过利用 GPU 及其主机 CPU 上的计算和内存资源，推动了使用最少 GPU 资源高效训练最大模型规模的边界。它允许在单个 NVIDIA V100 GPU 上训练多达 130 亿参数的模型，比最先进水平大 10 倍，同时保持每 GPU 超过 30 teraflops 的高训练吞吐量。更多详情请参阅 ZeRO-Offload 发布博客，以及与 DeepSpeed 集成的教程。 额外的内存与带宽优化 智能梯度累积 梯度累积允许在有限内存下运行更大的批量大小，方法是将有效批量拆分为多个顺序的小批量，并对这些小批量中的参数梯度取平均。此外，不是在所有 GPU 上对每个小批量的梯度取平均，而是在序列的每一步在本地对梯度取平均，并在序列末尾执行一次 allreduce，以生成所有 GPU 上有效批量的平均梯度。与对每个小批量进行全局平均的方法相比，这种策略显著减少了通信，特别是当每个有效批次的小批量数量很大时。 通信重叠 在反向传播期间，DeepSpeed 可以将已计算参数梯度的平均所需通信与正在进行的梯度计算重叠。这种计算-通信重叠使 DeepSpeed 即使在中等批量大小下也能实现更高吞吐量。 训练功能 简化的训练 API DeepSpeed 核心 API 仅由少量方法组成： 初始化：initialize 训练：backward 和 step 参数解析：add_config_arguments 检查点：load_checkpoint 和 store_checkpoint DeepSpeed 通过使用这些 API，以及用于启用和禁用功能的 deepspeed_config JSON 文件，支持本文档中描述的大多数功能。更多详情请参阅核心 API 文档。 激活检查点 API DeepSpeed 的激活检查点 API 支持激活检查点分区、CPU 检查点和连续内存优化，同时还允许逐层分析。更多详情请参阅核心 API 文档。 梯度裁剪 { "gradient_clipping": 1.0 } DeepSpeed 在底层根据用户指定的最大梯度范数处理梯度裁剪。更多详情请参阅核心 API 文档。 混合精度下的自动损失缩放 DeepSpeed 内部处理混合精度训练的损失缩放。损失缩放的参数可以在 deepspeed_config JSON 文件中指定。更多详情请参阅核心 API 文档。 训练优化器 1-bit Adam、0/1 Adam 和 1-bit LAMB 优化器，通信量最多减少 26 倍 DeepSpeed 有三个通信高效的优化器，称为 1-bit Adam、0/1 Adam 和 1-bit LAMB。它们提供与 Adam/LAMB 相同的收敛性，通信量最多减少 26 倍，从而在带宽受限集群上使 BERT-Large 预训练吞吐量最高提升 6.6 倍，SQuAD 微调吞吐量最高提升 2.7 倍。有关用法和性能的更多详情，请参阅 1-bit Adam 教程、1-bit Adam 博客文章、0/1 Adam 教程和 1-bit LAMB 教程。有关技术细节，请参阅 1-bit Adam 论文、0/1 Adam 论文和 1-bit LAMB 论文。 Fused Adam 优化器及任意 torch.optim.Optimizer 使用 DeepSpeed，用户可以选择使用来自 NVIDIA 的高性能 ADAM 实现，或任何扩展 torch 的 torch.optim.Optimizer 类的训练优化器。 CPU-Adam：高性能向量化实现的 Adam 我们引入了一种高效的 CPU 上 Adam 优化器实现，将参数更新性能提升了近一个数量级。我们为 CPU-Adam 实现使用 Intel-x86 架构上的 AVX SIMD 指令。我们同时支持 AVX-512 和 AVX-2 指令集。DeepSpeed 默认使用 AVX-2，可以在安装 DeepSpeed 时通过将构建标志 DS_BUILD_AVX512 设置为 1 来切换到 AVX-512。使用 AVX-512，在模型规模介于 10 亿到 100 亿参数之间时，我们观察到相对于 torch-adam 有 5.1 倍到 6.5 倍的加速。 内存带宽优化的 FP16 优化器 混合精度训练由 DeepSpeed FP16 优化器处理。该优化器不仅处理 FP16 训练，而且非常高效。权重更新的性能主要受内存带宽支配，而实现的内存带宽取决于输入操作数的大小。FP16 优化器旨在通过将模型的所有参数合并到一个大的缓冲区中，并在单个内核中应用权重更新，从而最大化可实现的内存带宽，使其能够实现高内存带宽。 使用 LAMB 优化器进行大批量训练 DeepSpeed 通过启用 LAMB 优化器，使大批量训练变得容易。有关 LAMB 的更多详情，请参阅 LAMB 论文。 使用 ZeRO 优化器进行内存高效训练 DeepSpeed 可以在没有模型并行的情况下训练多达 130 亿参数的模型，并在 16 路模型并行下训练多达 2000 亿参数的模型。这种模型规模的飞跃是通过 ZeRO 优化器实现的内存效率而成为可能的。更多详情请参阅 ZeRO 论文。 与训练无关的检查点 DeepSpeed 可以为你简化检查点，无论你使用的是数据并行训练、模型并行训练、混合精度训练、这三者的混合，还是使用 zero 优化器来支持更大的模型规模。更多详情请参阅入门指南和核心 API 文档。 高级参数搜索 DeepSpeed 支持多种学习率调度，以实现大批量扩展的更快收敛。 学习率范围测试 请参阅学习率范围测试教程。 1Cycle 学习率调度 请参阅 1Cycle 学习率调度教程。 简化的数据加载器 在数据加载方面，DeepSpeed 为用户抽象掉了数据并行和模型并行。用户只需提供一个 PyTorch 数据集，DeepSpeed 数据加载器就可以自动适当地处理批次创建。 数据效率 请参阅数据效率教程。 课程学习 请参阅课程学习教程。请注意，上述数据效率库提供更通用的课程学习支持。此旧版课程学习功能仍受支持，但我们建议使用数据效率库。 性能分析与调试 DeepSpeed 提供了一组用于性能分析和调试的工具。 墙钟时间分解 DeepSpeed 提供训练不同部分所花费时间的详细分解。可以通过在 deepspeed_config 文件中设置以下内容来启用。 { "wall_clock_breakdown": true, } 激活检查点函数的计时 当启用激活检查点时，可以在 deepspeed_config 文件中启用对每个检查点函数的前向和反向时间进行分析。 { "activation_checkpointing": { "profile": true } } Flops 分析器 DeepSpeed flops 分析器测量 PyTorch 模型的时间、flops 和参数，并显示哪些模块或层是瓶颈。与 DeepSpeed 运行时一起使用时，可以在 deepspeed_config 文件中配置 flops 分析器，如下所示： { "flops_profiler": { "enabled": true, "profile_step": 1, "module_depth": -1, "top_modules": 3, "detailed": true, } } flops 分析器也可以作为独立包使用。更多详情请参阅 Flops 分析器教程。 自动调优 DeepSpeed Autotuner 使用模型信息、系统信息和启发式方法，高效地调优 Zero 阶段、微批量大小和其他 Zero 配置。使用自动调优功能不需要 DeepSpeed 用户更改代码。虽然 "autotuning": {"enabled": true} 是启用自动调优所需的最小配置，但用户还可以定义其他参数来配置自动调优过程。下面显示了自动调优配置中的主要参数及其默认值。更多详情请参阅自动调优教程。 { "autotuning": { "enabled": true, "results_dir": null, "exps_dir": null, "overwrite": false, "metric": "throughput", "num_nodes": null, "num_gpus": null, "start_profile_step": 3, "end_profile_step": 5, "fast": true, "num_tuning_micro_batch_sizes": 3, "tuner_type": "model_based", "tuner_early_stopping": 5, "tuner_num_trials": 50, "arg_mappings": null } } flops 分析器也可以作为独立包使用。更多详情请参阅 Flops 分析器教程。 监控 DeepSpeed Monitor 将实时训练指标记录到一个或多个监控后端，包括 PyTorch 的 TensorBoard、WandB，或简单地记录到 CSV 文件。可以在 deepspeed_config 文件中配置一个或多个后端，如下所示： { "tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } "wandb": { "enabled": true, "team": "my_team", "group": "my_group", "project": "my_project" } "csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } } Monitor 也可以添加用于记录自定义指标和客户端代码。更多详情请参阅监控教程。 通信日志记录 DeepSpeed 提供在 deepspeed.comm 中启动的所有通信操作的日志记录。可以在 deepspeed_config 文件中配置通信日志记录器，如下所示： { "comms_logger": { "enabled": true, "verbose": false, "prof_all": true, "debug": false } } 客户端代码随后可以通过调用 deepspeed.comm.log_summary() 打印摘要。有关更多详情和示例用法，请参阅通信日志记录教程。 稀疏注意力 DeepSpeed 提供稀疏注意力以支持长序列。请参阅稀疏注意力教程。 --deepspeed_sparse_attention "sparse_attention": { "mode": "fixed", "block": 16, "different_layout_per_head": true, "num_local_blocks": 4, "num_global_blocks": 1, "attention": "bidirectional", "horizontal_global_attention": false, "num_different_global_patterns": 4 } 专家混合（MoE） 要了解有关使用 DeepSpeed 训练专家混合（MoE）模型的更多信息，请参阅我们的教程以获取更多详情。

torch.optim.Optimizer

模式 6： Flops Profiler 内容概览 Flops 测量 多 GPU、多节点、数据并行与模型并行 用法 在 DeepSpeed 运行时中使用 示例：Megatron-LM 在 DeepSpeed 运行时之外使用 在模型推理中 示例：AlexNet 示例：Bert 在模型训练工作流中 示例训练工作流 在本教程中，我们介绍 DeepSpeed Flops Profiler，并提供其用法示例。 概览 Flops 测量 多 GPU、多节点、数据并行与模型并行 用法 概览 有效利用硬件资源对获得良好性能至关重要，但大规模模型训练与推理的现有实现中的性能低效往往难以被发现，也难以归因到具体的模块组件。DeepSpeed Flops Profiler 帮助用户轻松测量模型的训练/推理速度（延迟、吞吐量）以及模型及其子模块的效率（每秒浮点运算次数，即 FLOPS），从而消除现有实现中的低效问题。下面是在 A100 GPU 上、batch size 为 80 的 BERT-Large(NVIDIA) 的示例输出： -------------------------- DeepSpeed Flops Profiler -------------------------- Profile Summary at step 10: Notations: data parallel size (dp_size), model parallel size(mp_size), number of parameters (params), number of multiply-accumulate operations(MACs), number of floating-point operations (flops), floating-point operations per second (FLOPS), fwd latency (forward propagation latency), bwd latency (backward propagation latency), step (weights update latency), iter latency (sum of fwd, bwd and step latency) world size: 1 data parallel size: 1 model parallel size: 1 batch size per GPU: 80 params per gpu: 336.23 M params of model = params per GPU * mp_size: 336.23 M fwd MACs per GPU: 3139.93 G fwd flops per GPU: 6279.86 G fwd flops of model = fwd flops per GPU * mp_size: 6279.86 G fwd latency: 76.67 ms bwd latency: 108.02 ms fwd FLOPS per GPU = fwd flops per GPU / fwd latency: 81.9 TFLOPS bwd FLOPS per GPU = 2 * fwd flops per GPU / bwd latency: 116.27 TFLOPS fwd+bwd FLOPS per GPU = 3 * fwd flops per GPU / (fwd+bwd latency): 102.0 TFLOPS step latency: 34.09 us iter latency: 184.73 ms samples/second: 433.07 ----------------------------- Aggregated Profile per GPU ----------------------------- Top modules in terms of params, MACs or fwd latency at different model depths: depth 0: params - {'BertForPreTrainingPreLN': '336.23 M'} MACs - {'BertForPreTrainingPreLN': '3139.93 GMACs'} fwd latency - {'BertForPreTrainingPreLN': '76.39 ms'} depth 1: params - {'BertModel': '335.15 M', 'BertPreTrainingHeads': '32.34 M'} MACs - {'BertModel': '3092.96 GMACs', 'BertPreTrainingHeads': '46.97 GMACs'} fwd latency - {'BertModel': '34.29 ms', 'BertPreTrainingHeads': '3.23 ms'} depth 2: params - {'BertEncoder': '302.31 M', 'BertLMPredictionHead': '32.34 M'} MACs - {'BertEncoder': '3092.88 GMACs', 'BertLMPredictionHead': '46.97 GMACs'} fwd latency - {'BertEncoder': '33.45 ms', 'BertLMPredictionHead': '2.61 ms'} depth 3: params - {'ModuleList': '302.31 M', 'Embedding': '31.79 M', 'Linear': '31.26 M'} MACs - {'ModuleList': '3092.88 GMACs', 'Linear': '36.23 GMACs'} fwd latency - {'ModuleList': '33.11 ms', 'BertPredictionHeadTransform': '1.83 ms''} depth 4: params - {'BertLayer': '302.31 M', 'LinearActivation': '1.05 M''} MACs - {'BertLayer': '3092.88 GMACs', 'LinearActivation': '10.74 GMACs'} fwd latency - {'BertLayer': '33.11 ms', 'LinearActivation': '1.43 ms'} depth 5: params - {'BertAttention': '100.76 M', 'BertIntermediate': '100.76 M'} MACs - {'BertAttention': '1031.3 GMACs', 'BertIntermediate': '1030.79 GMACs'} fwd latency - {'BertAttention': '19.83 ms', 'BertOutput': '4.38 ms'} depth 6: params - {'LinearActivation': '100.76 M', 'Linear': '100.69 M'} MACs - {'LinearActivation': '1030.79 GMACs', 'Linear': '1030.79 GMACs'} fwd latency - {'BertSelfAttention': '16.29 ms', 'LinearActivation': '3.48 ms'} ------------------------------ Detailed Profile per GPU ------------------------------ Each module profile is listed after its name in the following order: params, percentage of total params, MACs, percentage of total MACs, fwd latency, percentage of total fwd latency, fwd FLOPS BertForPreTrainingPreLN( 336.23 M, 100.00% Params, 3139.93 GMACs, 100.00% MACs, 76.39 ms, 100.00% latency, 82.21 TFLOPS, (bert): BertModel( 335.15 M, 99.68% Params, 3092.96 GMACs, 98.50% MACs, 34.29 ms, 44.89% latency, 180.4 TFLOPS, (embeddings): BertEmbeddings(...) (encoder): BertEncoder( 302.31 M, 89.91% Params, 3092.88 GMACs, 98.50% MACs, 33.45 ms, 43.79% latency, 184.93 TFLOPS, (FinalLayerNorm): FusedLayerNorm(...) (layer): ModuleList( 302.31 M, 89.91% Params, 3092.88 GMACs, 98.50% MACs, 33.11 ms, 43.35% latency, 186.8 TFLOPS, (0): BertLayer( 12.6 M, 3.75% Params, 128.87 GMACs, 4.10% MACs, 1.29 ms, 1.69% latency, 199.49 TFLOPS, (attention): BertAttention( 4.2 M, 1.25% Params, 42.97 GMACs, 1.37% MACs, 833.75 us, 1.09% latency, 103.08 TFLOPS, (self): BertSelfAttention( 3.15 M, 0.94% Params, 32.23 GMACs, 1.03% MACs, 699.04 us, 0.92% latency, 92.22 TFLOPS, (query): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 182.39 us, 0.24% latency, 117.74 TFLOPS,...) (key): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 57.22 us, 0.07% latency, 375.3 TFLOPS,...) (value): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 53.17 us, 0.07% latency, 403.91 TFLOPS,...) (dropout): Dropout(...) (softmax): Softmax(...) ) (output): BertSelfOutput( 1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 114.68 us, 0.15% latency, 187.26 TFLOPS, (dense): Linear(1.05 M, 0.31% Params, 10.74 GMACs, 0.34% MACs, 64.13 us, 0.08% latency, 334.84 TFLOPS, ...) (dropout): Dropout(...) ) ) (PreAttentionLayerNorm): FusedLayerNorm(...) (PostAttentionLayerNorm): FusedLayerNorm(...) (intermediate): BertIntermediate( 4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 186.68 us, 0.24% latency, 460.14 TFLOPS, (dense_act): LinearActivation(4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 175.0 us, 0.23% latency, 490.86 TFLOPS,...) ) (output): BertOutput( 4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 116.83 us, 0.15% latency, 735.28 TFLOPS, (dense): Linear(4.2 M, 1.25% Params, 42.95 GMACs, 1.37% MACs, 65.57 us, 0.09% latency, 1310.14 TFLOPS,...) (dropout): Dropout(...) ) ) ... (23): BertLayer(...) ) ) (pooler): BertPooler(...) ) (cls): BertPreTrainingHeads(...) ) ------------------------------------------------------------------------------ 在摘要 profile 中，DeepSpeed Flops Profiler 输出模型的参数数量、浮点运算次数（flops）、FLOPS、延迟以及以 samples/second 为单位的吞吐量。该 profile 展示了当前模型执行与峰值硬件性能之间还有多大的性能差距，并帮助用户调整训练或推理设置（例如超参数、数据并行、模型并行、系统配置等）以获得更好的性能。DeepSpeed Flops Profiler 还测量不同模型深度上的重要模块（聚合 profile）以及模型架构中特定模块的 profile（详细 profile）。借助这些 profile，DeepSpeed 用户可以了解每一层或子模块如何影响整体模型复杂度/性能。随后用户可以调整或重构模型设计以提升性能。例如，借助该 profiler，DeepSpeed 用户可以定量判断堆叠更小的层是否比使用更大的层更轻量或性能更好。聚合 profile 和详细 profile 还允许用户快速识别瓶颈模块。在上面的 BERT-Large 示例中，使用 DeepSpeed Flops Profiler，我们发现 BertLayer 是最重要的层，并且包含相当多的 dropout、softmax 和 layer norm 以及 linear 模块。这些模块的 flops 并不高，却会触发大量 GPU kernel 调用，并产生过多的内存读写请求。详细 profile 中展示的模式表明这非常适合 kernel fusion，于是我们开发了 fused transformer-kernels 以减少数据移动（参见 DeepSpeedBert）。应用我们的优化后，我们看到 DeepSpeed Flops Profiler 输出中每个 GPU 的 FLOPS 以及整体训练 samples/second 提升了 25%。DeepSpeed Flops Profiler 可以在无需更改任何用户代码的情况下与 DeepSpeed 运行时一起使用，也可以作为独立包脱离 DeepSpeed 使用。在使用 DeepSpeed 进行模型训练时，可以在 DeepSpeed 配置文件中启用该 profiler。作为独立包，该 profiler API 既可用于训练代码，也可用于推理代码。DeepSpeed profiler 仍在积极开发中，目前仅包含初始功能。敬请关注，更多令人期待的功能即将加入。 Flops 测量 与现有的 flops 计算工具或方法类似，DeepSpeed Flops Profiler 测量模块前向传播的 flops，而后向传播的 flops 估计为前向传播的两倍。与计算 PyTorch 算子 flops 的 PyTorch profiler 不同，DeepSpeed Flops Profiler 测量模型中模块内部的 flops，并为用户提供关于模型执行的更多洞察。flops 估计部分受到 ptflops 的启发，主要区别在于 DeepSpeed Flops Profiler 不仅支持直接在模块级别进行 flops 计算，还可以捕获模块中调用的 torch.nn.functional 来估计 flops。因此，DeepSpeed Flops Profiler 支持模型中的自定义模块，例如 Megatron-LM 中的 ParallelTransformerLayerworks、ParallelSelfAttention、RowParallelLinear 等。这与 ptflops 形成对比，后者要求用户为每个自定义模块编写自定义的 flops 计算函数。 多 GPU、多节点、数据并行与模型并行 DeepSpeed Flops Profiler 输出每个 GPU 的 profile 以及 world size、数据并行大小和模型并行大小。对于在多 GPU 或多节点上运行的模型，只有模型并行的变化（例如 Megatron-LM 中的 --model-parallel-size）会影响所分析的 flops 和参数数量，即 model_parallel_size * flops = total_flops 以及 model_parallel_size * parameters = total_parameters。数据并行大小或 world size（与 GPU 或节点数量相关）不会影响每个 GPU 的 profile。 用法 DeepSpeed Flops Profiler 可以与 DeepSpeed 运行时一起使用，也可以作为独立包使用。在使用 DeepSpeed 进行模型训练时，可以在 deepspeed 配置文件中配置该 profiler，而无需更改用户代码。要在 DeepSpeed 运行时之外使用 flops profiler，请安装 DeepSpeed 并导入 flops_profiler 包以直接使用这些 API。下面给出了每种用法的示例。 在 DeepSpeed 运行时中使用 示例：Megatron-LM 在 DeepSpeed 运行时之外使用 在模型推理中 示例：AlexNet 示例：Bert 在模型训练工作流中 示例训练工作流 在 DeepSpeed 运行时中使用 在使用 DeepSpeed 进行模型训练时，可以在 deepspeed 配置文件中配置该 profiler。使用该 profiler 无需显式调用 API。可以通过将以下字段添加到 deepspeed 的配置 json 文件中来启用该 profiler。详情请参阅 flops profiler。 { "flops_profiler": { "enabled": true, "profile_step": 1, "module_depth": -1, "top_modules": 1, "detailed": true, "output_file": null } } 示例：Megatron-LM 有关使用 DeepSpeed 运行 Megatron-LM 的信息，请参阅我们的教程 Megatron-LM。下面展示了 12 层 Megatron-LM 模型（hidden_size = 8192，num_attention_heads = 32，batch_size = 1024，seq_length = 1024）的示例输出。 -------------------------- DeepSpeed Flops Profiler -------------------------- Profile Summary at step 10: Notations: data parallel size (dp_size), model parallel size(mp_size), number of parameters (params), number of multiply-accumulate operations(MACs), number of floating-point operations (flops), floating-point operations per second (FLOPS), fwd latency (forward propagation latency), bwd latency (backward propagation latency), step (weights update latency), iter latency (sum of fwd, bwd and step latency) world size: 1 data parallel size: 1 model parallel size: 1 batch size per GPU: 1024 params per gpu: 1.29 M params of model = params per GPU * mp_size: 1.29 M fwd MACs per GPU: 41271.95 G fwd flops per GPU: 82543.9 G fwd flops of model = fwd flops per GPU * mp_size: 82543.9 G fwd latency: 1.89 s bwd latency: 5.38 s fwd FLOPS per GPU = fwd flops per GPU / fwd latency: 43.68 TFLOPS bwd FLOPS per GPU = 2 * fwd flops per GPU / bwd latency: 30.7 TFLOPS fwd+bwd FLOPS per GPU = 3 * fwd flops per GPU / (fwd+bwd latency): 34.07 TFLOPS step latency: 34.12 s iter latency: 41.39 s samples/second: 24.74 ----------------------------- Aggregated Profile per GPU ----------------------------- Top 1 modules in terms of params, MACs or fwd latency at different model depths: depth 0: params - {'GPT2Model': '1.29 M'} MACs - {'GPT2Model': '41271.95 GMACs'} fwd latency - {'GPT2Model': '1.84 s'} depth 1: params - {'TransformerLanguageModel': '1.29 M'} MACs - {'TransformerLanguageModel': '39584.03 GMACs'} fwd latency - {'TransformerLanguageModel': '1.83 s'} depth 2: params - {'ParallelTransformer': '1.29 M'} MACs - {'ParallelTransformer': '39584.03 GMACs'} fwd latency - {'ParallelTransformer': '1.81 s'} depth 3: params - {'ModuleList': '1.28 M'} MACs - {'ModuleList': '39584.03 GMACs'} fwd latency - {'ModuleList': '1.3 s'} depth 4: params - {'ParallelTransformerLayerPart2': '688.15 k'} MACs - {'ParallelTransformerLayerPart2': '26388.28 GMACs'} fwd latency - {'ParallelTransformerLayerPart2': '865.73 ms'} depth 5: params - {'ParallelMLP': '491.54 k'} MACs - {'ParallelMLP': '26388.28 GMACs'} fwd latency - {'ParallelMLP': '849.4 ms'} ------------------------------ Detailed Profile per GPU ------------------------------ Each module profile is listed after its name in the following order: params, percentage of total params, MACs, percentage of total MACs, fwd latency, percentage of total fwd latency, fwd FLOPS Note: 1. A module can have torch.nn.module or torch.nn.functional to compute logits (e.g. CrossEntropyLoss). They are not counted as submodules, thus not to be printed out. However they make up the difference between a parent's MACs(or latency) and the sum of its submodules'. 1. Number of floating-point operations is a theoretical estimation, thus FLOPS computed using that could be larger than the maximum system throughput. 2. The fwd latency listed in the top module's profile is directly captured at the module forward function in PyTorch, thus it's less than the fwd latency shown above which is captured in DeepSpeed. GPT2Model( 1.29 M, 100.00% Params, 41271.95 GMACs, 100.00% MACs, 1.84 s, 100.00% latency, 44.78 TFLOPS, (language_model): TransformerLanguageModel( 1.29 M, 100.00% Params, 39584.03 GMACs, 95.91% MACs, 1.83 s, 99.11% latency, 43.34 TFLOPS, (embedding): Embedding( 2, 0.00% Params, 0 MACs, 0.00% MACs, 18.1 ms, 0.98% latency, 0.0 FLOPS, (word_embeddings): VocabParallelEmbedding(1, 0.00% Params, 0 MACs, 0.00% MACs, 164.75 us, 0.01% latency, 0.0 FLOPS, ) (position_embeddings): Embedding(1, 0.00% Params, 0 MACs, 0.00% MACs, 489.23 us, 0.03% latency, 0.0 FLOPS, 1024, 8192) (embedding_dropout): Dropout(0, 0.00% Params, 0 MACs, 0.00% MACs, 93.94 us, 0.01% latency, 0.0 FLOPS, p=0.1, inplace=False) ) (transformer): ParallelTransformer( 1.29 M, 100.00% Params, 39584.03 GMACs, 95.91% MACs, 1.81 s, 98.11% latency, 43.78 TFLOPS, (layers): ModuleList( 1.28 M, 98.73% Params, 39584.03 GMACs, 95.91% MACs, 1.3 s, 70.66% latency, 60.79 TFLOPS, (0): ParallelTransformerLayerPart1( 49.15 k, 3.80% Params, 1099.65 GMACs, 2.66% MACs, 23.5 ms, 1.27% latency, 93.6 TFLOPS, (input_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 128.75 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) (attention): ParallelSelfAttention( 32.77 k, 2.53% Params, 1099.65 GMACs, 2.66% MACs, 22.8 ms, 1.24% latency, 96.46 TFLOPS, (query_key_value): ColumnParallelLinear(24.58 k, 1.90% Params, 824.63 GMACs, 2.00% MACs, 8.93 ms, 0.48% latency, 184.7 TFLOPS, ) (scale_mask_softmax): FusedScaleMaskSoftmax(0, 0.00% Params, 134.22 MMACs, 0.00% MACs, 151.16 us, 0.01% latency, 1.78 TFLOPS, ) (attention_dropout): Dropout(0, 0.00% Params, 0 MACs, 0.00% MACs, 79.63 us, 0.00% latency, 0.0 FLOPS, p=0.1, inplace=False) (dense): RowParallelLinear(8.19 k, 0.63% Params, 274.88 GMACs, 0.67% MACs, 2.67 ms, 0.14% latency, 205.81 TFLOPS, ) ) ) (1): ParallelTransformerLayerPart2( 57.35 k, 4.43% Params, 2199.02 GMACs, 5.33% MACs, 77.53 ms, 4.21% latency, 56.73 TFLOPS, (post_attention_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 116.11 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) (mlp): ParallelMLP( 40.96 k, 3.16% Params, 2199.02 GMACs, 5.33% MACs, 76.19 ms, 4.13% latency, 57.72 TFLOPS, (dense_h_to_4h): ColumnParallelLinear(32.77 k, 2.53% Params, 1099.51 GMACs, 2.66% MACs, 10.79 ms, 0.59% latency, 203.81 TFLOPS, ) (dense_4h_to_h): RowParallelLinear(8.19 k, 0.63% Params, 1099.51 GMACs, 2.66% MACs, 14.38 ms, 0.78% latency, 152.95 TFLOPS, ) ) ) ... (23): ParallelTransformerLayerPart2(...) ) (final_layernorm): FusedLayerNorm(16.38 k, 1.27% Params, 0 MACs, 0.00% MACs, 110.86 us, 0.01% latency, 0.0 FLOPS, torch.Size([8192]), eps=1e-05, elementwise_affine=True) ) ) ) ------------------------------------------------------------------------------ 在 DeepSpeed 运行时之外使用 该 profiler 可以作为独立包在 DeepSpeed 运行时之外使用。只需安装 DeepSpeed 并导入 flops_profiler 包即可直接使用这些 API。有关安装 DeepSpeed 的信息，请参阅 installation of DeepSpeed。 在模型推理中 要在推理中分析已训练模型，请使用 get_model_profile 函数。下面给出了示例。 示例：AlexNet 以下示例展示了如何使用 DeepSpeed flops profiler 分析 AlexNet。 import torchvision.models as models import torch from deepspeed.profiling.flops_profiler import get_model_profile from deepspeed.accelerator import get_accelerator with get_accelerator().device(0): model = models.alexnet() batch_size = 256 flops, macs, params = get_model_profile(model=model, # model input_shape=(batch_size, 3, 224, 224), # input shape to the model. If specified, the model takes a tensor with this shape as the only positional argument. args=None, # list of positional arguments to the model. kwargs=None, # dictionary of keyword arguments to the model. print_profile=True, # prints the model graph with the measured profile attached to each module detailed=True, # print the detailed profile module_depth=-1, # depth into the nested modules, with -1 being the inner most modules top_modules=1, # the number of top modules to print aggregated profile warm_up=10, # the number of warm-ups before measuring the time of each module as_string=True, # print raw numbers (e.g. 1000) or as human-readable strings (e.g. 1k) output_file=None, # path to the output file. If None, the profiler prints to stdout. ignore_modules=None) # the list of modules to ignore in the profiling 示例：Bert from functools import partial import torch from transformers import BertForSequenceClassification, BertTokenizer from deepspeed.profiling.flops_profiler import get_model_profile from deepspeed.accelerator import get_accelerator def bert_input_constructor(batch_size, seq_len, tokenizer): fake_seq = "" for _ in range(seq_len - 2): # ignore the two special tokens [CLS] and [SEP] fake_seq += tokenizer.pad_token inputs = tokenizer([fake_seq] * batch_size, padding=True, truncation=True, return_tensors="pt") labels = torch.tensor([1] * batch_size) inputs = dict(inputs) inputs.update({"labels": labels}) return inputs with get_accelerator().device(0): tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased') batch_size = 4 seq_len = 128 enable_profile = True if enable_profile: flops, macs, params = get_model_profile( model, kwargs=bert_input_constructor(batch_size, seq_len, tokenizer), print_profile=True, detailed=True, ) else: inputs = bert_input_constructor((batch_size, seq_len), tokenizer) outputs = model(inputs) 在模型训练工作流中 要在训练工作流中分析模型前向传播，请使用 FlopsProfilerclass。FlopsProfilerclass 提供以下方法： start_profile() - 开始分析 get_total_flops(as_string=False) - 返回模型中浮点运算的总次数 get_total_macs(as_string=False) - 返回模型中 MACs 的总数 get_total_params(as_string=False) - 返回模型中参数的总数 print_model_profile(profile_step=1, module_depth=-1, top_modules=3, detailed=True, output_file=None) - 打印模型 profile stop_profile() - 停止分析。这会停止模型中的 flops 计数。 end_profile() - 清理。这会清理分析期间添加到模型上的 profile 属性。应在分析结束时、并且在 get_total_flops、get_total_params 或 print_model_profile 之后调用。 示例训练工作流 下面是在典型训练工作流中使用该功能的示例。 from deepspeed.profiling.flops_profiler import FlopsProfiler model = Model() prof = FlopsProfiler(model) profile_step = 5 print_profile= True for step, batch in enumerate(data_loader): # start profiling at training step "profile_step" if step == profile_step: prof.start_profile() # forward() method loss = model(batch) # end profiling and print output if step == profile_step: # if using multi nodes, check global_rank == 0 as well prof.stop_profile() flops = prof.get_total_flops() macs = prof.get_total_macs() params = prof.get_total_params() if print_profile: prof.print_model_profile(profile_step=profile_step) prof.end_profile() # runs backpropagation loss.backward() # weight update optimizer.step() 更新于：2025 年 11 月 5 日 上一页 下一页

80

模式 7： DeepSpeed 配置 JSON 内容 批次大小相关参数 优化器参数 调度器参数 通信选项 FP16 训练选项 BFLOAT16 训练选项 自动混合精度（AMP）训练选项 梯度裁剪 FP16 训练的 ZeRO 优化 参数卸载 优化器卸载 异步 I/O 日志记录 自动调优 Flops Profiler 激活检查点 稀疏注意力 数据效率 课程学习 监控模块 弹性训练配置（V0.1 和 V0.2） 通信日志记录 压缩 层缩减 权重量化 激活量化 稀疏剪枝 行剪枝 头剪枝 通道剪枝 Checkpoint 选项 数据类型选项 批次大小相关参数 注意：train_batch_size 必须等于 train_micro_batch_size_per_gpu * gradient_accumulation_steps * GPU 数量。为简单起见，你可以选择只指定这三个参数中的两个，最后一个将由 DeepSpeed 自动推断。 train_batch_size：[integer] 值 示例 有效的训练批次大小。这是导致一次模型更新步骤的数据样本量。train_batch_size 由单个 GPU 在一次前向/反向传播中处理的批次大小（即 train_micro_batch_size_per_gpu）、梯度累积步数（即 gradient_accumulation_steps）以及 GPU 数量汇总而成。如果同时提供了 train_micro_batch_size_per_gpu 和 gradient_accumulation_steps，则可以省略。 32 train_micro_batch_size_per_gpu：[integer] 描述 默认值 一个 GPU 在一步中处理的批次大小（不含梯度累积）。如果同时提供了 train_batch_size 和 gradient_accumulation_steps，则可以省略。 train_batch_size 值 gradient_accumulation_steps：[integer] 描述 默认值 在平均并应用梯度之前累积梯度的训练步数。此特性有时有助于提升可扩展性，因为它会降低步与步之间梯度通信的频率。此特性的另一个影响是能够以每个 GPU 更大的批次大小进行训练。如果同时提供了 train_batch_size 和 train_micro_batch_size_per_gpu，则可以省略。 1 优化器参数 optimizer：[dictionary] 字段 值 示例 type 优化器名称。DeepSpeed 原生支持 Adam、AdamW、OneBitAdam、Lamb 和 OneBitLamb 优化器（详见此处），并将从 torch 导入其他优化器。 "Adam" params 用于实例化优化器的参数字典。参数名称必须与优化器构造函数签名匹配（例如，对于 Adam）。 {"lr": 0.001, "eps": 1e-8} 使用 Adam 的优化器示例 "optimizer": { "type": "Adam", "params": { "lr": 0.001, "betas": [ 0.8, 0.999 ], "eps": 1e-8, "weight_decay": 3e-7 } } 除 torch.optim.Adam 的标准参数外，Adam 优化器还支持以下两个 params 键/值： “params” 键 描述 默认值 torch_adam 使用 torch 的 adam 实现，而非我们的融合 adam 实现 false adam_w_mode 应用 L2 正则化（也称为 AdamW） true 另一个带有 1-bit Adam 特定参数的优化器示例如下。 "optimizer": { "type": "OneBitAdam", "params": { "lr": 0.001, "betas": [ 0.8, 0.999 ], "eps": 1e-8, "weight_decay": 3e-7, "freeze_step": 400, "cuda_aware": false, "comm_backend_name": "nccl" } } 除标准 Adam 外，1-bit Adam 优化器还支持以下三个 params 键/值（更多信息请参阅我们的教程）： “params” 键 描述 默认值 freeze_step 在 1-bit 压缩应用于通信之前的预热步数 100000 cuda_aware 表示底层 MPI 库是否支持 CUDA-Aware 通信 false comm_backend_name 表示使用哪个后端实现 “nccl” 1-bit Adam 的一个变体优化器是 0/1 Adam，它通过自适应方差冻结和优化器状态上的 1-bit 同步进一步优化 1-bit Adam。 "optimizer": { "type": "ZeroOneAdam", "params": { "lr": 1e-3, "weight_decay": 0.01, "bias_correction": false, "var_freeze_step": 1000, "var_update_scaler": 16, "local_step_scaler": 1000, "local_step_clipper": 16, "cuda_aware": false, "comm_backend_name": "nccl" } } 除标准 Adam 外，0/1 Adam 还支持以下 params 键/值（更多信息请参阅我们的教程。） “params” 键 描述 默认值 var_freeze_step 更新方差的最新步数 100000 var_update_scaler 更新方差的间隔 16 local_step_scaler 根据学习率策略缩放本地步数间隔的间隔 32678 local_step_clipper 使用学习率策略时本地步数的最大间隔 16 cuda_aware 表示底层 MPI 库是否支持 CUDA-Aware 通信 false comm_backend_name 表示使用哪个后端实现 “nccl” 另一个带有 1-bit LAMB 的优化器示例 "optimizer": { "type": "OneBitLamb", "params": { "lr": 11e-3, "weight_decay": 0.01, "bias_correction": false, "max_coeff": 0.3, "min_coeff": 0.01, "freeze_step": 1000, "cuda_aware": false, "comm_backend_name": "nccl", "coeff_beta": 0.9, "factor_max": 4.0, "factor_min": 0.5, "factor_threshold": 0.1 } } 除标准 LAMB 外，1-bit LAMB 优化器还支持以下 params 键/值（更多信息请参阅我们的教程）： “params” 键 描述 默认值 max_coeff 原始 LAMB 算法和 1-bit LAMB 预热阶段的缩放系数上界 10.0 min_coeff 原始 LAMB 算法和 1-bit LAMB 预热阶段的缩放系数下界 0.01 freeze_step 在 1-bit 压缩应用于通信之前的预热步数 100000 cuda_aware 表示底层 MPI 库是否支持 CUDA-Aware 通信 false comm_backend_name 表示使用哪个后端实现 “nccl” coeff_beta 用于计算 lamb 系数运行平均值的系数 0.9 factor_max 压缩阶段冻结 lamb 系数的缩放因子最大值 4.0 factor_min 压缩阶段冻结 lamb 系数的缩放因子最小值 0.5 factor_threshold 缩放因子在步与步之间可以波动的阈值 0.1 调度器参数 当执行 model_engine.step() 时，DeepSpeed 在每个训练步都会调用调度器的 step() 方法。 scheduler：[dictionary] 字段 值 示例 type 调度器名称。支持的调度器列表请见此处。 "WarmupLR" params 用于实例化调度器的参数字典。参数名称应与调度器构造函数签名匹配。 {"warmup_min_lr": 0, "warmup_max_lr": 0.001} 调度器示例 "scheduler": { "type": "WarmupLR", "params": { "warmup_min_lr": 0, "warmup_max_lr": 0.001, "warmup_num_steps": 1000 } } 通信选项 communication_data_type：[string] 描述 默认值 在梯度平均期间使用所选数据类型进行通信。默认情况下，它将由所选模式决定 None prescale_gradients：[boolean] 描述 默认值 在执行 allreduce 之前缩放梯度 false gradient_predivide_factor：[float] 描述 默认值 在梯度平均之前将梯度预先除以指定因子，在扩展到大量 GPU 时有时有助于 fp16 的稳定性 1.0 sparse_gradients：[boolean] 描述 默认值 启用 torch.nn.Embedding 梯度的稀疏压缩。此特性实际上已弃用，因为我们看到的用例已不再那么多。应当注意，此特性与 torch.sparse 相关特性不兼容。 false FP16 训练选项 注意：此模式不能与下面描述的 amp 模式组合使用。 fp16：[dictionary] 描述 默认值 用于使用混合精度/FP16 训练的配置，利用 NVIDIA 的 Apex 包。下面给出了一个示例，包括可用的字典键。注意：这不使用 Apex 的 AMP 模式（该模式允许在混合精度训练模式中具有更多灵活性），此模式类似于 AMP 的 O2 模式。如果你想使用更复杂的混合精度模式，请参阅下面的 AMP 支持。如果你想使用 ZeRO（目前），则必须使用此模式。 None "fp16": { "enabled": true, "auto_cast": false, "loss_scale": 0, "initial_scale_power": 16, "loss_scale_window": 1000, "hysteresis": 2, "consecutive_hysteresis": false, "min_loss_scale": 1 } fp16:enabled：[boolean] 描述 默认值 enabled 是一个 fp16 参数，指示是否启用 FP16 训练。 false fp16:auto_cast：[boolean] 描述 默认值 auto_cast 自动将输入转换为 fp16 false fp16:loss_scale：[float] 描述 默认值 loss_scale 是一个 fp16 参数，表示 FP16 训练的损失缩放值。默认值 0.0 会导致动态损失缩放，否则该值将用于静态固定损失缩放。 0.0 fp16:initial_scale_power：[integer] 描述 默认值 initial_scale_power 是一个 fp16 参数，表示初始动态损失缩放值的幂。实际损失缩放计算为 2initial_scale_power。 16 fp16:loss_scale_window：[integer] 描述 默认值 loss_scale_window 是一个 fp16 参数，表示提高/降低动态损失缩放值的窗口。 1000 fp16:hysteresis：[integer] 描述 默认值 hysteresis 是一个 fp16 参数，表示动态损失缩放中的延迟偏移。 2 fp16:consecutive_hysteresis：[boolean] 描述 默认值 consecutive_hysteresis 是一个 fp16 参数，表示当我们达到一个不溢出的迭代时是否重新填充 hysteresis false fp16:min_loss_scale：[integer] 描述 默认值 min_loss_scale 是一个 fp16 参数，表示最小动态损失缩放值。 1 BFLOAT16 训练选项 注意：此模式不能与下面描述的 amp 模式组合使用。 注意：此模式不能与上面描述的 fp16 模式组合使用。 bf16：[dictionary] 描述 默认值 用于使用 bfloat16 浮点格式作为 FP16 替代的配置。BFLOAT16 需要硬件支持（例如，NVIDIA A100）。下面给出了一个示例，包括可用的字典键。使用 bfloat16 训练不需要损失缩放。 None "bf16": { "enabled": true } bf16:enabled：[boolean] 描述 默认值 enabled 指示是否启用 BFLOAT16 训练。 false 自动混合精度（AMP）训练选项 注意：此模式不能与上面描述的 fp16 模式组合使用。此外，此模式目前与 ZeRO 不兼容。 amp：[dictionary] 描述 默认值 用于使用自动混合精度（AMP）训练的配置，利用 NVIDIA 的 Apex AMP 包。下面给出了一个示例，包括可用的字典键。与上面的 fp16 模式或 ZeRO 不兼容。除 “enabled” 之外的任何参数都将传递给 AMP 的 initialize 调用，请参阅 apex.amp.initialize 文档中的 API 和描述。 None "amp": { "enabled": true, ... "opt_level": "O1", ... } amp:enabled：[boolean] 描述 默认值 enabled 是一个 amp 参数，指示是否启用 AMP 训练。 false amp params：[various] 描述 默认值 除 “enabled” 之外的任何参数都将传递给 AMP 的 initialize 调用，请参阅 apex.amp.initialize 文档中的 API 和描述。 None 梯度裁剪 gradient_clipping：[float] 描述 默认值 启用值为 1.0 的梯度裁剪 ZeRO 优化（用于 FP16 训练） 启用和配置 ZeRO 内存优化 "zero_optimization": { "stage": [0|1|2|3], "allgather_partitions": [true|false], "allgather_bucket_size": 5e8, "overlap_comm": false, "reduce_scatter": [true|false], "reduce_bucket_size": 5e8, "contiguous_gradients" : [true|false], "offload_param": { ... }, "offload_optimizer": { ... }, "stage3_max_live_parameters" : 1e9, "stage3_max_reuse_distance" : 1e9, "stage3_prefetch_bucket_size" : 5e8, "stage3_param_persistence_threshold" : 1e6, "sub_group_size" : 1e12, "elastic_checkpoint" : [true|false], "stage3_gather_16bit_weights_on_model_save": [true|false], "ignore_unused_parameters": [true|false], "round_robin_gradients": [true|false], "zero_hpz_partition_size": 1, "zero_quantized_weights": [true|false], "zero_quantized_gradients": [true|false], "log_trace_cache_warnings": [true|false], } zero_optimization：[dictionary] 描述 默认值 启用 ZeRO 内存优化，与 FP16/BF16/FP32 和 Adam 优化器兼容。 false stage：[integer] 描述 默认值 选择 ZeRO 优化器的不同阶段。阶段 0、1、2 和 3 分别指禁用、优化器状态分区、优化器+梯度状态分区，以及优化器+梯度+参数分区。 0 allgather_partitions：[boolean] 描述 默认值 选择在每一步结束时从所有 GPU 收集更新参数时，使用 allgather 集合操作还是一系列 broadcast 集合操作 true allgather_bucket_size：[integer] 描述 默认值 每次 allgather 的元素数量。限制大型模型尺寸下 allgather 所需的内存 5e8 overlap_comm：[boolean] 描述 默认值 尝试将梯度 reduction 与反向计算重叠 false reduce_scatter：[boolean] 描述 默认值 使用 reduce 或 reduce scatter 而非 allreduce 来平均梯度 true reduce_bucket_size：[integer] 描述 默认值 每次 reduce/allreduce 的元素数量。限制大型模型尺寸下 allgather 所需的内存 5e8 contiguous_gradients：[boolean] 描述 默认值 在梯度产生时将其复制到连续缓冲区中。避免反向传播期间的内存碎片。 True load_from_fp32_weights：[boolean] 描述 默认值 从 checkpoint 中的 fp32 副本（无精度损失）或模型的 fp16 副本（有精度损失）初始化 fp32 主权重。这可用于在 checkpoint 缺少优化器状态时初始化优化器状态。 True grad_hooks：[boolean] 描述 默认值 用于 ZeRO 阶段 1，启用反向钩子以在反向传播期间减少梯度，或等待直到反向传播结束。 True round_robin_gradients：[boolean] 描述 默认值 阶段 1 和 2 的 CPU 卸载优化，通过细粒度梯度分区在 rank 之间并行化梯度复制到 CPU 内存。性能收益随梯度累积步数（优化器步之间更多复制）或 GPU 数量（增加并行性）而增长。 False offload_param：[dictionary] 描述 默认值 启用将模型参数卸载到 CPU 或 NVMe。这为更大的模型或批次大小释放 GPU 内存。仅对阶段 3 有效。更多详情请见此处。 False offload_optimizer：[dictionary] 描述 默认值 启用将优化器状态卸载到 CPU 或 NVMe，以及将优化器计算卸载到 CPU。这为更大的模型或批次大小释放 GPU 内存。对 ZeRO 阶段 1、2、3 有效。更多详情请见此处。 False stage3_max_live_parameters：[integer] 描述 默认值 释放前每个 GPU 上驻留的最大参数数量。较小的值使用更少内存，但执行更多通信。 1e9 stage3_max_reuse_distance：[integer] 描述 默认值 如果参数将在此参数阈值内被重用，则不要释放它。较小的值使用更少内存，但执行更多通信。 1e9 stage3_prefetch_bucket_size：[integer] 描述 默认值 用于预取参数的固定缓冲区大小。较小的值使用更少内存，但可能因通信而增加停顿。 5e8 stage3_param_persistence_threshold：[integer] 描述 默认值 不要对比此阈值更小的参数进行分区。较小的值使用更少内存，但可能大幅增加通信（尤其是受延迟限制的消息）。 1e5 stage3_gather_16bit_weights_on_model_save：[boolean] 描述 默认值 在通过 save_16bit_model() 保存模型之前合并权重。由于权重跨 GPU 分区，它们不属于 state_dict，因此当启用此选项时，此函数会自动收集权重，然后保存 fp16 模型权重。 False stage3_module_granularity_threshold：[integer] | 描述 | 默认值 | |——————————————————————————————————————————————————————————————————————————————————————————–| ——- | | 模块的粒度由 parameter_count / (1 + descendant_count) 的比率确定。ZeRO3 将粒度低于阈值的模块归类为细粒度模块，在参数获取期间将其视为整体单元。这减少了来自单独钩子的主机和通信开销。 | 0 | zero_hpz_partition_size：[integer] 描述 默认值 ZeRO++ 的分层分区 ZeRO（hpZ）次级张量组中的 rank 数量，默认值为 1 表示无 hpZ，理想值是每个节点的 rank（GPU）数量。 1 zero_quantized_weights：[boolean] 描述 默认值 布尔值，指示是否启用 ZeRO++ 的通信高效量化权重。 False zero_quantized_gradients：[boolean] 描述 默认值 布尔值，指示是否启用 ZeRO++ 的通信高效量化梯度。 False log_trace_cache_warnings：[boolean] 描述 默认值 记录来自参数分片的 trace cache 优化的警告，例如缓存失效事件。 False cpu_offload：[boolean] 已弃用：cpu_offload 已弃用并将在未来移除，请改用 offload_optimizer。 描述 默认值 启用将优化器内存和计算卸载到 CPU。这为更大的模型或批次大小释放 GPU 内存。对阶段 1 和 2 有效。 False 参数卸载 启用和配置将参数卸载到 CPU/NVMe 的 ZeRO 优化。仅在 ZeRO 阶段 3 可用。请注意，如果未指定 “device” 的值或不受支持，将会触发断言。 "offload_param": { "device": "[cpu|nvme]", "nvme_path": "/local_nvme", "pin_memory": [true|false], "buffer_count": 5, "buffer_size": 1e8, "max_in_cpu": 1e9 } device：[string] 描述 默认值 用于卸载模型参数的设备内存。支持的选项为 cpu 和 nvme。 cpu nvme_path：[string] 描述 默认值 用于参数卸载的 NVMe 设备的文件系统路径。 /local_nvme pin_memory：[boolean] 描述 默认值 卸载到页锁定 CPU 内存。这可以提高吞吐量，代价是额外的内存开销。 false buffer_count：[integer] 描述 默认值 用于将参数卸载到 NVMe 的缓冲区池中的缓冲区数量。 5 buffer_size：[integer] 描述 默认值 用于将参数卸载到 NVMe 的缓冲区池中缓冲区的大小。 1e8 max_in_cpu：[integer] 描述 默认值 启用卸载到 NVMe 时，在 CPU 内存中维护的参数元素数量。 1e9 优化器卸载 启用和配置将优化器计算卸载到 CPU 以及状态卸载到 CPU/NVMe 的 ZeRO 优化。CPU 卸载在 ZeRO 阶段 1、2、3 可用。NVMe 卸载仅在 ZeRO 阶段 3 可用。请注意，如果未指定 “device” 的值或不受支持，将会触发断言。 "offload_optimizer": { "device": "[cpu|nvme]", "nvme_path": "/local_nvme", "pin_memory": [true|false], "ratio": 0.3, "buffer_count": 4, "fast_init": false } device：[string] 描述 默认值 用于卸载优化器状态的设备内存。支持的选项为 cpu 和 nvme。无论 device 选项如何，优化器计算都会卸载到 CPU。 cpu nvme_path：[string] 描述 默认值 用于优化器状态卸载的 NVMe 设备的文件系统路径。 /local_nvme pin_memory：[boolean] 描述 默认值 卸载到页锁定 CPU 内存。这可以提高吞吐量，代价是额外的内存开销。 false ratio：[float] 描述 默认值 在 CPU 端更新参数（即优化器步）的比例。 1 buffer_count：[integer] 描述 默认值 用于将优化器状态卸载到 NVMe 的缓冲区池中的缓冲区数量。这应至少是优化器为每个参数维护的状态数。例如，Adam 优化器有 4 个状态（参数、梯度、动量、方差）。 4 fast_init：[boolean] 描述 默认值 卸载到 NVMe 时启用快速优化器初始化。 false 异步 I/O 配置用于将参数和优化器状态卸载到持久（NVMe）存储的异步 I/O 模块。此模块使用 Linux 原生异步 I/O（libaio）。 "aio": { "block_size": 1048576, "queue_depth": 8, "thread_count": 1, "single_submit": false, "overlap_events": true } block_size：[integer] 描述 默认值 I/O 块大小（字节）。 1048576 queue_depth：[integer] 描述 默认值 I/O 队列深度。 8 thread_count：[integer] 描述 默认值 用户线程提交的每次读/写的请求内并行度。 1 single_submit：[boolean] 描述 默认值 将请求作为多个单独请求提交到存储设备，而非作为一组请求。 false overlap_events：[boolean] 描述 默认值 以重叠方式向存储设备提交请求，不等待先前请求的完成。 true ignore_unused_parameters：[boolean] 描述 默认值 模块中未使用的参数在静态网络中可能出乎意料，但在动态网络中可能是正常的。这控制当检测到未使用参数时，训练是否应以错误消息终止。默认设置为 True，这意味着忽略未使用参数并继续训练。目前仅在阶段 2 中使用。 True 日志记录 steps_per_print：[integer] 描述 默认值 每 N 个训练步打印一次进度报告。报告包括训练步数、跳过的优化器更新数（可能由于混合精度训练中的溢出）、当前学习率和当前动量。 10 wall_clock_breakdown：[boolean] 描述 默认值 启用前向/反向/更新训练阶段延迟的计时 false dump_state：[boolean] 描述 默认值 在初始化后打印 DeepSpeed 对象的状态信息 false 自动调优 { "autotuning": { "enabled": false, "results_dir": "autotuning_results", "exps_dir": "autotuning_exps", "overwrite": false, "metric": "throughput", "start_profile_step": 3, "end_profile_step": 5, "fast": true, "max_train_batch_size": null, "mp_size": 1, "num_tuning_micro_batch_sizes": 3, "tuner_type": "model_based", "tuner_early_stopping": 5, "tuner_num_trials": 50, "arg_mappings": null } } enabled：[boolean] 描述 默认值 启用自动调优器。 false results_dir：[string] 描述 默认值 自动调优实验结果目录的路径。默认出现在启动 Deepspeed 的工作目录中。 “autotuning_results” exps_dir：[string] 描述 默认值 自动调优实验描述目录的路径。默认出现在启动 Deepspeed 的工作目录中。 “autotuning_exps” overwrite：[boolean] 描述 默认值 是否运行结果已存在的自动调优实验。将其设置为 true 将覆盖现有结果。 false metric：[string] 描述 默认值 用于对自动调优实验进行排序的性能指标。目前支持 latency、throughput 和 FLOPS，分别指每个 GPU 实现的训练步延迟、每秒训练样本数和每秒浮点运算数。 throughput start_profile_step：[integer] 描述 默认值 在自动调优实验中开始性能分析的全局训练步。请注意，为了准确的性能测量，需要进行预热。 3 end_profile_step：[integer] 描述 默认值 在自动调优实验中结束性能分析的全局训练步。不得小于 start_profile_step。 5 fast：[boolean] 描述 默认值 启用快速模型自动调优，其中仅调优每个 GPU 的 Zero 阶段和微批次大小。 true max_train_batch_size：[int] 描述 默认值 模型训练的最大训练批次大小（全局有效批次大小）。 null mp_size：[int] 描述 默认值 模型并行度。 1 num_tuning_micro_batch_sizes：[integer] 描述 默认值 要探索的微批次大小的数量。 3 tuner_type：[string] 描述 默认值 该算法定义 ZeRO 阶段内自动调优空间探索的顺序。 model_based tuner_early_stopping：[integer] 描述 默认值 在当前最佳实验之后运行的实验数量。如果在该数量内未找到更好的实验，Autotuner 将停止探索。 5 tuner_num_trials：[integer] 描述 默认值 在 ZeRO 阶段内的调优空间中要探索的最大实验数量。 50 Flops Profiler { "flops_profiler": { "enabled": false, "profile_step": 1, "module_depth": -1, "top_modules": 1, "detailed": true, "output_file": null, } } enabled：[boolean] 描述 默认值 启用 flops profiler。这也会启用 wall_clock_breakdown false profile_step：[integer] 描述 默认值 进行性能分析的全局训练步。请注意，为了准确的时间测量，需要预热步。 1 module_depth：[integer] 描述 默认值 打印聚合模块信息的模型深度。当设置为 -1 时，它打印从顶层模块到最内层模块的信息（最大深度）。 -1 top_modules：[integer] 描述 默认值 将聚合 profile 输出限制为指定的顶层模块数量。 1 detailed：[boolean] 描述 默认值 是否打印详细的模型 profile。 true output_file：[string] 描述 默认值 输出文件的路径。如果为 None，则 profiler 打印到 stdout。 null 激活检查点 "activation_checkpointing": { "partition_activations": false, "cpu_checkpointing": false, "contiguous_memory_optimization": false, "number_checkpoints": null, "synchronize_checkpoint_boundary": false, "profile": false } partition_activations：[boolean] 描述 默认值 与模型并行一起使用时启用分区激活 false cpu_checkpointing：[boolean] 描述 默认值 如果启用了 partition_activations，则将分区激活卸载到 CPU false contiguous_memory_optimization：[boolean] 描述 默认值 复制分区激活，使其在内存中连续 false number_checkpoints：[integer] 描述 默认值 用于为 contiguous_memory_optimization 分配内存缓冲区的激活检查点总数 None synchronize_checkpoint_boundary：[boolean] 描述 默认值 在每个检查点边界插入 get_accelerator().synchronize()。 false profile：[boolean] 描述 默认值 记录每个检查点函数的前向和反向时间 false 稀疏注意力 sparse_attention：[dictionary] 字段 值 示例 mode 确定稀疏结构类型的字符串。Deepspeed 目前支持 "dense"、"fixed"、"bigbird"、"bslongformer" 和 "variable"。 "fixed" block 确定块大小的整数。当前稀疏自注意力实现基于块稀疏矩阵。其中此参数定义此类块的大小，Block X Block。 16 different_layout_per_head 确定是否为每个头分配不同的稀疏布局的布尔值；这将根据可用性来满足。 false num_local_blocks 确定每个块行中随机块数量的整数；仅在 "fixed" 模式中使用。 4 num_global_blocks 确定局部窗口中多少连续块用作全局注意力窗口代表；在 "fixed" 和 "bigbird" 模式中使用。 1 attention 确定注意力类型的字符串。注意力可以是 "unidirectional"，例如自回归模型，其中 token 只关注上下文中出现在其之前的 token。考虑到这一点，注意力矩阵的上三角为空。或者是 "bidirectional"，例如 BERT，其中 token 可以关注其之前或之后的任何其他 token。那么注意力矩阵的上三角部分是下三角部分的镜像；在 "fixed" 和 "variable" 模式中使用。 "bidirectional" horizontal_global_attention 确定作为局部窗口全局代表的块是否也关注所有其他块的布尔值。仅在注意力类型为 "bidirectional" 时有效。从注意力矩阵来看，这意味着全局注意力不仅包括垂直块，还包括水平块；在 "fixed" 和 "variable" 模式中使用。 false num_different_global_patterns 确定不同全局注意力布局数量的整数。虽然全局注意力可以通过哪个块/哪些块作为任何局部窗口的代表来固定，但由于存在多头，每个头可以使用不同的全局代表；仅在 "fixed" 模式中使用。 4 num_random_blocks 确定每个块行中随机块数量的整数；在 "variable" 和 "bigbird" 模式中使用。 0 local_window_blocks 确定每个局部注意力窗口中块数量的整数列表。它假设第一个数字确定第一个局部窗口中的块数，第二个确定第二个窗口中的块数，……，最后一个数字确定剩余局部窗口中的块数；仅在 "variable" 模式中使用。 [4] global_block_indices 确定哪些块被视为全局注意力的整数列表。给定索引，确定所有其他 token 块都关注的块以及它们关注所有其他 token 块的块。注意，如果设置了 global_block_end_indices 参数，则此参数用作每个全局窗口的起始索引；在 "variable" 和 "bslongformer" 模式中使用。 [0] global_block_end_indices 确定全局窗口块结束索引的整数列表。默认情况下不使用。但如果设置了，它必须与 global_block_indices 参数大小相同，结合这两个参数，对于每个索引 i，从 global_block_indices[i] 到 global_block_end_indices[i]（不含）的块被视为全局注意力；在 "variable" 和 "bslongformer" 模式中使用。 None num_sliding_window_blocks 确定滑动局部注意力窗口中块数量的整数；在 "bigbird" 和 "bslongformer" 模式中使用。 3 sparse_attention 示例 "sparse_attention": { "mode": "fixed", "block": 16, "different_layout_per_head": true, "num_local_blocks": 4, "num_global_blocks": 1, "attention": "bidirectional", "horizontal_global_attention": false, "num_different_global_patterns": 4, "num_random_blocks": 0, "local_window_blocks": [4], "global_block_indices": [0], "global_block_end_indices": None, "num_sliding_window_blocks": 3 } 数据效率 DeepSpeed 数据效率库包含两种技术：课程学习和随机分层 token 丢弃（random-LTD）。了解更多关于如何使用 DeepSpeed 数据效率库的信息，请参阅我们的教程。 "data_efficiency": { "enabled": true, "seed": 1234, "data_routing": { "enabled": true, "random_ltd":{ "enabled": true, "total_layer_num": 24, "random_ltd_layer_num": 22, "random_ltd_layer_id": [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22], "model_mask_name": "attention_mask", "model_type": "decoder", "hidden_state_order": "seq_batch_dim", "random_ltd_schedule": { "min_value": 128, "max_value": 2048, "schedule_type":"fixed_linear", "schedule_config": { "require_steps": 200000, "seq_per_step": 16 } } } }, "data_sampling": { "enabled": true, "num_epochs": 1, "num_workers": 0, "curriculum_learning": { "enabled": true, "data_cluster_path": "/path/to/data_clusters", "curriculum_metrics": { "vocabularyrarity": { "index_to_sample_path": "/path/to/index_to_sample", "index_to_metric_path": "/path/to/index_to_metric", "difficulty_type": "percentile", "clustering_type": "schedule_based", "min_difficulty": 1, "max_difficulty": 100, "schedule_type": "fixed_root", "schedule_config": { "total_curriculum_step": 110000, "difficulty_step": 1, "root_degree": 2 } } } } } } data_efficiency：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用数据效率。 false seed：[integer] 数据采样的随机种子。 1234 data_routing：[dictionary] 数据路由技术的配置。 N/A data_sampling：[dictionary] 数据采样技术的配置。 N/A data_routing：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用数据路由技术。 false random_ltd：[dictionary] random-LTD 技术的配置。 N/A data_sampling：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用数据采样技术。 false num_epochs：[integer] 原始数据集最多迭代多少个 epoch。 1000 num_workers：[integer] 数据加载器的工作线程数。 0 curriculum_learning：[dictionary] 课程学习技术的配置。 N/A random_ltd：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用 random-LTD 技术。 false total_layer_num：[integer] 预训练/微调模型的层数（或深度）。 N/A random_ltd_layer_num：[integer] 将应用 random-LTD 的层数。 N/A random_ltd_layer_id：[list] 将应用 random-LTD 的确切 layer_id。此列表的长度必须与 random_ltd_layer_num 相同。 N/A model_mask_name：[str] attention_mask 的变量名。不同库有不同的名称，例如 att_mask。对于 huggingface 模型，它名为 “attention_mask”。用户需要检查原始模型文件中的 forward 函数。如果原始模型 forward 函数中的 attention mask 输入不是关键字/命名参数（例如 attention_mask=None），用户需要将其更改为关键字/命名参数，并将该关键字作为 model_mask_name 提供。 N/A model_type：[str] 用户需要识别模型是 decoder 还是 encoder。目前我们只支持这两种。 N/A hidden_state_order：[str] 用户需要了解隐藏状态张量的输入顺序。通常，它是 batch、sequence，然后是隐藏维度，即 batch_seq_dim。有时，batch 和 sequence 之间的顺序会切换为 seq_batch_dim。目前，我们支持这两种。 N/A random_ltd_schedule：[dictionary] token 丢弃后有效序列长度的调度。它是一个线性函数，其中 random-LTD 逐渐丢弃更少的 token 并增加有效序列长度。 N/A min_value：[integer] 在第 0 步/迭代时的初始有效序列长度（token 丢弃后）。 N/A max_value：[integer] 最大有效序列长度（通常是不进行任何 token 丢弃的情况）。通常这设置为基线的 seqlen。 N/A schedule_type：[str] 序列长度遵循从 min_value 开始并达到 max_value 的线性递增函数。我们目前只支持此类型。 N/A schedule_config：[dictionary] 线性递增函数的配置。 N/A require_steps：[integer] 从 min_value 达到 max_value 需要多少迭代。 N/A seq_per_step：[integer] 在任何时候，有效序列长度都是此 seq_per_step 的倍数。将此设置为 8（对于 FP16 数据）或 16（对于 INT8 数据）的倍数，以启用 NVIDIA Tensor Core 加速。 N/A curriculum_learning：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用课程学习技术。 false data_cluster_path：[str] 课程学习将存储相同难度范围内数据样本索引的目录路径。 N/A curriculum_metrics：[dictionary] 此字典包括所有所需课程指标及其配置。每个指标将是一个单独的子字典，其中键是指标名称，值是下面的配置。 N/A index_to_sample_path：[str] 在离线数据分析期间生成的 index_to_sample 文件的路径。注意，数据分析将生成两种 index_to_sample 文件：metric_name_index_to_sample_percentile_merged 文件是为性能改进而连接的索引，但它仅在设置 difficulty_type=percentile 时有效。如果使用 difficulty_type=value，则需要将其更改为使用 metric_name_index_to_sample 文件。 N/A index_to_metric_path：[str] 在离线数据分析期间生成的 index_to_metric_path 文件的路径。 N/A difficulty_type：[str] 在训练期间，如何增加最大可接受难度。目前支持 value（按绝对值增加）和 percentile（按难度百分位增加）。 N/A clustering_type：[str] 目前支持 schedule_based（基于下面的难度调度（节奏函数）对数据进行聚类）和 single_cluster（无需聚类，可能通过数据后处理实现 CL，例如序列长度截断）。 N/A min_difficulty：[integer] 第一步的起始难度。当 difficulty_type=value 时，min_difficulty 是绝对难度值。当 difficulty_type=percentile 时，min_difficulty 是难度百分位值。 N/A max_difficulty：[integer] 最终最大难度。当 difficulty_type=value 时，max_difficulty 是绝对难度值。当 difficulty_type=percentile 时，max_difficulty 是难度百分位值。 N/A schedule_type：[str] 难度调度（节奏函数），定义最大可接受难度在训练期间如何从 min_difficulty 增加到 max_difficulty。目前支持 fixed_linear、fixed_root、fixed_discrete 和 custom。 N/A schedule_config：[dictionary] 节奏函数的配置。当 schedule_type=custom 时，此字典不需要。相反，用户需要提供一个回调函数（通过 deepspeed/runtime/engine.py 中的 set_custom_curriculum_learning_schedule API），它将在训练期间更新最大可接受难度。下面的配置都属于 schedule_config。 N/A total_curriculum_step：[integer] 课程学习从最小难度到最大难度需要多少步。由 fixed_linear 和 fixed_root 调度使用。 N/A difficulty_step：[integer] 每步确定的最大可接受难度级别必须是此 difficulty_step 的倍数。这用于确保使用 NVIDIA Tensor Core 加速（要求 8（FP16）或 16（INT8）的倍数）。由 fixed_linear 和 fixed_root 调度使用。 N/A root_degree：[integer] 根函数的次数。次数 2 表示平方根，次数 3 表示立方根。次数 1 等效于线性。由 fixed_root 调度使用。 N/A difficulty：[list] 调度期间要使用的最大可接受难度级别列表。由 fixed_discrete 调度使用。 N/A max_step：[list] 更改最大可接受难度级别的步数列表。由 fixed_discrete 调度使用。 N/A 课程学习 注意：在 2022 年 12 月 12 日，我们发布了 DeepSpeed 数据效率库，它提供更通用的课程学习支持。下面这个旧版课程学习特性仍然受支持，但我们建议使用数据效率库。 "curriculum_learning": { "enabled": true, "curriculum_type": "seqlen", "min_difficulty": 8, "max_difficulty": 1024, "schedule_type": "fixed_linear", "schedule_config": { "total_curriculum_step": 40000, "difficulty_step": 8 } } enabled：[boolean] 描述 默认值 设置为 true 以启用课程学习 false curriculum_type：[string] 描述 默认值 课程难度指标的类型。目前支持 seqlen。 N/A min_difficulty：[integer] 描述 默认值 起始难度级别 N/A max_difficulty：[integer] 描述 默认值 结束难度级别 N/A schedule_type：[string] 描述 默认值 课程调度的类型。目前支持 fixed_linear、fixed_root 和 fixed_discrete。 N/A total_curriculum_step：[integer] 描述 默认值 课程学习总步数。当使用 fixed_linear 和 fixed_root schedule_type 时 schedule_config 之一。 N/A difficulty_step：[integer] 描述 默认值 在任何时候，课程学习难度必须是此 difficulty_step 的倍数。将此设置为 8（对于 FP16 数据）或 16（对于 INT8 数据）的倍数，以启用 NVIDIA Tensor Core 加速。当使用 fixed_linear 和 fixed_root schedule_type 时 schedule_config 之一。 N/A root_degree：[integer] 描述 默认值 课程调度函数的根次数。当使用 fixed_root schedule_type 时 schedule_config 之一。 N/A difficulty：[list of integer] 描述 默认值 调度期间要使用的难度级别列表。当使用 fixed_discrete schedule_type 时 schedule_config 之一。 N/A max_step：[list of integer] 描述 默认值 更改难度级别的步数列表。当使用 fixed_discrete schedule_type 时 schedule_config 之一。 N/A 监控模块 注意：Deepspeed 通过 PyTorch 记录到 TensorBoard。记录到 TensorBoard 需要安装 tensorboard 包（更多信息请参阅 PyTorch 文档）。 注意：记录到 WandB 需要安装 wandb 包（更多信息请参阅 WandB 文档）。 注意：记录到 Comet 需要安装 comet_ml 包（更多信息请参阅 Comet 文档）。 Deepspeed 的 Monitor 模块可以将训练详情记录到 Tensorboard 兼容文件、WandB、Comet 或简单 CSV 文件。下面是 DeepSpeed 将自动记录的内容概述。 字段 描述 条件 Train/Samples/train_loss 训练损失。 None Train/Samples/lr 训练期间的学习率。 None Train/Samples/loss_scale 使用 fp16 训练时的损失缩放。必须启用 fp16。 Train/Eigenvalues/ModelBlockParam_{i} 每个参数块的特征值。必须启用 eigenvalue。 Train/Samples/elapsed_time_ms_forward 前向传播的全局持续时间。 flops_profiler.enabled 或 wall_clock_breakdown。 Train/Samples/elapsed_time_ms_backward 前向传播的全局持续时间。 flops_profiler.enabled 或 wall_clock_breakdown。 Train/Samples/elapsed_time_ms_backward_inner 不包括梯度 reduction 时间的反向时间。仅在梯度 reduction 不重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。 flops_profiler.enabled 或 wall_clock_breakdown。 Train/Samples/elapsed_time_ms_backward_allreduce allreduce 操作的全局持续时间。 flops_profiler.enabled 或 wall_clock_breakdown。 Train/Samples/elapsed_time_ms_step 优化器步时间 flops_profiler.enabled 或 wall_clock_breakdown。 tensorboard：[dictionary] 字段 值 默认值 enabled 是否启用记录到 Tensorboard。 false output_path Tensorboard 日志写入的路径。如果为 None，输出路径设置在训练脚本的启动路径下。 null job_name 当前作业的名称。这将成为 output_path 内的新目录。 "DeepSpeedJobName" tensorboard 配置示例： "tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } wandb：[dictionary] 字段 值 默认值 enabled 是否启用记录到 WandB。 false group WandB 组的名称。这可用于将运行分组在一起。 None team WandB 团队名称。 None project WandB 项目名称。 deepspeed wandb 配置示例： "wandb": { "enabled": true, "group": "my_group", "team": "my_team", "project": "my_project" } comet：[dictionary] 字段 值 默认值 enabled 是否启用记录到 Comet。 false workspace Comet 工作区名称。 None project Comet 项目名称。 None samples_log_interval 每处理 samples_log_intervas 个样本后，指标将提交到 Comet。 100 experiment_name 用于记录的 comet 实验名称。 None api_key Comet API 密钥。不建议在代码中保存 Comet API Key。 None experiment_key 用于记录的 comet 实验密钥。必须是长度在 32 到 50 个字符之间的字母数字字符串。 None online 如果为 True，数据将记录到 Comet 服务器，否则将本地存储在离线实验中。默认为 True。 None mode 控制 Comet 实验的启动方式。“get”：继续记录到由 experiment_key 值标识的现有实验。“create”：始终创建新实验，对 HPO 扫描有用。“get_or_create”（默认）：如果需要，启动新实验，或持续记录到现有实验。 None comet 配置示例： "comet": { "enabled": true, "workspace": "my_workspace", "project": "my_project", "samples_log_interval": 50, "experiment_name": "llama-fine-tuning", "experiment_key": "0c4a1c4a90664f2a8084e600b19a9d7", "online": false, "mode": "get", } csv_monitor：[dictionary] 字段 值 默认值 enabled 是否启用记录到本地 CSV 文件。 false output_path csv 文件写入的路径。如果为 None，输出路径设置在训练脚本的启动路径下。 null job_name 当前作业的名称。这将成为 output_path 内的新目录 "DeepSpeedJobName" csv_monitor 配置示例： "csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } 弹性训练配置（V0.1 和 V0.2） "elasticity": { "enabled": true, "max_train_batch_size": "seqlen", "micro_batch_sizes": 8, "min_gpus": 1024, "max_gpus": "fixed_linear", "min_time": "seqlen", "version": 8, "ignore_non_elastic_batch_info": 1024, "num_gpus_per_node": "fixed_linear", "model_parallel_size": MODEL_PARALLEL_SIZE } 字段 描述 默认值 enabled 在弹性训练中启用全局批次大小的计算。 false max_train_batch_size 训练中可使用的最大可接受批次大小。 2000 micro_batch_sizes 可接受的微批次大小，与 train_micro_batch_size_per_gpu 相同 [2,4,6] min_gpus 在 v0.1 和 v0.2 中计算高度合成批次大小时搜索的最小 GPU 数量。 1 max_gpus 在 v0.1 和 v0.2 中计算高度合成批次大小时搜索的最大 GPU 数量。 10000 min_time 调度器再次扩展前的最小运行时间（分钟）（仅在 v0.1 中使用）。0 表示未知 0 prefer_large_batch 查找合适的批次大小时，尝试查找最接近给定最大训练批次大小的批次。 true version 要使用的弹性逻辑版本。 0.2 ignore_non_elastic_batch_info 忽略弹性配置之外提供的所有批次信息。为减少混淆，我们要求所有批次相关信息仅在弹性配置中提供。 false num_gpus_per_node 每个节点的 GPU 数量。此信息由 v0.2 用于支持模型并行训练（仅由 v0.2 使用） 1 model_parallel_size 张量或模型并行大小（仅由 v0.2 使用） 1 通信日志记录 DeepSpeed 提供灵活通信日志记录工具，可以自动检测和记录通过 deepspeed.comm 启动的通信操作。注意：所有日志记录通信调用都是同步的，以提供准确的时间信息。如果你的模型大量使用异步通信操作，这可能会妨碍性能。一旦日志填充完成，可以使用 deepspeed.comm.log_summary() 进行汇总。更多细节和示例用法，请参阅教程 comms_logger：[dictionary] 字段 值 默认值 enabled 是否启用通信日志记录。 false verbose 是否立即打印每个通信操作 false prof_all 是否分析所有操作。 true debug 将调用者函数附加到每个通信操作的 log_name。 false prof_ops 要记录的通信操作列表（仅指定的操作将被分析）。 [] comms_logger 推荐配置示例： "comms_logger": { "enabled": true, "verbose": false, "prof_all": true, "debug": false } 仅记录特定操作的 comms_logger 配置示例： "comms_logger": { "enabled": true, "verbose": false, "prof_all": false, "debug": false, "prof_ops": ["all_reduce", "all_gather"] } 压缩 注意：压缩有七个不同组件，包括层缩减、权重量化、激活量化、稀疏剪枝、行剪枝、头剪枝和通道剪枝。我们使用简单的 json 示例逐一解释它们。了解更多关于如何使用 DeepSpeed 压缩库的信息，请参阅我们的教程。 层缩减 注意：使用知识蒸馏时，层缩减效果要好得多（更多信息请参阅我们的教程）： "compression_training": { "layer_reduction": { "enabled": true, "keep_number_layer": 5, "module_name_prefix": "bert.encoder.layer", "teacher_layer": [ 2, 4, 6, 8, 10 ], "other_module_name": [ "bert.pooler", "bert.embeddings", "classifier" ] } } layer_reduction：[dictionary] 字段 值 默认值 enabled：[boolean] 是否启用层缩减。 false keep_number_layer：[list] 模型中要保留的层数。 N/A module_name_prefix：[str] 模型模块的（统一）名称前缀，其关联的权重参数将被重新初始化。 N/A teacher_layer：[list] 权重参数要重新初始化的层。列表的长度等于 ‘keep_number_layer’。 N/A other_module_name：[list] 其关联的权重参数将被重新初始化的模块名称。它是 module_name_prefix 的补充或替代。例如，“other_module_name”:[“bert.encoder.layer.2”,“bert.encoder.layer.4”] 等同于 “module_name_prefix”:“bert.encoder.layer” 和 “teacher_layer”:[2,4]。 N/A 权重量化 "compression_training": { "weight_quantization": { "shared_parameters":{ "enabled": true, "quantizer_kernel": false, "schedule_offset": 0, "quantize_groups": 1, "quantize_verbose": false, "quantization_type": "symmetric", "rounding": "nearest", "quantize_weight_in_forward": false, "fp16_mixed_quantize":{ "enabled": false, "quantize_change_ratio": 0.001 } }, "different_groups":{ "wq1": { "params": { "start_bits": 8, "target_bits": 8, "quantization_period": 50 }, "modules": [ "attention.self", "intermediate" ] }, "wq2": { "params": { "start_bits": 4, "target_bits": 4, "quantization_period": 50 }, "modules": [ "attention.output" ] } } } } shared_parameters：[dictionary] 所有权重量化组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用权重量化。 false quantizer_kernel：[boolean] 使用 DeepSpeed 量化内核进行 >=4 bit 量化。这只能在使用 DeepSpeed FP16 优化器时启用。 false schedule_offset：[integer] 在预定步数后启用权重量化（可视为预热步）。 0 quantize_groups：[integer] 将权重矩阵拆分为不同数量的组，每组有自己的缩放因子。 1 quantize_verbose：[boolean] 打印量化相关日志。 false quantization_type：[string] 选择量化算法，symmetric 或 asymmetric。 "symmetric" rounding：[string] 与量化相关的舍入算法，nearest 或 stochastic。 "nearest" quantize_weight_in_forward：[boolean] 在优化器或前向步中量化权重，对于 FP32 优化器训练必须设置为 true。 false fp16_mixed_quantize：[dictionary] 使用 FP16 值和量化值混合的值。 N/A enabled：[boolean] 是否启用 fp16 混合量化。 false quantize_change_ratio：[float] 初始量化值比率，将逐渐增加到 1。 0.001 different_groups：[dictionary] 不同的量化集，用于不同的量化参数。在此示例中，我们给出两个不同的集。在实践中，你可以根据需求选择集的数量。 字段 值 默认值 params：[dictionary] start_bits：[integer] 量化起始 bits，将逐渐减少到目标 bits。 8 target_bits：[integer] 量化目标 bits，需要 <= start_bits。 8 quantization_period：[integer] 每隔 n 步，量化 bits 将减少 1。 1 modules：[list] 与 params 设置关联的权重参数范围。 "All Linear and CONV2D layers" 激活量化 "compression_training": { "activation_quantization": { "shared_parameters":{ "enabled": true, "quantization_type": "asymmetric", "range_calibration": "dynamic", "schedule_offset": 50 }, "different_groups":{ "aq1": { "params": { "bits": 8 }, "modules": [ "attention.output" ] } } } shared_parameters：[dictionary] 所有激活量化组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用激活量化。 false quantization_type：[string] 选择量化算法，symmetric 或 asymmetric。 "symmetric" range_calibration：[string] 使用 dynamic（每 token 或每图像）或 static（使用动量的固定 min/max）进行推理。 "static" schedule_offset：[integer] 在预定步数后启用激活量化（可视为预热步）。 0 different_groups：[dictionary] 不同的量化集，用于不同的量化参数。在此示例中，我们给出一个集。在实践中，你可以根据需求选择集的数量。 字段 值 默认值 params：[dictionary] bits：[integer] 用于激活目标 bits 的 bits 数量，需要 >= 4。 8 modules：[list] 与 params 设置关联的权重参数范围。 "All Linear and CONV2D layers" 稀疏剪枝 "compression_training": { "sparse_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 30, "method": "l1" }, "different_groups":{ "sp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "attention.self" ] } } } } "compression_training": { "sparse_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 30, "schedule_offset_end": 90, "schedule_offset_stride": 15, "method": "snip_momentum", "block_pattern": "4x1", "dense_ratio": 0.4, "excluded_modules": ['classifier', 'pooler'] }, "different_groups":{ } } } shared_parameters：[dictionary] 所有稀疏剪枝组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用稀疏剪枝。 false schedule_offset：[integer] 在预定步数后启用稀疏剪枝（可视为预热步）。 0 schedule_offset_end：[integer] 在预定步数后禁用稀疏剪枝，对于 snip_momentum 为必需项。 0 schedule_offset_stride：[integer] 训练步上剪枝的步幅，对于 snip_momentum 为必需项。 "1" method：[string] 选择不同的剪枝方法，l1（静态，基于幅度）、topk（动态，可学习）或 snip_momentum（结构化剪枝）。 "l1" block_pattern：[string] 选择不同的结构化剪枝块模式，NxM 或 N:M（N 和 M 是整数）。例如，“4x1” 或 “2:4” 是常见的块模式，对于 snip_momentum 为必需项。 "4x1" dense_ratio：[float] 用于获取目标全局稀疏率，对于 snip_momentum 为必需项。 "0.1" excluded_modules：[list] 排除某些特殊模块（如输出层）的剪枝范围。 [] different_groups：[dictionary] 不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，你可以根据需求选择集的数量。对于 snip_momentum 方法，你可以将其留空。 字段 值 默认值 params：[dictionary] dense_ratio：[float] 剪枝后要保留的权重百分比。 0.5 modules：[list] 与 params 设置关联的权重参数范围。 "All Linear and CONV2D layers" 行剪枝 注意：行剪枝是为两个连续线性层（例如，Transformer 中的前馈网络）设计的特性。因此，我们建议对第一个线性层使用行剪枝（即 BERT 的 intermediate.dense 层）。减少此矩阵的行维度有助于减少后续矩阵的列（即 BERT 的 layer.\w+.output.dense 层）。它也应该适用于其他线性层。 "compression_training": { "row_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 20, "method": "topk" }, "different_groups":{ "rp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "intermediate.dense" ], "related_modules":[ ["layer.\w+.output.dense"] ] } } } } shared_parameters：[dictionary] 所有行剪枝组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用行剪枝。 false schedule_offset：[integer] 在预定步数后启用行剪枝（可视为预热步）。 0 method：[string] 选择不同的剪枝方法，l1（静态，基于幅度）或 topk（动态，可学习）。 "l1" different_groups：[dictionary] 不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，你可以根据需求选择集的数量。 字段 值 默认值 params：[dictionary] dense_ratio：[float] 剪枝后要保留的权重百分比。 0.5 modules：[list] 与 params 设置关联的权重参数范围。 "All Linear and CONV2D layers" related_modules：[list[list]] 与行剪枝模块相关的模块，可以执行列剪枝。 None 头剪枝 注意：头剪枝是为两个注意力层（例如，Transformer 中的多头注意力）设计的特性。目前，它只能应用于 Transformer 的输出矩阵（即 BERT 中的 attention.output.dense）。剪枝输出矩阵也可以导致 Query/Key/Value 矩阵的剪枝。 "compression_training": { "head_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 10, "method": "topk", "num_heads": 12 }, "different_groups":{ "rp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "attention.output.dense" ], "related_modules":[ ["self.query", "self.key", "self.value"] ] } } } } shared_parameters：[dictionary] 所有头剪枝组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用头剪枝。 false schedule_offset：[integer] 在预定步数后启用头剪枝（可视为预热步）。 0 method：[string] 选择不同的剪枝方法。目前，我们只支持 topk（动态，可学习）。 "topk" num_heads：[int] 头数（必须由用户提供）。 N/A different_groups：[dictionary] 不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，你可以根据需求选择集的数量。 字段 值 默认值 params：[dictionary] dense_ratio：[float] 剪枝后要保留的权重百分比。 0.5 modules：[list] 与 params 设置关联的权重参数范围。 "All Linear and CONV2D layers" related_modules：[list[list]] 与头剪枝模块（即输出矩阵）相关的模块（通常是 Q/K/V）。目前，此特性仅适用于 BERT。 None 通道剪枝 注意：通道剪枝是为两个连续 CONV2d 层（例如，ResNet 中的残差连接）设计的特性。因此，我们建议对第一个 CONV2d 层使用通道剪枝。减少此层的输出通道数有助于减少后续层的输入通道数。它也应该适用于其他 CONV2d 层。 "compression_training": { "channel_pruning":{ "shared_parameters":{ "enabled": true, "schedule_offset": 0, "method": "topk" }, "different_groups":{ "cp1": { "params": { "dense_ratio": 0.5 }, "modules": [ "layer....conv1" ], "related_modules": [ ["layer....conv2", "layer....bn1"] ] } } } } shared_parameters：[dictionary] 所有通道剪枝组的共享参数。 字段 值 默认值 enabled：[boolean] 是否启用通道剪枝。 false schedule_offset：[integer] 在预定步数后启用通道剪枝（可视为预热步）。 0 method：[string] 选择不同的剪枝方法，l1（静态，基于幅度）或 topk（动态，可学习）。 "l1" different_groups：[dictionary] 不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，你可以根据需求选择集的数量。 字段 值 默认值 params：[dictionary] dense_ratio：[float] 剪枝后要保留的权重百分比。 0.5 modules：[list] 与 params 设置关联的权重参数范围。 "All CONV2D layers" related_modules：[list[list]] 与通道剪枝模块相关的模块。 None Checkpoint 选项 "checkpoint": { "tag_validation"="Warn", "load_universal"=false, "use_node_local_storage"=false, "parallel_write":{ "pipeline_stage": false } } tag_validation：[“Ignore” “Warn” “Fail”] 描述 默认值 启用以确保 checkpoint 标签在所有 rank 间一致的检查级别。在使用不同 world 大小恢复时有用。 “Warn” load_universal：[boolean] 描述 默认值 为所有加载最新 checkpoint。 false use_node_local_storage：[boolean] 描述 默认值 如果为 true，DeepSpeed 将基于本地 rank 存储模型参数状态和 checkpoint 状态，允许在无法访问共享文件系统的情况下加载 checkpoint。 false pipeline_stage：[boolean] 描述 默认值 使用流水线阶段并行化 checkpoint 的写入。 false 数据类型选项 "data_types": { "grad_accum_dtype"=["fp32"|"fp16"|"bf16"] } } grad_accum_dtype：[“fp32” “fp16” “bf16”] 描述 默认值 指定进行梯度累积的数据类型。如果为 None，则默认与模型类型匹配。 None

32

模式 8： 监控内容概览 用法 自动监控 自定义监控 在本教程中，我们介绍 DeepSpeed Monitor 并提供其用法示例。概览 用法 概览 在训练期间监控模型和系统指标对于确保硬件资源得到充分利用至关重要。DeepSpeed Monitor 支持通过一个或多个监控后端实时记录指标，例如 PyTorch 的 TensorBoard、WandB、Comet 以及简单的 CSV 文件。下面是 TensorBoard 的实时监控视图：下面是 WandB 的实时监控视图：下面是 Comet 的实时监控视图：用法 DeepSpeed Monitor 在 deepspeed 配置文件中进行配置。DeepSpeed 将自动监控关键训练指标，包括通过 wall_clock_breakdown 配置选项跟踪的指标。此外，用户还可以记录自己的自定义事件和指标。自动监控 自定义监控 自动监控 使用 DeepSpeed 进行模型训练时，可以在 DeepSpeed 配置文件中配置 Monitor。使用 Monitor 无需显式调用 API。可以通过在 DeepSpeed 的配置 json 文件中添加以下字段来启用 Monitor。详情请参阅 Monitoring。{ "tensorboard": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } "wandb": { "enabled": true, "team": "my_team", "group": "my_group", "project": "my_project" } "comet": { "enabled": true, "project": "my_project", "experiment_name": "my_experiment" } "csv_monitor": { "enabled": true, "output_path": "output/ds_logs/", "job_name": "train_bert" } } DeepSpeed 将自动记录到配置中列出的所有可用且已启用的监控后端，并生成如上所列的实时监控视图。自定义监控 除了自动监控之外，用户还可以在客户端脚本中记录自己的自定义指标。目前，有两种方式初始化 Monitor 对象：(推荐) - 创建 MonitorMaster(ds_config.monitor_config) 对象，它会自动初始化 DeepSpeed 配置中存在的所有监控后端 创建特定的 TensorBoardMonitor(ds_config.monitor_config)、WandbMonitor(ds_config.monitor_config)、csvMonitor(ds_config.monitor_config) 对象，它只会初始化 DeepSpeed 配置中存在的特定监控后端 创建自定义监控的步骤如下：将 import 添加到您想要的 Monitor 使用 DeepSpeed 配置的 monitor_config 初始化 monitor 以 [("label", value, ds_engine.global_samples), ...]* 格式创建一个包含一个或多个 3 元组的列表 对步骤 3 中的列表调用 monitor.write_events * 注意 - 某些 Monitor 后端不支持混合样本值。请务必在每个 3 元组中使用 DeepSpeed 引擎对象的 global_samples 属性 有关用法示例，请参阅以下修改后的 DeepSpeedExamples/cifar 示例：# Step 1: Import monitor (and DeepSpeed config, if needed) from deepspeed.monitor.monitor import MonitorMaster from deepspeed.runtime.config import DeepSpeedConfig # Step 2: Initialized monitor with DeepSpeed config (get DeepSpeed config object, if needed) ds_config = DeepSpeedConfig("ds_config.json") monitor = MonitorMaster(ds_config.monitor_config) for epoch in range(2): running_loss = 0.0 for i, data in enumerate(trainloader): pre = time.time() inputs, labels = data[0].to(model_engine.local_rank), data[1].to( model_engine.local_rank) if fp16: inputs = inputs.half() outputs = model_engine(inputs) loss = criterion(outputs, labels) model_engine.backward(loss) model_engine.step() post = time.time() # Step 3: Create list of 3-tuple records (single entry in this case) events = [("Time per step", post-pre, model_engine.global_samples)] # Step 4: Call monitor.write_events on the list from step 3 monitor.write_events(events) 更新于：2025 年 11 月 5 日 上一页 下一页

wall_clock_breakdown

示例代码模式

示例 1 (python)：

### Create aio_handle
from deepspeed.ops.op_builder import AsyncIOBuilder
aio_handle = AsyncIOBuilder().load().aio_handle()

参考文件

此技能在 references/ 中包含全面的文档：

• 08.md - 08 文档
• 09.md - 09 文档
• 2020.md - 2020 文档
• 2023.md - 2023 文档
• assets.md - Assets 文档
• mii.md - Mii 文档
• other.md - 其他文档
• tutorials.md - 教程文档

当需要详细信息时，使用 view 读取特定的参考文件。

使用此技能

对于初学者

从 getting_started 或 tutorials 参考文件开始，了解基础概念。

对于特定功能

使用相应的类别参考文件（api、guides 等）获取详细信息。

对于代码示例

上面的快速参考部分包含从官方文档中提取的常见模式。

资源

references/

从官方来源提取的整理后的文档。这些文件包含：

• 详细说明
• 带语言标注的代码示例
• 原始文档的链接
• 用于快速导航的目录

scripts/

在此处添加用于常见自动化任务的辅助脚本。

assets/

在此处添加模板、样板代码或示例项目。

说明

• 此技能是从官方文档自动生成的
• 参考文件保留了源文档的结构和示例
• 代码示例包含语言检测，以实现更好的语法高亮
• 快速参考模式是从文档中的常见用法示例中提取的

更新

要使用更新后的文档刷新此技能：

1. 使用相同配置重新运行抓取工具
2. 此技能将使用最新信息重新构建