Accelerate documentation

勾配の同期

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

勾配の同期

PyTorchの分散モジュールは、システム内のすべてのGPU間で双方向に通信することによって動作します。 この通信には時間がかかり、ddpモジュールを使用する場合、すべてのプロセスが互いの状態を把握する処理は、特定のトリガーポイントで実行されます。

これらのトリガーポイントは、PyTorchモデル、具体的にはそのforward()およびbackward()メソッドに追加されます。 これは、モデルがDistributedDataParallelでラップされた際に発生します:

import torch.nn as nn
from torch.nn.parallel import DistributedDataParallel

model = nn.Linear(10, 10)
ddp_model = DistributedDataParallel(model)

Accelerate では、prepare()を呼び出してモデルを渡す際に、この変換が自動的に実行されます。

+ from accelerate import Accelerator
+ accelerator = Accelerator()
  import torch.nn as nn
- from torch.nn.parallel import DistributedDataParallel

  model = nn.Linear(10,10)
+ model = accelerator.prepare(model)

勾配蓄積の遅延

PyTorch は、分散環境での学習時に、PyTorch モデルの forward メソッドと backward メソッドにフックを追加します。では、これがどのようにしてコードの速度低下につながる可能性があるのでしょうか。

DDP(分散データ並列)では、特定の処理が特定の順序で実行され、特定の時点でそれらがほぼ同時に完了することが期待されます。

最も直接的な例は、optimizer.step() によってモデルのパラメータを更新する場合です。 勾配の蓄積を行わない場合、次のデータバッチに進む前に、モデルのすべてのインスタンスで更新された勾配の計算、集約、更新を完了させる必要があります。 勾配の蓄積を実行する場合、n 個の損失勾配を蓄積し、n バッチに達するまで optimizer.step() をスキップします。すべての学習プロセスは optimizer.step() が呼び出される時点で同期するだけで済むため、学習ステップを変更せずにこの不要なプロセス間通信を行うと、大幅なスローダウンを引き起こす可能性があります。

このオーバーヘッドをどのように回避できますか?

スローダウン問題の解決

これらのバッチでの学習時にモデルパラメータの更新をスキップしているため、optimizer.step() が実際に呼び出される時点まで、それらの勾配を同期する必要はありません。 PyTorch は、この処理が必要となるタイミングを自動的に検出することはできませんが、DDP に変換した後にモデルに追加される no_sync コンテキストマネージャを通じて、この処理を支援するツールを提供しています。

このコンテキストマネージャの下では、.backward() が呼び出された際に PyTorch は勾配の同期をスキップし、このコンテキストマネージャの外で初めて .backward() が呼び出されたときに同期がトリガーされます。以下の例を参照してください。

ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

for index, batch in enumerate(dataloader):
    inputs, targets = batch
    # Trigger gradient synchronization on the last batch
    if index != (len(dataloader) - 1):
        with ddp_model.no_sync():
            # Gradients only accumulate
            outputs = ddp_model(inputs)
            loss = loss_func(outputs)
            accelerator.backward(loss)
    else:
        # Gradients finally sync
        outputs = ddp_model(inputs)
        loss = loss_func(outputs)
        accelerator.backward(loss)
        optimizer.step()

Accelerate では、トレーニングデバイスに関係なく呼び出せる API にするために、ddp_model.no_sync が no_sync() に置き換えられ、同じように動作します(ただし、分散システムでない場合は何も行われない可能性があります!):

  ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

  for index, batch in enumerate(dataloader):
      inputs, targets = batch
      # Trigger gradient synchronization on the last batch
      if index != (len(dataloader)-1):
-         with ddp_model.no_sync():
+         with accelerator.no_sync(model):
              # Gradients only accumulate
              outputs = ddp_model(inputs)
              loss = loss_func(outputs, targets)
              accelerator.backward(loss)
      else:
          # Gradients finally sync
          outputs = ddp_model(inputs)
          loss = loss_func(outputs)
          accelerator.backward(loss)
          optimizer.step()
          optimizer.zero_grad()

予想通り、accumulate()関数は現在のバッチ番号を追跡することでこの条件分岐をラップし、最終的な勾配蓄積APIが得られます:

ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

for batch in dataloader:
    with accelerator.accumulate(model):
        optimizer.zero_grad()
        inputs, targets = batch
        outputs = model(inputs)
        loss = loss_function(outputs, targets)
        accelerator.backward(loss)
        optimizer.step()
        optimizer.zero_grad()

そのため、API の選択としては、accelerator.accumulate または accelerator.no_sync を使用することになります。

実際にはどの程度のスローダウンが発生するのか、そして起こしやすい簡単なミス

現実的な例を設定するために、以下の構成を考慮してください。

  • シングルGPUのT4ノード2台と、2つのGPUを備えたノード1台
  • 各GPUはT4であり、GCP上でホストされています
  • 使用されるスクリプトは、NLP Exampleスクリプトの修正版です
  • GPUごとのバッチサイズは16で、4ステップごとに勾配を累積します

すべてのスクリプトはこのリポジトリで利用できます。

勾配の同期とGPU間の通信に注意を払わない場合、これらのGPUが不要なタイミングで互いに通信する際に、大量の時間が浪費される可能性があります。

どのくらいですか?

参照:

  • ベースライン: ここで説明する同期手法を一切使用しません
  • no_sync を不適切に使用しています: no_sync は backward の呼び出しの周りにのみ適用し、forward には適用しないでください
  • no_sync: no_sync パターンを正しく使用すること
  • accumulate: accumulate()の適切な使用方法

以下は、単一ノードおよびデュアルノード構成のそれぞれについて、29バッチのデータを反復処理した際の1バッチあたりの平均秒数です。

ベースラインno_sync を正しくno_syncaccumulate
マルチノード2±0.01s2.13±0.08s0.91±0.11s0.91±0.11s
シングルノード0.50±0.01s0.50±0.01s0.41±0.015s0.41±0.015s

ご覧のとおり、勾配同期の設定に注意を払わない場合、トレーニング中に2倍以上の遅延が発生する可能性があります。

すべてが適切に行われていることを心配している場合は、accumulate() 関数を利用し、gradient_accumulation_steps または gradient_accumulation_plugin を Accelerator オブジェクトに渡すことを強くお勧めします。これにより、Accelerate がこの処理を代行してくれます。

FSDPを使用する場合、no_syncは追加のGPUメモリを必要とします

勾配を同期しないことは、FSDPトレーニングの実行中に悪影響を及ぼす可能性があることに注意してください。torchでも警告されているように、FSDP用のno_syncコンテキストマネージャーは、追加のメモリを必要とします。

そのため、FSDP を使用している際のメモリ負荷が高い状況では、GradientAccumulationPlugin で sync_each_batch を True に設定して no_sync を無効にすることを推奨します。

以下の例では、8 枚の A100-80GB GPU 上で Mixtral(47B パラメータ)をファインチューニングしています。gradient_accumulation_steps=2 という modest な設定でも、no_sync が有効な場合、すぐにメモリ不足(OOM)が発生します。これもまた、FSDP の no_sync による追加のメモリオーバーヘッドが原因です。一方、sync_each_batch=True によって no_sync を無効にすると、gradient_accumulation_steps=16 時のメモリ消費量は gradient_accumulation_steps=1 時のものに戻ります。

モデルno_sync (accum=1)no_sync(accum=2)no_sync 無効 (accum=16)
mixtral 8x7B69GOOM69G

no_syncを無効にすると、このガイドの前述のセクションで説明したように、追加のデータ同期が発生するため、処理速度が低下します。

Update on GitHub