Accelerate documentation

DeepSpeedで複数のモデルを使用する

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.16.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DeepSpeedで複数のモデルを使用する

このガイドでは、DeepSpeed usage guideを読み、内容を理解していることを前提としています。

AccelerateとDeepSpeedで複数のモデルを同時に実行することは、次のような場合に役立ちます。

  • 知識蒸留
  • RLHF(TRL ライブラリにさらに多くの例があります)などのポストトレーニング手法
  • 複数のモデルを同時にトレーニング

現在、Accelerateには複数のモデルを使用するための非常に実験的なAPIが用意されています。

このチュートリアルでは、2つの一般的なユースケースに焦点を当てます:

  1. 知識蒸留では、より大きく高性能な教師モデルを模倣するように、より小さい生徒モデルを訓練します。生徒モデルが1つのGPUに収まる場合、訓練にはZeRO-2、教師モデルの推論にはシャード化のためにZeRO-3を使用できます。これは、両方のモデルにZeRO-3を使用するよりも大幅に高速です。
  2. 複数のdisjointモデルを同時にトレーニングします。

知識蒸留

Knowledge distillationは、複数のモデルを使用しながら、そのうち1つだけを学習させるというアプローチの良い例です。

通常、両方のモデルに単一のutils.DeepSpeedPluginを使用します。しかし、この場合は2つの独立した設定があります。Accelerateでは、必要に応じて適切なプラグインを参照して有効化できるように、dict内にプラグインを格納している場合のみ、複数のプラグインを作成して使用できます。

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)

では、それらの使用方法を見ていきましょう。

Studentモデル

デフォルトでは、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()

複数の非交差モデルを学習する

複数のモデルをトレーニングする場合は、より複雑なシナリオになります。 現在の状態では、トレーニング中は各モデルが互いに完全に独立していると仮定しています。

このシナリオでは、引き続き2つのutils.DeepSpeedPluginを作成する必要があります。ただし、異なるタイミングで異なるdeepspeedエンジンが呼び出されるため、2番目のAcceleratorも必要になります。1つのAcceleratorが同時に保持できるのは1つのインスタンスのみです。

ただし、state.AcceleratorStateはステートフルなオブジェクトであるため、利用可能なutils.DeepSpeedPluginの両方をすでに認識しています。したがって、追加の引数なしで2番目の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()

リソース

の現在の関連テストを確認すると、さらに多くの例をご覧いただけます。

Update on GitHub