Tour rápido

Existen muchas formas de iniciar y ejecutar tu código según tu entorno de entrenamiento (torchrun, DeepSpeed, etc.) y el hardware disponible. Accelerate ofrece una interfaz unificada para iniciar y entrenar en diferentes configuraciones distribuidas, lo que te permite centrarte en tu código de entrenamiento de PyTorch en lugar de en las complejidades de adaptar tu código a estas distintas configuraciones. Esto te permite escalar fácilmente tu código de PyTorch para el entrenamiento y la inferencia en configuraciones distribuidas con hardware como GPUs y TPUs. Accelerate también proporciona Big Model Inference para hacer más accesible la carga y la ejecución de inferencia con modelos realmente grandes que normalmente no caben en la memoria.

Esta introducción rápida presenta las tres funciones principales de Accelerate:

• una interfaz de línea de comandos unificada para lanzar scripts de entrenamiento distribuido
• una biblioteca de entrenamiento para adaptar el código de entrenamiento de PyTorch para que se ejecute en diferentes configuraciones distribuidas
• Inferencia de modelos grandes

Interfaz de lanzamiento unificada

Accelerate selecciona automáticamente los valores de configuración adecuados para cualquier marco de entrenamiento distribuido (DeepSpeed, FSDP, etc.) mediante un archivo de configuración unificado generado desde el comando accelerate config. También puede pasar los valores de configuración explícitamente a la línea de comandos, lo cual resulta útil en ciertas situaciones, como cuando se utiliza SLURM.

Pero en la mayoría de los casos, siempre debes ejecutar accelerate config primero para ayudar a Accelerate a conocer tu configuración de entrenamiento.

accelerate config

El comando accelerate config crea y guarda un archivo default_config.yaml en la carpeta de caché de Accelerate. Este archivo almacena la configuración de tu entorno de entrenamiento, lo que ayuda a Accelerate a lanzar correctamente tu script de entrenamiento según tu máquina.

Después de configurar tu entorno, puedes probar tu configuración con accelerate test, que inicia un script breve para probar el entorno distribuido.

accelerate test

Agregue --config_file al comando accelerate test o accelerate launch para especificar la ubicación del archivo de configuración si se guarda en una ubicación no predeterminada, como la caché.

Una vez que hayas configurado tu entorno, ¡inicia tu script de entrenamiento con accelerate launch!

accelerate launch path_to_script.py --args_for_the_script

Para obtener más información, consulte el tutorial Lanzamiento de código distribuido para más detalles sobre cómo lanzar sus scripts.

También contamos con un zoo de configuraciones que presenta una serie de configuraciones de ejemplo minimales preelaboradas para una variedad de configuraciones que puedes ejecutar.

Adaptar el código de entrenamiento

La siguiente característica principal de Accelerate es la clase Accelerator, que adapta tu código de PyTorch para que se ejecute en diferentes configuraciones distribuidas.

Solo necesitas añadir unas pocas líneas de código a tu script de entrenamiento para que pueda ejecutarse en varias GPU o TPU.

+ 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. Importa e instancia la clase Accelerator al inicio de tu script de entrenamiento. La clase Accelerator inicializa todo lo necesario para el entrenamiento distribuido y detecta automáticamente tu entorno de entrenamiento (una sola máquina con una GPU, una máquina con varias GPUs, varias máquinas con múltiples GPUs o un TPU, etc.) en función de cómo se lanzó el código.

from accelerate import Accelerator

accelerator = Accelerator()

2. Elimina llamadas como .cuda() en tu modelo y datos de entrada. La clase Accelerator coloca automáticamente estos objetos en el dispositivo adecuado por ti.

Este paso es opcional, pero se considera una buena práctica permitir que Accelerate gestione la colocación de dispositivos. También puedes desactivar la colocación automática de dispositivos pasando device_placement=False al inicializar el Accelerator. Si deseas colocar objetos explícitamente en un dispositivo con .to(device), asegúrate de usar accelerator.device en su lugar. Por ejemplo, si creas un optimizador antes de colocar un modelo en accelerator.device, el entrenamiento fallará en un TPU.

Accelerate no utiliza transferencias no bloqueantes de forma predeterminada para su colocación automática de dispositivos, lo que puede dar lugar a sincronizaciones de CUDA no deseadas. Puede habilitar las transferencias no bloqueantes pasando una DataLoaderConfiguration con non_blocking=True establecido como dataloader_config al inicializar el Accelerator. Como es habitual, las transferencias no bloqueantes solo funcionarán si el dataloader también tiene pin_memory=True establecido. Tenga en cuenta que el uso de transferencias no bloqueantes de GPU a CPU puede causar resultados incorrectos si provoca que se realicen operaciones en CPU sobre tensores que no están listos.

device = accelerator.device

3. Pase todos los objetos de PyTorch relevantes para el entrenamiento (optimizador, modelo, cargadores de datos, programador de tasa de aprendizaje) al método prepare() en cuanto se creen. Este método envuelve el modelo en un contenedor optimizado para su configuración distribuida, utiliza la versión de Accelerate del optimizador y del programador, y crea una versión fragmentada de su cargador de datos para su distribución entre GPUs o TPUs.

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

4. Reemplace loss.backward() con backward() para usar el método backward() correcto para su configuración de entrenamiento.

accelerator.backward(loss)

Lea la guía Mecanismos internos de Accelerate para obtener más detalles sobre cómo Accelerate adapta su código.

Evaluación distribuida

Para realizar una evaluación distribuida, pase su dataloader de validación al método prepare():

validation_dataloader = accelerator.prepare(validation_dataloader)

Cada dispositivo en tu configuración distribuida solo recibe una parte de los datos de evaluación, lo que significa que debes agrupar tus predicciones con el método gather_for_metrics(). Este método requiere que todos los tensores tengan el mismo tamaño en cada proceso, por lo que si tus tensores tienen tamaños diferentes en cada proceso (por ejemplo, al rellenar dinámicamente hasta la longitud máxima en un lote), debes usar el método pad_across_processes() para rellenar tu tensor hasta el tamaño más grande entre los procesos. Ten en cuenta que los tensores deben ser de 1D y que concatenamos los tensores a lo largo de la primera dimensión.

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 más complejos (p. ej. tensores 2D, no se desea concatenar tensores, diccionario de tensores 3D), se puede pasar use_gather_object=True en gather_for_metrics. Esto devolverá la lista de objetos después de la recopilación. Tenga en cuenta que su uso con tensores de GPU no está bien soportado y es ineficiente.

Los datos al final de un conjunto de datos pueden duplicarse para que el lote se pueda dividir equitativamente entre todos los trabajadores. El método gather_for_metrics() elimina automáticamente los datos duplicados para calcular una métrica más precisa.

Inferencia de modelos grandes

Big Model Inference de Accelerate tiene dos funciones principales, init_empty_weights() y load_checkpoint_and_dispatch(), para cargar modelos grandes para inferencia que normalmente no caben en la memoria.

Echa un vistazo a la guía Handling big models for inference para comprender mejor cómo funciona Big Model Inference por debajo de las capas.

Inicialización de pesos vacíos

El gestor de contexto init_empty_weights() inicializa modelos de cualquier tamaño creando un esqueleto del modelo y moviendo y colocando los parámetros cada vez que se crean en el dispositivo meta de PyTorch. De esta manera, no se cargan todos los pesos de inmediato y solo se carga en memoria una pequeña parte del modelo a la vez.

Por ejemplo, cargar un modelo Mixtral-8x7B vacío requiere significativamente menos memoria que cargar por completo los modelos y los pesos en la 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)

Cargar y despachar pesos

La función load_checkpoint_and_dispatch() carga puntos de control completos o fragmentados en el modelo vacío y distribuye automáticamente los pesos entre todos los dispositivos disponibles.

El parámetro device_map determina dónde colocar cada capa del modelo, y especificar "auto" los coloca primero en la GPU, luego en la CPU y, finalmente, en el disco duro como tensores mapeados en memoria si aún no hay suficiente memoria. Use el parámetro no_split_module_classes para indicar qué módulos no deben dividirse entre dispositivos (típicamente aquellos con una conexión 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óximos pasos

Ahora que ha sido introducido a las funciones principales de Accelerate, sus próximos pasos podrían incluir:

• Echa un vistazo a los tutoriales para una introducción gradual a Accelerate. Esto es especialmente útil si eres nuevo en el entrenamiento distribuido y en la biblioteca.
• Sumérgete en las guías para ver cómo usar Accelerate para casos de uso específicos.
• Profundice su comprensión conceptual de cómo funciona Accelerate internamente leyendo las guías de conceptos.
• Busque las clases y los comandos en la referencia de la API para ver qué parámetros y opciones están disponibles.