Tour rápido

Existem muitas formas de iniciar e executar seu código, dependendo do seu ambiente de treinamento (torchrun, DeepSpeed, etc.) e do hardware disponível. O Accelerate oferece uma interface unificada para iniciar e treinar em diferentes configurações distribuídas, permitindo que você foque no seu código de treinamento em PyTorch em vez das complexidades de adaptar seu código a essas diferentes configurações. Isso permite que você escale facilmente seu código em PyTorch para treinamento e inferência em configurações distribuídas com hardware como GPUs e TPUs. O Accelerate também fornece Big Model Inference para tornar mais acessível o carregamento e a execução de inferência com modelos realmente grandes que normalmente não cabem na memória.

Este quicktour apresenta os três recursos principais do Accelerate:

• uma interface de linha de comando unificada para iniciar scripts de treinamento distribuído
• uma biblioteca de treinamento para adaptar o código de treinamento do PyTorch para executar em diferentes configurações distribuídas
• Inferência de Modelos Grandes

Interface de lançamento unificada

O Accelerate seleciona automaticamente os valores de configuração apropriados para qualquer framework de treinamento distribuído (DeepSpeed, FSDP, etc.) por meio de um arquivo de configuração unificado gerado a partir do comando accelerate config. Você também pode passar os valores de configuração explicitamente para a linha de comando, o que é útil em certas situações, como ao usar SLURM.

Mas, na maioria dos casos, você deve sempre executar accelerate config primeiro para ajudar o Accelerate a aprender sobre sua configuração de treinamento.

accelerate config

O comando accelerate config cria e salva um arquivo default_config.yaml na pasta de cache do Accelerate. Este arquivo armazena a configuração do seu ambiente de treinamento, o que ajuda o Accelerate a iniciar corretamente seu script de treinamento com base na sua máquina.

Depois de configurar o ambiente, você pode testar a configuração com accelerate test, que inicia um script curto para testar o ambiente distribuído.

accelerate test

Adicione --config_file ao comando accelerate test ou accelerate launch para especificar a localização do arquivo de configuração, caso ele esteja salvo em um local não padrão, como o cache.

Depois que o seu ambiente estiver configurado, inicie o seu script de treinamento com accelerate launch!

accelerate launch path_to_script.py --args_for_the_script

Para saber mais, consulte o tutorial Launch distributed code para obter mais informações sobre como executar seus scripts.

Também temos um zoo de configurações que apresenta uma série de configurações de exemplo minimais prontas para uma variedade de cenários que você pode executar.

Adaptar o código de treinamento

O próximo recurso principal do Accelerate é a classe Accelerator, que adapta seu código do PyTorch para executar em diferentes configurações distribuídas.

Você só precisa adicionar algumas linhas de código ao seu script de treinamento para habilitá-lo a ser executado em múltiplas GPUs ou TPUs.

+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()

1. Importe e instancie a classe Accelerator no início do seu script de treinamento. A classe Accelerator inicializa tudo o que é necessário para o treinamento distribuído e detecta automaticamente o seu ambiente de treinamento (uma máquina única com GPU, uma máquina com várias GPUs, várias máquinas com múltiplas GPUs ou um TPU, etc.) com base em como o código foi iniciado.

from accelerate import Accelerator

accelerator = Accelerator()

2. Remova chamadas como .cuda() no seu modelo e nos dados de entrada. A classe Accelerator posiciona automaticamente esses objetos no dispositivo apropriado para você.

Esta etapa é opcional, mas é considerado uma boa prática permitir que o Accelerate gerencie a colocação de dispositivos. Você também pode desativar a colocação automática de dispositivos passando device_placement=False ao inicializar o Accelerator. Se você deseja colocar explicitamente objetos em um dispositivo com .to(device), certifique-se de usar accelerator.device em vez disso. Por exemplo, se você criar um otimizador antes de colocar um modelo em accelerator.device, o treinamento falhará em um TPU.

O Accelerate não usa transferências não bloqueantes por padrão para o posicionamento automático de dispositivos, o que pode resultar em sincronizações CUDA potencialmente indesejadas. Você pode habilitar transferências não bloqueantes passando um DataLoaderConfiguration com non_blocking=True definido como dataloader_config ao inicializar o Accelerator. Como de costume, as transferências não bloqueantes só funcionarão se o dataloader também tiver pin_memory=True definido. Tenha em mente que o uso de transferências não bloqueantes de GPU para CPU pode causar resultados incorretos se resultar em operações de CPU sendo executadas em tensores não prontos.

device = accelerator.device

3. Passe todos os objetos relevantes do PyTorch para o treinamento (otimizador, modelo, dataloader(s), agendador de taxa de aprendizado) para o método prepare() assim que forem criados. Este método envolve o modelo em um container otimizado para sua configuração distribuída, usa a versão do Accelerate do otimizador e do agendador, e cria uma versão fragmentada do seu dataloader para distribuição entre GPUs ou TPUs.

model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)

4. Substitua loss.backward() por backward() para usar o método backward() correto para a sua configuração de treinamento.

accelerator.backward(loss)

Leia o guia mecanismos internos do Accelerate para saber mais detalhes sobre como o Accelerate adapta seu código.

Avaliação distribuída

Para realizar a avaliação distribuída, passe seu dataloader de validação para o método prepare():

validation_dataloader = accelerator.prepare(validation_dataloader)

Cada dispositivo em sua configuração distribuída recebe apenas uma parte dos dados de avaliação, o que significa que você deve agrupar suas previsões usando o método gather_for_metrics(). Este método exige que todos os tensores tenham o mesmo tamanho em cada processo, portanto, se seus tensores tiverem tamanhos diferentes em cada processo (por exemplo, ao aplicar padding dinamicamente até o comprimento máximo em um lote), você deve usar o método pad_across_processes() para aplicar padding ao seu tensor até o maior tamanho entre os processos. Observe que os tensores precisam ser unidimensionais e que concatenamos os tensores ao longo da primeira dimensão.

for inputs, targets in validation_dataloader:
    predictions = model(inputs)
    # Gather all predictions and targets
    all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
    # Example of use with a *Datasets.Metric*
    metric.add_batch(all_predictions, all_targets)

Para casos mais complexos (por exemplo, tensores 2D, não deseja concatenar tensores, dicionário de tensores 3D), você pode passar use_gather_object=True em gather_for_metrics. Isso retornará a lista de objetos após a coleta. Observe que o uso com tensores de GPU não é bem suportado e é ineficiente.

Dados no final de um conjunto de dados podem ser duplicados para que o lote possa ser dividido igualmente entre todos os workers. O método gather_for_metrics() remove automaticamente os dados duplicados para calcular uma métrica mais precisa.

Inferência de Modelos Grandes

O Big Model Inference do Accelerate possui duas funcionalidades principais, init_empty_weights() e load_checkpoint_and_dispatch(), para carregar modelos grandes para inferência que normalmente não cabem na memória.

Dê uma olhada no guia Tratando modelos grandes para inferência para uma melhor compreensão de como o Big Model Inference funciona por baixo dos panos.

Inicialização de pesos vazios

O gerenciador de contexto init_empty_weights() inicializa modelos de qualquer tamanho criando um esqueleto do modelo e movendo e posicionando os parâmetros, sempre que são criados, para o dispositivo meta do PyTorch. Dessa forma, nem todos os pesos são carregados imediatamente e apenas uma pequena parte do modelo é carregada na memória de cada vez.

Por exemplo, carregar um modelo Mixtral-8x7B vazio consome significativamente menos memória do que carregar completamente os modelos e pesos na CPU.

from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM

config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
    model = AutoModelForCausalLM.from_config(config)

Carregar e despachar pesos

A função load_checkpoint_and_dispatch() carrega checkpoints completos ou fragmentados no modelo vazio e distribui automaticamente os pesos entre todos os dispositivos disponíveis.

O parâmetro device_map determina onde posicionar cada camada do modelo, e especificar "auto" os coloca primeiro na GPU, depois na CPU e, por fim, no disco rígido como tensores mapeados em memória, caso ainda não haja memória suficiente. Use o parâmetro no_split_module_classes para indicar quais módulos não devem ser divididos entre dispositivos (tipicamente aqueles com uma conexão residual).

from accelerate import load_checkpoint_and_dispatch

model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
    model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)

Próximas etapas

Agora que você foi apresentado às principais funcionalidades do Accelerate, seus próximos passos podem incluir:

• Confira os tutoriais para uma introdução gradual ao Accelerate. Isso é especialmente útil se você é novo em treinamento distribuído e na biblioteca.
• Explore os guias para ver como usar o Accelerate para casos de uso específicos.
• Aprofunde sua compreensão conceitual de como o Accelerate funciona internamente lendo os guias conceituais.
• Consulte as classes e os comandos na referência da API para ver quais parâmetros e opções estão disponíveis.