Callback

Il framework Ultralytics supporta i callback, che fungono da punti di ingresso in fasi strategiche durante il train, val, export, e predict modalità. Ogni callback accetta un Trainer, Validator, oppure Predictor object, a seconda del tipo di operazione. Tutte le proprietà di questi oggetti sono descritte in dettaglio nella Sezione di riferimento della documentazione.

Guarda: Come utilizzare i Callback di Ultralytics | Callback di previsione, addestramento, convalida ed esportazione | Ultralytics YOLO🚀

Esempi

Restituzione di informazioni aggiuntive con la previsione

In questo esempio, dimostriamo come restituire il frame originale insieme a ogni oggetto risultato:

from ultralytics import YOLO


def on_predict_batch_end(predictor):
    """Combine prediction results with corresponding frames."""
    _, image, _, _ = predictor.batch

    # Ensure that image is a list
    image = image if isinstance(image, list) else [image]

    # Combine the prediction results with the corresponding frames
    predictor.results = zip(predictor.results, image)


# Create a YOLO model instance
model = YOLO("yolo11n.pt")

# Add the custom callback to the model
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Iterate through the results and frames
for result, frame in model.predict():  # or model.track()
    pass

Accedi alle metriche del modello utilizzando il on_model_save callback

Questo esempio mostra come recuperare i dettagli dell'addestramento, come il punteggio best_fitness, la total_loss e altre metriche dopo che un checkpoint è stato salvato utilizzando il on_model_save callback.

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.pt")


def print_checkpoint_metrics(trainer):
    """Print trainer metrics and loss details after each checkpoint is saved."""
    print(
        f"Model details\n"
        f"Best fitness: {trainer.best_fitness}, "
        f"Loss names: {trainer.loss_names}, "  # List of loss names
        f"Metrics: {trainer.metrics}, "
        f"Total loss: {trainer.tloss}"  # Total loss value
    )


if __name__ == "__main__":
    # Add on_model_save callback.
    model.add_callback("on_model_save", print_checkpoint_metrics)

    # Run model training on custom dataset.
    results = model.train(data="coco8.yaml", epochs=3)

Tutti i Callback

Di seguito sono elencate tutte le callback supportate. Per maggiori dettagli, consultare il codice sorgente delle callback.

Callback del Trainer

Callback del Validator

Callback del Predictor

Callback dell'Exporter

FAQ

Cosa sono le callback di Ultralytics e come posso utilizzarle?

I callback di Ultralytics sono punti di ingresso specializzati che vengono attivati durante le fasi chiave delle operazioni del modello, come training, convalida, esportazione e previsione. Questi callback consentono funzionalità personalizzate in punti specifici del processo, consentendo miglioramenti e modifiche al flusso di lavoro. Ogni callback accetta un Trainer, Validator, oppure Predictor oggetto, a seconda del tipo di operazione. Per le proprietà dettagliate di questi oggetti, fare riferimento alla sezione Sezione di riferimento.

Per utilizzare una callback, definisci una funzione e aggiungila al modello usando il model.add_callback() metodo. Ecco un esempio di restituzione di informazioni aggiuntive durante la previsione:

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("yolo11n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Come posso personalizzare la routine di training di Ultralytics utilizzando i callback?

Personalizza la tua routine di training Ultralytics iniettando logica in fasi specifiche del processo di training. Ultralytics YOLO fornisce una varietà di callback di training, come on_train_start, on_train_end, e on_train_batch_end, che consentono di aggiungere metriche personalizzate, elaborazione o registrazione.

Ecco come bloccare le statistiche BatchNorm quando si bloccano i livelli con le 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("yolo11n.pt")
model.add_callback("on_train_epoch_start", put_in_eval_mode)
model.train(data="coco.yaml", epochs=10)

Per maggiori dettagli sull'utilizzo efficace dei callback di addestramento, consultare la Guida all'addestramento.

Perché dovrei usare i callback durante la validazione in Ultralytics YOLO?

L'utilizzo di callback durante la validazione in Ultralytics YOLO migliora la valutazione del modello consentendo l'elaborazione personalizzata, la registrazione o il calcolo 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 convalida dettagliati e completi.

Ad esempio, per tracciare tutti i batch di convalida invece solo dei 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("yolo11n.pt")
model.add_callback("on_val_batch_end", plot_samples)
model.val(data="coco.yaml")

Per maggiori informazioni sull'integrazione dei callback nel processo di convalida, consultare la Guida alla convalida.

Come posso collegare un callback personalizzato per la modalità di prediction in Ultralytics YOLO?

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

Ecco un esempio in cui una callback personalizzata salva le predizioni in base alla presenza di un oggetto di una particolare classe:

from ultralytics import YOLO

model = YOLO("yolo11n.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 = model("pedestrians.mp4", stream=True, save=True)

for results in results:
    pass

Per un utilizzo più completo, fare riferimento alla Guida alla previsione, che include istruzioni dettagliate e opzioni di personalizzazione aggiuntive.

Quali sono alcuni esempi pratici di utilizzo dei callback in Ultralytics YOLO?

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

• Registrazione di metriche personalizzate: Registra metriche aggiuntive in diverse fasi, come alla fine del training o delle epoche di convalida.
• Aumento dei dati: implementa trasformazioni o aumenti di dati personalizzati durante i batch di previsione o addestramento.
• Risultati intermedi: Salva i risultati intermedi, come previsioni o frame, per ulteriori analisi o visualizzazioni.

Esempio: combinazione di frame con risultati di previsione durante la previsione 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("yolo11n.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 ulteriori opzioni ed esempi.

📅 Creato 1 anno fa ✏️ Aggiornato 3 mesi fa

Commenti