Epoch

Un'epoca è un passaggio completo di un modello di machine learning sull'intero dataset di addestramento. Durante un'epoca, ogni esempio di addestramento contribuisce una sola volta all'aggiornamento dei pesi del modello. I modelli di deep learning raramente imparano abbastanza con un solo passaggio, quindi l'addestramento dura molte epoche e, in genere, l'errore sui dati di addestramento diminuisce a ogni epoca mentre la rete perfeziona le sue previsioni.

Epoca, batch e iterazione a confronto#

Tre termini descrivono la struttura di un'esecuzione di addestramento e ciascuno è contenuto nel precedente:

• Epoca: un passaggio completo sul dataset di addestramento.
• Batch: il gruppo di esempi elaborati insieme in un singolo passaggio. Raramente i dataset entrano tutti in una volta nella memoria della GPU, quindi ogni epoca viene suddivisa in batch, di solito dopo aver mescolato i dati.
• Iterazione: un aggiornamento dei pesi, eseguito dopo aver calcolato la funzione di perdita su un batch e aver propagato i gradienti all'indietro tramite la retropropagazione. «Step» è un sinonimo.

Il numero di iterazioni per epoca è pari alla dimensione del dataset divisa per la dimensione del batch, arrotondando per eccesso. Un dataset di 1.000 immagini con batch di 100 richiede 10 iterazioni per epoca, quindi 50 epoche comportano 500 aggiornamenti dei pesi. In PyTorch, questa struttura si presenta come due cicli annidati: un ciclo esterno sulle epoche e uno interno sui batch gestiti da DataLoader.

import torch
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(0)

# 1,000 noisy samples of the line y = 3x + 2, served in shuffled batches of 100
x = torch.rand(1000, 1)
y = 3 * x + 2 + 0.1 * torch.randn(1000, 1)
loader = DataLoader(TensorDataset(x, y), batch_size=100, shuffle=True)

model = torch.nn.Linear(1, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(5):  # one epoch = one full pass over all 1,000 samples
    for xb, yb in loader:  # 1,000 / 100 = 10 iterations per epoch
        loss = torch.nn.functional.mse_loss(model(xb), yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch + 1}: {len(loader)} iterations, last batch loss {loss.item():.4f}")

Ogni epoca comprende 10 iterazioni e la perdita sull'ultimo batch scende da 0.1096 dopo la prima epoca a 0.0088 dopo la quinta, mentre il modello converge sulla retta reale. Quando l'addestramento usa l'aumento dei dati, ogni epoca presenta una versione trasformata di recente di ogni immagine; le epoche successive aggiungono quindi varietà anziché ripetizioni esatte.

Scegliere il numero di epoche#

Il numero di epoche è una delle impostazioni principali nell'ottimizzazione degli iperparametri. Se le epoche sono troppo poche, il modello non apprende abbastanza e va in underfitting, con errori elevati sia sui dati di addestramento sia sui dati di convalida. Se sono troppe, il modello tende all'overfitting: la perdita di addestramento continua a diminuire, mentre il punteggio di convalida si arresta o cala perché il modello ha iniziato a memorizzare gli esempi di addestramento. Il numero corretto dipende dalle dimensioni del dataset e del modello, dalla pianificazione del tasso di apprendimento e dall'eventuale uso di pesi preaddestrati tramite l'apprendimento per trasferimento. Anche la scala cambia il risultato: i piccoli dataset di visione spesso richiedono centinaia di epoche, mentre i modelli linguistici di grandi dimensioni analizzano gran parte dei dati meno di una volta; GPT-3 ha completato 0,44 epoche sui dati Common Crawl filtrati.

L'arresto anticipato automatizza la scelta. Il modello viene valutato sui dati di convalida dopo ogni epoca, viene conservato il checkpoint migliore e l'addestramento termina quando il punteggio di convalida non migliora per un numero prestabilito di epoche, detto pazienza.

Pianificazioni di addestramento basate sulle epoche#

Oltre al punto di arresto, molte impostazioni di addestramento cambiano secondo una pianificazione basata sulle epoche, come il riscaldamento e il decadimento del tasso di apprendimento o l'intensità dell'aumento dei dati. Nell'addestramento Ultralytics YOLO, epochs e patience hanno entrambi un valore predefinito di 100, il tasso di apprendimento viene aumentato gradualmente nelle prime 3 epoche e l'aumento dei dati mosaic viene disattivato nelle ultime 10 epoche (close_mosaic=10), così il modello conclude l'addestramento su immagini simili agli input reali. La ricetta di addestramento di YOLO26 mostra quanto il numero vari con le dimensioni del modello: dopo 150 epoche di preaddestramento su Objects365, la messa a punto di COCO è durata 245 epoche per YOLO26n e 40 per YOLO26x.

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n.pt")

# Addestra per 50 epoche: 50 passaggi completi sulle immagini di addestramento di COCO8
results = model.train(data="coco8.yaml", epochs=50, imgsz=640)

Durante questa esecuzione, il trainer convalida il modello YOLO26 dopo ogni epoca, sovrascrive ogni volta last.pt e salva best.pt quando la fitness di convalida, pari a mAP_50-95 per il rilevamento, raggiunge un nuovo massimo.