0Pricing
Learn AI with Python · Leçon

Entraînement efficace avec Hugging Face Accelerate

accelerate.Accelerator, entraînement indépendant du périphérique, accumulation des gradients, intégration de DeepSpeed.

Entraînement efficace avec Hugging Face Accelerate est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Le problème du code répétitif

Écrire manuellement l'affectation des périphériques, la configuration de DDP et la précision mixte est verbeux et source d'erreurs. Hugging Face Accelerate supprime ce code répétitif : le même script s'exécute sur CPU, un GPU, plusieurs GPU ou même des TPU, sans aucune modification du code.

L'objet Accelerator

Le cœur de la bibliothèque est Accelerator. Vous en créez un au début de votre script ; il détecte l'environnement et gère pour vous les périphériques, la configuration distribuée et la précision.

from accelerate import Accelerator

accelerator = Accelerator()
device = accelerator.device

Préparer les objets

accelerator.prepare prend votre modèle, votre optimiseur et votre chargeur de données, puis renvoie des versions adaptées à la configuration actuelle : déplacées vers le bon périphérique, encapsulées dans DDP si nécessaire, avec le chargeur de données partitionné entre les processus.

model, optimizer, dataloader = accelerator.prepare(
    model, optimizer, dataloader
)

Ce que fait prepare

En arrière-plan, prepare gère le travail que vous devriez autrement effectuer manuellement : transfert vers le périphérique, encapsulation dans DDP, échantillonnage distribué et activation de la précision mixte. Un seul appel remplace des dizaines de lignes.

Plus besoin d'appeler .to(device) manuellement

Comme le chargeur de données préparé fournit des lots déjà placés sur le bon périphérique, vous pouvez supprimer les appels manuels à x.to(device). La même boucle fonctionne partout.

for batch in dataloader:
    inputs, labels = batch   # already on device
    outputs = model(inputs)
    loss = loss_fn(outputs, labels)

accelerator.backward

Au lieu de loss.backward(), appelez accelerator.backward(loss). Celui-ci emprunte automatiquement le chemin approprié pour l'entraînement distribué et en précision mixte, y compris la mise à l'échelle des gradients.

optimizer.zero_grad()
accelerator.backward(loss)
optimizer.step()

Une boucle d'entraînement complète

La boucle Accelerate complète est remarquablement claire et indépendante du périphérique.

accelerator = Accelerator()
model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

for epoch in range(epochs):
    for batch in dataloader:
        inputs, labels = batch
        outputs = model(inputs)
        loss = loss_fn(outputs, labels)
        optimizer.zero_grad()
        accelerator.backward(loss)
        optimizer.step()

Précision mixte via la configuration

Vous activez FP16/BF16 sans toucher au code, en définissant ce paramètre lors de la création de l'Accelerator ou via la configuration de la CLI. Accelerate gère ensuite pour vous autocast et la mise à l'échelle des gradients.

accelerator = Accelerator(mixed_precision="fp16")

unwrap_model pour l'enregistrement

Après prepare, le modèle peut être encapsulé dans DDP. Avant l'enregistrement, appelez accelerator.unwrap_model(model) pour obtenir le modèle sous-jacent simple, afin que le point de contrôle soit propre et portable.

unwrapped = accelerator.unwrap_model(model)
accelerator.save(unwrapped.state_dict(), "model.pt")

Lancement sur plusieurs appareils

Vous exécutez le même script avec la commande accelerate launch, qui lit votre configuration (nombre de processus, machines, précision) et démarre les processus, en gérant de manière transparente les cas à un seul GPU, à plusieurs GPU et à plusieurs nœuds.

accelerate config        # one-time interactive setup
accelerate launch train.py

Pourquoi utiliser Accelerate

Accelerate vous offre une gestion transparente de plusieurs appareils : écrivez une seule boucle claire et passez d'un CPU d'ordinateur portable à un cluster de GPU à plusieurs nœuds sans réécrire le code. Il s'appuie sur les mêmes concepts DDP et AMP que vous avez déjà appris, en masquant simplement les détails techniques.

Vérification rapide

Vérifiez vos connaissances sur Accelerate.

Récapitulatif

Vous avez appris à entraîner efficacement des modèles avec Hugging Face Accelerate :

  • Accelerator() détecte et gère l'environnement
  • acc.prepare(model, optimizer, dataloader) configure tout pour les appareils actuels
  • acc.backward(loss) gère la rétropropagation distribuée et en précision mixte
  • acc.unwrap_model fournit un modèle propre à enregistrer
  • Un seul script s'adapte de manière transparente d'un CPU à plusieurs nœuds GPU

Questions Fréquemment Posées

La leçon « Entraînement efficace avec Hugging Face Accelerate » est-elle gratuite ?

Oui — le texte complet de « Entraînement efficace avec Hugging Face Accelerate » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Entraînement efficace avec Hugging Face Accelerate » ?

accelerate.Accelerator, entraînement indépendant du périphérique, accumulation des gradients, intégration de DeepSpeed. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Entraînement efficace avec Hugging Face Accelerate » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Entraînement multi-GPU avec DataParallel
  2. DistributedDataParallel (DDP)
  3. Entraînement en précision mixte avec AMP
  4. Entraînement efficace avec Hugging Face Accelerate
← Retour à Learn AI with Python