Modellen trainen met Accelerator

Efficiënt AI-modellen trainen met PyTorch

Dennis Lee

Data Engineer, Amazon

Trainer en Accelerator

Grafiek die gebruiksgemak vs. aanpasbaarheid vergelijkt voor Accelerator en Trainer.

Aangepaste trainingslussen

Trainer: geen aangepaste trainingslussen
Sommige geavanceerde generatieve AI-taken vereisen twee netwerken

Afbeelding van een generative adversarial network.

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

Trainer en Accelerator

Grafiek die gebruiksgemak vs. aanpasbaarheid vergelijkt voor Accelerator en Trainer.

Een basis-trainingslus aanpassen

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

Zet de gradients op nul
Verplaats data naar een device: .to(device)
Voer een forward pass uit
Bereken cross-entropy loss
Bereken gradients in een backward pass
Werk modelparameters en learning rate bij

Maak een Accelerator-object

Accelerator biedt een interface voor gedistribueerd trainen

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

device_placement (bool, standaard True): regelt automatisch device-toewijzing

Definieer model en optimizer

Laad een voorgetraind model

from transformers import AutoModelForSequenceClassification

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

Optimaliseer modelparameters met Adam

from torch.optim import Adam

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

Definieer de scheduler

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, zoals Adam
num_warmup_steps (int): stappen om lr lineair te verhogen, stel in op int(num_training_steps * 0.1)
num_training_steps (int): totale trainingsstappen, stel in op len(train_dataloader) * num_epochs

Bereid het model voor op efficiënt trainen

De methode prepare regelt device-toewijzing

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

                        optimizer,

                        dataloader,

                        lr_scheduler)

Een trainingslus bouwen met Accelerator

for batch in dataloader:

    optimizer.zero_grad()

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

Zet de gradients op nul
Eerder gegevens naar het device verplaatst

Een trainingslus bouwen met Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

Zet de gradients op nul
Eerder gegevens naar het device verplaatst
Verwijder regels die data handmatig verplaatsen

Een trainingslus bouwen met Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)

    loss = outputs.loss
    loss.backward()

Zet de gradients op nul
Eerder gegevens naar het device verplaatst
Verwijder regels die data handmatig verplaatsen
Voer een forward pass uit
Bereken cross-entropy loss en gradients

Een trainingslus bouwen met Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)
    loss = outputs.loss

    accelerator.backward(loss)

    optimizer.step()
    scheduler.step()

Zet de gradients op nul
Eerder gegevens naar het device verplaatst
Verwijder regels die data handmatig verplaatsen
Voer een forward pass uit
Bereken cross-entropy loss en gradients
Vervang loss.backward door accelerator
Werk modelparameters en learning rate bij

Samenvatting van wijzigingen

Voor Accelerator

Data handmatig naar devices verplaatsen
- inputs.to(device)
- targets.to(device)
Gradients berekenen met loss.backward()

Na Accelerator

Automatische device-toewijzing en data-parallelisme
- accelerator.prepare(model)
- accelerator.prepare(dataloader)
Gradient-synchronisatie met accelerator.backward(loss)
Aanpasbare lus
Gebruiksvriendelijk, hardware-agnostisch, schaalbaar en onderhoudbaar

Laten we oefenen!

Efficiënt AI-modellen trainen met PyTorch