Richiami

Richiami

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

Guarda: Padroneggiare Ultralytics YOLOv8 : Callback

Esempi

Restituzione di informazioni aggiuntive con Prediction

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

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("yolov8n.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. Vedi il codice sorgente delle callback per ulteriori dettagli.

Richiami dell'allenatore

Callback del validatore

Callback del predittore

Callback dell'esportatore

DOMANDE FREQUENTI

Cosa sono i callback di Ultralytics e come posso utilizzarli?

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

Per utilizzare un callback, puoi 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("yolov8n.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, puoi iniettare la tua logica in fasi specifiche del processo di allenamento. Ultralytics YOLO fornisce una serie di callback per l'allenamento, come ad esempio on_train_start, on_train_end, e on_train_batch_end. Questi ti permettono di aggiungere metriche, elaborazioni o registrazioni personalizzate.

Ecco un esempio di come registrare ulteriori metriche 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("yolov8n.pt")
model.add_callback("on_train_epoch_end", on_train_epoch_end)
model.train(data="coco.yaml", epochs=10)

Per maggiori dettagli su come utilizzare efficacemente i richiami di formazione, consulta la Guida alla formazione.

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

Utilizzando callback durante la convalida 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, potresti 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("yolov8n.pt")
model.add_callback("on_val_end", on_val_end)
model.val(data="coco.yaml")

Dai un'occhiata alla Guida alla convalida per ulteriori approfondimenti sull'integrazione delle callback nel tuo processo di convalida.

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

Per allegare un callback personalizzato per l'opzione modalità di previsione in Ultralytics YOLO , definisci una funzione di callback e registrala con il processo di predizione. Le callback comuni per la predizione includono on_predict_start, on_predict_batch_end, e on_predict_end. Questi permettono di modificare i risultati delle previsioni 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("yolov8n.pt")
model.add_callback("on_predict_end", on_predict_end)
results = model.predict(source="image.jpg")

Per un utilizzo più completo, consulta 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 la formazione, la convalida e la previsione. Alcuni esempi pratici includono:

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

Esempio: Combinare i fotogrammi con i risultati della 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("yolov8n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Esplora il Riferimento completo alle Callback per trovare altre opzioni ed esempi.

Commenti