Accelerate documentation
Exécuter et différer des tâches
Exécuter et différer des tâches
Lorsque vous exécutez votre script habituel, les instructions sont exécutées dans l’ordre. L’utilisation d’Accelerate pour déployer votre script sur plusieurs GPU simultanément introduit une complication : bien que chaque processus exécute toutes les instructions dans l’ordre, certains peuvent être plus rapides que d’autres.
Vous devrez peut-être attendre que tous les processus aient atteint un certain point avant d’exécuter une instruction donnée. Par exemple, vous ne devriez pas enregistrer un modèle avant d’être certain que chaque processus a terminé l’entraînement, et vous ne voudriez pas continuer l’entraînement avant que tous les poids du modèle n’aient été chargés. Pour ce faire, il suffit d’écrire la ligne suivante dans votre code :
accelerator.wait_for_everyone()Cette instruction bloquera tous les processus qui arrivent en premier jusqu’à ce que tous les autres processus aient atteint ce point (si vous exécutez votre script sur un seul GPU ou CPU, cela n’aura aucun effet).
Quelques exemples de cas d'utilisation de cet utilitaire sont listés ci-dessous :
Certaines de ces fonctions sont utilisées avec le gestionnaire de contexte main_process_first(), qui s’appuie sur wait_for_everyone() pour exécuter un ensemble spécifique de code sur le processus principal avant de déclencher et de lancer les autres processus.
Téléchargement d'un jeu de données
Lors du téléchargement d'un jeu de données, vous devez d'abord le télécharger sur le processus principal, puis charger le jeu de données mis en cache.
load_datasetmet en place un verrouillage en interne pour empêcher plusieurs téléchargements simultanés, mais si vous téléchargez des données sans utiliser cette bibliothèque, vous devriez utiliser cette méthode.
with accelerator.main_process_first():
datasets = load_dataset("glue", "mrpc")En interne, cela revient à appeler :
# 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()Enregistrer le state_dict
Lors de l'enregistrement du state_dict du modèle, comme vous enregistrez normalement un seul fichier sur le processus principal uniquement, vous devez le préciser :
if accelerator.is_main_process:
model = accelerator.unwrap_model(model)
torch.save(model.state_dict(), "weights.pth")Chargement du state_dict
Lors du chargement du state_dict dans un modèle, un optimiseur ou un planificateur, vous devez attendre que tous les workers aient terminé le chargement des poids avant de passer à l'entraînement.
with accelerator.main_process_first():
state = torch.load("weights.pth")
model.load_state_dict(state)Application d'une opération CPU multi-travailleurs
L’application d’une opération map() sur plusieurs workers, comme la tokenization, doit d’abord être effectuée sur le processus principal, puis propagée à chacun d’eux.
datasets = load_dataset("glue", "mrpc")
with accelerator.main_process_first():
tokenized_datasets = datasets.map(
tokenize_function,
batched=True,
remove_columns=["idx", "sentence1", "sentence2"],
)Application de contrôles tels que l’arrêt anticipé
Pour disposer d’un contrôle qui fonctionne avec un drapeau défini par un processus particulier, les API set_trigger et check_trigger doivent être utilisées. Des exemples utiles de cette approche incluent des situations telles que l’utilisation de l’arrêt anticipé et la surveillance de la perte (chaque perte étant légèrement différente sur chaque processus).
Appelez Accelerator.set_trigger() lorsque votre condition est remplie, et Accelerator.check_trigger() pour vérifier si cette condition a été remplie dans un des processus :
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