Accelerate documentation
Ejecución y diferimiento de trabajos
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_datasetejecuta 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