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}

使用 Adam 的optimizer 示例

"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 感知通信	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 感知通信	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 感知通信	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 的 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 的 initialize 调用，请参阅此处 apex.amp.initialize 文档 中的 API 和描述。	无

"amp": {
    "enabled": true,
    ...
    "opt_level": "O1",
    ...
}

amp:enabled: [布尔值]

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

amp 参数: [各种]

描述	默认值
除了“enabled”之外的任何参数都将传递给 AMP 的 initialize 调用，请参阅此处 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]
    }

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: [整数]

描述	默认值
每次归约/allreduce 的元素数量。限制了大型模型尺寸的 allgather 所需的内存。	5e8

contiguous_gradients: [布尔值]

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

load_from_fp32_weights: [布尔值]

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

grad_hooks: [布尔值]

描述	默认值
用于 ZeRO 阶段 1，启用反向钩子以在反向传播期间减少梯度或等到反向传播结束。	True

round_robin_gradients: [布尔值]

描述	默认值
阶段 1 和 2 的 CPU 卸载优化，通过细粒度梯度分区并行化梯度复制到 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

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 设备的文件系统路径。	/local_nvme

pin_memory: [布尔值]

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

buffer_count: [整数]

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

buffer_size: [整数]

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

max_in_cpu: [整数]

描述	默认值
启用卸载到 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: [字符串]

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

nvme_path: [字符串]

描述	默认值
用于优化器状态卸载的 NVMe 设备的文件系统路径。	/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: [int]

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

mp_size: [int]

描述	默认值
模型并行度。	1

num_tuning_micro_batch_sizes: [整数]

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

tuner_type: [字符串]

描述	默认值
该算法定义了在 ZeRO 阶段内自动调整空间探索的顺序。	基于模型

tuner_early_stopping: [整数]

描述	默认值
在当前最佳实验之外运行的实验次数。如果在此次数内未找到更好的实验，则自动调整器将停止探索。	5

tuner_num_trials: [整数]

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

浮点运算计数分析器

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

enabled: [布尔值]

描述	默认值
启用浮点运算次数分析器。这也将启用 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	一个布尔值，确定每个 head 是否应该分配不同的稀疏布局；这将根据可用性得到满足。	false
num_local_blocks	一个整数，确定每个块行中随机块的数量；仅在"fixed"模式下使用。	4
num_global_blocks	一个整数，确定局部窗口中多少个连续块用作全局注意力的窗口代表；用于"fixed"和"bigbird"模式。	1
注意力	一个确定注意力类型的字符串。注意力可以是"unidirectional"，例如自回归模型，其中标记仅关注上下文中出现在它们之前的标记。考虑到这一点，注意力矩阵的上三角为空。或者它可以是"bidirectional"，例如 BERT，其中标记可以关注它们之前或之后的任何其他标记。然后，注意力矩阵的上三角部分是下三角的镜像；用于"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	一个整数列表，确定哪些块被视为全局注意力。给定索引，确定所有其他标记块关注的块以及它们关注所有其他标记块。请注意，如果设置了 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 数据效率库包含两种技术：课程学习和随机分层标记丢弃（随机-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: [字典]	数据路由技术的配置。	N/A
data_sampling: [字典]	数据采样技术的配置。	N/A

data_routing: [字典]

字段	值	默认值
enabled: [布尔值]	启用或禁用数据路由技术。	false
random_ltd: [字典]	随机-LTD 技术的配置。	N/A

data_sampling: [字典]

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

random_ltd: [字典]

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

curriculum_learning: [字典]

字段	值	默认值
enabled: [布尔值]	启用或禁用课程学习技术。	false
data_cluster_path: [字符串]	课程学习将存储在同一难度范围内的数据样本索引的目录路径。	N/A
curriculum_metrics: [字典]	此字典包含所有所需的课程指标及其配置。每个指标都将是一个单独的子字典，其中键是指标名称，值是在其下面的配置。	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: [字符串]	难度计划（步调函数），定义在训练期间最大接受难度如何从 min_difficulty 增加到 max_difficulty。目前支持 fixed_linear、fixed_root、fixed_discrete 和 custom。	N/A
schedule_config: [字典]	步调函数的配置。当 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 日，我们发布了 深度加速器数据效率库，该库提供了更通用的课程学习支持。以下旧版课程学习功能仍然受支持，但我们建议使用数据效率库。

  "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: [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_config 中的一个。	N/A

difficulty_step: [integer]

描述	默认值
在任何时候，课程学习难度都必须是此 difficulty_step 的倍数。将其设置为 8 的倍数（对于 FP16 数据）或 16 的倍数（对于 INT8 数据）以启用 NVIDIA Tensor Core 加速。当使用 fixed_linear 和 fixed_root 计划类型时，它是 schedule_config 中的一个。	N/A

root_degree: [integer]

描述	默认值
课程计划函数的根次数。当使用 fixed_root 计划类型时，它是 schedule_config 中的一个。	N/A

difficulty: [整数列表]

描述	默认值
计划期间要使用的难度级别的列表。当使用 fixed_discrete 计划类型时，它是 schedule_config 中的一个。	N/A

max_step: [整数列表]

描述	默认值
更改难度级别的步骤列表。当使用 fixed_discrete 计划类型时，它是 schedule_config 中的一个。	N/A

监控模块

注意：深度加速器通过 PyTorch 将日志记录到 TensorBoard。记录到 TensorBoard 需要安装 tensorboard 包（在 PyTorch 文档 中了解更多信息）。

注意：记录到 WandB 需要安装 wandb 包（在 WandB 文档 中了解更多信息）。

注意：记录到 Comet 需要安装 comet_ml 包（在 Comet 文档 中了解更多信息）。

深度加速器的 Monitor 模块可以将训练细节记录到与 Tensorboard 兼容的文件、WandB、Comet 或简单的 CSV 文件中。以下是深度加速器将自动记录的内容概述。

字段	描述	条件
Train/Samples/train_loss	训练损失。	无
Train/Samples/lr	训练期间的学习率。	无
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	不包括梯度规约时间的反向传播时间。仅在梯度规约不重叠的情况下，如果重叠，则内部时间应与整个反向传播时间大致相同。	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 组的名称。这可用于将运行分组在一起。	无
team	WandB 团队的名称。	无
project	WandB 项目的名称。	deepspeed

wandb 配置示例

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

comet: [dictionary]

字段	值	默认值
enabled	是否启用记录到 Comet。	false
workspace	Comet 工作区名称。	无
project	Comet 项目名称。	无
samples_log_interval	处理完每 samples_log_intervas 个样本后，指标将提交到 Comet。	100
experiment_name	用于日志记录的 Comet 实验名称。	无
api_key	Comet API 密钥。不建议在代码中保存 Comet API 密钥。	无
experiment_key	用于日志记录的 Comet 实验密钥。必须是长度在 32 到 50 个字符之间的字母数字字符串。	无
online	如果为 True，则数据将记录到 Comet 服务器，否则将存储在离线实验的本地。默认为 True。	无
模式	控制 Comet 实验的启动方式。“get”：继续记录到由 experiment_key 值标识的现有实验。“create”：始终创建一个新实验，这对 HPO 扫描很有用。“get_or_create”（默认）：在需要时启动一个新的实验，或持续记录到一个现有的实验。	无

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
最大训练批大小	训练中可接受的最大批大小。	2000
微批大小	可接受的微批大小，与 train_micro_batch_size_per_gpu 相同。	[2,4,6]
最小GPU数	在 v0.1 和 v0.2 中计算高度复合批大小时要搜索的最小 GPU 数。	1
最大GPU数	在 v0.1 和 v0.2 中计算高度复合批大小时要搜索的最大 GPU 数。	10000
最短时间	调度程序再次扩展之前最短运行时间（分钟）（仅在 v0.1 中使用）。0 表示未知	0
优先选择大批次	在找到合适的批大小时，尝试找到最接近给定最大训练批大小的批大小。	true
版本	要使用的弹性逻辑版本。	0.2
忽略非弹性批次信息	忽略弹性配置之外提供的所有批次信息。为了减少混淆，我们要求所有与批次相关的信息都仅在弹性配置中给出。	false
每个节点的GPU数	每个节点的 GPU 数。v0.2 使用此信息来支持模型并行训练（仅 v0.2 使用）。	1
模型并行大小	张量或模型并行大小（仅 v0.2 使用）。	1

通信日志记录

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

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

comms_logger: [字典]

字段	值	默认值
enabled	是否启用通信日志记录。	false
详细	是否立即打印每个通信操作。	false
分析所有操作	是否分析所有操作。	true
调试	将调用函数追加到每个通信操作的 log_name 中。	false
分析操作	要记录的通信操作列表（仅分析指定的操作）。	[]

推荐的 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: [列表]	要保留的模型中的层数。	N/A
module_name_prefix: [字符串]	模型模块的（统一）名称前缀，其关联的权重参数将被重新初始化。	N/A
teacher_layer: [列表]	要重新初始化的权重参数的层。列表的长度等于“keep_number_layer”。	N/A
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]。	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: [字典]

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

字段	值	默认值
enabled: [布尔值]	是否启用权重量化。	false
quantizer_kernel: [布尔值]	对于 >=4 位量化，使用 DeepSpeed 量化内核。只有在使用 DeepSpeed FP16 优化器时才能启用此功能。	false
schedule_offset: [整数]	在计划的步骤后启用权重量化（可以视为预热步骤）。	0
quantize_groups: [整数]	将权重矩阵分成不同的组数，每个组都有自己的缩放因子。	1
quantize_verbose: [布尔值]	打印与量化相关的日志。	false
quantization_type: [字符串]	选择量化算法，对称或非对称。	"对称"
rounding: [字符串]	与量化相关的舍入算法，最近邻或随机。	"最近邻"
quantize_weight_in_forward: [布尔值]	在优化器或前向步骤中量化权重，对于 FP32 优化器训练必须设置为 true。	false
fp16_mixed_quantize: [字典]	使用 FP16 值和量化值的混合值。	N/A
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: [列表]	与 params 设置关联的权重参数的范围。	"所有线性层和 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: [字符串]	选择量化算法，对称或非对称。	"对称"
range_calibration: [字符串]	使用动态（每个标记或每个图像）或静态（使用动量固定最小/最大值）进行推理。	"静态"
schedule_offset: [整数]	在计划的步骤后启用激活量化（可以视为预热步骤）。	0

different_groups: [字典]

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

字段	值	默认值
params: [字典]
bits: [整数]	用于激活目标位数的位数，需要 >= 4。	8
modules: [列表]	与 params 设置关联的权重参数的范围。	"所有线性层和 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: [列表]	与 params 设置关联的权重参数的范围。	"所有线性层和 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: [列表]	与 params 设置关联的权重参数的范围。	"所有线性层和 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: [整数]	头数（必须由用户提供）。	N/A

different_groups: [字典]

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

字段	值	默认值
params: [字典]
dense_ratio: [浮点数]	剪枝后要保留的权重百分比。	0.5
modules: [列表]	与 params 设置关联的权重参数的范围。	"所有线性层和 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: [列表]	与 params 设置关联的权重参数的范围。	"所有 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 将根据本地排名存储模型参数状态和检查点状态，从而允许在没有访问共享文件系统的情况下加载检查点。	false

pipeline_stage: [布尔值]

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

数据类型选项

"data_types": {
    "grad_accum_dtype"=["fp32"|"fp16"|"bf16"]
    }
}

grad_accum_dtype: [“fp32”

“fp16”

“bf16”]

描述	默认值
指定执行梯度累积的数据类型。如果为 None，则默认为与模型类型匹配。	无