Accelerate documentation
Iniciando scripts do Accelerate
Iniciando scripts do Accelerate
No tutorial anterior, você foi apresentado a como modificar seu script de treinamento atual para usar o Accelerate. A versão final desse código é mostrada abaixo:
from accelerate import Accelerator
accelerator = Accelerator()
model, optimizer, training_dataloader, scheduler = accelerator.prepare(
model, optimizer, training_dataloader, scheduler
)
for batch in training_dataloader:
optimizer.zero_grad()
inputs, targets = batch
outputs = model(inputs)
loss = loss_function(outputs, targets)
accelerator.backward(loss)
optimizer.step()
scheduler.step()Mas como você executa esse código e faz com que ele utilize o hardware especial disponível?
Primeiro, você deve reescrever o código acima em uma função e torná-lo chamável como um script. Por exemplo:
from accelerate import Accelerator
+ def main():
accelerator = Accelerator()
model, optimizer, training_dataloader, scheduler = accelerator.prepare(
model, optimizer, training_dataloader, scheduler
)
for batch in training_dataloader:
optimizer.zero_grad()
inputs, targets = batch
outputs = model(inputs)
loss = loss_function(outputs, targets)
accelerator.backward(loss)
optimizer.step()
scheduler.step()
+ if __name__ == "__main__":
+ main()Em seguida, você precisa executá-lo com accelerate launch.
É recomendável executar
accelerate configantes de usaraccelerate launchpara configurar seu ambiente conforme sua preferência. Caso contrário, o Accelerate usará padrões muito básicos, dependendo da configuração do seu sistema.
Usando accelerate launch
O Accelerate possui um comando de CLI especial para ajudar você a executar seu código no seu sistema por meio de accelerate launch.
Esse comando encapsula todos os diferentes comandos necessários para iniciar seu script em várias plataformas, sem que você precise lembrar qual é cada um deles.
Se você está familiarizado com a execução de scripts no PyTorch por conta própria, como com
torchrun, você ainda pode fazer isso. Não é obrigatório usaraccelerate launch.
Você pode executar seu script rapidamente usando:
accelerate launch {script_name.py} --arg1 --arg2 ...Basta colocar accelerate launch no início do seu comando e passar os argumentos e parâmetros adicionais para o seu script em seguida, como de costume!
Como isso executa os vários métodos de spawn do torch, todas as variáveis de ambiente esperadas também podem ser modificadas aqui.
Por exemplo, aqui está como usar accelerate launch com uma única GPU:
# for cuda device:
CUDA_VISIBLE_DEVICES="0" accelerate launch {script_name.py} --arg1 --arg2 ...
# for xpu device:
ZE_AFFINITY_MASK="0" accelerate launch {script_name.py} --arg1 --arg2 ...Você também pode usar accelerate launch sem executar accelerate config primeiro, mas pode ser necessário passar manualmente os parâmetros de configuração corretos.
Nesse caso, o Accelerate tomará algumas decisões de hiperparâmetros por você, por exemplo, se houver GPUs disponíveis, ele usará todas por padrão, sem a precisão mista.
Aqui está como usar todas as GPUs e treinar com a precisão mista desativada:
accelerate launch --multi_gpu {script_name.py} {--arg1} {--arg2} ...Ou especificando o número de GPUs a serem usadas:
accelerate launch --num_processes=2 {script_name.py} {--arg1} {--arg2} ...Para ser mais específico, você deve passar os parâmetros necessários por conta própria. Por exemplo, veja como você também executaria o mesmo script em duas GPUs usando precisão mista, evitando todos os avisos:
accelerate launch --multi_gpu --mixed_precision=fp16 --num_processes=2 {script_name.py} {--arg1} {--arg2} ...Para uma lista completa dos parâmetros que você pode passar, execute:
accelerate launch -h
Mesmo que você não esteja usando o Accelerate no seu código, ainda é possível usar o launcher para iniciar seus scripts!
Para uma visualização dessa diferença, aquele accelerate launch anterior em multi-gpu se pareceria com o seguinte usando torchrun:
MIXED_PRECISION="fp16" torchrun --nproc_per_node=2 --nnodes=1 {script_name.py} {--arg1} {--arg2} ...Você também pode executar seu script utilizando o CLI de lançamento como um módulo Python, o que permite passar outros comportamentos de lançamento específicos do Python. Para isso, use accelerate.commands.launch em vez de accelerate launch:
python -m accelerate.commands.launch --num_processes=2 {script_name.py} {--arg1} {--arg2}Se você deseja executar o script com outras flags do python, você pode passá-las da mesma forma que -m, como no exemplo abaixo que habilita stdout e stderr sem buffer:
python -u -m accelerate.commands.launch --num_processes=2 {script_name.py} {--arg1} {--arg2}Você também pode executar seu código na CPU! Isso é útil para fins de depuração e testes em modelos e conjuntos de dados pequenos.
accelerate launch --cpu {script_name.py} {--arg1} {--arg2}
Por que você deve sempre usar accelerate config
Por que é tão útil que você deve sempre executar accelerate config?
Lembre-se da chamada anterior para accelerate launch e também para torchrun?
Após a configuração, para executar esse script com as partes necessárias, basta usar accelerate launch diretamente, sem passar nada mais:
accelerate launch {script_name.py} {--arg1} {--arg2} ...Configurações Personalizadas
Como brevemente mencionado anteriormente, o accelerate launch deve ser usado principalmente combinando configurações definidas com o comando accelerate config. Essas configurações são salvas em um arquivo default_config.yaml na pasta de cache do Accelerate.
Essa pasta de cache está localizada em (em ordem decrescente de prioridade):
- O conteúdo da sua variável de ambiente
HF_HOMEcom o sufixoaccelerate. - Se não existir, o conteúdo da sua variável de ambiente
XDG_CACHE_HOMEcom o sufixohuggingface/accelerate. - Se isso também não existir, a pasta
~/.cache/huggingface/accelerate.
Para ter múltiplas configurações, a flag --config_file pode ser passada ao comando accelerate launch em conjunto com a localização do yaml personalizado.
Um exemplo de yaml pode ser parecido com o seguinte para duas GPUs em uma única máquina usando fp16 para precisão mista:
compute_environment: LOCAL_MACHINE
deepspeed_config: {}
distributed_type: MULTI_GPU
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: falseA execução de um script a partir da localização desse arquivo yaml personalizado é feita da seguinte forma:
accelerate launch --config_file {path/to/config/my_config_file.yaml} {script_name.py} {--arg1} {--arg2} ...Treinamento multi-nó
O treinamento multi-nó com Accelerate é semelhante ao treinamento multi-nó com torchrun. A maneira mais simples de iniciar uma execução de treinamento multi-nó é fazer o seguinte:
- Copie sua base de código e seus dados para todos os nós. (ou coloque-os em um sistema de arquivos compartilhado)
- Configure seus pacotes Python em todos os nós.
- Execute
accelerate configprimeiro no nó principal. Após especificar o número de nós, você será solicitado a especificar o rank de cada nó (isso será 0 para o nó principal/master), juntamente com o endereço IP e a porta para o processo principal. Isso é necessário para que os nós de trabalho se comuniquem com o processo principal. Em seguida, você pode copiar ou enviar esse arquivo de configuração para todos os seus nós, alterando omachine_rankpara 1, 2, 3, etc., para evitar ter que executar o comando (ou simplesmente seguir as instruções diretamente para iniciar comtorchruntambém).
Depois de fazer isso, você pode iniciar sua execução de treinamento multi-nó executando accelerate launch (ou torchrun) em todos os nós.
It is required that the command be run on all nodes for everything to start, not just running it from the main node. You can use something like SLURM or a different process executor to wrap around this requirement and call everything from a single command.
É recomendável usar o IP da intranet do seu nó principal em vez do IP público para obter melhor latência. Este é o endereço
192.168.x.xou172.x.x.xque você vê ao executarhostname -Ino nó principal.
Para ter uma melhor ideia sobre treinamento multi-nó, confira nosso exemplo de treinamento multi-nó com FSDP.
Update on GitHub