Lanzamiento de scripts de Accelerate

En el tutorial anterior, se te introdujo cómo modificar tu script de entrenamiento actual para usar Accelerate. La versión final de ese código se muestra a continuación:

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

Pero, ¿cómo se ejecuta este código para que aproveche el hardware especial disponible?

Primero, debes reescribir el código anterior en una función y hacerlo ejecutable como un script. Por ejemplo:

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

A continuación, debe lanzarlo con accelerate launch.

Se recomienda ejecutar accelerate config antes de usar accelerate launch para configurar tu entorno a tu gusto. De lo contrario, Accelerate usará valores predeterminados muy básicos según la configuración de tu sistema.

Usando accelerate launch

Accelerate tiene un comando CLI especial para ayudarte a ejecutar tu código en tu sistema mediante accelerate launch. Este comando encapsula todos los distintos comandos necesarios para lanzar tu script en varias plataformas, sin que tengas que recordar cuál es cada uno.

Si está familiarizado con el lanzamiento de scripts en PyTorch por su cuenta, como con torchrun, puede seguir haciéndolo. No es obligatorio usar accelerate launch.

Puedes iniciar tu script rápidamente usando:

accelerate launch {script_name.py} --arg1 --arg2 ...

Solo coloca accelerate launch al inicio de tu comando y, a continuación, pasa los argumentos y parámetros adicionales a tu script como de costumbre.

Dado que esto ejecuta los diversos métodos de spawn de torch, todas las variables de entorno esperadas también pueden modificarse aquí. Por ejemplo, así es como se usa accelerate launch con una sola 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 ...

También puede usar accelerate launch sin ejecutar accelerate config primero, pero es posible que tenga que pasar manualmente los parámetros de configuración correctos. En este caso, Accelerate tomará algunas decisiones de hiperparámetros por usted, por ejemplo, si hay GPUs disponibles, las usará todas de forma predeterminada sin precisión mixta. Así es como usaría todas las GPUs y entrenaría con la precisión mixta deshabilitada:

accelerate launch --multi_gpu {script_name.py} {--arg1} {--arg2} ...

O especificando el número de GPUs a usar:

accelerate launch --num_processes=2 {script_name.py} {--arg1} {--arg2} ...

Para ser más específico, debe pasar los parámetros necesarios usted mismo. Por ejemplo, así es como lanzaría ese mismo script en dos GPUs usando precisión mixta y evitando todas las advertencias:

accelerate launch --multi_gpu --mixed_precision=fp16 --num_processes=2 {script_name.py} {--arg1} {--arg2} ...

Para obtener una lista completa de los parámetros que puede pasar, ejecute:

accelerate launch -h

Incluso si no estás usando Accelerate en tu código, ¡puedes usar el lanzador para iniciar tus scripts!

Para visualizar esta diferencia, ese accelerate launch anterior en multi-gpu se vería algo así con torchrun:

MIXED_PRECISION="fp16" torchrun --nproc_per_node=2 --nnodes=1 {script_name.py} {--arg1} {--arg2} ...

También puede ejecutar su script utilizando el CLI de lanzamiento como un módulo de Python, lo que permite pasar otros comportamientos de lanzamiento específicos de Python. Para hacerlo, use accelerate.commands.launch en lugar de accelerate launch:

python -m accelerate.commands.launch --num_processes=2 {script_name.py} {--arg1} {--arg2}

Si desea ejecutar el script con otras banderas de python, puede pasarlas de la misma manera que -m, como en el siguiente ejemplo que habilita stdout y stderr sin búfer:

python -u -m accelerate.commands.launch --num_processes=2 {script_name.py} {--arg1} {--arg2}

¡También puedes ejecutar tu código en CPU! Esto resulta útil para depurar y probar con modelos y conjuntos de datos de ejemplo.

Copiado

accelerate launch --cpu {script_name.py} {--arg1} {--arg2}

Por qué debes usar siempre accelerate config

¿Por qué es tan útil que deberías siempre ejecutar accelerate config?

Recuerden la llamada anterior a accelerate launch y a torchrun. Una vez configurado, para ejecutar ese script con las partes necesarias solo tienen que usar accelerate launch directamente, sin pasar nada más:

accelerate launch {script_name.py} {--arg1} {--arg2} ...

Configuraciones personalizadas

Como se mencionó brevemente antes, accelerate launch debe usarse principalmente combinando configuraciones establecidas con el comando accelerate config. Estas configuraciones se guardan en un archivo default_config.yaml en la carpeta de caché de Accelerate. Esta carpeta de caché se encuentra en (en orden decreciente de prioridad):

• El contenido de su variable de entorno HF_HOME con el sufijo accelerate.
• Si no existe, el contenido de su variable de entorno XDG_CACHE_HOME con el sufijo huggingface/accelerate.
• Si tampoco existe, la carpeta ~/.cache/huggingface/accelerate.

Para tener varias configuraciones, se puede pasar la bandera --config_file al comando accelerate launch junto con la ubicación del yaml personalizado.

Un ejemplo de yaml podría parecerse al siguiente para dos GPUs en una sola máquina usando fp16 para precisión mixta:

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: false

Para lanzar un script desde la ubicación de ese archivo yaml personalizado, se hace de la siguiente manera:

accelerate launch --config_file {path/to/config/my_config_file.yaml} {script_name.py} {--arg1} {--arg2} ...

Entrenamiento multinodo

El entrenamiento multinodo con Accelerate es similar al entrenamiento multinodo con torchrun. La forma más sencilla de iniciar una ejecución de entrenamiento multinodo es hacer lo siguiente:

• Copia tu base de código y tus datos a todos los nodos. (o colócalos en un sistema de archivos compartido)
• Configura tus paquetes de Python en todos los nodos.
• Ejecute accelerate config primero en el nodo principal. Después de especificar el número de nodos, se le pedirá que especifique el rango de cada nodo (será 0 para el nodo principal/master), junto con la dirección IP y el puerto para el proceso principal. Esto es necesario para que los nodos de trabajo se comuniquen con el proceso principal. Después, puede copiar o enviar este archivo de configuración a todos sus nodos, cambiando machine_rank a 1, 2, 3, etc. para evitar tener que ejecutar el comando (o simplemente seguir sus instrucciones directamente para lanzar con torchrun también).

Una vez que hayas hecho esto, puedes iniciar tu ejecución de entrenamiento multinodo ejecutando accelerate launch (o torchrun) en todos los nodos.

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.

Se recomienda usar la IP de la intranet de su nodo principal en lugar de la IP pública para obtener una mejor latencia. Esta es la dirección 192.168.x.x o 172.x.x.x que ve cuando ejecuta hostname -I en el nodo principal.

Para obtener una mejor idea sobre el entrenamiento multinodo, consulte nuestro ejemplo de entrenamiento multinodo con FSDP.