Accelerate documentation

Ejecución y diferimiento de trabajos

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.16.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ejecución y diferimiento de trabajos

Cuando ejecuta su script habitual, las instrucciones se ejecutan en orden. Usar Accelerate para desplegar su script en varias GPUs al mismo tiempo introduce una complicación: aunque cada proceso ejecuta todas las instrucciones en orden, algunos pueden ser más rápidos que otros.

Es posible que necesites esperar a que todos los procesos hayan alcanzado un punto determinado antes de ejecutar una instrucción dada. Por ejemplo, no deberías guardar un modelo antes de asegurarte de que cada proceso ha terminado con el entrenamiento, y no querrías continuar con el entrenamiento antes de que todos los pesos del modelo hayan sido cargados. Para hacer esto, simplemente escribe la siguiente línea en tu código:

accelerator.wait_for_everyone()

Esta instrucción bloqueará todos los procesos que lleguen primero hasta que todos los demás procesos hayan alcanzado ese punto (si ejecutas tu script en una sola GPU o CPU, esto no hará nada).

A continuación se enumeran algunos casos de ejemplo de cuándo utilizar esta utilidad:

Algunas de estas se utilizan con el gestor de contexto main_process_first(), que emplea wait_for_everyone() para ejecutar un conjunto específico de código en el proceso principal antes de activar y lanzar los demás procesos.

Descarga de un conjunto de datos

Al descargar un conjunto de datos, primero debe descargarse en el proceso principal y luego cargar el conjunto de datos en caché.

load_dataset ejecuta un bloqueo internamente para evitar que se realicen varias descargas a la vez, pero si estás descargando algo sin usar esta biblioteca, debes usar este método.

with accelerator.main_process_first():
    datasets = load_dataset("glue", "mrpc")

Por debajo, esto es lo mismo que llamar a:

# First do something on the main process
if accelerator.is_main_process:
    datasets = load_dataset("glue", "mrpc")
else:
    accelerator.wait_for_everyone()

# And then send it to the rest of them
if not accelerator.is_main_process:
    datasets = load_dataset("glue", "mrpc")
else:
    accelerator.wait_for_everyone()

Guardar el state_dict

Al guardar el state_dict del modelo, ya que normalmente se guarda un archivo solo en el proceso principal, debes especificarlo:

if accelerator.is_main_process:
    model = accelerator.unwrap_model(model)
    torch.save(model.state_dict(), "weights.pth")

Cargando el state_dict

Al cargar el state_dict en un modelo, optimizador o programador, debe esperar a que todos los workers hayan cargado los pesos antes de pasar al entrenamiento

with accelerator.main_process_first():
    state = torch.load("weights.pth")
    model.load_state_dict(state)

Aplicar una operación de CPU con múltiples trabajadores

Aplicar una operación map() en varios workers, como la tokenización, debe realizarse primero en el proceso principal y luego propagarse a cada uno.

datasets = load_dataset("glue", "mrpc")

with accelerator.main_process_first():
    tokenized_datasets = datasets.map(
        tokenize_function,
        batched=True,
        remove_columns=["idx", "sentence1", "sentence2"],
    )

Aplicar comprobaciones como Early Stopping

Para contar con una comprobación que funcione con una bandera establecida por un proceso en particular, se deben utilizar las API set_trigger y check_trigger. Los ejemplos útiles para hacerlo pueden incluir situaciones como el uso de parada anticipada y el monitoreo de la pérdida (ya que cada pérdida difiere ligeramente en cada proceso).

Llama a Accelerator.set_trigger() cuando se haya cumplido tu condición, y a Accelerator.check_trigger() al comprobar si esa condición se ha cumplido en algún proceso:

for (x,y) in data_loader:
    logits = model(x)
    loss = loss_func(logits, y)
    # Assume `should_do_early_stopping` is a custom defined function that returns a conditional
    if should_do_early_stopping(loss):
        accelerator.set_trigger()

    # Later in the training script when we need to check for the breakpoint
    if accelerator.check_trigger():
        break
Update on GitHub