Callback#

I callback di Ultralytics sono punti di accesso specializzati che vengono attivati durante fasi chiave delle operazioni del modello come addestramento, convalida, esportazione e predizione. Questi callback consentono funzionalità personalizzate in punti specifici del processo, permettendo miglioramenti e modifiche al flusso di lavoro. Ciascun callback accetta un oggetto Trainer, Validator o Predictor, a seconda del tipo di operazione. Per le proprietà dettagliate di questi oggetti, fai riferimento alla sezione di riferimento.

Per utilizzare un callback, definisci una funzione e aggiungila al modello utilizzando il metodo model.add_callback(). Ecco un esempio di restituzione di 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 tua routine di addestramento Ultralytics iniettando logica in fasi specifiche del processo di addestramento. Ultralytics YOLO offre una varietà di callback di addestramento, come on_train_start, on_train_end e on_train_batch_end, che ti consentono di aggiungere metriche personalizzate, elaborazione o logging.

Ecco come bloccare le statistiche di BatchNorm quando si bloccano i livelli con i callback:

from ultralytics import YOLO

# Add a callback to put the frozen layers in eval mode to prevent BN values from changing
def put_in_eval_mode(trainer):
    n_layers = trainer.args.freeze
    if not isinstance(n_layers, int):
        return

    for i, (name, module) in enumerate(trainer.model.named_modules()):
        if name.endswith("bn") and int(name.split(".")[1]) < n_layers:
            module.eval()
            module.track_running_stats = False

model = YOLO("yolo26n.pt")
model.add_callback("on_train_epoch_start", put_in_eval_mode)
model.train(data="coco.yaml", epochs=10)

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

L'uso dei callback durante la convalida in Ultralytics YOLO migliora la valutazione del modello consentendo elaborazione personalizzata, logging o calcolo delle metriche. Callback come on_val_start, on_val_batch_end e on_val_end forniscono punti di accesso per iniettare logica personalizzata, garantendo processi di convalida dettagliati e completi.

Ad esempio, per tracciare tutti i batch di validazione invece dei soli 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 approfondimenti sull'incorporazione dei callback nel tuo processo di convalida, consulta la Guida alla convalida.

Per collegare un callback personalizzato per la modalità di predizione in Ultralytics YOLO, definisci una funzione di callback e registrala con il processo di predizione. I callback di predizione comuni includono on_predict_start, on_predict_batch_end e on_predict_end. Questi consentono la modifica degli output di predizione e l'integrazione di funzionalità aggiuntive, come il data logging o la trasformazione dei risultati.

Ecco un esempio in cui un callback personalizzato salva le previsioni in base alla presenza di un oggetto di una particolare 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, fai riferimento alla Guida alla predizione, che include istruzioni dettagliate e opzioni di personalizzazione aggiuntive.

Ultralytics YOLO supporta varie implementazioni pratiche di callback per migliorare e personalizzare diverse fasi come addestramento, validazione e previsione. Alcuni esempi pratici includono:

• Logging di metriche personalizzate: registra metriche aggiuntive in diverse fasi, ad esempio alla fine delle epoche di addestramento o convalida.
• Aumento dei dati: implementa trasformazioni o aumenti di dati personalizzati durante la predizione o i batch di addestramento.
• Risultati intermedi: Salva risultati intermedi, come previsioni o fotogrammi, per ulteriori analisi o visualizzazioni.

Esempio: combinazione di fotogrammi con i risultati di predizione durante la predizione utilizzando 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 del callback per ulteriori opzioni ed esempi.