Accelerate documentation

大規模モデルをメモリに読み込む

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

大規模モデルをメモリに読み込む

PyTorchで事前学習済みモデルを読み込む場合、通常のワークフローは次のようになります。

import torch

my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)

平たく言うと、これらの手順は以下の通りです。

  1. ランダムに初期化された重みでモデルを作成します
  2. state dict(通常、辞書として呼ばれる)からディスク上のモデルの重みを読み込みます
  3. …

このアプローチは、サイズが一定のモデルに対して非常に有効ですが、巨大なモデルを扱う場合、このワークフローには明確な制限があります。ステップ1では、モデルの完全なバージョンをRAMに読み込み、重みをランダムに初期化するのに時間を費やします(これらの重みはステップ3で破棄されます)。ステップ2では、事前学習済みの重みを含むモデルの別の完全なバージョンをRAMに読み込みます。60億パラメータのモデルを読み込む場合、モデルの各コピーには24GBのRAMが必要であり、合計で48GB(その半分はモデルをFP16で読み込むために使用されます)必要になります。

このAPIは非常に新しく、まだ実験段階にあります。安定したAPIの提供に努めていますが、将来、パブリックAPIの一部が変更される可能性があります。

処理の仕組み: 簡単な概要

プロセスの仕組み: コードでの作業

空のモデルのインスタンス化

Accelerate が大規模モデルの処理を支援するために導入する最初のツールは、コンテキストマネージャー init_empty_weights() です。これにより、RAM を一切使用せずにモデルを初期化できるため、ステップ 1 は任意のサイズのモデルに対して実行できます。動作は以下の通りです:

from accelerate import init_empty_weights

with init_empty_weights():
    my_model = ModelClass(...)

例えば:

with init_empty_weights():
    model = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])

1000億パラメータを超える空のモデルを初期化します。この処理は、PyTorch 1.9 で導入された meta デバイスに依存しています。コンテキストマネージャー下での初期化中にパラメータが作成されるたびに、そのパラメータは即座にそのデバイスへ移動されます。

このように初期化されたモデルにはデータが含まれていないため、CPUや他のデバイスに直接移動することはできません。また、すべての操作がmetaデバイスでサポートされているわけではないため、その空のモデルでフォワードパスを実行しても失敗する可能性が高いです。

シャード化されたチェックポイント

モデルが大きすぎて、RAMにコピーを1つだけ保存しても収まらない可能性があります。しかし、それでは読み込めないという意味ではありません。1つ以上のGPUがあれば、モデルを保存するための追加のメモリとして利用できます。この場合、チェックポイントを複数の小さなファイルに分割しておく方が望ましいです。これらをcheckpoint shardsと呼びます。

Accelerate は、以下の形式に従う限り、シャード化されたチェックポイントを処理します。チェックポイントはフォルダ内に配置し、部分状態辞書を含む複数のファイルと、パラメータ名からその重みを含むファイルへのマッピングを含む JSON 形式のインデックスが必要です。save_model() を使用すると、モデルを簡単にシャード化できます。例えば、次のようなフォルダを持つことができます。

first_state_dict.bin
index.json
second_state_dict.bin

index.json は以下のファイルです:

{
  "linear1.weight": "first_state_dict.bin",
  "linear1.bias": "first_state_dict.bin",
  "linear2.weight": "second_state_dict.bin",
  "linear2.bias": "second_state_dict.bin"
}

first_state_dict.bin には "linear1.weight" と "linear1.bias" の重みが、second_state_dict.bin には "linear2.weight" と "linear2.bias" の重みが含まれています。

重みの読み込み

Accelerate が提供する2つ目のツールは、load_checkpoint_and_dispatch() という関数です。この関数を使用すると、空のモデル内にチェックポイントをロードできます。完全なチェックポイント(state dict 全体を1つのファイルに含むもの)と、シャーディングされたチェックポイントの両方をサポートしています。また、利用可能なデバイス(GPU、CPU RAM)にわたってこれらの重みを自動的にディスパッチするため、シャーディングされたチェックポイントをロードする場合、最大 RAM 使用量は最大のシャードのサイズになります。

Transformersモデルで大きなモデルの推論を使用したい場合は、このドキュメントをご覧ください。

以下は、これを使用してGPT2-1.5Bモデルを読み込む方法です。

このモデルのシャード版をダウンロードしましょう。

pip install huggingface_hub
from huggingface_hub import snapshot_download
checkpoint = "marcsun13/gpt2-xl-linear-sharded"
weights_location = snapshot_download(repo_id=checkpoint)

モデルを初期化するために、ライブラリminGPTを使用します。

git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    model = GPT(model_config)

次に、…で、先ほどダウンロードしたチェックポイントをロードします。

from accelerate import load_checkpoint_and_dispatch

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map="auto", no_split_module_classes=['Block']
)

device_map="auto" を渡すことで、Accelerate に、利用可能なリソースに応じてモデルの各レイヤーをどこに配置するかを自動的に判断するように指示します。

  • まず、GPUで利用可能な最大スペースを使用します
  • スペースがまだ必要であれば、残りの重みをCPUに保存します
  • RAMが不足している場合、残りの重みをメモリマップドテンソルとしてハードドライブに保存します

no_split_module_classes

このパラメータは、"Block" という名前のモジュールの一部を、異なるデバイス間で分割しないことを示します。ここでは、何らかの残差接続を含むすべてのブロックを設定する必要があります。

device_map

モデルのhf_device_map属性にアクセスすることで、Accelerateが選択したdevice_mapを確認できます。

model.hf_device_map
{'transformer.wte': 0,
 'transformer.wpe': 0,
 'transformer.drop': 0,
 'transformer.h.0': 0,
 ...
 'transformer.h.21': 0, 
 'transformer.h.22': 1, 
 'transformer.h.23': 1, 
 'transformer.h.24': 1,
 ...
 'transformer.h.47': 1, 
 'transformer.ln_f': 1, 
 'lm_head': 1}

レイヤーに使用する独自のデバイスマップを作成することも完全に可能であり、使用するGPUデバイス(数値)、"cpu"、または"disk"を指定して、これを渡すことができます:

device_map = {
    "transformer.wte": "cpu",
    "transformer.wpe": 0,
    "transformer.drop": "cpu",
    "transformer.h.0": "disk"
}

model = load_checkpoint_and_dispatch(
    model, checkpoint=weights_location, device_map=device_map
)

モデルの実行

これにより、モデルは複数のデバイス、場合によってはハードドライブにまたがって配置されます。それでもなお、通常のPyTorchモデルとして使用できます。

from mingpt.bpe import BPETokenizer
tokenizer = BPETokenizer()
inputs = tokenizer("Hello, my name is").to(0)

outputs = model.generate(x1, max_new_tokens=10, do_sample=False)[0]
tokenizer.decode(outputs.cpu().squeeze())

裏側では、Accelerate がモデルにフックを追加しているため、以下のように動作します:

  • 各レイヤーにおいて、入力が適切なデバイスに配置されます(モデルが複数のGPUに分散して配置されていても動作します)。
  • CPUにオフロードされた重みについては、フォワードパスの直前にGPUに配置され、直後に解放されます
  • ハードドライブにオフロードされた重みについては、RAMに読み込まれ、フォワードパスの直前にGPUに配置され、直後にクリーンアップされます。

この方法により、モデルが1つのGPUやCPU RAMに収まらなくても、推論を実行できます!

これはモデルの推論のみをサポートしており、トレーニングはサポートしていません。中間活性化によるGPUメモリ消費を避けるため、計算の大部分はtorch.no_grad()コンテキストマネージャー内で実行されます。

デバイスマップの設計

device_map をサポートされているオプション ("auto"、"balanced"、"balanced_low_0"、"sequential") のいずれかに設定することで、Accelerate にデバイスマップの計算を任せることもできます。各レイヤーの配置をより細かく制御したい場合は、自分でデバイスマップを作成することも可能です。

メタデバイス上のモデルから、モデルのすべてのサイズを導出(したがってdevice_mapを計算)できます。

GPUメモリがモデル全体を収容するのに十分でない場合(GPUに収容できるものはすべてGPUに配置し、RAMが不足している場合はCPUやディスクに重みをオフロードする)、すべてのオプションは同じ結果を生成します。

モデルサイズよりも多くのGPUメモリが利用可能な場合、各オプションの違いは以下の通りです。

  • "auto" と "balanced" は、利用可能なすべての GPU にモデルを均等に分割します。これにより、バッチサイズを 1 より大きく設定できます。
  • "balanced_low_0" は、最初の GPU 以外のすべての GPU にモデルを均等に分割して配置し、GPU 0 には他の GPU に収まらない部分のみを配置します。Transformers モデルの generate 関数を使用する場合のように、出力の処理に GPU 0 を使用したい場合に、このオプションは非常に適しています。
  • "sequential" は、GPU 0 に収まる分だけ配置し、その後 GPU 1 へ移動し、そのように続けていきます(必要なければ最後の GPU は使用されません)。

オプション"auto"と"balanced"は現在、同じ結果を生成しますが、より合理的な戦略が見つかった場合、"auto"の動作は将来変更される可能性があります。一方、"balanced"は安定したままです。

まず、max_memory 引数(infer_auto_device_map() およびそれを使用するすべての関数で利用可能)を使用することで、各 GPU で使用されるメモリを制限できる点に注意してください。max_memory を設定する際は、GPU の識別子(0、1 など)と、CPU オフロードに使用したい最大 RAM 量を示す "cpu" キーを含む辞書を渡す必要があります。値は、バイト単位の整数、または "10GiB" や "10GB" のように単位付きの数を表す文字列のいずれかです。

2つのGPUそれぞれで10GiBを超えず、モデルの重みにはCPU RAMを30GiBを超えないようにしたい場合の例を以下に示します。

from accelerate import infer_auto_device_map

device_map = infer_auto_device_map(my_model, max_memory={0: "10GiB", 1: "10GiB", "cpu": "30GiB"})

PyTorchで最初の割り当てが発生すると、GPUの種類によって約1〜2GBのメモリを消費するCUDAカーネルが読み込まれます。そのため、常にGPUの実際のサイズよりも少ないメモリしか使用できません。実際に使用されているメモリ量を確認するには、torch.ones(1).cuda()を実行してメモリ使用量を確認してください。

したがって、max_memory を使用してメモリマップを作成する際は、メモリ不足エラーを回避するために、利用可能なメモリを適切に調整してください。

また、出力をCPUに戻さずに追加の操作を行う場合(例えば、Transformersのgenerateメソッド内で)かつ、入力をGPUに配置している場合、そのGPUは他のGPUよりも多くのメモリを消費します(Accelerateは常に出力を入力と同じデバイスに戻します)。したがって、最大バッチサイズを最適化したい場合、かつ複数のGPUを使用している場合は、最初のGPUに割り当てるメモリを少なくしてください。例えば、8x80 A100構成でBLOOM-176Bを使用する場合、ほぼ理想的なマップは以下のようになります:

max_memory = {0: "30GIB", 1: "46GIB", 2: "46GIB", 3: "46GIB", 4: "46GIB", 5: "46GIB", 6: "46GIB", 7: "46GIB"}

ご覧のとおり、GPU 0 以外の残り 7 つの GPU には、GPU 0 より約 50% 多くのメモリを割り当てました。

device_map を完全に自分で設計する場合は、キーにモデルのモジュール名、値に有効なデバイス識別子(GPU の場合は整数など)または CPU オフロード用の "cpu"、ディスクオフロード用の "disk" を持つ辞書である必要があります。キーはモデル全体をカバーする必要があり、その上でデバイスマップを自由に定義できます。例えば、モデルに 2 つのブロック(block1 と block2 とします)があり、それぞれに 3 つの線形層(linear1、linear2、linear3 とします)が含まれている場合、有効なデバイスマップは次のようになります。

device_map = {"block1": 0, "block2": 1}

有効な別の例としては、以下が挙げられます。

device_map = {"block1": 0, "block2.linear1": 0, "block2.linear2": 1, "block2.linear3": 1}

一方、これはモデルのすべてのパラメータをカバーしていないため、無効です:

device_map = {"block1": 0, "block2.linear1": 1, "block2.linear2": 1}

最も効率的にするためには、デバイスマップがパラメータを GPU にシーケンシャルに配置していることを確認してください(例: 最初の重みの 1 つを GPU 0 に配置し、次に重みを GPU 1 に配置し、最後の重みを再び GPU 0 に配置しない)。これにより、GPU 間のデータ転送を多数回行うことを回避できます。

CPUオフロードのみ

モデルをCPUにオフロードしたい場合は、cpu_offload()を使用できます。これにより、モデルのすべてのパラメータがオフロードされ、モデルのstate dictのコピーは1つだけ保持されます。フォワードパスの間、パラメータはそのstate dictから抽出され、実行デバイスに配置されて必要に応じて渡され、その後再びオフロードされます。

cpu_offload(model, execution_device)

You can also use cpu_offload_with_hook(). This function will offloads a model on the CPU and puts it back to an execution device when executed. The difference with cpu_offload() is that the model stays on the execution device after the forward and is only offloaded again when the offload method of the returned hook is called. Furthermore, cpu_offload_with_hook() is more performant but less memory saving. It is useful for pipelines running a model in a loop:

model_1, hook_1 = cpu_offload_with_hook(model_1, execution_device)
model_2, hook_2 = cpu_offload_with_hook(model_2, execution_device, prev_module_hook=hook_1)
model_3, hook_3 = cpu_offload_with_hook(model_3, execution_device, prev_module_hook=hook_2)

hid_1 = model_1(input)
for i in range(50):
    # model1 is offloaded on the CPU at the first iteration, model 2 stays on the GPU for this whole loop.
    hid_2 = model_2(hid_1)
# model2 is offloaded to the CPU just before this forward.
hid_3 = model_3(hid_3)

# For model3, you need to manually call the hook offload method.
hook_3.offload()

ディスクオフロードのみ

ディスクオフロードを実行するには、disk_offload()を使用できます。これにより、モデルのすべてのパラメータが、指定されたフォルダー内のメモリマップド配列としてオフロードされます。フォワードパスの間、パラメータは必要に応じてそのフォルダーからアクセスされ、実行デバイスにそのまま配置され、その後再びオフロードされます。

disk_offload(model, offload_dir, execution_device)

制限事項と今後の開発

APIの現在の制限について認識しています:

  • infer_auto_device_map()(または load_checkpoint_and_dispatch() における device_map="auto")は、実行時に利用可能な GPU および CPU の RAM を最大限に活用しようとします。PyTorch は GPU RAM を効率的に管理し、不要になったときに解放する点で非常に優れていますが、Python と CPU RAM については完全に同じことが言えません。そのため、自動計算されたデバイスマップは CPU に負荷をかけすぎる可能性があります。RAM 不足によるクラッシュが発生した場合は、一部のモジュールをディスクデバイスに移動してください。
  • infer_auto_device_map()(または load_checkpoint_and_dispatch() における device_map="auto")は、デバイスを順番に割り当てます(データの往復移動を避けるため)。そのため、最初のレイヤーが利用可能な GPU のサイズより大きい場合、最終的にすべての処理が CPU/Disk 上で行われることになります。
  • 現在、load_checkpoint_and_dispatch() および load_checkpoint_in_model() は、モデルに対する state dict の正確性について何らかのチェックを実行していません(これは将来のバージョンで修正される予定です)。そのため、キーが不一致または欠落しているチェックポイントをロードしようとすると、奇妙なエラーが発生する可能性があります。
  • モデルが複数のGPUに分割される場合に使用されるモデル並列性は単純な実装であり、最適化されていません。つまり、ある時点で動作するのは1つのGPUのみで、他のGPUは待機状態になります。
  • 重みがCPU/ハードドライブにオフロードされている場合、プリフェッチは行われません(今後のバージョンで対応する予定です)。つまり、重みは必要になった時点でGPUに配置され、それ以前には配置されません。
  • 実行環境のハードウェアが、ディスクとCPU間の高速通信(NVMesなど)を備えていない場合、ハードドライブへのオフロードは非常に遅くなる可能性があります。
Update on GitHub