Modelle mit Accelerator trainieren

Effizientes KI-Modelltraining mit PyTorch

Dennis Lee

Data Engineer, Amazon

Trainer und Accelerator

Diagramm: Vergleich Bedienkomfort vs. Anpassbarkeit für Accelerator und Trainer.

Eigene Trainingsschleifen

Trainer: keine eigenen Trainingsschleifen
Einige fortgeschrittene Generative-AI-Aufgaben brauchen zwei Netze

Bild eines Generative Adversarial Network.

¹ https://www.aitude.com/basics-of-generative-adversarial-network-model/

Trainer und Accelerator

Diagramm: Vergleich Bedienkomfort vs. Anpassbarkeit für Accelerator und Trainer.

Einen einfachen Trainingsloop anpassen

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)

    outputs = model(inputs)

    loss = outputs.loss

    loss.backward()

    optimizer.step()
    scheduler.step()

Gradienten nullen
Daten auf ein Gerät verschieben: .to(device)
Forward-Pass ausführen
Kreuzentropie-Loss berechnen
Gradienten im Backward-Pass berechnen
Modellparameter und Lernrate aktualisieren

Ein Accelerator-Objekt erstellen

Accelerator bietet ein Interface für verteiltes Training

from accelerate import Accelerator
accelerator = Accelerator(
    device_placement=True
)

device_placement (bool, Standard True): Geräteplatzierung automatisch verwalten

Modell und Optimizer definieren

Vorgefertigtes Modell laden

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-cased", return_dict=True)

Modellparameter mit Adam optimieren

from torch.optim import Adam

optimizer = Adam(params=model.parameters(), lr=2e-5)

Scheduler definieren

from transformers import get_linear_schedule_with_warmup

lr_scheduler = get_linear_schedule_with_warmup(
      optimizer=optimizer,

      num_warmup_steps=num_warmup_steps,

      num_training_steps=num_training_steps)

optimizer (obj): PyTorch-Optimizer, z. B. Adam
num_warmup_steps (int): Schritte für lineares Erhöhen von lr, setze int(num_training_steps * 0.1)
num_training_steps (int): gesamte Trainingsschritte, setze len(train_dataloader) * num_epochs

Modell fürs effiziente Training vorbereiten

Die Methode prepare übernimmt die Geräteplatzierung

model, optimizer, dataloader, lr_scheduler = \
    accelerator.prepare(model,

                        optimizer,

                        dataloader,

                        lr_scheduler)

Trainingsloop mit Accelerator aufbauen

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)

Gradienten nullen
Daten zuvor aufs Gerät verschoben

Trainingsloop mit Accelerator aufbauen

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

Gradienten nullen
Daten zuvor aufs Gerät verschoben
Zeilen zum manuellen Verschieben entfernen

Trainingsloop mit Accelerator aufbauen

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)

    loss = outputs.loss
    loss.backward()

Gradienten nullen
Daten zuvor aufs Gerät verschoben
Zeilen zum manuellen Verschieben entfernen
Forward-Pass ausführen
Kreuzentropie-Loss und Gradienten berechnen

Trainingsloop mit Accelerator aufbauen

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)
    loss = outputs.loss

    accelerator.backward(loss)

    optimizer.step()
    scheduler.step()

Gradienten nullen
Daten zuvor aufs Gerät verschoben
Zeilen zum manuellen Verschieben entfernen
Forward-Pass ausführen
Kreuzentropie-Loss und Gradienten berechnen
loss.backward durch accelerator ersetzen
Modellparameter und Lernrate aktualisieren

Änderungen zusammengefasst

Vor Accelerator

Daten manuell auf Geräte verschieben
- inputs.to(device)
- targets.to(device)
Gradienten mit loss.backward() berechnen

Mit Accelerator

Automatische Geräteplatzierung und Datenparallelität
- accelerator.prepare(model)
- accelerator.prepare(dataloader)
Gradienten-Synchronisierung mit accelerator.backward(loss)
Anpassbarer Loop
Benutzerfreundlich, hardwareunabhängig, skalierbar, wartbar

Lass uns üben!

Effizientes KI-Modelltraining mit PyTorch