Valuta i modelli con Accelerator

Efficient AI Model Training with PyTorch

Dennis Lee

Data Engineer, Amazon

Perché mettere un modello in modalità evaluation?

Modalità training
- Dropout: azzera alcuni neuroni
- Batch normalization

Dropout e batch normalization Diagramma di una rete neurale con più livelli: input, nascosti e output. Il dropout è applicato ai livelli nascosti per ridurre l’overfitting e la batch normalization normalizza l’output di ogni livello prima dell’attivazione.

Perché mettere un modello in modalità evaluation?

Modalità training
- Dropout: azzera neuroni
- Batch normalization
La modalità evaluation disattiva questi layer
model.eval() attiva la modalità evaluation

Disattivare i gradienti con torch.no_grad()

Il training richiede il calcolo dei gradienti
torch.no_grad() disattiva i gradienti
Chiama sia model.eval sia torch.no_grad:

model.eval()
with torch.no_grad():
    outputs = model(**inputs)

Calcolo dei gradienti nel backpropagation Diagramma di una rete neurale che illustra la backpropagation: i gradienti sono calcolati a ogni livello per aggiornare i pesi. Mostra come l’errore si propaga all’indietro dallo strato di output a quelli nascosti, aggiornando i pesi con la discesa del gradiente.

Prepara un dataset di validazione

Carica lo split di validazione di MRPC

validation_dataset = load_dataset("glue", "mrpc", split="validation")

Tokenizza il dataset di validazione

def encode(examples):
    return tokenizer(examples["sentence1"], 
                      examples["sentence2"],
                      truncation=True,
                      padding="max_length")

validation_dataset = validation_dataset.map(encode, batched=True)

Ciclo di un’epoca: loop di training ed evaluation

A ogni epoca, itera sui dataset di train e validazione
Prima esegui il modello in modalità training
Poi in modalità evaluation e registra le metriche

for epoch in range(num_epochs):

    model.train()
    for step, batch in enumerate(train_dataloader):
        # Perform training step

    model.eval()
    for step, batch in enumerate(eval_dataloader):
        # Perform evaluation step

    # Log evaluation metrics

Dentro il loop di evaluation

metric = evaluate.load("glue", "mrpc")
model.eval()
for step, batch in enumerate(eval_dataloader):

    with torch.no_grad():
        outputs = model(**batch)
    predictions = outputs.logits.argmax(dim=-1)

    predictions, references = accelerator.gather_for_metrics((predictions, batch["labels"]))

    metric.add_batch(predictions=predictions, references=references)

eval_metric = metric.compute()

print(f"Eval metrics: \n{eval_metric}")

Metriche di eval: 
{'accuracy': 0.81, 'f1': 0.77}

Fai il log delle metriche dopo l’evaluation

Strumenti di tracking: notebook che registrano metriche; es. TensorBoard e MLflow
log_with: usa tutti gli strumenti di tracking
.init_trackers(): inizializza gli strumenti
.log(): registra accuracy, f1, epoch
.end_training(): termina il tracking

accelerator = Accelerator(project_dir=".",
                          log_with="all")

accelerator.init_trackers("my_project")


for epoch in range(num_epochs):
    # Training loop is here
    # Evaluation loop is here
    accelerator.log({

        "accuracy": eval_metric["accuracy"],
        "f1": eval_metric["f1"],

    }, step=epoch)


accelerator.end_training()

¡Vamos a practicar!

Efficient AI Model Training with PyTorch