Antrenați modele cu Accelerator

Antrenament eficient al modelelor AI cu PyTorch

Dennis Lee

Data Engineer, Amazon

Trainer și Accelerator

Grafic care compară ușurința de utilizare față de posibilitatea de personalizare pentru Accelerator și Trainer.

Bucle de antrenament personalizate

Trainer: fără bucle de antrenament personalizate
Unele sarcini avansate de AI generativ necesită două rețele

Imagine a unei rețele generative adversariale.

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

Trainer și Accelerator

Grafic care compară ușurința de utilizare față de posibilitatea de personalizare pentru Accelerator și Trainer.

Modificarea unei bucle de antrenament de bază

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

Resetați gradienții
Mutați datele pe dispozitivul specificat: .to(device)
Efectuați trecerea înainte
Calculați pierderea cross-entropie
Calculați gradienții în trecerea înapoi
Actualizați parametrii modelului și rata de învățare

Creați un obiect Accelerator

Accelerator oferă o interfață pentru antrenament distribuit

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

device_placement (bool, implicit True): gestionează plasarea pe dispozitiv

Definiți modelul și optimizatorul

Încărcați un model preantrenat

from transformers import AutoModelForSequenceClassification

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

Optimizați parametrii modelului cu Adam

from torch.optim import Adam

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

Definiți planificatorul

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): optimizator PyTorch, precum Adam
num_warmup_steps (int): pași pentru creșterea liniară a lr, setat la int(num_training_steps * 0.1)
num_training_steps (int): total pași de antrenament, setat la len(train_dataloader) * num_epochs

Pregătiți modelul pentru antrenament eficient

Metoda prepare gestionează plasarea pe dispozitiv

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

                        optimizer,

                        dataloader,

                        lr_scheduler)

Construiți o buclă de antrenament cu Accelerator

for batch in dataloader:

    optimizer.zero_grad()

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

Resetați gradienții
Datele au fost mutate anterior pe dispozitiv

Construiți o buclă de antrenament cu Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

Resetați gradienții
Datele au fost mutate anterior pe dispozitiv
Eliminați liniile care mută datele manual

Construiți o buclă de antrenament cu Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)

    loss = outputs.loss
    loss.backward()

Resetați gradienții
Datele au fost mutate anterior pe dispozitiv
Eliminați liniile care mută datele manual
Efectuați o trecere înainte
Calculați pierderea cross-entropie și gradienții

Construiți o buclă de antrenament cu Accelerator

for batch in dataloader:

    optimizer.zero_grad()

    inputs, targets = batch

    outputs = model(inputs)
    loss = outputs.loss

    accelerator.backward(loss)

    optimizer.step()
    scheduler.step()

Resetați gradienții
Datele au fost mutate anterior pe dispozitiv
Eliminați liniile care mută datele manual
Efectuați o trecere înainte
Calculați pierderea cross-entropie și gradienții
Înlocuiți loss.backward cu accelerator
Actualizați parametrii modelului și rata de învățare

Rezumatul modificărilor

Înainte de Accelerator

Datele trebuie mutate manual pe dispozitive
- inputs.to(device)
- targets.to(device)
Calculați gradienții cu loss.backward()

După Accelerator

Plasare automată pe dispozitiv și paralelism de date
- accelerator.prepare(model)
- accelerator.prepare(dataloader)
Sincronizarea gradienților cu accelerator.backward(loss)
Buclă personalizabilă
Ușor de utilizat, agnostic hardware, scalabil și ușor de întreținut

Să exersăm!

Antrenament eficient al modelelor AI cu PyTorch