Callbacks#

Les rappels Ultralytics sont des points d'entrée spécialisés qui sont déclenchés lors d'étapes clés des opérations du modèle telles que l'entraînement, la validation, l'exportation et la prédiction. Ces rappels permettent d'ajouter des fonctionnalités personnalisées à des moments précis du processus, ce qui permet d'améliorer et de modifier le flux de travail. Chaque rappel accepte un objet Trainer, Validator ou Predictor, selon le type d'opération. Pour connaître les propriétés détaillées de ces objets, consulte la section Référence.

Pour utiliser un rappel, définis une fonction et ajoute-la au modèle à l'aide de la méthode model.add_callback(). Voici un exemple de renvoi d'informations supplémentaires lors de 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 de la logique à des étapes spécifiques du processus d'entraînement. Ultralytics YOLO propose une variété de rappels d'entraînement, tels que on_train_start, on_train_end et on_train_batch_end, qui te permettent d'ajouter des métriques, un traitement ou un journal personnalisés.

Voici comment figer les statistiques BatchNorm lors du gel des couches avec des 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("yolo26n.pt")
model.add_callback("on_train_epoch_start", put_in_eval_mode)
model.train(data="coco.yaml", epochs=10)

Pour plus de détails sur l'utilisation efficace des rappels d'entraînement, consulte le Guide d'entraînement.

L'utilisation de rappels lors de la validation dans Ultralytics YOLO améliore l'évaluation du modèle en permettant un traitement personnalisé, la journalisation ou le calcul de métriques. Des rappels comme on_val_start, on_val_batch_end et on_val_end fournissent des points d'entrée pour injecter une logique personnalisée, garantissant des processus de validation détaillés et complets.

Par exemple, pour tracer tous les lots de validation au lieu de seulement les trois premiers :

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 plus d'informations sur l'intégration de rappels dans ton processus de validation, consulte le Guide de validation.

Pour associer un rappel personnalisé au mode de prédiction dans Ultralytics YOLO, définis une fonction de rappel et enregistre-la auprès du processus de prédiction. Les rappels de prédiction courants incluent on_predict_start, on_predict_batch_end et on_predict_end. Ceux-ci permettent de modifier les sorties de prédiction et d'intégrer des fonctionnalités supplémentaires, telles que la journalisation des données ou la transformation des résultats.

Voici un exemple où un callback personnalisé enregistre les prédictions en fonction de la présence ou non d'un objet d'une classe particulière :

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 utilisation plus complète, consulte le Guide de prédiction, qui comprend des instructions détaillées et des options de personnalisation supplémentaires.

Ultralytics YOLO prend en charge diverses implémentations pratiques de callbacks pour améliorer et personnaliser différentes phases comme l'entraînement, la validation et la prédiction. Quelques exemples pratiques incluent :

• Journalisation des métriques personnalisées : Enregistre des métriques supplémentaires à différentes étapes, comme à la fin des époques d'entraînement ou de validation.
• Augmentation des données : Implémente des transformations ou des augmentations de données personnalisées pendant la prédiction ou les lots d'entraînement.
• Résultats intermédiaires : Enregistre des résultats intermédiaires, tels que des prédictions ou des images, pour une analyse ou une visualisation ultérieure.

Exemple : Combinaison de cadres avec les résultats de prédiction lors de la prédiction à l'aide de 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

Explore le code source des rappels pour plus d'options et d'exemples.