Rappels#

Les callbacks Ultralytics sont des points d’entrée spécialisés qui se déclenchent à des étapes clés des opérations sur les modèles, comme l’entraînement, la validation, l’exportation et la prédiction. Ils permettent d’ajouter des fonctionnalités personnalisées à des étapes précises du processus, afin d’améliorer et de modifier le flux de travail. Chaque callback accepte un objet Trainer, Validator ou Predictor, selon le type d’opération. Pour connaître en détail les propriétés de ces objets, consulte les pages de référence BaseTrainer, BaseValidator et BasePredictor.

Pour utiliser un callback, définis une fonction et ajoute-la au modèle à l’aide de la méthode model.add_callback(). Voici un exemple qui renvoie des informations supplémentaires pendant la prédiction :

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

Personnalise ta routine d’entraînement Ultralytics en injectant une logique à des étapes précises du processus d’entraînement. Ultralytics YOLO fournit différents callbacks d’entraînement, comme on_train_start, on_train_end et on_train_batch_end, qui te permettent d’ajouter des métriques, du traitement ou de la journalisation personnalisés.

Voici comment enregistrer le taux d’apprentissage de chaque groupe de paramètres de l’optimiseur à la fin de chaque époque d’entraînement :

from ultralytics import YOLO

def log_learning_rates(trainer):
    """Print the current learning rates after each training epoch."""
    print(f"Epoch {trainer.epoch + 1}: {trainer.lr}")

model = YOLO("yolo26n.pt")
model.add_callback("on_train_epoch_end", log_learning_rates)
model.train(data="coco8.yaml", epochs=3)

Pour en savoir plus sur l’utilisation efficace des callbacks d’entraînement, consulte le Guide d’entraînement.

L’utilisation de callbacks pendant la validation avec Ultralytics YOLO améliore l’évaluation du modèle en permettant d’effectuer des traitements personnalisés, de la journalisation ou le calcul de métriques. Des callbacks comme on_val_start, on_val_batch_end et on_val_end fournissent des points d’entrée où injecter une logique personnalisée, pour des processus de validation détaillés et complets.

Par exemple, voici comment tracer tous les lots de validation au lieu des trois premiers uniquement :

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("yolo26n.pt")
model.add_callback("on_val_batch_end", plot_samples)
model.val(data="coco.yaml")

Pour en savoir plus sur l’intégration de callbacks à ton processus de validation, consulte le Guide de validation.

Pour associer un callback personnalisé au mode prédiction d’Ultralytics YOLO, définis une fonction de callback et enregistre-la auprès du processus de prédiction. Parmi les callbacks de prédiction courants, on trouve on_predict_start, on_predict_batch_end et on_predict_end. Ils permettent de modifier les sorties de prédiction et d’intégrer des fonctionnalités supplémentaires, comme la journalisation des données ou la transformation des résultats.

Voici un exemple dans lequel un callback personnalisé enregistre les prédictions selon la présence ou non d’un objet d’une classe donnée :

from ultralytics import YOLO

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

for result in results_stream:
    pass

Pour une présentation plus complète de l’utilisation, consulte le Guide de prédiction, qui comprend des instructions détaillées et d’autres options de personnalisation.

Ultralytics YOLO prend en charge différentes utilisations pratiques des callbacks pour améliorer et personnaliser plusieurs phases, comme l’entraînement, la validation et la prédiction. En voici quelques exemples :

• Journalisation de métriques personnalisées : enregistre des métriques supplémentaires à différentes étapes, par exemple à la fin des époques d’entraînement ou de validation.
• Augmentation des données : mets en œuvre des transformations ou des augmentations de données personnalisées pendant les lots de prédiction ou d’entraînement.
• Résultats intermédiaires : enregistre des résultats intermédiaires, comme des prédictions ou des frames, pour les analyser ou les visualiser ultérieurement.

Exemple : associer les frames aux résultats de prédiction pendant la prédiction avec 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("yolo26n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Consulte le code source des callbacks pour découvrir d’autres options et exemples.