Callback#

I callback di Ultralytics sono punti di ingresso specializzati che si attivano nelle fasi chiave delle operazioni sui modelli, come addestramento, validazione, esportazione e predizione. Questi callback consentono di implementare funzionalità personalizzate in punti specifici del processo, permettendo di migliorare e modificare il flusso di lavoro. Ogni callback accetta un oggetto Trainer, Validator oppure Predictor, a seconda del tipo di operazione. Per informazioni dettagliate sulle proprietà di questi oggetti, consulta le pagine di riferimento BaseTrainer, BaseValidator e BasePredictor.

Per usare un callback, definisci una funzione e aggiungila al modello usando il metodo model.add_callback(). Ecco un esempio di come restituire informazioni aggiuntive durante la predizione:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
    _, image, _ = predictor.batch
    image = image if isinstance(image, list) else [image]
    predictor.results = zip(predictor.results, image)

model = YOLO("yolo26n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Personalizza la procedura di addestramento di Ultralytics inserendo la tua logica in fasi specifiche del processo di addestramento. Ultralytics YOLO offre diversi callback di addestramento, come on_train_start, on_train_end e on_train_batch_end, che ti consentono di aggiungere metriche, elaborazioni o registrazioni personalizzate.

Ecco come registrare il tasso di apprendimento di ogni gruppo di parametri dell'ottimizzatore al termine di ogni epoca di addestramento:

from ultralytics import YOLO

def log_learning_rates(trainer):
    """Print the current learning rates after each training epoch."""
    print(f"Epoch {trainer.epoch + 1}: {trainer.lr}")

model = YOLO("yolo26n.pt")
model.add_callback("on_train_epoch_end", log_learning_rates)
model.train(data="coco8.yaml", epochs=3)

Per maggiori dettagli su come usare efficacemente i callback di addestramento, consulta la Guida all'addestramento.

L'uso dei callback durante la validazione in Ultralytics YOLO migliora la valutazione del modello consentendo di eseguire elaborazioni personalizzate, registrazioni o calcoli delle metriche. Callback come on_val_start, on_val_batch_end e on_val_end forniscono punti di ingresso per inserire logica personalizzata, garantendo processi di validazione dettagliati e completi.

Ad esempio, per tracciare tutti i batch di validazione anziché solo i primi tre:

import inspect

from ultralytics import YOLO

def plot_samples(validator):
    frame = inspect.currentframe().f_back.f_back
    v = frame.f_locals
    validator.plot_val_samples(v["batch"], v["batch_i"])
    validator.plot_predictions(v["batch"], v["preds"], v["batch_i"])

model = YOLO("yolo26n.pt")
model.add_callback("on_val_batch_end", plot_samples)
model.val(data="coco.yaml")

Per ulteriori informazioni su come integrare i callback nel processo di validazione, consulta la Guida alla validazione.

Per associare un callback personalizzato alla modalità di predizione in Ultralytics YOLO, definisci una funzione callback e registrala nel processo di predizione. Tra i callback di predizione più comuni ci sono on_predict_start, on_predict_batch_end e on_predict_end. Questi consentono di modificare gli output della predizione e integrare funzionalità aggiuntive, come la registrazione dei dati o la trasformazione dei risultati.

Ecco un esempio in cui un callback personalizzato salva le predizioni in base alla presenza di un oggetto appartenente a una determinata classe:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

class_id = 2

def save_on_object(predictor):
    r = predictor.results[0]
    if class_id in r.boxes.cls:
        predictor.args.save = True
    else:
        predictor.args.save = False

model.add_callback("on_predict_postprocess_end", save_on_object)
results_stream = model("pedestrians.mp4", stream=True, save=True)

for result in results_stream:
    pass

Per un utilizzo più completo, consulta la Guida alla predizione, che include istruzioni dettagliate e ulteriori opzioni di personalizzazione.

Ultralytics YOLO supporta diverse applicazioni pratiche dei callback per migliorare e personalizzare fasi diverse, come l'addestramento, la validazione e la predizione. Ecco alcuni esempi pratici:

• Registrazione di metriche personalizzate: registra metriche aggiuntive in diverse fasi, ad esempio al termine delle epoche di addestramento o validazione.
• Aumento dei dati: implementa trasformazioni o aumenti dei dati personalizzati durante la predizione o i batch di addestramento.
• Risultati intermedi: salva risultati intermedi, come predizioni o frame, per ulteriori analisi o visualizzazioni.

Esempio: combinare i frame con i risultati della predizione durante la predizione usando on_predict_batch_end:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Combine prediction results with frames."""
    _, image, _ = predictor.batch
    image = image if isinstance(image, list) else [image]
    predictor.results = zip(predictor.results, image)

model = YOLO("yolo26n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Esplora il codice sorgente dei callback per altre opzioni ed esempi.