Accelerate documentation
Carregando modelos grandes na memória
Carregando modelos grandes na memória
Ao carregar um modelo pré-treinado em PyTorch, o fluxo de trabalho usual é o seguinte:
import torch
my_model = ModelClass(...)
state_dict = torch.load(checkpoint_file)
my_model.load_state_dict(state_dict)Em termos simples, essas etapas são:
- Crie o modelo com pesos inicializados aleatoriamente
- Carregue os pesos do modelo (em um dicionário geralmente chamado de state dict) do disco
- Carregue esses pesos dentro do modelo
Embora isso funcione muito bem para modelos de tamanho regular, esse fluxo de trabalho apresenta limitações claras quando lidamos com um modelo enorme: na etapa 1, carregamos uma versão completa do modelo na RAM e gastamos algum tempo inicializando aleatoriamente os pesos (que serão descartados na etapa 3). Na etapa 2, carregamos outra versão completa do modelo na RAM, com os pesos pré-treinados. Se você estiver carregando um modelo com 6 bilhões de parâmetros, isso significa que você precisará de 24GB de RAM para cada cópia do modelo, ou seja, 48GB no total (metade disso para carregar o modelo em FP16).
Esta API é bastante nova e ainda está em fase experimental. Embora nos esforcemos para fornecer uma API estável, é possível que pequenas partes da API pública mudem no futuro.
Como o Processo Funciona: Uma Visão Rápida
Como o Processo Funciona: Trabalhando com Código
Instanciando um modelo vazio
A primeira ferramenta que o Accelerate introduz para ajudar com modelos grandes é um gerenciador de contexto init_empty_weights() que ajuda você a inicializar um modelo sem usar nenhum RAM, de modo que a etapa 1 possa ser feita em modelos de qualquer tamanho. Veja como funciona:
from accelerate import init_empty_weights
with init_empty_weights():
my_model = ModelClass(...)Por exemplo:
with init_empty_weights():
model = nn.Sequential(*[nn.Linear(10000, 10000) for _ in range(1000)])inicializa um modelo vazio com um pouco mais de 100B de parâmetros. Por trás dos panos, isso depende do dispositivo meta introduzido no PyTorch 1.9. Durante a inicialização sob o gerenciador de contexto, cada vez que um parâmetro é criado, ele é instantaneamente movido para esse dispositivo.
Você não pode mover um modelo inicializado dessa forma para a CPU ou outro dispositivo diretamente, pois ele não possui nenhum dado. Também é muito provável que uma passagem de frente com esse modelo vazio falhe, já que nem todas as operações são suportadas no dispositivo meta.
Pontos de verificação fragmentados
É possível que seu modelo seja tão grande que nem uma única cópia caiba na RAM. Isso não significa que ele não possa ser carregado: se você tiver uma ou várias GPUs, há mais memória disponível para armazenar seu modelo. Nesse caso, é melhor que seu checkpoint seja dividido em vários arquivos menores, que chamamos de shards de checkpoint.
O Accelerate tratará checkpoints fragmentados, desde que você siga o seguinte formato: seu checkpoint deve estar em uma pasta, com vários arquivos contendo os state dicts parciais, e deve haver um índice no formato JSON que contenha um dicionário mapeando os nomes dos parâmetros para o arquivo que contém seus pesos. Você pode fragmentar facilmente seu modelo com save_model(). Por exemplo, poderíamos ter uma pasta contendo:
first_state_dict.bin index.json second_state_dict.bin
com o arquivo index.json sendo o seguinte:
{
"linear1.weight": "first_state_dict.bin",
"linear1.bias": "first_state_dict.bin",
"linear2.weight": "second_state_dict.bin",
"linear2.bias": "second_state_dict.bin"
}e first_state_dict.bin contendo os pesos para "linear1.weight" e "linear1.bias", second_state_dict.bin os de "linear2.weight" e "linear2.bias"
Carregando pesos
A segunda ferramenta que o Accelerate introduz é a função load_checkpoint_and_dispatch(), que permite carregar um checkpoint dentro do seu modelo vazio. Isso suporta checkpoints completos (um único arquivo contendo o state dict inteiro) bem como checkpoints fragmentados. Ele também distribuirá automaticamente esses pesos entre os dispositivos disponíveis (GPUs, RAM da CPU), de modo que, se você estiver carregando um checkpoint fragmentado, o uso máximo de RAM será o tamanho do maior fragmento.
Se você deseja usar inferência de modelos grandes com modelos do Transformers, confira esta documentação.
Aqui está como podemos usar isso para carregar o modelo GPT2-1.5B.
Vamos baixar a versão fragmentada deste modelo.
pip install huggingface_hub
from huggingface_hub import snapshot_download
checkpoint = "marcsun13/gpt2-xl-linear-sharded"
weights_location = snapshot_download(repo_id=checkpoint)Para inicializar o modelo, usaremos a biblioteca 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)Em seguida, carregue o checkpoint que acabamos de baixar com:
from accelerate import load_checkpoint_and_dispatch
model = load_checkpoint_and_dispatch(
model, checkpoint=weights_location, device_map="auto", no_split_module_classes=['Block']
)Ao passar device_map="auto", informamos ao Accelerate para determinar automaticamente onde colocar cada camada do modelo, de acordo com os recursos disponíveis:
- primeiro, usamos o espaço máximo disponível na(s) GPU(s)
- se ainda precisarmos de espaço, armazenamos os pesos restantes na CPU
- se não houver RAM suficiente, armazenamos os pesos restantes no disco rígido como tensores mapeados em memória
no_split_module_classes
Este parâmetro indicará que alguns dos módulos com o nome "Block" não devem ser divididos entre diferentes dispositivos. Você deve definir aqui todos os blocos que
incluem uma conexão residual de algum tipo.
O device_map
Você pode ver o device_map escolhido pelo Accelerate acessando o atributo hf_device_map do seu modelo:
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}É totalmente possível criar seu próprio mapa de dispositivos para as camadas, especificando o dispositivo de GPU a ser usado (um número), "cpu" ou "disk", e passá-lo da seguinte forma:
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
)
Execute o modelo
Agora que fizemos isso, nosso modelo está distribuído em vários dispositivos e, talvez, no disco rígido. Mas ele ainda pode ser usado como um modelo PyTorch regular:
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())Por trás dos bastidores, o Accelerate adicionou hooks ao modelo, de modo que:
- em cada camada, as entradas são colocadas no dispositivo correto (portanto, funciona mesmo que seu modelo esteja distribuído em várias GPUs)
- para os pesos descarregados na CPU, eles são colocados em uma GPU logo antes da passagem para frente e limpos logo depois
- para os pesos descarregados no disco rígido, eles são carregados na RAM e então colocados em uma GPU logo antes da passagem para frente e limpos logo depois
Dessa forma, seu modelo pode executar inferência mesmo que não caiba em uma das GPUs ou na RAM da CPU!
Isso suporta apenas a inferência do seu modelo, não o treinamento. A maior parte do processamento ocorre dentro dos gerenciadores de contexto
torch.no_grad()para evitar o uso de memória de GPU com ativações intermediárias.
Projetando um mapa de dispositivos
Você pode deixar que o Accelerate calcule o mapa de dispositivos definindo device_map para uma das opções suportadas ("auto", "balanced", "balanced_low_0", "sequential") ou criar um por conta própria, se quiser mais controle sobre onde cada camada deve ser alocada.
Você pode derivar todos os tamanhos do modelo (e, portanto, calcular um
device_map) em um modelo que está no meta device.
Todas as opções produzirão o mesmo resultado quando você não tiver memória de GPU suficiente para acomodar o modelo inteiro (ou seja, colocar na GPU tudo o que couber e, em seguida, descarregar os pesos para a CPU ou até mesmo para o disco, caso não haja RAM suficiente).
Quando você tem mais memória de GPU disponível do que o tamanho do modelo, aqui está a diferença entre cada opção:
"auto"e"balanced"dividem o modelo igualmente em todas as GPUs disponíveis, permitindo que você use um tamanho de lote maior que 1."balanced_low_0"divide o modelo igualmente em todos os GPUs, exceto o primeiro, e coloca apenas no GPU 0 o que não couber nos demais. Essa opção é ótima quando você precisa usar o GPU 0 para algum processamento das saídas, como ao usar a funçãogeneratepara modelos do Transformers"sequential"preenche o que puder na GPU 0, depois passa para a GPU 1 e assim por diante (portanto, não usará as últimas GPUs se não precisar).
As opções
"auto"e"balanced"produzem os mesmos resultados por enquanto, mas o comportamento de"auto"pode mudar no futuro se encontrarmos uma estratégia que faça mais sentido, enquanto"balanced"permanecerá estável.
Primeiro, observe que você pode limitar a memória usada em cada GPU usando o argumento max_memory (disponível em infer_auto_device_map() e em todas as funções que o utilizam). Ao definir max_memory, você deve passar um dicionário contendo os identificadores das GPUs (por exemplo, 0, 1 etc.) e a chave "cpu" para a quantidade máxima de RAM que deseja usar para offload de CPU. Os valores podem ser um inteiro (em bytes) ou uma string representando um número com sua unidade, como "10GiB" ou "10GB".
Aqui está um exemplo em que não queremos usar mais de 10GiB em cada uma das duas GPUs e no máximo 30GiB de RAM de CPU para os pesos do modelo:
from accelerate import infer_auto_device_map
device_map = infer_auto_device_map(my_model, max_memory={0: "10GiB", 1: "10GiB", "cpu": "30GiB"})Quando a primeira alocação ocorre no PyTorch, ele carrega kernels CUDA que consomem cerca de 1-2GB de memória, dependendo da GPU. Portanto, você sempre tem menos memória utilizável do que o tamanho real da GPU. Para ver quanto de memória está sendo usado de fato, execute
torch.ones(1).cuda()e verifique o uso de memória.Portanto, ao criar mapas de memória com
max_memory, certifique-se de ajustar a memória disponível de acordo para evitar erros de falta de memória.
Além disso, se você realizar algumas operações adicionais com suas saídas sem colocá-las de volta na CPU (por exemplo, dentro do método generate do Transformers) e se você colocou suas entradas em uma GPU, essa GPU consumirá mais memória do que as outras (o Accelerate sempre coloca a saída de volta no dispositivo da entrada). Portanto, se você deseja otimizar o tamanho máximo do lote e possui muitas GPUs, atribua menos memória à primeira GPU. Por exemplo, com o BLOOM-176B em uma configuração de 8x80 A100, o mapa próximo do ideal é:
max_memory = {0: "30GIB", 1: "46GIB", 2: "46GIB", 3: "46GIB", 4: "46GIB", 5: "46GIB", 6: "46GIB", 7: "46GIB"}como você pode ver, atribuímos às 7 GPUs restantes cerca de 50% mais memória do que à GPU 0.
Se você optar por projetar completamente o device_map por conta própria, ele deve ser um dicionário com chaves sendo os nomes dos módulos do seu modelo e valores sendo um identificador de dispositivo válido (por exemplo, um inteiro para as GPUs) ou "cpu" para offload de CPU, "disk" para offload de disco. As chaves precisam cobrir o modelo inteiro, então você pode definir seu mapa de dispositivos como desejar: por exemplo, se o seu modelo tem dois blocos (digamos block1 e block2) que cada um contém três camadas lineares (digamos linear1, linear2 e linear3), um mapa de dispositivos válido pode ser:
device_map = {"block1": 0, "block2": 1}outra que é válida pode ser:
device_map = {"block1": 0, "block2.linear1": 0, "block2.linear2": 1, "block2.linear3": 1}Por outro lado, este não é válido, pois não cobre todos os parâmetros do modelo:
device_map = {"block1": 0, "block2.linear1": 1, "block2.linear2": 1}Para ser o mais eficiente possível, certifique-se de que seu device map coloca os parâmetros nas GPUs de forma sequencial (por exemplo, não coloque um dos primeiros pesos na GPU 0, depois pesos na GPU 1 e o último peso de volta para a GPU 0) para evitar muitas transferências de dados entre as GPUs.
Apenas offload para CPU
Se você deseja mover seu modelo para a CPU, pode usar cpu_offload(). Como resultado, todos os parâmetros do modelo serão movidos e apenas uma cópia do state dict do modelo será mantida. Durante a passagem para frente, os parâmetros serão extraídos desse state dict, colocados no dispositivo de execução e passados conforme necessário, sendo então movidos de volta.
cpu_offload(model, execution_device)
Você também pode usar cpu_offload_with_hook(). Esta função transfere o modelo para a CPU e o devolve para o dispositivo de execução quando executado. A diferença em relação ao cpu_offload() é que o modelo permanece no dispositivo de execução após o forward e só é transferido novamente quando o método offload do hook retornado é chamado. Além disso, o cpu_offload_with_hook() é mais performático, porém economiza menos memória. É útil para pipelines que executam um modelo em um 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()Apenas offload em disco
Para executar o offload em disco, você pode usar disk_offload(). Como resultado, todos os parâmetros do modelo serão offloadados como arrays mapeados em memória em uma pasta especificada. Durante a passagem de frente, os parâmetros serão acessados a partir dessa pasta e colocados no dispositivo de execução passado, conforme necessário, e depois offloadados novamente.
disk_offload(model, offload_dir, execution_device)
Limites e desenvolvimento futuro
Estamos cientes das limitações atuais na API:
- infer_auto_device_map() (ou
device_map="auto"em load_checkpoint_and_dispatch()) tenta maximizar a RAM de GPU e CPU que vê disponível quando você o executa. Embora o PyTorch seja muito bom em gerenciar a RAM de GPU de forma eficiente (e devolvê-la quando não for necessária), isso não é totalmente verdade para o Python e a RAM de CPU. Portanto, um mapa de dispositivos calculado automaticamente pode ser muito intenso para a CPU. Mova alguns módulos para o dispositivo de disco se você tiver crashes devido à falta de RAM. - infer_auto_device_map() (ou
device_map="auto"em load_checkpoint_and_dispatch()) atribui dispositivos sequencialmente (para evitar mover dados de um lado para o outro), então, se a sua primeira camada for maior que o tamanho da GPU que você possui, tudo acabará ficando na CPU/Disk. - load_checkpoint_and_dispatch() e load_checkpoint_in_model() não realizam nenhuma verificação sobre a correção do seu state dict em comparação com o seu modelo no momento (isso será corrigido em uma versão futura), portanto, você pode receber alguns erros estranhos ao tentar carregar um checkpoint com chaves incompatíveis ou ausentes.
- O paralelismo de modelo usado quando seu modelo é dividido em várias GPUs é ingênuo e não otimizado, o que significa que apenas uma GPU funciona em um dado momento e as outras ficam ociosas.
- Quando os pesos são descarregados na CPU/no disco rígido, não há pré-busca (ainda, trabalharemos nisso para versões futuras), o que significa que os pesos são colocados na GPU quando são necessários e não antes.
- O offloading para o disco rígido pode ser muito lento se o hardware em que você está executando não tiver comunicação rápida entre o disco e a CPU (como NVMe).