DeepSpeed 配置 JSON

注意： train_batch_size 必须等于 train_micro_batch_size_per_gpu * gradient_accumulation_steps * GPU 数量。为简化操作，您可以选择只指定这三个参数中的两个，第三个将由 DeepSpeed 自动推断。

train_batch_size: [整数]

值 示例
有效的训练批处理大小。这是导致模型更新一步的数据样本量。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: [整数]

描述 默认
单个 GPU 在一步中（不进行梯度累积）处理的批处理大小。如果同时提供了 train_batch_size 和 gradient_accumulation_steps，则可以省略此参数。 train_batch_size 值

gradient_accumulation_steps: [整数]

描述 默认
在平均和应用梯度之前累积梯度的训练步数。此功能有时有助于提高可伸缩性，因为它减少了步骤之间的梯度通信频率。此功能的另一个影响是能够以每个 GPU 更大的批处理大小进行训练。如果同时提供了 train_batch_size 和 train_micro_batch_size_per_gpu，则可以省略此参数。 1

优化器参数

optimizer: [字典]

字段 值 示例
类型 优化器名称。DeepSpeed 原生支持 Adam、AdamW、OneBitAdam、Lamb 和 OneBitLamb 优化器（详见此处），并将从 torch 导入其他优化器。 "Adam"
参数 用于实例化优化器的参数字典。参数名称必须与优化器构造函数的签名匹配（例如，对于 Adam）。 {"lr": 0.001, "eps": 1e-8}

optimizer 使用 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 比特 Adam 特定参数的 optimizer 示例如下。

"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 比特 Adam 优化器还支持以下三个 `params` 键/值（详见我们的教程）

“params” 键 描述 默认
freeze_step 在将 1 比特压缩应用于通信之前，热身步数 100000
cuda_aware 指示底层 MPI 库支持 CUDA-Aware 通信 false
comm_backend_name 指示要使用的后端实现 "nccl"

1 比特 Adam 的一个变体 optimizer 是 0/1 Adam，它通过自适应方差冻结和优化器状态的 1 比特同步进一步优化了 1 比特 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 比特 LAMB 的 optimizer 示例

"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 比特 LAMB 优化器还支持以下 `params` 键/值（详见我们的教程）

“params” 键 描述 默认
max_coeff 原始 LAMB 算法和 1 比特 LAMB 热身阶段的缩放系数上限 10.0
min_coeff 原始 LAMB 算法和 1 比特 LAMB 热身阶段的缩放系数下限 0.01
freeze_step 在将 1 比特压缩应用于通信之前，热身步数 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: [字典]

字段 值 示例
类型 调度器名称。支持的调度器列表请参见此处。 "WarmupLR"
参数 用于实例化调度器的参数字典。参数名称应与调度器构造函数签名匹配。 {"warmup_min_lr": 0, "warmup_max_lr": 0.001}

scheduler 示例

 "scheduler": {
      "type": "WarmupLR",
      "params": {
          "warmup_min_lr": 0,
          "warmup_max_lr": 0.001,
          "warmup_num_steps": 1000
      }
  }

通信选项

communication_data_type: [字符串]

描述 默认
在梯度平均期间，使用选定的数据类型执行通信。默认情况下，它将由选定的模式决定 无

prescale_gradients: [布尔值]

描述 默认
在执行 allreduce 之前缩放梯度 false

gradient_predivide_factor: [浮点数]

描述 默认
在梯度平均之前，将梯度预除以一个指定因子，这有时有助于在扩展到大量 GPU 时提高 fp16 的稳定性 1.0

sparse_gradients: [布尔值]

描述 默认
启用 torch.nn.Embedding 梯度的稀疏压缩。此功能基本上已弃用，因为我们不再看到太多用例。应注意，此功能与 torch.sparse 相关功能不兼容。 false

FP16 训练选项

注意： 此模式不能与下面描述的 amp 模式结合使用。

fp16: [字典]

描述 默认
使用混合精度/FP16 训练的配置，该训练利用了 NVIDIA 的 Apex 包。下面展示了一个示例，包括可用的字典键。注意：这不使用 Apex 的 AMP 模式，AMP 模式允许在混合精度训练模式中提供更大的灵活性，此模式类似于 AMP 的 O2 模式。如果您想使用更复杂的混合精度模式，请参阅下面的 AMP 支持。如果您想使用 ZeRO（目前），则必须使用此模式。 无 
"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: [布尔值]

描述 默认
enabled 是一个 fp16 参数，指示是否启用 FP16 训练。 false

fp16:auto_cast: [布尔值]

描述 默认
auto_cast 自动将输入转换为 fp16 false

fp16:loss_scale: [浮点数]

描述 默认
loss_scale 是一个 fp16 参数，表示 FP16 训练的损失缩放值。默认值 0.0 会导致动态损失缩放，否则该值将用于静态固定损失缩放。 0.0

fp16:initial_scale_power: [整数]

描述 默认
initial_scale_power 是一个 fp16 参数，表示初始动态损失缩放值的幂。实际损失缩放值计算为 2initial_scale_power。 16

fp16:loss_scale_window: [整数]

描述 默认
loss_scale_window 是一个 fp16 参数，表示动态损失缩放值升高/降低的窗口。 1000

fp16:hysteresis: [整数]

描述 默认
hysteresis 是一个 fp16 参数，表示动态损失缩放中的延迟偏移。 2

fp16:consecutive_hysteresis: [布尔值]

描述 默认
consecutive_hysteresis 是一个 fp16 参数，表示如果我们达到一个不溢出的迭代，是否重新填充滞后。 false

fp16:min_loss_scale: [整数]

描述 默认
min_loss_scale 是一个 fp16 参数，表示最小动态损失缩放值。 1

BFLOAT16 训练选项

注意： 此模式不能与下面描述的 amp 模式结合使用。

注意： 此模式不能与上面描述的 fp16 模式结合使用。

bf16: [字典]

描述 默认
使用 bfloat16 浮点格式替代 FP16 的配置。BFLOAT16 需要硬件支持（例如 NVIDIA A100）。下面展示了一个示例，包括可用的字典键。使用 bfloat16 训练不需要损失缩放。 无 
"bf16": {
   "enabled": true
 }

bf16:enabled: [布尔值]

描述 默认
enabled 指示是否启用 BFLOAT16 训练。 false

自动混合精度 (AMP) 训练选项

注意： 此模式不能与上面描述的 fp16 模式结合使用。此外，此模式目前与 ZeRO 不兼容。

amp: [字典]

描述 默认
使用自动混合精度 (AMP) 训练的配置，该训练利用了 NVIDIA 的 Apex AMP 包。下面展示了一个示例，包括可用的字典键。与上面的 fp16 模式或 ZeRO 不兼容。除了“enabled”之外的任何参数都将传递给 AMP 的初始化调用，请参见 apex.amp.initialize 文档 中的 API 和描述。 无 
"amp": {
    "enabled": true,
    ...
    "opt_level": "O1",
    ...
}

amp:enabled: [布尔值]

描述 默认
enabled 是一个 amp 参数，指示是否启用 AMP 训练。 false

AMP 参数: [各种]

描述 默认
除了“enabled”之外的任何参数都将传递给 AMP 的初始化调用，请参见 apex.amp.initialize 文档 中的 API 和描述。 无

梯度裁剪

gradient_clipping: [浮点数]

描述 默认
启用梯度裁剪并指定值 1.0

用于 FP16 训练的 ZeRO 优化

启用和配置 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: [字典]

描述 默认
启用 ZeRO 内存优化，兼容 FP16/BF16/FP32 和 Adam 优化器。 false

stage: [整数]

描述 默认
选择 ZeRO 优化器的不同阶段。阶段 0、1、2 和 3 分别指禁用、优化器状态分区、优化器+梯度状态分区，以及优化器+梯度+参数分区。 0

allgather_partitions: [布尔值]

描述 默认
选择 allgather 集合操作或一系列广播集合操作，以在每个步骤结束时从所有 GPU 收集更新的参数 true

allgather_bucket_size: [整数]

描述 默认
一次 allgather 的元素数量。限制了大型模型所需的 allgather 内存 5e8

overlap_comm: [布尔值]

描述 默认
尝试将梯度归约与反向计算重叠 false

reduce_scatter: [布尔值]

描述 默认
使用 reduce 或 reduce scatter 而非 allreduce 来平均梯度 true

reduce_bucket_size: [整数]

描述 默认
一次 reduce/allreduce 的元素数量。限制了大型模型所需的 allgather 内存 5e8

contiguous_gradients: [布尔值]

描述 默认
在梯度生成时将其复制到连续缓冲区。避免了反向传播期间的内存碎片。 True

load_from_fp32_weights: [布尔值]

描述 默认
从检查点中的 fp32 副本（无精度损失）或模型的 fp16 副本（有精度损失）初始化 fp32 主权重。这可以用于在检查点缺少优化器状态时初始化优化器状态。 True

grad_hooks: [布尔值]

描述 默认
与 ZeRO 阶段 1 结合使用，启用反向钩子以在反向传播期间减小梯度，或者等待反向传播结束。 True

round_robin_gradients: [布尔值]

描述 默认
用于 CPU 卸载的阶段 1 和 2 优化，通过细粒度梯度分区在各进程之间并行化梯度复制到 CPU 内存。性能提升随着梯度累积步数（优化器步骤之间更多复制）或 GPU 数量（并行性增加）而增长。 False

offload_param: [字典]

描述 默认
启用将模型参数卸载到 CPU 或 NVMe。这可以释放 GPU 内存，以支持更大的模型或批处理大小。仅在阶段 3 有效。详见此处。 False

offload_optimizer: [字典]

描述 默认
启用将优化器状态卸载到 CPU 或 NVMe，并将优化器计算卸载到 CPU。这可以释放 GPU 内存，以支持更大的模型或批处理大小。适用于 ZeRO 阶段 1、2、3。详见此处。 False

stage3_max_live_parameters: [整数]

描述 默认
在释放之前，每个 GPU 常驻参数的最大数量。值越小，内存使用越少，但通信量越大。 1e9

stage3_max_reuse_distance: [整数]

描述 默认
如果参数将在该参数阈值内被重用，则不释放该参数。值越小，内存使用越少，但通信量越大。 1e9

stage3_prefetch_bucket_size: [整数]

描述 默认
用于预取参数的固定缓冲区大小。值越小，内存使用越少，但可能因通信而增加停顿。 5e8

stage3_param_persistence_threshold: [整数]

描述 默认
不对小于此阈值的参数进行分区。值越小，内存使用越少，但可能会大大增加通信（特别是延迟受限的消息）。 1e5

stage3_gather_16bit_weights_on_model_save: [布尔值]

描述 默认
通过 save_16bit_model() 在保存模型之前整合权重。由于权重在 GPU 之间分区，它们不属于 state_dict，因此当此选项启用时，此函数会自动收集权重，然后保存 fp16 模型权重。 False

stage3_module_granularity_threshold: [整数] | 描述 | 默认 | |——————————————————————————————————————————————————————————————————————————————————————————–| ——- | | 模块的粒度由 parameter_count / (1 + descendant_count) 的比率决定。ZeRO3 将粒度低于阈值的模块归类为细粒度，在参数获取期间将其视为整体单元。这减少了独立钩子带来的主机和通信开销。 | 0 |

zero_hpz_partition_size: [整数]

描述 默认
分层分区 ZeRO (hpZ) ZeRO++ 次级张量组中的进程数，默认值为 1 表示无 hpZ，理想值为每个节点上的进程数（GPU 数量）。 1

zero_quantized_weights: [布尔值]

描述 默认
布尔值，指示是否启用 ZeRO++ 的通信高效量化权重。 False

zero_quantized_gradients: [布尔值]

描述 默认
布尔值，指示是否启用 ZeRO++ 的通信高效量化梯度。 False

log_trace_cache_warnings: [布尔值]

描述 默认
记录来自参数分片跟踪缓存优化的警告，例如缓存失效事件。 False

cpu_offload: [布尔值]

已弃用： 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: [字符串]

描述 默认
用于卸载模型参数的设备内存。支持的选项有 cpu 和 nvme。 cpu

nvme_path: [字符串]

描述 默认
用于参数卸载的 NVMe 设备的 filesystem 路径。 /local_nvme

pin_memory: [布尔值]

描述 默认
卸载到页锁定 CPU 内存。这可能会以额外的内存开销为代价提高吞吐量。 false

buffer_count: [整数]

描述 默认
用于将参数卸载到 NVMe 的缓冲区池中的缓冲区数量。 5

buffer_size: [整数]

描述 默认
用于将参数卸载到 NVMe 的缓冲区池中的缓冲区大小。 1e8

max_in_cpu: [整数]

描述 默认
当启用卸载到 NVMe 时，在 CPU 内存中维护的参数元素数量。 1e9

优化器卸载

启用和配置 ZeRO 优化，将优化器计算卸载到 CPU，并将状态卸载到 CPU/NVMe。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: [字符串]

描述 默认
用于卸载优化器状态的设备内存。支持的选项是 cpu 和 nvme。无论设备选项如何，优化器计算都卸载到 CPU。 cpu

nvme_path: [字符串]

描述 默认
用于优化器状态卸载的 NVMe 设备的 filesystem 路径。 /local_nvme

pin_memory: [布尔值]

描述 默认
卸载到页锁定 CPU 内存。这可能会以额外的内存开销为代价提高吞吐量。 false

ratio: [浮点数]

描述 默认
CPU 端参数更新（即优化器步骤）的比率。 1

buffer_count: [整数]

描述 默认
用于将优化器状态卸载到 NVMe 的缓冲区池中的缓冲区数量。这应至少是优化器为每个参数维护的状态数量。例如，Adam 优化器有 4 种状态（参数、梯度、动量和方差）。 4

fast_init: [布尔值]

描述 默认
启用快速优化器初始化，当卸载到 NVMe 时。 false

异步 I/O

配置异步 I/O 模块，用于将参数和优化器状态卸载到持久（NVMe）存储。此模块使用 Linux 原生异步 I/O (libaio)。

  "aio": {
    "block_size": 1048576,
    "queue_depth": 8,
    "thread_count": 1,
    "single_submit": false,
    "overlap_events": true
  }

block_size: [整数]

描述 默认
I/O 块大小（字节）。 1048576

queue_depth: [整数]

描述 默认
I/O 队列深度。 8

thread_count: [整数]

描述 默认
用户线程提交的每个读/写请求的内部请求并行度。 1

single_submit: [布尔值]

描述 默认
将请求作为多个单独的请求提交到存储设备，而不是作为一个请求块。 false

overlap_events: [布尔值]

描述 默认
以重叠方式向存储设备提交请求，无需等待早期请求完成。 true

ignore_unused_parameters: [布尔值]

描述 默认
模块中未使用的参数在静态网络中可能出乎意料，但在动态网络中可能正常。这控制了当检测到未使用参数时，训练是否应以错误消息终止。默认情况下设置为 True，这意味着未使用参数将被忽略，训练继续进行。现在仅在阶段 2 使用。 True

日志记录

steps_per_print: [整数]

描述 默认
每 N 个训练步打印进度报告。报告包括训练步数、跳过的优化器更新次数（可能是由于混合精度训练中的溢出）、当前学习率和当前动量。 10

wall_clock_breakdown: [布尔值]

描述 默认
启用前向/反向/更新训练阶段的延迟计时 false

dump_state: [布尔值]

描述 默认
初始化后打印 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: [布尔值]

描述 默认
启用自动调优器。 false

results_dir: [字符串]

描述 默认
自动调优实验结果目录的路径。默认情况下，它将出现在 DeepSpeed 启动时所在的工作目录中。 "autotuning_results"

exps_dir: [字符串]

描述 默认
自动调优实验描述目录的路径。默认情况下，它将出现在 DeepSpeed 启动时所在的工作目录中。 "autotuning_exps"

overwrite: [布尔值]

描述 默认
是否运行结果已存在的自动调优实验。设置为 true 将覆盖现有结果。 false

metric: [字符串]

描述 默认
用于对自动调优实验进行排名的性能指标。目前支持 latency（训练步延迟）、throughput（每秒训练样本数）和 FLOPS（每 GPU 每秒浮点运算次数）。 throughput

start_profile_step: [整数]

描述 默认
在自动调优实验中开始分析的全局训练步数。请注意，为了获得准确的性能测量，需要进行热身。 3

end_profile_step: [整数]

描述 默认
在自动调优实验中结束分析的全局训练步数。不得小于 start_profile_step。 5

fast: [布尔值]

描述 默认
启用快速模型自动调优，其中仅调整 Zero 阶段和每个 GPU 的微批处理大小。 true

max_train_batch_size: [整数]

描述 默认
模型训练的最大训练批处理大小（全局有效批处理大小）。 null

mp_size: [整数]

描述 默认
模型并行度。 1

num_tuning_micro_batch_sizes: [整数]

描述 默认
要探索的微批处理大小的数量。 3

tuner_type: [字符串]

描述 默认
该算法定义了 ZeRO 阶段内自动调优空间探索的顺序。 model_based

tuner_early_stopping: [整数]

描述 默认
在当前最佳实验之外运行的实验数量。如果在该数量内没有找到更好的实验，自动调优器将停止探索。 5

tuner_num_trials: [整数]

描述 默认
在 ZeRO 阶段内，在调优空间中探索的最大实验数量。 50

Flops 分析器

{
  "flops_profiler": {
    "enabled": false,
    "profile_step": 1,
    "module_depth": -1,
    "top_modules": 1,
    "detailed": true,
    "output_file": null,
    }
}

enabled: [布尔值]

描述 默认
启用 flops 分析器。这将同时启用 wall_clock_breakdown false

profile_step: [整数]

描述 默认
进行分析的全局训练步数。请注意，为了获得准确的时间测量，需要热身步。 1

module_depth: [整数]

描述 默认
打印聚合模块信息的模型深度。当设置为 -1 时，它将打印从顶部模块到最内部模块的信息（最大深度）。 -1

top_modules: [整数]

描述 默认
将聚合分析输出限制为指定数量的顶部模块。 1

detailed: [布尔值]

描述 默认
是否打印详细的模型分析。 true

output_file: [字符串]

描述 默认
输出文件的路径。如果为 None，分析器将打印到标准输出。 null

激活检查点

  "activation_checkpointing": {
    "partition_activations": false,
    "cpu_checkpointing": false,
    "contiguous_memory_optimization": false,
    "number_checkpoints": null,
    "synchronize_checkpoint_boundary": false,
    "profile": false
    }

partition_activations: [布尔值]

描述 默认
与模型并行配合使用时，启用分区激活 false

cpu_checkpointing: [布尔值]

描述 默认
如果启用了 partition_activations，则将分区激活卸载到 CPU false

contiguous_memory_optimization: [布尔值]

描述 默认
复制分区激活，使其在内存中连续 false

number_checkpoints: [整数]

描述 默认
用于为 contiguous_memory_optimization 分配内存缓冲区的激活检查点总数 无

synchronize_checkpoint_boundary: [布尔值]

描述 默认
在每个检查点边界插入 get_accelerator().synchronize()。 false

profile: [布尔值]

描述 默认
记录每个检查点函数的前向和反向时间 false

稀疏注意力

sparse_attention: [字典]

字段 值 示例
模式 确定稀疏结构类型的字符串。DeepSpeed 目前支持 "dense"、"fixed"、"bigbird"、"bslongformer" 和 "variable"。 "fixed"
块 确定块大小的整数。稀疏自注意力的当前实现基于分块稀疏矩阵。其中此参数定义此类块的大小，即 Block X Block。 16
different_layout_per_head 布尔值，确定是否应为每个头部分配不同的稀疏布局；这将根据可用性进行满足。 false
num_local_blocks 确定每个块行中随机块数量的整数；仅在 "fixed" 模式中使用。 4
num_global_blocks 确定局部窗口中有多少个连续块被用作全局注意力的窗口代表的整数；在 "fixed" 和 "bigbird" 模式中使用。 1
注意力 确定注意力类型的字符串。注意力可以是 "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" 模式中使用。 无
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: [字典]

字段 值 默认
enabled: [布尔值] 是否启用数据效率。 false
seed: [整数] 数据采样随机种子。 1234
data_routing: [字典] 数据路由技术的配置。 不适用
data_sampling: [字典] 数据采样技术的配置。 不适用

data_routing: [字典]

字段 值 默认
enabled: [布尔值] 是否启用数据路由技术。 false
random_ltd: [字典] random-LTD 技术的配置。 不适用

data_sampling: [字典]

字段 值 默认
enabled: [布尔值] 是否启用数据采样技术。 false
num_epochs: [整数] 原始数据集最多将迭代多少个 epoch。 1000
num_workers: [整数] 数据加载器 worker 数量。 0
curriculum_learning: [字典] 课程学习技术的配置。 不适用

random_ltd: [字典]

字段 值 默认
enabled: [布尔值] 是否启用 random-LTD 技术。 false
total_layer_num: [整数] 预训练/微调模型的层数（或深度）。 不适用
random_ltd_layer_num: [整数] 将应用 random-LTD 的层数。 不适用
random_ltd_layer_id: [列表] 将应用 random-LTD 的精确 layer_id。此列表的长度必须与 random_ltd_layer_num 相同。 不适用
model_mask_name: [字符串] attention_mask 的变量名。不同的库有不同的名称，例如 att_mask。对于 huggingface 模型，它被命名为“attention_mask”。用户需要检查原始模型文件中的 forward 函数。如果原始模型 forward 函数中的 attention mask 输入不是关键字/命名参数（例如，attention_mask=None），用户需要将其更改为关键字/命名参数，并将该关键字作为 model_mask_name 提供。 不适用
model_type: [字符串] 用户需要确定模型是 decoder 还是 encoder。目前我们只支持这两种。 不适用
hidden_state_order: [字符串] 用户需要知道隐藏状态张量的输入顺序。通常，它是批处理、序列，然后是隐藏维度，即 batch_seq_dim。有时，批处理和序列之间的顺序会切换，例如 seq_batch_dim。目前，我们支持这两种。 不适用
random_ltd_schedule: [字典] token 丢弃后有效序列长度的调度。它是一个线性函数，其中 random-LTD 逐渐丢弃更少的 token 并增加有效序列长度。 不适用
  min_value: [整数] 在步/迭代 0 时的初始有效序列长度（token 丢弃后）。 不适用
  max_value: [整数] 最大有效序列长度（通常是没有 token 丢弃的情况）。通常将其设置为基线的 seqlen。 不适用
  schedule_type: [字符串] 序列长度遵循从 min_value 开始并达到 max_value 的线性递增函数。我们目前只支持这种类型。 不适用
  schedule_config: [字典] 线性递增函数的配置。 不适用
    require_steps: [整数] 从 min_value 到 max_value 需要多少次迭代。 不适用
    seq_per_step: [整数] 在任何时候，有效序列长度都是 seq_per_step 的倍数。将其设置为 8（用于 FP16 数据）或 16（用于 INT8 数据）的倍数，以启用 NVIDIA Tensor Core 加速。 不适用

curriculum_learning: [字典]

字段 值 默认
enabled: [布尔值] 是否启用课程学习技术。 false
data_cluster_path: [字符串] 课程学习将存储相同难度范围内数据样本索引的目录路径。 不适用
curriculum_metrics: [字典] 此字典包含所有期望的课程指标及其配置。每个指标都将是一个独立的子字典，其中键是指标名称，值是下面的配置。 不适用
  index_to_sample_path: [字符串] 在离线数据分析期间生成的 index_to_sample 文件的路径。请注意，数据分析将生成两种 index_to_sample 文件：metric_name_index_to_sample_percentile_merged 文件是用于性能改进的连接索引，但它仅在您设置 difficulty_type=percentile 时有效。如果您使用 difficulty_type=value，则需要将其更改为使用 metric_name_index_to_sample 文件。 不适用
  index_to_metric_path: [字符串] 在离线数据分析期间生成的 index_to_metric_path 文件的路径。 不适用
  difficulty_type: [字符串] 训练期间，如何增加最大接受难度。目前支持 value（按绝对值增加）和 percentile（按难度百分位数增加）。 不适用
  clustering_type: [字符串] 目前支持 schedule_based（根据下面的难度调度（步调函数）聚类数据）和 single_cluster（不需要聚类，并且可能通过数据后处理（例如序列长度截断）实现课程学习）。 不适用
  min_difficulty: [整数] 第一步的起始难度。当 difficulty_type=value 时，min_difficulty 是一个绝对难度值。当 difficulty_type=percentile 时，min_difficulty 是一个难度百分位数。 不适用
  max_difficulty: [整数] 最终最大难度。当 difficulty_type=value 时，max_difficulty 是一个绝对难度值。当 difficulty_type=percentile 时，max_difficulty 是一个难度百分位数。 不适用
  schedule_type: [字符串] 难度调度（步调函数），定义了训练期间最大接受难度如何从 min_difficulty 增加到 max_difficulty。目前支持 fixed_linear、fixed_root、fixed_discrete 和 custom。 不适用
  schedule_config: [字典] 步调函数的配置。当 schedule_type=custom 时，此字典不是必需的。相反，用户需要提供一个回调函数（通过 deepspeed/runtime/engine.py 中的 set_custom_curriculum_learning_schedule API），该函数将在训练期间更新最大接受难度。下面的配置都属于 schedule_config。 不适用
    total_curriculum_step: [整数] 课程学习从最小难度到最大难度所需的步数。由 fixed_linear 和 fixed_root 调度使用。 不适用
    difficulty_step: [整数] 每步确定的最大接受难度级别必须是 difficulty_step 的倍数。这用于确保使用 NVIDIA Tensor Core 加速（需要 8 (FP16) 或 16 (INT8) 的倍数）。由 fixed_linear 和 fixed_root 调度使用。 不适用
    root_degree: [整数] 课程调度函数的根次数。次数为 2 表示平方根，次数为 3 表示立方根。次数为 1 等同于线性。由 fixed_root 调度使用。 不适用
    difficulty: [列表] 调度期间要使用的最大接受难度级别列表。由 fixed_discrete 调度使用。 不适用
    max_step: [列表] 更改最大接受难度级别的步数列表。由 fixed_discrete 调度使用。 不适用

课程学习

注意： 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: [布尔值]

描述 默认
设置为 true 以启用课程学习 false

curriculum_type: [字符串]

描述 默认
课程难度指标的类型。目前支持 seqlen。 不适用

min_difficulty: [整数]

描述 默认
起始难度级别 不适用

max_difficulty: [整数]

描述 默认
结束难度级别 不适用

schedule_type: [字符串]

描述 默认
课程调度类型。目前支持 fixed_linear、fixed_root 和 fixed_discrete。 不适用

total_curriculum_step: [整数]

描述 默认
课程学习的总步数。当使用 fixed_linear 和 fixed_root 调度类型时，属于 schedule_config 之一。 不适用

difficulty_step: [整数]

描述 默认
在任何时候，课程学习难度都必须是 difficulty_step 的倍数。将其设置为 8（用于 FP16 数据）或 16（用于 INT8 数据）的倍数，以启用 NVIDIA Tensor Core 加速。当使用 fixed_linear 和 fixed_root 调度类型时，属于 schedule_config 之一。 不适用

root_degree: [整数]

描述 默认
课程调度函数的根次数。当使用 fixed_root 调度类型时，属于 schedule_config 之一。 不适用

difficulty: [整数列表]

描述 默认
调度期间要使用的难度级别列表。当使用 fixed_discrete 调度类型时，属于 schedule_config 之一。 不适用

max_step: [整数列表]

描述 默认
更改难度级别的步数列表。当使用 fixed_discrete 调度类型时，属于 schedule_config 之一。 不适用

监控模块

注意： DeepSpeed 通过 PyTorch 记录到 TensorBoard。记录到 TensorBoard 需要安装 tensorboard 包（详见 PyTorch 文档）。

注意： 记录到 WandB 需要安装 wandb 包（详见 WandB 文档）。

注意： 记录到 Comet 需要安装 comet_ml 包（详见 Comet 文档）。

DeepSpeed 的监控模块可以将训练详情记录到与 Tensorboard 兼容的文件、WandB、Comet 或简单的 CSV 文件中。下面是 DeepSpeed 将自动记录内容的概述。

字段 描述 条件
训练/样本/训练损失 训练损失。 无
训练/样本/学习率 训练期间的学习率。 无
训练/样本/损失缩放 fp16 必须启用。 训练/特征值/模型块参数_{i}
eigenvalue 必须启用。 训练/样本/前向耗时（毫秒） 前向传播的全局持续时间。
训练/样本/反向耗时（毫秒） 训练/样本/反向内部耗时（毫秒） 不包括梯度归约时间的反向时间。仅在梯度归约未重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。
训练/样本/反向 allreduce 耗时（毫秒） 训练/样本/反向内部耗时（毫秒） 不包括梯度归约时间的反向时间。仅在梯度归约未重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。
allreduce 操作的全局持续时间。 训练/样本/步长耗时（毫秒） 不包括梯度归约时间的反向时间。仅在梯度归约未重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。
优化器步长耗时 tensorboard: [字典] 不包括梯度归约时间的反向时间。仅在梯度归约未重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。
enabled 是否启用记录到 Tensorboard。 不包括梯度归约时间的反向时间。仅在梯度归约未重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。

output_path

字段 值 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 job_name false
当前作业的名称。这将在 output_path 内创建一个新目录。 "DeepSpeedJobName" null
tensorboard 配置示例 wandb: [字典] 是否启用记录到 WandB。

group

"tensorboard": {
    "enabled": true,
    "output_path": "output/ds_logs/",
    "job_name": "train_bert"
}

WandB 组的名称。这可用于将运行分组。

字段 值 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 team false
WandB 团队的名称。 project 无
WandB 项目的名称。 deepspeed 无
wandb 配置示例 comet: [字典] 是否启用记录到 Comet。

workspace

"wandb": {
    "enabled": true,
    "group": "my_group",
    "team": "my_team",
    "project": "my_project"
}

Comet 工作区名称。

字段 值 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 Comet 项目名称。 false
samples_log_interval 处理完每 samples_log_intervas 个样本后，指标将提交到 Comet。 无
wandb 配置示例 experiment_name 无
用于日志记录的 Comet 实验名称。 api_key 100
Comet API 密钥。不建议在代码中保存 Comet API 密钥。 experiment_key 无
用于日志记录的 Comet 实验密钥。必须是长度在 32 到 50 个字符之间的字母数字字符串。 online 无
如果为 True，数据将记录到 Comet 服务器，否则将本地存储在离线实验中。默认值为 True。 控制 Comet 实验的启动方式。“get”：继续记录到由 experiment_key 值标识的现有实验。“create”：始终创建新实验，适用于 HPO 扫描。“get_or_create”（默认）：如果需要，启动新实验，或持久记录到现有实验。 无
comet 配置示例 csv_monitor: [字典] 无
模式 是否启用记录到本地 CSV 文件。 无

CSV 文件将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。

"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",
}

当前作业的名称。这将在 output_path 内创建一个新目录

字段 值 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 csv_monitor 配置示例 false
当前作业的名称。这将在 output_path 内创建一个新目录。 在弹性训练中启用全局批处理大小的计算。 null
tensorboard 配置示例 max_train_batch_size 是否启用记录到 WandB。

训练中可使用的最大可接受批处理大小。

"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
  }
字段 描述 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 micro_batch_sizes false
可接受的微批处理大小，与 train_micro_batch_size_per_gpu 相同 min_gpus 2000
在 v0.1 和 v0.2 中计算高度复合批处理大小时，要搜索的最小 GPU 数量。 max_gpus [2,4,6]
在 v0.1 和 v0.2 中计算高度复合批处理大小时，要搜索的最大 GPU 数量。 min_time 1
调度器再次扩展之前的最短运行时间（分钟）（仅在 v0.1 中使用）。0 表示未知 prefer_large_batch 10000
在寻找合适的批处理大小时，尝试找到一个最接近给定最大训练批处理大小的值。 version 0
要使用的弹性逻辑版本。 ignore_non_elastic_batch_info true
忽略弹性配置之外提供的所有批处理信息。为减少混淆，我们要求所有与批处理相关的信息仅在弹性配置中提供。 num_gpus_per_node 0.2
每个节点的 GPU 数量。此信息由 v0.2 用于支持模型并行训练（仅由 v0.2 使用） model_parallel_size false
张量或模型并行大小（仅由 v0.2 使用） DeepSpeed 提供了一个灵活的通信日志记录工具，可以自动检测和记录通过 deepspeed.comm 启动的通信操作。注意：所有日志记录通信调用都是同步的，以提供准确的时间信息。如果您的模型大量使用异步通信操作，这可能会影响性能。 1
日志填充后，可以使用 deepspeed.comm.log_summary() 进行汇总。有关更多详细信息和使用示例，请参阅教程 张量或模型并行大小（仅由v0.2使用） 1

通信日志记录

DeepSpeed 提供了一个灵活的通信日志工具，可以自动检测和记录通过 deepspeed.comm 发起的通信操作。注意：所有日志记录的通信调用都是同步的，以提供准确的时间信息。如果您的模型大量使用异步通信操作，这可能会影响性能。

日志填充完成后，可以使用 deepspeed.comm.log_summary() 进行汇总。有关更多详细信息和示例用法，请参阅教程

comms_logger: [字典]

字段 值 默认
Tensorboard 日志将被写入的路径。如果为 None，输出路径将设置在训练脚本的启动路径下。 是否启用通信日志记录。 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: [字典]

字段 值 默认
enabled: [布尔值] 是否启用层数缩减。 false
keep_number_layer: [列表] 模型中要保留的层数。 不适用
module_name_prefix: [字符串] 模型模块（其关联的权重参数将被重新初始化）的（统一）名称前缀。 不适用
teacher_layer: [列表] 要重新初始化权重参数的层。列表的长度等于“keep_number_layer”。 不适用
other_module_name: [列表] 要重新初始化其关联权重参数的模块名称。它是 module_name_prefix 的补充或替代。例如，“other_module_name”：[“bert.encoder.layer.2”，“bert.encoder.layer.4”] 等同于 “module_name_prefix”：“bert.encoder.layer” 和 “teacher_layer”：[2,4]。 不适用

权重量化

  "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: [字典]

所有权重量化组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用权重量化。 false
quantizer_kernel: [布尔值] 使用 DeepSpeed 量化内核进行 >=4 比特量化。这只能在使用 DeepSpeed FP16 优化器时启用。 false
schedule_offset: [整数] 在调度步数后启用权重量化（可视为热身步数）。 0
quantize_groups: [整数] 将权重矩阵分成不同数量的组，每组都有自己的缩放因子。 1
quantize_verbose: [布尔值] 打印量化相关日志。 false
quantization_type: [字符串] 选择量化算法，对称或非对称。 "symmetric"
rounding: [字符串] 与量化相关的舍入算法，最近或随机。 "nearest"
quantize_weight_in_forward: [布尔值] 在优化器或前向步骤中量化权重，对于 FP32 优化器训练必须设置为 true。 false
fp16_mixed_quantize: [字典] 使用 FP16 值和量化值混合的值。 不适用
  enabled: [布尔值] 是否启用 fp16 混合量化。 false
  quantize_change_ratio: [浮点数] 初始量化值比率，将逐渐增加到 1。 0.001

different_groups: [字典]

不同的量化集，用于不同的量化参数。在此示例中，我们给出两个不同的集。在实践中，您可以根据您的要求选择集的数量。

字段 值 默认
params: [字典]    
  start_bits: [整数] 量化起始比特数，将逐渐减少到目标比特数。 8
  target_bits: [整数] 量化目标比特数，需要 <= start_bits。 8
  quantization_period: [整数] 每 n 步，量化比特数将减少 1。 1
modules: [列表] 与参数设置关联的权重参数范围。 "所有线性层和 CONV2D 层"

激活量化

"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: [字典]

所有激活量化组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用激活量化。 false
quantization_type: [字符串] 选择量化算法，对称或非对称。 "symmetric"
range_calibration: [字符串] 推断时使用动态（按 token 或按图像）或静态（使用动量固定最小/最大值）。 "static"
schedule_offset: [整数] 在调度步数后启用激活量化（可视为热身步数）。 0

different_groups: [字典]

不同的量化集，用于不同的量化参数。在此示例中，我们给出一个集。在实践中，您可以根据您的要求选择集的数量。

字段 值 默认
params: [字典]    
  bits: [整数] 用于激活目标比特数的比特数，需要 >= 4。 8
modules: [列表] 与参数设置关联的权重参数范围。 "所有线性层和 CONV2D 层"

稀疏剪枝

"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: [字典]

所有稀疏剪枝组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用稀疏剪枝。 false
schedule_offset: [整数] 在调度步数后启用稀疏剪枝（可视为热身步数）。 0
schedule_offset_end: [整数] 在调度步数后禁用稀疏剪枝，对于 snip_momentum 是强制性的。 0
schedule_offset_stride: [整数] 训练步数上的剪枝步长，对于 snip_momentum 是强制性的。 "1"
method: [字符串] 选择不同的剪枝方法，l1（静态，基于幅值）、topk（动态，可学习）或 snip_momentum（结构化剪枝）。 "l1"
block_pattern: [字符串] 选择不同的结构化剪枝块模式，NxM 或 N:M（N 和 M 为整数）。例如，“4x1”或“2:4”是常见的块模式，对于 snip_momentum 是强制性的。 "4x1"
dense_ratio: [浮点数] 用于获取目标全局稀疏度比率，对于 snip_momentum 是强制性的。 "0.1"
excluded_modules: [列表] 在某些特殊模块（如输出层）上排除剪枝范围。 []

different_groups: [字典]

不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，您可以根据您的要求选择集的数量。请注意，对于 snip_momentum 方法，您可以将其留空。

字段 值 默认
params: [字典]    
  dense_ratio: [浮点数] 剪枝后要保留的权重百分比。 0.5
modules: [列表] 与参数设置关联的权重参数范围。 "所有线性层和 CONV2D 层"

行剪枝

注意： 行剪枝 是一项为两个背靠背的线性层（例如 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: [字典]

所有行剪枝组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用行剪枝。 false
schedule_offset: [整数] 在调度步数后启用行剪枝（可视为热身步数）。 0
method: [字符串] 选择不同的剪枝方法，l1（静态，基于幅值）或 topk（动态，可学习）。 "l1"

different_groups: [字典]

不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，您可以根据您的要求选择集的数量。

字段 值 默认
params: [字典]    
  dense_ratio: [浮点数] 剪枝后要保留的权重百分比。 0.5
modules: [列表] 与参数设置关联的权重参数范围。 "所有线性层和 CONV2D 层"
related_modules: [列表[列表]] 与行剪枝模块相关的模块，可以进行列剪枝。 无

头剪枝

注意： 头剪枝 是一项为两个注意力层（例如 Transformer 中的多头注意力）设计的功能。目前，它只能应用于 Transformer 的输出矩阵（即 BERT 中的 attention.output.dense）。剪枝输出矩阵也可能导致查询/键/值矩阵的剪枝。

"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: [字典]

所有头剪枝组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用头剪枝。 false
schedule_offset: [整数] 在调度步数后启用头剪枝（可视为热身步数）。 0
method: [字符串] 选择不同的剪枝方法。目前，我们只支持 topk（动态，可学习）。 "topk"
num_heads: [整数] 头部数量（必须由用户提供）。 不适用

different_groups: [字典]

不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，您可以根据您的要求选择集的数量。

字段 值 默认
params: [字典]    
  dense_ratio: [浮点数] 剪枝后要保留的权重百分比。 0.5
modules: [列表] 与参数设置关联的权重参数范围。 "所有线性层和 CONV2D 层"
related_modules: [列表[列表]] 与头剪枝模块（即输出矩阵）相关的模块（通常是 Q/K/V）。目前，此功能仅适用于 BERT。 无

通道剪枝

注意： 通道剪枝 是一项为两个背靠背的 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: [字典]

所有通道剪枝组的共享参数。

字段 值 默认
enabled: [布尔值] 是否启用通道剪枝。 false
schedule_offset: [整数] 在调度步数后启用通道剪枝（可视为热身步数）。 0
method: [字符串] 选择不同的剪枝方法，l1（静态，基于幅值）或 topk（动态，可学习）。 "l1"

different_groups: [字典]

不同的剪枝集，用于不同的剪枝参数。在此示例中，我们给出一个集。在实践中，您可以根据您的要求选择集的数量。

字段 值 默认
params: [字典]    
  dense_ratio: [浮点数] 剪枝后要保留的权重百分比。 0.5
modules: [列表] 与参数设置关联的权重参数范围。 "所有 CONV2D 层"
related_modules: [列表[列表]] 与通道剪枝模块相关的模块。 无

检查点选项

"checkpoint": {
    "tag_validation"="Warn",
    "load_universal"=false,
    "use_node_local_storage"=false,
    "parallel_write":{
        "pipeline_stage": false
    }
}
tag_validation: ["忽略" "警告" "失败"]
描述 默认
启用检查级别，以确保检查点标签在所有进程中保持一致。在不同世界大小下恢复时很有用。 "警告"

load_universal: [布尔值]

描述 默认
加载所有最新的检查点。 false

use_node_local_storage: [布尔值]

描述 默认
如果为 true，DeepSpeed 将根据本地 rank 存储模型参数状态和检查点状态，从而允许在无需访问共享文件系统的情况下加载检查点。 false

pipeline_stage: [布尔值]

描述 默认
使用流水线阶段并行化检查点的写入。 false

数据类型选项

"data_types": {
    "grad_accum_dtype"=["fp32"|"fp16"|"bf16"]
    }
}
grad_accum_dtype: ["fp32" "fp16" "bf16"]
描述 默认
指定进行梯度累积的数据类型。如果为 None，则默认匹配模型类型。 无