0Pricing
Learn AI with Python · Lektion

Effizientes Training mit Hugging Face Accelerate

accelerate.Accelerator, geräteunabhängiges Training, Gradient Accumulation, DeepSpeed-Integration.

Effizientes Training mit Hugging Face Accelerate ist eine kostenlose Learn AI with Python-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn AI with Python-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.

Das Boilerplate-Problem

Geräteplatzierung, DDP-Einrichtung und gemischte Präzision von Hand zu schreiben, ist umfangreich und fehleranfällig. Hugging Face Accelerate beseitigt diesen Boilerplate-Code: Dasselbe Skript läuft auf der CPU, einer GPU, vielen GPUs oder sogar TPUs, ohne dass der Code geändert werden muss.

Das Accelerator-Objekt

Das Herzstück der Bibliothek ist der Accelerator. Sie erstellen ihn am Anfang Ihres Skripts; er erkennt die Umgebung und verwaltet Geräte, die verteilte Einrichtung und die Präzision für Sie.

from accelerate import Accelerator

accelerator = Accelerator()
device = accelerator.device

Objekte vorbereiten

accelerator.prepare übernimmt Ihr Modell, Ihren Optimizer und Ihren Dataloader und gibt Versionen zurück, die für die aktuelle Konfiguration eingerichtet sind: auf das richtige Gerät verschoben, bei Bedarf in DDP verpackt und mit einem über Prozesse verteilten Dataloader.

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

Was prepare übernimmt

Im Hintergrund übernimmt prepare die Aufgaben, die Sie sonst manuell erledigen müssten: Geräteübertragung, DDP-Verpackung, verteiltes Sampling und die Einbindung gemischter Präzision. Ein einziger Aufruf ersetzt Dutzende Zeilen.

Kein manuelles .to(device)

Da der vorbereitete Dataloader bereits Batches liefert, die sich auf dem richtigen Gerät befinden, können Sie die manuellen Aufrufe von x.to(device) entfernen. Derselbe Loop funktioniert überall.

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

accelerator.backward

Rufen Sie statt loss.backward() accelerator.backward(loss) auf. Dadurch wird automatisch der richtige Ablauf für verteiltes Training und Training mit gemischter Präzision verwendet, einschließlich der Gradientenskalierung.

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

Ein vollständiger Trainings-Loop

Der vollständige Accelerate-Loop ist bemerkenswert übersichtlich und geräteunabhängig.

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()

Gemischte Präzision per Konfiguration

Sie aktivieren FP16/BF16, ohne den Code anzufassen, indem Sie die Einstellung beim Erstellen des Accelerators oder über die CLI-Konfiguration festlegen. Accelerate verwaltet dann autocast und die Gradientenskalierung für Sie.

accelerator = Accelerator(mixed_precision="fp16")

unwrap_model zum Speichern

Nach prepare kann das Modell in DDP verpackt sein. Rufen Sie vor dem Speichern accelerator.unwrap_model(model) auf, um das unverpackte zugrunde liegende Modell zu erhalten, sodass der Checkpoint sauber und portierbar ist.

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

Starten auf mehreren Geräten

Sie führen dasselbe Skript mit dem Befehl accelerate launch aus. Dieser liest Ihre Konfiguration (Anzahl der Prozesse, Maschinen und Präzision) ein und startet die Prozesse. Dabei werden Szenarien mit einer einzelnen GPU, mehreren GPUs und mehreren Knoten transparent unterstützt.

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

Warum Accelerate

Accelerate bietet Ihnen eine transparente Unterstützung mehrerer Geräte: Sie schreiben eine übersichtliche Schleife und skalieren sie von der Laptop-CPU bis zu einem GPU-Cluster mit mehreren Knoten, ohne den Code neu schreiben zu müssen. Dabei baut Accelerate auf den DDP- und AMP-Konzepten auf, die Sie bereits kennengelernt haben – nur die technische Umsetzung bleibt verborgen.

Kurze Überprüfung

Testen Sie Ihr Wissen über Accelerate.

Zusammenfassung

Sie haben effizientes Training mit Hugging Face Accelerate gelernt:

  • Accelerator() erkennt und verwaltet die Umgebung
  • acc.prepare(model, optimizer, dataloader) richtet alles für die aktuell verwendeten Geräte ein
  • acc.backward(loss) übernimmt die Backpropagation für verteiltes Training und Training mit gemischter Präzision
  • acc.unwrap_model liefert ein unverändertes Modell zum Speichern
  • Ein Skript skaliert transparent von der CPU bis zu einer GPU mit mehreren Knoten

Häufig gestellte Fragen

Ist die Lektion „Effizientes Training mit Hugging Face Accelerate“ kostenlos?

Ja — der vollständige Text von „Effizientes Training mit Hugging Face Accelerate“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn AI with Python-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn AI with Python-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Effizientes Training mit Hugging Face Accelerate“?

accelerate.Accelerator, geräteunabhängiges Training, Gradient Accumulation, DeepSpeed-Integration. Du übst Learn AI with Python mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn AI with Python zu starten?

Keine Vorkenntnisse erforderlich. Learn AI with Python auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Effizientes Training mit Hugging Face Accelerate“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn AI with Python-Lektion Code schreiben und ausführen?

Ja. Jede Learn AI with Python-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Multi-GPU-Training mit DataParallel
  2. DistributedDataParallel (DDP)
  3. Mixed-Precision-Training mit AMP
  4. Effizientes Training mit Hugging Face Accelerate
← Zurück zu Learn AI with Python