Accelerate documentation

메모리에 대형 모델 로드

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)])

100B개 이상의 매개변수를 가진 빈 모델을 초기화합니다. 내부적으로 PyTorch 1.9에서 도입된 meta 디바이스에 의존합니다. 컨텍스트 매니저 하의 초기화 동안 매개변수가 생성될 때마다 즉시 해당 디바이스로 이동됩니다.

이렇게 초기화된 모델은 데이터가 없으므로 CPU나 다른 디바이스로 직접 이동할 수 없습니다. 또한 모든 연산이 meta 디바이스에서 지원되지 않으므로, 해당 빈 모델에 대한 forward pass가 실패할 가능성이 매우 높습니다.

Sharded checkpoints

모델이 너무 커서 RAM에 단일 복사본조차 저장되지 않을 수 있습니다. 하지만 이는 로드할 수 없다는 뜻이 아닙니다. 하나 이상의 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"
}

그리고 "linear1.weight" 및 "linear1.bias"의 가중치를 포함하는 first_state_dict.bin, "linear2.weight" 및 "linear2.bias"의 가중치를 포함하는 second_state_dict.bin

가중치 로드

두 번째로 Accelerate가 도입하는 도구는 load_checkpoint_and_dispatch() 함수입니다. 이 함수를 사용하면 빈 모델 안에 체크포인트를 로드할 수 있습니다. 전체 체크포인트(전체 state dict를 포함하는 단일 파일)와 샤드화된 체크포인트를 모두 지원합니다. 또한 사용 가능한 장치(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가 사용 가능한 리소스에 따라 모델의 각 레이어를 어디에 배치할지 자동으로 결정하도록 지시합니다:

  • first, GPU에서 사용할 수 있는 최대 공간을 사용합니다
  • 여전히 공간이 필요하면 나머지 가중치를 CPU에 저장합니다
  • RAM이 부족하면 나머지 가중치를 하드 드라이브에 메모리 매핑 텐서로 저장합니다

no_split_module_classes

이 매개변수는 이름이 "Block"인 일부 모듈을 다른 장치로 나누지 않아야 함을 나타냅니다. 어떤 종류의 잔차 연결(residual connection)을 포함하는 모든 블록을 여기에 설정해야 합니다.

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}

레이어가 사용할 자체 device map을 생성하는 것도 완전히 가능하며, 사용할 GPU device(숫자), "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에 오프로드된 가중치는 forward pass 직전에 GPU로 이동되고, forward pass 직후에 정리됩니다
  • 하드 드라이브에 오프로드된 가중치는 RAM으로 로드된 후, forward pass 직전에 GPU로 이동되고, forward pass 직후에 정리됩니다.

이렇게 하면 모델이 GPU 또는 CPU RAM 하나에 맞지 않더라도 추론을 실행할 수 있습니다!

이 기능은 모델의 추론만 지원하며 학습은 지원하지 않습니다. 중간 활성화 값으로 인한 GPU 메모리 사용량을 줄이기 위해 대부분의 연산은 torch.no_grad() 컨텍스트 매니저 안에서 수행됩니다.

디바이스 맵 설계

device_map을 지원되는 옵션("auto", "balanced", "balanced_low_0", "sequential") 중 하나로 설정하면 Accelerate가 디바이스 맵 계산을 처리하도록 할 수 있으며, 각 레이어가 어디에 배치되어야 하는지에 대해 더 세밀한 제어가 필요하면 직접 디바이스 맵을 생성할 수도 있습니다.

meta device에 있는 모델에서 모델의 모든 크기를 유도할 수 있으며(따라서 device_map을 계산할 수 있습니다).

GPU 메모리가 모델 전체를 수용하기에 부족할 경우(즉, GPU에 가능한 한 많은 것을 배치하고, RAM이 부족하면 CPU 또는 디스크로 가중치를 오프로딩하는 것) 모든 옵션은 동일한 결과를 생성합니다.

모델 크기보다 사용 가능한 GPU 메모리가 더 많은 경우, 각 옵션의 차이는 다음과 같습니다:

  • "auto"와 "balanced"는 모델을 사용 가능한 모든 GPU에 고르게 분할하여 배치 크기를 1보다 크게 사용할 수 있게 합니다.
  • "balanced_low_0"는 첫 번째 GPU를 제외한 모든 GPU에 모델을 균등하게 분배하고, 다른 GPU에 맞지 않는 부분만 GPU 0에 배치합니다. Transformers 모델의 generate 함수를 사용할 때와 같이 GPU 0을 출력 처리에 사용해야 하는 경우에 이 옵션이 유용합니다.
  • "sequential"은 GPU 0에 가능한 한 많은 부분을 배치한 다음 GPU 1로 이동하는 식으로 진행합니다(필요하지 않으면 마지막 GPU들을 사용하지 않습니다).

옵션 "auto"와 "balanced"는 현재 동일한 결과를 생성하지만, 더 합리적인 전략이 발견될 경우 "auto"의 동작 방식은 미래에 변경될 수 있는 반면, "balanced"는 안정적으로 유지됩니다.

먼저, infer_auto_device_map() 및 이를 사용하는 모든 함수에서 사용할 수 있는 max_memory 인수를 사용하여 각 GPU에서 사용하는 메모리를 제한할 수 있습니다. max_memory를 설정할 때는 GPU 식별자(예: 0, 1 등)와 CPU 오프로드에 사용할 최대 RAM을 위한 "cpu" 키를 포함하는 사전(dict)을 전달해야 합니다. 값은 정수(바이트 단위) 또는 "10GiB"나 "10GB"와 같이 단위를 가진 숫자를 나타내는 문자열일 수 있습니다.

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

보시다시피 나머지 7개의 GPU에 GPU 0보다 약 50% 더 많은 메모리를 할당했습니다.

device_map을 직접 완전히 설계하는 경우, 키는 모델의 모듈 이름, 값은 유효한 디바이스 식별자(예: GPU의 경우 정수) 또는 CPU 오프로드를 위한 "cpu", 디스크 오프로드를 위한 "disk"여야 하는 사전(dictionary)이어야 합니다. 키는 모델 전체를 커버해야 하며, 이후 원하는 대로 디바이스 맵을 정의할 수 있습니다. 예를 들어, 모델에 두 개의 블록(예: block1과 block2)이 있고 각각 세 개의 선형 레이어(예: 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 간에 데이터를 여러 번 전송하는 것을 방지하려면, 장치 맵이 GPU에 순차적으로 매개변수를 배치하도록 확인하십시오(예: 첫 번째 가중치 중 하나를 GPU 0에 배치한 다음, 가중치를 GPU 1에 배치하고, 마지막 가중치를 다시 GPU 0으로 배치하지 마십시오).

CPU 오프로드만

모델을 CPU로 오프로드하려면 cpu_offload()를 사용할 수 있습니다. 이렇게 하면 모델의 모든 파라미터가 오프로드되고 모델의 state dict는 한 부만 유지됩니다. forward pass 동안에는 해당 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의 경우 완전히 그렇지는 않습니다. 따라서 자동으로 계산된 device map이 CPU에 과도한 부하를 줄 수 있습니다. RAM 부족으로 인해 크래시가 발생하면 일부 모듈을 disk device로 이동해 보세요.
  • infer_auto_device_map()(또는 load_checkpoint_and_dispatch()의 device_map="auto")는 장치를 순차적으로 할당합니다(이동 오버헤드를 피하기 위함). 따라서 첫 번째 레이어가 사용 가능한 GPU 용량보다 크면 모든 것이 CPU/Disk에 배치됩니다.
  • 현재 load_checkpoint_and_dispatch()와 load_checkpoint_in_model()은 모델과 state dict의 정확성을 비교하여 검사하지 않습니다(이 문제는 향후 버전에서 수정될 예정입니다). 따라서 키가 일치하지 않거나 누락된 checkpoint를 로드하려고 하면 예상치 못한 오류가 발생할 수 있습니다.
  • 여러 GPU에 걸쳐 모델이 분할될 때 사용되는 모델 병렬성은 단순하고 최적화되지 않은 방식으로 동작합니다. 즉, 특정 시점에 하나의 GPU만 작업을 수행하고 나머지 GPU는 유휴 상태로 대기합니다.
  • weights가 CPU/하드 드라이브로 오프로드된 경우, 사전 가져오기(pre-fetching)가 없습니다(향후 버전에서 이 부분을 개선할 예정입니다). 즉, weights는 필요할 때 GPU에 올라가며, 그 전에 올라가지 않습니다.
  • 하드 드라이브 오프로딩은 디스크와 CPU 간의 통신이 빠르지 않은 하드웨어(예: NVMes)에서 실행될 경우 매우 느릴 수 있습니다.
Update on GitHub