Accelerate documentation

使用 DeepSpeed 搭配多个模型

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

使用 DeepSpeed 搭配多个模型

本指南假定您已阅读并理解了DeepSpeed 使用指南。

使用 Accelerate 和 DeepSpeed 运行多个模型适用于以下场景:

  • 知识蒸馏
  • 诸如 RLHF 等后训练技术(更多示例请参阅 TRL 库)
  • 同时训练多个模型

目前,Accelerate 提供了一个非常实验性的 API,以帮助你使用多个模型。

本教程将聚焦于两个常见用例:

  1. 知识蒸馏,即训练一个较小的学生模型去模仿一个更大、性能更优的教师模型。如果学生模型可以装入单个 GPU,我们可以使用 ZeRO-2 进行训练,并使用 ZeRO-3 对教师模型进行分片以用于推理。这比对两个模型都使用 ZeRO-3 要快得多。
  2. 同时训练多个不相交的模型。

知识蒸馏

知识蒸馏是同时使用多个模型但只训练其中一个模型的一个很好的例子。

通常,你会为两个模型使用同一个 utils.DeepSpeedPlugin。但在此情况下,存在两个独立的配置。只有当这些插件位于 dict 中时,Accelerate 才允许你创建并使用多个插件 (且仅在此条件下),以便在需要时引用并启用正确的插件。

from accelerate.utils import DeepSpeedPlugin

zero2_plugin = DeepSpeedPlugin(hf_ds_config="zero2_config.json")
zero3_plugin = DeepSpeedPlugin(hf_ds_config="zero3_config.json")

deepspeed_plugins = {"student": zero2_plugin, "teacher": zero3_plugin}

zero2_config.json 应配置为完整训练(如果未使用自己的,请指定 scheduler 和 optimizer),而 zero3_config.json 应仅配置为推理模型,如下面的示例所示。

{
    "bf16": {
        "enabled": "auto"
    },
    "zero_optimization": {
        "stage": 3,
        "overlap_comm": true,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": "auto",
        "stage3_max_reuse_distance": "auto",
    },
    "train_micro_batch_size_per_gpu": 1
}

下面展示了一个 zero2_config.json 配置示例。

{
    "bf16": {
        "enabled": "auto"
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto",
            "torch_adam": true,
            "adam_w_mode": true
        }
    },
    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
}

如果未指定 train_micro_batch_size_per_gpu,即使该特定模型并未进行训练,DeepSpeed 也会引发错误。

在此处,创建一个单独的 Accelerator 并传入这两个配置。

from accelerate import Accelerator

accelerator = Accelerator(deepspeed_plugins=deepspeed_plugins)

现在让我们看看如何使用它们。

学生模型

默认情况下,Accelerate 会将 dict 中的第一个条目设置为默认或启用的插件("student" 插件)。您可以使用 utils.deepspeed.get_active_deepspeed_plugin() 函数来查看当前启用的插件,以验证此设置。

active_plugin = get_active_deepspeed_plugin(accelerator.state)
assert active_plugin is deepspeed_plugins["student"]

AcceleratorState 还会将当前激活的 DeepSpeed 插件保存在 state.deepspeed_plugin 中。

assert active_plugin is accelerator.deepspeed_plugin

由于 student 是当前激活的插件,让我们继续准备模型、优化器和调度器。

student_model, optimizer, scheduler = ...
student_model, optimizer, scheduler, train_dataloader = accelerator.prepare(student_model, optimizer, scheduler, train_dataloader)

现在该处理教师模型了。

教师模型

首先,你需要在 Accelerator 中指定使用 zero3_config.json 配置。

accelerator.state.select_deepspeed_plugin("teacher")

这将禁用 "student" 插件,并改为启用 "teacher" 插件。Transformers 内部的 DeepSpeed 有状态配置会随之更新,从而改变在使用 deepspeed.initialize() 时调用的插件配置。这使得您可以使用 Transformers 提供的自动 deepspeed.zero.Init 上下文管理器集成。

teacher_model = AutoModel.from_pretrained(...)
teacher_model = accelerator.prepare(teacher_model)

否则,您应使用 deepspeed.zero.Init 手动初始化模型。

with deepspeed.zero.Init(accelerator.deepspeed_plugin.config):
    model = MyModel(...)

训练

从这里开始,您的训练循环可以任意设计,只要确保teacher_model始终不参与训练即可。

teacher_model.eval()
student_model.train()
for batch in train_dataloader:
    with torch.no_grad():
        output_teacher = teacher_model(**batch)
    output_student = student_model(**batch)
    # Combine the losses or modify it in some way
    loss = output_teacher.loss + output_student.loss
    accelerator.backward(loss)
    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()

训练多个互不相关的模型

训练多个模型是一个更复杂的场景。 目前,我们假设在训练过程中,每个模型与其他模型完全独立。

此场景仍然需要创建两个 utils.DeepSpeedPlugin。不过,由于在不同的时间点会调用不同的 deepspeed 引擎,因此还需要第二个 Accelerator。单个 Accelerator 一次只能承载一个实例。

不过,由于 state.AcceleratorState 是一个有状态的对象,它已经知晓 utils.DeepSpeedPlugin 的可用情况。你只需实例化第二个 Accelerator,无需传入任何额外参数。

first_accelerator = Accelerator(deepspeed_plugins=deepspeed_plugins)
second_accelerator = Accelerator()

您可以调用 first_accelerator.state.select_deepspeed_plugin() 来启用或禁用某个特定的插件,然后调用 prepare。

# can be `accelerator_0`, `accelerator_1`, or by calling `AcceleratorState().select_deepspeed_plugin(...)`
first_accelerator.state.select_deepspeed_plugin("first_model")
first_model = AutoModel.from_pretrained(...)
# For this example, `get_training_items` is a nonexistent function that gets the setup we need for training
first_optimizer, first_scheduler, train_dl, eval_dl = get_training_items(model1)
first_model, first_optimizer, first_scheduler, train_dl, eval_dl = accelerator.prepare(
    first_model, first_optimizer, first_scheduler, train_dl, eval_dl
)

second_accelerator.state.select_deepspeed_plugin("second_model")
second_model = AutoModel.from_pretrained(...)
# For this example, `get_training_items` is a nonexistent function that gets the setup we need for training
second_optimizer, second_scheduler, _, _ = get_training_items(model2)
second_model, second_optimizer, second_scheduler = accelerator.prepare(
    second_model, second_optimizer, second_scheduler
)

现在你可以开始训练了:

for batch in dl:
    outputs1 = first_model(**batch)
    first_accelerator.backward(outputs1.loss)
    first_optimizer.step()
    first_scheduler.step()
    first_optimizer.zero_grad()
    
    outputs2 = model2(**batch)
    second_accelerator.backward(outputs2.loss)
    second_optimizer.step()
    second_scheduler.step()
    second_optimizer.zero_grad()

资源

要查看更多示例,请查看 [Accelerate] 中当前的相关测试。

Update on GitHub