TRL documentation

Distribuindo o Treinamento

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Distribuindo o Treinamento

Treinamento Multi-GPU com TRL

Os treinadores do TRL são iniciados com torchrun, o lançador distribuído do PyTorch. Ele inicia um processo por GPU:

torchrun --nproc_per_node 8 train.py <SCRIPT_ARGS>

O CLI trl faz a mesma coisa por baixo dos panos, portanto trl sft ... é executado em todas as GPUs da máquina; passe --nproc_per_node para usar menos.

Por baixo dos panos, o 🤗 Accelerate cria um modelo por GPU. Cada processo:

  • Processa seu próprio lote de dados
  • Calcula a perda e os gradientes para esse lote
  • Compartilha as atualizações de gradiente entre todas as GPUs

multi gpu

O tamanho efetivo do lote é calculado como: Batch Size=per_device_train_batch_size×num_devices×gradient_accumulation_steps \text{Batch Size} = \text{per\_device\_train\_batch\_size} \times \text{num\_devices} \times \text{gradient\_accumulation\_steps}

Para manter um tamanho de lote consistente ao escalar para múltiplas GPUs, certifique-se de atualizar per_device_train_batch_size e gradient_accumulation_steps de acordo.

Por exemplo, estas configurações são equivalentes e devem produzir os mesmos resultados:

Número de GPUsTamanho do lote por dispositivoPassos de acúmulo de gradienteComentários
1321Possível alto uso de memória, mas treinamento mais rápido
148Menor uso de memória, treinamento mais lento
841Multi-GPU para obter o melhor dos dois mundos

Ter um modelo por GPU pode levar a um alto uso de memória, o que pode não ser viável para modelos grandes ou GPUs com pouca memória. Nesses casos, você pode aproveitar o DeepSpeed, que fornece otimizações como sharding de modelo, Zero Redundancy Optimizer, treinamento em precisão mista e offloading para CPU ou NVMe. Consulte nosso guia de DeepSpeed Integration para mais detalhes.

O treinamento em sequências muito longas possui seu próprio guia: Training Beyond 1M Tokens.

Treinamento Multi-Nó

Quando uma única máquina não possui GPUs suficientes, o torchrun pode escalar o treinamento para várias máquinas (nós). Cada nó executa o mesmo comando com o número total de nós, seu próprio rank e um endpoint de rendezvous no nó principal.

Opção 1: Lançamento manual (não-HPC)

Execute o seguinte manualmente em cada nó:

# Node 0 (main node, IP 10.0.0.1)
torchrun --nnodes 2 --nproc_per_node 8 --node_rank 0 --rdzv_backend c10d --rdzv_endpoint 10.0.0.1:29500 train.py

# Node 1
torchrun --nnodes 2 --nproc_per_node 8 --node_rank 1 --rdzv_backend c10d --rdzv_endpoint 10.0.0.1:29500 train.py

Substitua 10.0.0.1 pelo endereço IP real do nó de rank 0 (principal).

Opção 2: Inicialização com SLURM (Clusters HPC)

Para clusters que usam o agendador de jobs SLURM, crie um script de job (por exemplo, slurm_job.sh):

#!/bin/bash
#SBATCH --nodes=2
#SBATCH --gpus-per-node=8
#SBATCH --job-name=trl_multi

MAIN_NODE=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
srun torchrun --nnodes 2 --nproc_per_node 8 --node_rank $SLURM_NODEID --rdzv_backend c10d --rdzv_endpoint $MAIN_NODE:29500 train.py

Em seguida, envie o job:

sbatch slurm_job.sh

srun inicia um torchrun por nó, e cada um deles inicia um processo por GPU.

Principais diretivas do SLURM:

  • --nodes=2: Solicita 2 nós de computação
  • --gpus-per-node=8: Aloca 8 GPUs por nó (16 no total)
  • --job-name: Rótulo para rastreamento na fila de jobs

Você pode combinar multi-node com DeepSpeed definindo deepspeed na configuração de treinamento. Consulte o guia de integração do DeepSpeed.

Leituras adicionais

Update on GitHub