Richiami

Ultralytics framework Ultralytics supporta le callback, che servono come punti di ingresso in fasi strategiche del processo. train, val, export, e predict modalità. Ogni callback accetta un elemento Trainer, Validator, o Predictor a seconda del tipo di operazione. Tutte le proprietà di questi oggetti sono dettagliate nella sezione Sezione di riferimento della documentazione.

Guarda: Padroneggiare Ultralytics YOLO : Callback

Esempi

Restituzione di informazioni aggiuntive con la previsione

In questo esempio, dimostriamo come restituire il fotogramma originale insieme a ciascun 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

Tutti i callback

Di seguito sono riportati tutti i callback supportati. Per maggiori dettagli, consultare il codice sorgente delle callback.

Richiami dell'allenatore

Callback del validatore

Richiami al predittore

Callback dell'esportatore

FAQ

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

Le callback di Ultralytics sono punti di ingresso specializzati che vengono attivati durante le fasi chiave delle operazioni del modello, come l'addestramento, la convalida, l'esportazione e la predizione. Queste callback abilitano funzionalità personalizzate in punti specifici del processo, consentendo miglioramenti e modifiche al flusso di lavoro. Ogni callback accetta un parametro 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, definire una funzione e aggiungerla al modello usando il metodo model.add_callback() metodo. 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("yolo11n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Come si può personalizzare la routine di allenamento di Ultralytics utilizzando i callback?

Personalizzate la vostra routine di allenamento Ultralytics iniettando la logica in fasi specifiche del processo di allenamento. Ultralytics YOLO offre una serie di callback per l'allenamento, come ad esempio on_train_start, on_train_end, e on_train_batch_endche consentono di aggiungere metriche, elaborazioni o registrazioni personalizzate.

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

Per ulteriori dettagli sull'uso efficace dei callback di formazione, consultare la Guida alla formazione.

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

L'uso di callback durante la convalida 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 iniettare logica personalizzata, garantendo processi di validazione dettagliati e completi.

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

Per ulteriori informazioni sull'integrazione delle callback nel processo di validazione, consultare la Guida alla validazione.

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

Per collegare un callback personalizzato per la modalità di predizione in Ultralytics YOLO, definire una funzione di callback e registrarla 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.

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("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 diverse fasi, ad esempio al termine delle epoche di addestramento o 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

Esplorate il codice sorgente del callback per ulteriori opzioni ed esempi.

📅C reato 1 anno fa ✏️ Aggiornato 9 giorni fa

Commenti