Richiami

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

Callback del validatore

Richiami al predittore

Callback dell'esportatore

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.

Ecco un esempio di come registrare metriche aggiuntive alla fine di ogni periodo di allenamento:

from ultralytics import YOLO


def on_train_epoch_end(trainer):
    """Custom logic for additional metrics logging at the end of each training epoch."""
    additional_metric = compute_additional_metric(trainer)
    trainer.log({"additional_metric": additional_metric})


model = YOLO("yolo11n.pt")
model.add_callback("on_train_epoch_end", on_train_epoch_end)
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.

Ad esempio, si potrebbe voler registrare ulteriori metriche di convalida o salvare i risultati intermedi per ulteriori analisi. Ecco un esempio di come registrare metriche personalizzate al termine della convalida:

from ultralytics import YOLO


def on_val_end(validator):
    """Log custom metrics at end of validation."""
    custom_metric = compute_custom_metric(validator)
    validator.log({"custom_metric": custom_metric})


model = YOLO("yolo11n.pt")
model.add_callback("on_val_end", on_val_end)
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.

Ecco un esempio in cui viene utilizzato un callback personalizzato per registrare le previsioni:

from ultralytics import YOLO


def on_predict_end(predictor):
    """Log predictions at the end of prediction."""
    for result in predictor.results:
        log_prediction(result)


model = YOLO("yolo11n.pt")
model.add_callback("on_predict_end", on_predict_end)
results = model.predict(source="image.jpg")

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:

1. Registrazione di metriche personalizzate: Registrare metriche aggiuntive in fasi diverse, come la fine dell'addestramento o delle epoche di convalida.
2. Aumento dei dati: Implementare trasformazioni o incrementi dei dati personalizzati durante i lotti di previsione o di addestramento.
3. 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 Riferimento completo per i callback per trovare altre opzioni ed esempi.

📅C reato 1 anno fa ✏️ Aggiornato 1 mese fa

Commenti