Callbacks

Le framework Ultralytics prend en charge les callbacks, qui servent de points d'entrée à des étapes stratégiques pendant le train, val, export, et predict modes. Chaque callback accepte un Trainer, Validator, ou Predictor objet, selon le type d'opération. Toutes les propriétés de ces objets sont détaillées dans le Section de référence de la documentation.

Regarder : Comment utiliser les Callbacks Ultralytics | Prévoir, entraîner, valider et exporter les Callbacks | Ultralytics YOLO 🚀

Exemples

Retour d'informations supplémentaires avec la prédiction

Dans cet exemple, nous montrons comment renvoyer la trame originale avec chaque objet de résultat :

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

Accéder aux métriques du modèle en utilisant le on_model_save callback

Cet exemple montre comment récupérer les détails de l'entraînement, tels que le meilleur score de fitness, la perte totale et d'autres métriques après l'enregistrement d'un point de contrôle à l'aide de on_model_save callback.

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.pt")


def print_checkpoint_metrics(trainer):
    """Print trainer metrics and loss details after each checkpoint is saved."""
    print(
        f"Model details\n"
        f"Best fitness: {trainer.best_fitness}, "
        f"Loss names: {trainer.loss_names}, "  # List of loss names
        f"Metrics: {trainer.metrics}, "
        f"Total loss: {trainer.tloss}"  # Total loss value
    )


if __name__ == "__main__":
    # Add on_model_save callback.
    model.add_callback("on_model_save", print_checkpoint_metrics)

    # Run model training on custom dataset.
    results = model.train(data="coco8.yaml", epochs=3)

Tous les rappels

Vous trouverez ci-dessous tous les rappels pris en charge. Pour plus de détails, consultez le code source des rappels.

Callbacks de l'entraîneur

Callbacks du validateur

Callbacks du prédicteur

Callbacks de l'exportateur

FAQ

Que sont les callbacks Ultralytics et comment puis-je les utiliser ?

Les callbacks Ultralytics sont des points d'entrée spécialisés qui sont déclenchés lors des étapes clés des opérations du modèle telles que l'entraînement, la validation, l'exportation et la prédiction. Ces callbacks permettent une fonctionnalité personnalisée à des points spécifiques du processus, permettant des améliorations et des modifications du workflow. Chaque callback accepte un Trainer, Validator, ou Predictor objet, selon le type d'opération. Pour les propriétés détaillées de ces objets, consultez la Section de référence.

Pour utiliser un callback, définissez une fonction et ajoutez-la au modèle en utilisant le model.add_callback() méthode. Voici un exemple de retour d'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("yolo11n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Comment puis-je personnaliser la routine d'entraînement Ultralytics en utilisant des callbacks ?

Personnalisez votre routine d'entraînement Ultralytics en injectant de la logique à des étapes spécifiques du processus d'entraînement. Ultralytics YOLO fournit une variété de callbacks d'entraînement, tels que on_train_start, on_train_end, et on_train_batch_end, qui vous permettent d'ajouter des métriques personnalisées, un traitement ou une journalisation.

Voici comment figer les statistiques BatchNorm lors du gel de calques avec des rappels :

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)

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

Pourquoi devrais-je utiliser des callbacks pendant la validation dans Ultralytics YOLO ?

L'utilisation de callbacks pendant la validation dans Ultralytics YOLO améliore l'évaluation du modèle en permettant un traitement personnalisé, l'enregistrement ou le calcul de métriques. Les callbacks tels que on_val_start, on_val_batch_end, et on_val_end fournissent des points d'entrée pour injecter une logique personnalisée, assurant des processus de validation détaillés et complets.

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

Pour plus d'informations sur l'intégration de callbacks dans votre processus de validation, consultez le Guide de Validation.

Comment puis-je attacher un callback personnalisé pour le mode de prédiction dans Ultralytics YOLO ?

Pour attacher un rappel personnalisé pour le mode de prédiction dans Ultralytics YOLO, définissez une fonction de rappel et enregistrez-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 la modification des sorties de prédiction et l'intégration de fonctionnalités supplémentaires, comme la journalisation des données ou la transformation des résultats.

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

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

Pour une utilisation plus complète, consultez le Guide de prédiction, qui comprend des instructions détaillées et des options de personnalisation supplémentaires.

Quels sont quelques exemples pratiques d'utilisation de callbacks dans Ultralytics YOLO ?

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

• Journalisation des métriques personnalisées : Enregistrez des métriques supplémentaires à différentes étapes, par exemple à la fin de l’entraînement ou des époques de validation.
• Augmentation des données : implémentez des transformations ou augmentations de données personnalisées pendant les lots de prédiction ou d’entraînement.
• Résultats intermédiaires : Enregistrez les résultats intermédiaires, tels que les prédictions ou les trames, pour une analyse ou une visualisation plus approfondie.

Exemple : combiner des images avec les résultats de prédiction pendant la prédiction en utilisant 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

Explorez le code source du callback pour plus d'options et d'exemples.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 3 mois

Commentaires