Richiami

Q: What are Ultralytics callbacks and how can I use them?

Ultralytics Le callback sono punti di ingresso specializzati attivati durante le fasi chiave delle operazioni del modello, come l'addestramento, la convalida, l'esportazione e la predizione. Queste callback consentono di personalizzare le funzionalità in punti specifici del processo, consentendo miglioramenti e modifiche al flusso di lavoro. Ogni callback accetta un oggetto Trainer, Validator o Predictor, a seconda del tipo di operazione. Per le proprietà dettagliate di questi oggetti, consultare la sezione Riferimento. Per usare un callback, si può definire una funzione e poi aggiungerla al modello con il metodo add_callback. Ecco un esempio di come restituire informazioni aggiuntive durante la predizione:

Q: How can I customize Ultralytics training routine using callbacks?

To customize your Ultralytics training routine using callbacks, you can inject your logic at specific stages of the training process. Ultralytics YOLO provides a variety of training callbacks such as on_train_start, on_train_end, and on_train_batch_end. These allow you to add custom metrics, processing, or logging. Here's an example of how to freeze BatchNorm statistics when freezing layers with callbacks: Refer to the Training Guide for more details on how to effectively use training callbacks.

Q: Why should I use callbacks during validation in Ultralytics YOLO?

Using callbacks during validation in Ultralytics YOLO can enhance model evaluation by allowing custom processing, logging, or metrics calculation. Callbacks such as on_val_start, on_val_batch_end, and on_val_end provide entry points to inject custom logic, ensuring detailed and comprehensive validation processes. For instance, you might want to plot all the validation batches, instead of just the first 3. Here's how you can do that: Check out the Validation Guide for further insights on incorporating callbacks into your validation process.

Q: How do I attach a custom callback for the prediction mode in Ultralytics YOLO?

To attach a custom callback for the prediction mode in Ultralytics YOLO, you define a callback function and register it with the prediction process. Common prediction callbacks include on_predict_start, on_predict_batch_end, and on_predict_end. These allow for modification of prediction outputs and integration of additional functionalities like data logging or result transformation. Here is an example where a custom callback is used to save predictions based on whether an object of a particular class is present: For more comprehensive usage, refer to the Prediction Guide which includes detailed instructions and additional customization options.

Q: What are some practical examples of using callbacks in Ultralytics YOLO?

Ultralytics YOLO supporta varie implementazioni pratiche di callback per migliorare e personalizzare diverse fasi come l'addestramento, la validazione e la predizione. Alcuni esempi pratici includono: Esempio: Combinazione di fotogrammi con i risultati della predizione durante la predizione utilizzando on_predict_batch_end: Esplorate il Riferimento completo alle callback per trovare altre opzioni ed esempi.

Richiami

Ultralytics supporta i callback come punti di ingresso in fasi strategiche delle modalità train, val, export e predict. Ogni callback accetta un elemento Trainer, Validator, o Predictor a seconda del tipo di operazione. Tutte le proprietà di questi oggetti si trovano nella sezione Reference della documentazione.

Guarda: Padroneggiare Ultralytics YOLO : Callback

Esempi

Restituzione di informazioni aggiuntive con Prediction

In questo esempio, vogliamo restituire il fotogramma originale con ogni oggetto risultato. Ecco come fare

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

    # 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

Tutti i callback

Ecco tutti i callback supportati. Vedere il codice sorgente delle callback per ulteriori dettagli.

Richiami dell'allenatore

Richiamo	Descrizione
`on_pretrain_routine_start`	Attivato all'inizio della routine di pre-allenamento
`on_pretrain_routine_end`	Attivato al termine della routine di pre-allenamento
`on_train_start`	Attivato all'inizio della formazione
`on_train_epoch_start`	Attivato all'inizio di ogni epoca di addestramento
`on_train_batch_start`	Attivato all'inizio di ogni batch di addestramento
`optimizer_step`	Attivato durante la fase di ottimizzazione
`on_before_zero_grad`	Attivato prima dell'azzeramento dei gradienti
`on_train_batch_end`	Attivato alla fine di ogni batch di formazione
`on_train_epoch_end`	Attivato alla fine di ogni epoca di addestramento
`on_fit_epoch_end`	Attivato alla fine di ogni epoca di fit
`on_model_save`	Attivato quando il modello viene salvato
`on_train_end`	Attivato al termine del processo di formazione
`on_params_update`	Attivato quando i parametri del modello vengono aggiornati
`teardown`	Attivato quando il processo di formazione viene ripulito

Callback del validatore

Richiamo	Descrizione
`on_val_start`	Attivato quando inizia la convalida
`on_val_batch_start`	Attivato all'inizio di ogni lotto di convalida
`on_val_batch_end`	Attivato alla fine di ogni lotto di convalida
`on_val_end`	Attivato al termine della convalida

Richiami al predittore

Richiamo	Descrizione
`on_predict_start`	Attivato all'avvio del processo di previsione
`on_predict_batch_start`	Attivato all'inizio di ogni lotto di predizione
`on_predict_postprocess_end`	Attivato al termine della postelaborazione della previsione
`on_predict_batch_end`	Attivato alla fine di ogni lotto di previsione
`on_predict_end`	Attivato quando il processo di previsione termina

Callback dell'esportatore

Richiamo	Descrizione
`on_export_start`	Attivato all'avvio del processo di esportazione
`on_export_end`	Attivato al termine del processo di esportazione

FAQ

Cosa sono i callback di Ultralytics e come si possono usare?

Ultralytics callback sono punti di ingresso specializzati attivati durante le fasi chiave delle operazioni del modello, come l'addestramento, la convalida, l'esportazione e la predizione. Questi callback permettono di personalizzare le funzionalità in punti specifici del processo, consentendo miglioramenti e modifiche al flusso di lavoro. Ogni callback accetta un elemento Trainer, Validator, o Predictor a seconda del tipo di operazione. Per le proprietà dettagliate di questi oggetti, fare riferimento alla sezione Sezione di riferimento.

Per usare un callback, si può definire una funzione e poi aggiungerla al modello con l'opzione add_callback metodo. 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("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 allenamento di Ultralytics utilizzando i callback?

Per personalizzare la routine di allenamento di Ultralytics utilizzando i callback, è possibile iniettare la propria logica in fasi specifiche del processo di allenamento. Ultralytics YOLO fornisce una serie di callback di allenamento, come ad esempio on_train_start, on_train_end, e on_train_batch_end. Consentono di aggiungere metriche, elaborazioni o registrazioni personalizzate.

Here's an example of how to freeze BatchNorm statistics when freezing layers with callbacks:

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 ulteriori dettagli su come utilizzare efficacemente i richiami di formazione, consultare la Guida alla formazione.

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

Utilizzo callback durante la validazione in Ultralytics YOLO possono migliorare 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 iniettare logica personalizzata, garantendo processi di validazione dettagliati e completi.

For instance, you might want to plot all the validation batches, instead of just the first 3. Here's how you can do that:

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")

Consultate la Guida alla convalida per ulteriori approfondimenti sull'incorporazione dei callback nel vostro processo di convalida.

Come posso allegare un callback personalizzato per la modalità di previsione in Ultralytics YOLO ?

Per allegare un callback personalizzato per il metodo modalità di previsione in Ultralytics YOLO , si definisce una funzione di callback e la si registra con il processo di predizione. I callback di predizione più comuni sono on_predict_start, on_predict_batch_end, e on_predict_end. Questi consentono di modificare i risultati della previsione e di integrare funzionalità aggiuntive come la registrazione dei dati o la trasformazione dei risultati.

Here is an example where a custom callback is used to save predictions based on whether an object of a particular class is present:

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, consultare la Guida alla previsione, che include istruzioni dettagliate e ulteriori opzioni di personalizzazione.

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

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

Registrazione di metriche personalizzate: Registrare metriche aggiuntive in fasi diverse, come la fine dell'addestramento o delle epoche di convalida.
Aumento dei dati: Implementare trasformazioni o incrementi dei dati personalizzati durante i lotti di previsione o di addestramento.
Risultati intermedi: Salvare i risultati intermedi, come le previsioni o i fotogrammi, per ulteriori analisi o visualizzazioni.

Esempio: Combinazione di fotogrammi con i risultati della predizione durante la predizione con l'uso di 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