Accelerate documentation

Lancement de l'entraînement distribué depuis Jupyter Notebooks

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Lancement de l'entraînement distribué depuis Jupyter Notebooks

Ce tutoriel vous apprend à affiner un modèle de vision par ordinateur avec 🤗 Accelerate depuis un Jupyter Notebook sur un système distribué. Vous apprendrez également à configurer quelques prérequis nécessaires pour vous assurer que votre environnement est correctement configuré, que vos données ont été correctement préparées, et enfin comment lancer l’entraînement.

Ce tutoriel est également disponible sous forme de Jupyter Notebook ici

Configurer l'environnement

Avant de pouvoir effectuer un entraînement, un fichier de configuration Accelerate doit exister dans le système. Cela se fait généralement en exécutant la commande suivante dans un terminal et en répondant aux invites :

accelerate config

Cependant, si les valeurs par défaut générales conviennent et que vous ne lancez pas sur un TPU, Accelerate propose un utilitaire pour écrire rapidement votre configuration de périphérique dans un fichier de configuration via utils.write_basic_config().

Le code suivant redémarrera Jupyter après avoir écrit la configuration, car le runtime CUDA ou le runtime XPU a été appelé pour effectuer cette opération.

CUDA et XPU ne peuvent pas être initialisés plus d’une fois sur un système multi-appareils. Il est possible de déboguer dans le notebook et d’effectuer des appels à CUDA/XPU, mais pour entraîner finalement un modèle, un nettoyage complet et un redémarrage devront être effectués.

import os
from accelerate.utils import write_basic_config

write_basic_config()  # Write a config file
os._exit(00)  # Restart the notebook

Préparation du jeu de données et du modèle

Vous devez ensuite préparer votre jeu de données. Comme mentionné précédemment, il faut prendre grand soin de la préparation des DataLoaders et du modèle afin de s'assurer que rien n'est placé sur aucun GPU.

Si c’est le cas, il est recommandé de placer ce code spécifique dans une fonction et de l’appeler depuis l’interface de lancement du notebook, qui sera présentée plus tard.

Assurez-vous que le jeu de données est téléchargé conformément aux instructions ci-dessous

import os, re, torch, PIL
import numpy as np

from torch.optim.lr_scheduler import OneCycleLR
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor

from accelerate import Accelerator
from accelerate.utils import set_seed
from timm import create_model

Vous devez d'abord créer une fonction pour extraire le nom de la classe à partir d'un nom de fichier :

import os

data_dir = "../../images"
fnames = os.listdir(data_dir)
fname = fnames[0]
print(fname)
beagle_32.jpg

Dans ce cas, l'étiquette est beagle. En utilisant des expressions régulières, vous pouvez extraire l'étiquette du nom de fichier :

import re


def extract_label(fname):
    stem = fname.split(os.path.sep)[-1]
    return re.search(r"^(.*)_\d+\.jpg$", stem).groups()[0]
extract_label(fname)

Et vous pouvez voir qu'il a bien renvoyé le bon nom pour notre fichier :

"beagle"

Ensuite, une classe Dataset doit être créée pour récupérer l'image et l'étiquette :

class PetsDataset(Dataset):
    def __init__(self, file_names, image_transform=None, label_to_id=None):
        self.file_names = file_names
        self.image_transform = image_transform
        self.label_to_id = label_to_id

    def __len__(self):
        return len(self.file_names)

    def __getitem__(self, idx):
        fname = self.file_names[idx]
        raw_image = PIL.Image.open(fname)
        image = raw_image.convert("RGB")
        if self.image_transform is not None:
            image = self.image_transform(image)
        label = extract_label(fname)
        if self.label_to_id is not None:
            label = self.label_to_id[label]
        return {"image": image, "label": label}

Passons maintenant à la construction du jeu de données. En dehors de la fonction d'entraînement, vous pouvez trouver et déclarer tous les noms de fichiers et les étiquettes, puis les utiliser comme références à l'intérieur de la fonction lancée :

fnames = [os.path.join("../../images", fname) for fname in fnames if fname.endswith(".jpg")]

Rassemblez ensuite tous les étiquettes :

all_labels = [extract_label(fname) for fname in fnames]
id_to_label = list(set(all_labels))
id_to_label.sort()
label_to_id = {lbl: i for i, lbl in enumerate(id_to_label)}

Ensuite, vous devez créer une fonction get_dataloaders qui renverra les dataloaders que vous avez construits. Comme mentionné précédemment, si les données sont automatiquement envoyées vers un GPU ou un appareil TPU lors de la construction de vos DataLoaders, ceux-ci doivent être construits à l'aide de cette méthode.

def get_dataloaders(batch_size: int = 64):
    "Builds a set of dataloaders with a batch_size"
    random_perm = np.random.permutation(len(fnames))
    cut = int(0.8 * len(fnames))
    train_split = random_perm[:cut]
    eval_split = random_perm[cut:]

    # For training a simple RandomResizedCrop will be used
    train_tfm = Compose([RandomResizedCrop((224, 224), scale=(0.5, 1.0)), ToTensor()])
    train_dataset = PetsDataset([fnames[i] for i in train_split], image_transform=train_tfm, label_to_id=label_to_id)

    # For evaluation a deterministic Resize will be used
    eval_tfm = Compose([Resize((224, 224)), ToTensor()])
    eval_dataset = PetsDataset([fnames[i] for i in eval_split], image_transform=eval_tfm, label_to_id=label_to_id)

    # Instantiate dataloaders
    train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=4)
    eval_dataloader = DataLoader(eval_dataset, shuffle=False, batch_size=batch_size * 2, num_workers=4)
    return train_dataloader, eval_dataloader

Enfin, vous devez importer le planificateur qui sera utilisé plus tard :

from torch.optim.lr_scheduler import CosineAnnealingLR

Écrire la fonction d'entraînement

Vous pouvez maintenant construire la boucle d’entraînement. notebook_launcher() fonctionne en transmettant une fonction à appeler, qui sera exécutée sur l’ensemble du système distribué.

Voici une boucle d'entraînement de base pour le problème de classification d'animaux :

Le code a été découpé afin de permettre des explications sur chaque section. Une version complète, prête à être copiée-collée, sera disponible à la fin

def training_loop(mixed_precision="fp16", seed: int = 42, batch_size: int = 64):
    set_seed(seed)
    accelerator = Accelerator(mixed_precision=mixed_precision)

Tout d'abord, vous devez définir la graine et créer un objet Accelerator le plus tôt possible dans la boucle d'entraînement.

Si vous entraînez sur TPU, votre boucle d’entraînement doit recevoir le modèle en paramètre et celui-ci doit être instancié en dehors de la fonction de boucle d’entraînement. Consultez les bonnes pratiques TPU pour comprendre pourquoi

Ensuite, vous devez construire vos chargeurs de données et créer votre modèle :

    train_dataloader, eval_dataloader = get_dataloaders(batch_size)
    model = create_model("resnet50d", pretrained=True, num_classes=len(label_to_id))

Vous construisez le modèle ici afin que la graine contrôle également l'initialisation des nouveaux poids

Comme vous effectuez un apprentissage par transfert dans cet exemple, l'encodeur du modèle est initialement figé afin que la tête du modèle puisse être entraînée en premier lieu :

    for param in model.parameters():
        param.requires_grad = False
    for param in model.get_classifier().parameters():
        param.requires_grad = True

Normaliser les lots d'images accélérera légèrement l'entraînement :

    mean = torch.tensor(model.default_cfg["mean"])[None, :, None, None]
    std = torch.tensor(model.default_cfg["std"])[None, :, None, None]

Pour rendre ces constantes disponibles sur l’appareil actif, vous devez définir celui-ci sur l’appareil de l’Accelerator :

    mean = mean.to(accelerator.device)
    std = std.to(accelerator.device)

Instanciez ensuite le reste des classes PyTorch utilisées pour l’entraînement :

    optimizer = torch.optim.Adam(params=model.parameters(), lr=3e-2 / 25)
    lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=3e-2, epochs=5, steps_per_epoch=len(train_dataloader))

Avant de tout passer à prepare().

Il n’y a pas d’ordre spécifique à retenir, il suffit de dépaqueter les objets dans le même ordre que celui dans lequel vous les avez transmis à la méthode prepare.

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

Entraînez maintenant le modèle :

    for epoch in range(5):
        model.train()
        for batch in train_dataloader:
            inputs = (batch["image"] - mean) / std
            outputs = model(inputs)
            loss = torch.nn.functional.cross_entropy(outputs, batch["label"])
            accelerator.backward(loss)
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()

La boucle d'évaluation sera légèrement différente de la boucle d'entraînement. Le nombre d'éléments transmis ainsi que la précision globale de chaque lot seront ajoutés à deux constantes :

        model.eval()
        accurate = 0
        num_elems = 0

Ensuite, vous avez le reste de votre boucle PyTorch standard :

        for batch in eval_dataloader:
            inputs = (batch["image"] - mean) / std
            with torch.no_grad():
                outputs = model(inputs)
            predictions = outputs.argmax(dim=-1)

Avant de conclure, la dernière grande différence.

Lors de l'évaluation distribuée, les prédictions et les étiquettes doivent être transmises via gather() afin que toutes les données soient disponibles sur l'appareil actuel et qu'une métrique correctement calculée puisse être obtenue :

            accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch["label"])
            num_elems += accurate_preds.shape[0]
            accurate += accurate_preds.long().sum()

Il ne vous reste plus qu'à calculer la métrique réelle pour ce problème, que vous pouvez afficher sur le processus principal à l'aide de print() :

        eval_metric = accurate.item() / num_elems
        accelerator.print(f"epoch {epoch}: {100 * eval_metric:.2f}")

Une version complète de cette boucle d’entraînement est disponible ci-dessous :

def training_loop(mixed_precision="fp16", seed: int = 42, batch_size: int = 64):
    set_seed(seed)
    # Initialize accelerator
    accelerator = Accelerator(mixed_precision=mixed_precision)
    # Build dataloaders
    train_dataloader, eval_dataloader = get_dataloaders(batch_size)

    # Instantiate the model (you build the model here so that the seed also controls new weight initializations)
    model = create_model("resnet50d", pretrained=True, num_classes=len(label_to_id))

    # Freeze the base model
    for param in model.parameters():
        param.requires_grad = False
    for param in model.get_classifier().parameters():
        param.requires_grad = True

    # You can normalize the batches of images to be a bit faster
    mean = torch.tensor(model.default_cfg["mean"])[None, :, None, None]
    std = torch.tensor(model.default_cfg["std"])[None, :, None, None]

    # To make these constants available on the active device, set it to the accelerator device
    mean = mean.to(accelerator.device)
    std = std.to(accelerator.device)

    # Instantiate the optimizer
    optimizer = torch.optim.Adam(params=model.parameters(), lr=3e-2 / 25)

    # Instantiate the learning rate scheduler
    lr_scheduler = OneCycleLR(optimizer=optimizer, max_lr=3e-2, epochs=5, steps_per_epoch=len(train_dataloader))

    # Prepare everything
    # There is no specific order to remember, you just need to unpack the objects in the same order you gave them to the
    # prepare method.
    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
    )

    # Now you train the model
    for epoch in range(5):
        model.train()
        for batch in train_dataloader:
            inputs = (batch["image"] - mean) / std
            outputs = model(inputs)
            loss = torch.nn.functional.cross_entropy(outputs, batch["label"])
            accelerator.backward(loss)
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()

        model.eval()
        accurate = 0
        num_elems = 0
        for batch in eval_dataloader:
            inputs = (batch["image"] - mean) / std
            with torch.no_grad():
                outputs = model(inputs)
            predictions = outputs.argmax(dim=-1)
            accurate_preds = accelerator.gather(predictions) == accelerator.gather(batch["label"])
            num_elems += accurate_preds.shape[0]
            accurate += accurate_preds.long().sum()

        eval_metric = accurate.item() / num_elems
        # Use accelerator.print to print only on the main process.
        accelerator.print(f"epoch {epoch}: {100 * eval_metric:.2f}")

Utilisation de notebook_launcher

Il ne reste plus qu'à utiliser notebook_launcher().

Vous passez la fonction, les arguments (sous forme de tuple) et le nombre de processus sur lesquels entraîner. (Voir la documentation pour plus d'informations)

from accelerate import notebook_launcher
args = ("fp16", 42, 64)
notebook_launcher(training_loop, args, num_processes=2)

Lors de l’exécution sur plusieurs nœuds, vous devez configurer une session Jupyter sur chaque nœud et exécuter la cellule de lancement simultanément.

Pour un environnement contenant 2 nœuds (ordinateurs) avec 8 GPU chacun et l’ordinateur principal ayant une adresse IP de « 172.31.43.8 », cela ressemblerait à ceci :

notebook_launcher(training_loop, args, master_addr="172.31.43.8", node_rank=0, num_nodes=2, num_processes=8)

Et dans la deuxième session Jupyter sur l'autre machine :

Remarquez que le node_rank a changé

notebook_launcher(training_loop, args, master_addr="172.31.43.8", node_rank=1, num_nodes=2, num_processes=8)

Dans le cas d'une exécution sur TPU, cela ressemblerait à ceci :

model = create_model("resnet50d", pretrained=True, num_classes=len(label_to_id))

args = (model, "fp16", 42, 64)
notebook_launcher(training_loop, args, num_processes=8)

Pour lancer le processus d'entraînement avec de l'élasticité, permettant la tolérance aux pannes, vous pouvez utiliser la fonctionnalité elastic_launch fournie par PyTorch. Cela nécessite de définir des paramètres supplémentaires tels que rdzv_backend et max_restarts. Voici un exemple d'utilisation de notebook_launcher avec des capacités élastiques :

notebook_launcher(
    training_loop,
    args,
    num_processes=2,
    max_restarts=3
)

Pendant son exécution, il affiche la progression ainsi que le nombre de dispositifs utilisés. Ce tutoriel a été exécuté sur deux GPU :

Launching training on 2 GPUs.
epoch 0: 88.12
epoch 1: 91.73
epoch 2: 92.58
epoch 3: 93.90
epoch 4: 94.71

Et c’est tout !

Veuillez noter que notebook_launcher() ignore le fichier de configuration d’Accelerate. Pour lancer en fonction de la configuration, utilisez :

accelerate launch

Débogage

Un problème courant lors de l’exécution du notebook_launcher est l’erreur indiquant que CUDA/XPU a déjà été initialisé. Cela provient généralement d’un import ou d’un code antérieur dans le notebook qui effectue un appel à la sous-bibliothèque PyTorch torch.cuda ou torch.xpu. Pour aider à identifier l’origine du problème, vous pouvez lancer le notebook_launcher avec ACCELERATE_DEBUG_MODE=yes dans votre environnement, et un contrôle supplémentaire sera effectué lors de la création du processus pour vérifier qu’un processus standard peut être créé et utiliser CUDA/XPU sans problème. (Votre code CUDA/XPU peut toujours être exécuté par la suite).

Conclusion

Ce notebook a montré comment effectuer une formation distribuée depuis l'intérieur d'un Jupyter Notebook. Voici quelques points clés à retenir :

  • Assurez-vous d'enregistrer tout code utilisant CUDA/XPU (ou des imports CUDA/XPU) pour la fonction passée à notebook_launcher()
  • Définissez num_processes sur le nombre d’appareils utilisés pour l’entraînement (par exemple, le nombre de GPU, XPU, CPU, TPU, etc.)
  • Si vous utilisez le TPU, déclarez votre modèle en dehors de la fonction de boucle d'entraînement
Update on GitHub