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

字段	值	示例
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
    }
  }

Adam优化器除了支持torch.optim.Adam的标准参数外，还支持以下两个参数键/值：

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

1-bit Adam 优化器除了支持标准 Adam 的参数外，还支持以下三个参数键/值（了解更多请参阅我们的 教程）：

“params” 键	描述	默认值
freeze_step	在1位压缩应用于通信之前的热身步骤数	100000
cuda_aware	表示底层MPI库支持CUDA-Aware通信	false
comm_backend_name	用于指示使用哪个后端实现	“nccl”

1-bit Adam 的一个变体 optimizer 是 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"
    }
  }

0/1 Adam 除了支持标准 Adam 的参数外，还支持以下键/值参数（了解更多请参阅我们的 教程。）

“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": {
    "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
    }
  }

1-bit LAMB 优化器除了支持标准 LAMB 的参数键/值外，还支持以下参数键/值（了解更多请参阅我们的 教程）：

“params” 键	描述	默认值
max_coeff	原始LAMB算法和1-bit LAMB预热阶段的缩放系数上限	10.0
min_coeff	原始LAMB算法和1-bit 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

调度器参数

DeepSpeed 在每次训练步骤中执行 model_engine.step() 时，会调用调度器的 step() 方法。

scheduler: [字典]

字段	值	示例
type	调度器名称。查看这里获取支持的调度器列表。	"WarmupLR"
params	用于实例化调度器的参数字典。参数名称应与调度器构造函数签名匹配。	{"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: [string]

描述	默认值
在梯度平均过程中使用选定的数据类型进行通信。默认情况下，它将由选定的模式决定	None

prescale_gradients: [布尔值]

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

gradient_predivide_factor: [浮点数]

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

sparse_gradients: [布尔值]

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

FP16 训练选项

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

fp16: [字典]

描述	默认值
配置用于利用NVIDIA的Apex包进行混合精度/FP16训练。下面展示了一个示例，包括可用的字典键。注意：这不使用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 是一个 fp16 参数，表示是否启用 FP16 训练。	false

fp16:auto_cast: [布尔值]

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

fp16:loss_scale: [float]

描述	默认值
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 是一个 fp16 参数，表示动态损失缩放中的延迟偏移。	2

fp16:consecutive_hysteresis: [布尔值]

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

fp16:最小损失比例: [整数]

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

BFLOAT16 训练选项

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

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

bf16: [字典]

描述	默认值
配置使用bfloat16浮点格式作为FP16的替代方案。BFLOAT16需要硬件支持（例如，NVIDIA A100）。下面展示了一个示例，包括可用的字典键。使用bfloat16进行训练不需要损失缩放。	None

"bf16": {
   "enabled": true
 }

bf16:enabled: [布尔值]

描述	默认值
enabled 表示是否启用了BFLOAT16训练。	false

自动混合精度（AMP）训练选项

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

amp: [字典]

描述	默认值
配置用于利用NVIDIA的Apex AMP包进行自动混合精度（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: [float]

描述	默认值
启用梯度裁剪，值为	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

阶段: [整数]

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

allgather_partitions: [布尔值]

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

allgather_bucket_size: [整数]

描述	默认值
每次全收集的元素数量。限制了大模型尺寸下全收集所需的内存	5e8

overlap_comm: [布尔值]

描述	默认值
尝试将梯度的减少与反向计算重叠	false

reduce_scatter: [布尔值]

描述	默认值
使用reduce或reduce scatter代替allreduce来平均梯度	true

reduce_bucket_size: [整数]

描述	默认值
一次减少/全部减少的元素数量。限制了大模型尺寸下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）二级张量组中的排名数量，默认值为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
  }

设备: [string]

描述	默认值
用于卸载模型参数的设备内存。支持的选项是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

优化器卸载

启用和配置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
  }

设备: [string]

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

nvme_path: [字符串]

描述	默认值
用于优化器状态卸载的NVMe设备的文件系统路径。	/local_nvme

pin_memory: [布尔值]

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

ratio: [float]

描述	默认值
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: [string]

描述	默认值
用于排名自动调优实验的性能指标。目前支持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_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

详细: [boolean]

描述	默认值
是否打印详细的模型配置文件。	true

output_file: [字符串]

描述	默认值
输出文件的路径。如果为None，分析器将打印到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: [布尔值]

描述	默认值
当与模型并行使用时启用分区激活	false

cpu_checkpointing: [布尔值]

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

contiguous_memory_optimization: [布尔值]

描述	默认值
复制分区的激活，使它们在内存中是连续的	false

number_checkpoints: [整数]

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

synchronize_checkpoint_boundary: [布尔值]

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

profile: [布尔值]

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

稀疏注意力

sparse_attention: [字典]

字段	值	示例
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"，例如自回归模型，其中标记仅关注上下文中出现在它们之前的标记。考虑到这一点，注意力矩阵的上三角部分为空。或者可以是"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"模式中使用。	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 数据效率库包含两种技术：课程学习和随机分层令牌丢弃（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: [boolean]	是否启用数据效率。	false
seed: [integer]	用于数据采样的随机种子。	1234
data_routing: [dictionary]	数据路由技术的配置。	N/A
data_sampling: [dictionary]	数据采样技术的配置。	N/A

data_routing: [字典]

字段	值	默认值
enabled: [boolean]	是否启用数据路由技术。	false
random_ltd: [dictionary]	随机LTD技术的配置。	N/A

data_sampling: [字典]

字段	值	默认值
enabled: [boolean]	是否启用数据采样技术。	false
num_epochs: [integer]	最多会迭代原始数据集的多少个周期。	1000
num_workers: [integer]	数据加载器的工作线程数。	0
curriculum_learning: [dictionary]	课程学习技术的配置。	N/A

random_ltd: [字典]

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

curriculum_learning: [字典]

字段	值	默认值
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: [列表]	用于更改最大接受难度级别的步骤列表。由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: [布尔值]

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

curriculum_type: [string]

描述	默认值
课程难度指标的类型。目前支持 seqlen。	N/A

min_difficulty: [整数]

描述	默认值
起始难度级别	N/A

max_difficulty: [整数]

描述	默认值
结束难度级别	N/A

schedule_type: [字符串]

描述	默认值
课程表类型。目前支持 fixed_linear, fixed_root, 和 fixed_discrete。	N/A

total_curriculum_step: [整数]

描述	默认值
课程学习的总步数。当使用fixed_linear和fixed_root schedule_type时，schedule_config之一。	N/A

difficulty_step: [整数]

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

root_degree: [整数]

描述	默认值
课程表函数的根度数。当使用fixed_root schedule_type时，schedule_config之一。	N/A

难度: [整数列表]

描述	默认值
用于调度期间的难度级别列表。当使用fixed_discrete调度类型时，schedule_config之一。	N/A

max_step: [整数列表]

描述	默认值
更改难度级别的步骤列表。当使用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	不包括梯度减少时间的反向时间。仅在梯度减少不重叠的情况下，如果重叠，则内部时间应与整个反向时间大致相同。	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: [字典]

字段	值	默认值
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: [字典]

字段	值	默认值
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: [字典]

字段	值	默认值
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 密钥保存在代码中。	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: [字典]

字段	值	默认值
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: [字典]

字段	值	默认值
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: [字典]

字段	值	默认值
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: [字典]

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

字段	值	默认值
enabled: [boolean]	是否启用权重量化。	false
quantizer_kernel: [boolean]	使用DeepSpeed量化内核进行大于等于4位的量化。这只能在启用DeepSpeed FP16优化器时使用。	false
schedule_offset: [integer]	在预定的步骤后启用权重量化（可以视为预热步骤）。	0
quantize_groups: [integer]	将权重矩阵分成不同数量的组，每组都有自己的缩放因子。	1
quantize_verbose: [boolean]	打印与量化相关的日志。	false
quantization_type: [string]	选择量化算法，对称或非对称。	"symmetric"
rounding: [string]	与量化相关的舍入算法，最近邻或随机。	"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: [字典]

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

字段	值	默认值
params: [dictionary]
start_bits: [integer]	量化起始位数，将逐渐减少到目标位数。	8
target_bits: [integer]	量化目标位数，需要小于等于起始位数。	8
quantization_period: [integer]	每n步，量化位数将减少1。	1
modules: [list]	与参数设置相关的权重参数范围。	"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: [字典]

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

字段	值	默认值
enabled: [boolean]	是否启用激活量化。	false
quantization_type: [string]	选择量化算法，对称或非对称。	"symmetric"
range_calibration: [string]	使用动态（每个token或每个图像）或静态（使用动量的固定最小/最大值）进行推理。	"static"
schedule_offset: [integer]	在预定的步骤后启用激活量化（可以视为预热步骤）。	0

different_groups: [字典]

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

字段	值	默认值
params: [dictionary]
bits: [integer]	用于激活目标位的位数，需要大于等于4。	8
modules: [list]	与参数设置相关的权重参数范围。	"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: [字典]

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

字段	值	默认值
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: [字典]

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

字段	值	默认值
params: [dictionary]
dense_ratio: [float]	剪枝后保留的权重百分比。	0.5
modules: [list]	与参数设置相关的权重参数范围。	"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: [字典]

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

字段	值	默认值
enabled: [boolean]	是否启用行修剪。	false
schedule_offset: [integer]	在预定步骤后启用行修剪（可以视为预热步骤）。	0
method: [string]	选择不同的剪枝方法，l1（静态，基于大小）或topk（动态，可学习）。	"l1"

different_groups: [字典]

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

字段	值	默认值
params: [dictionary]
dense_ratio: [float]	剪枝后保留的权重百分比。	0.5
modules: [list]	与参数设置相关的权重参数范围。	"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: [字典]

所有头部修剪组的共享参数。

字段	值	默认值
enabled: [boolean]	是否启用头部修剪。	false
schedule_offset: [integer]	在计划的步骤后启用头部修剪（可以视为预热步骤）。	0
method: [string]	选择不同的剪枝方法。目前，我们仅支持topk（动态、可学习）。	"topk"
num_heads: [int]	头数（必须由用户提供）。	N/A

different_groups: [字典]

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

字段	值	默认值
params: [dictionary]
dense_ratio: [float]	剪枝后保留的权重百分比。	0.5
modules: [list]	与参数设置相关的权重参数范围。	"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: [字典]

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

字段	值	默认值
enabled: [boolean]	是否启用通道剪枝。	false
schedule_offset: [integer]	在预定的步骤后启用通道修剪（可以视为预热步骤）。	0
method: [string]	选择不同的剪枝方法，l1（静态，基于大小）或topk（动态，可学习）。	"l1"

different_groups: [字典]

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

字段	值	默认值
params: [dictionary]
dense_ratio: [float]	剪枝后保留的权重百分比。	0.5
modules: [list]	与参数设置相关的权重参数的范围。	"All CONV2D layers"
related_modules: [list[list]]	与通道修剪模块相关的模块。	None

检查点选项

"checkpoint": {
    "tag_validation"="Warn",
    "load_universal"=false,
    "use_node_local_storage"=false,
    "parallel_write":{
        "pipeline_stage": false
    }
}

tag_validation: [“忽略”

“警告”

“失败”]

描述	默认值
启用检查级别以确保所有等级的检查点标签一致。在不同世界大小恢复时非常有用。	“Warn”

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，则默认与模型类型匹配。	None