Rappels

Rappels

Ultralytics prend en charge les rappels comme points d'entrée dans les étapes stratégiques des modes train, val, export et predict. Chaque rappel accepte un Trainer, Validatorou Predictor en fonction du type d'opération. Toutes les propriétés de ces objets se trouvent dans la section Référence de la documentation.

Regarde : Mastering Ultralytics YOLOv8 : Rappels

Exemples

Renvoyer des informations supplémentaires avec la prédiction

Dans cet exemple, nous voulons renvoyer l'image originale avec chaque objet de résultat. Voici comment procéder

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

Tous les rappels

Voici tous les rappels pris en charge. Voir le code source des rappels pour plus de détails.

Rappels de formateurs

Rappels du validateur

Rappels de prédicteurs

Rappels de l'exportateur

FAQ

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

Ultralytics rappels sont des points d'entrée spécialisés déclenchés pendant les étapes clés des opérations du modèle comme l'entraînement, la validation, l'exportation et la prédiction. Ces rappels permettent d'obtenir 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 Trainer, Validatorou Predictor selon le type d'opération. Pour connaître les propriétés détaillées de ces objets, reporte-toi à la rubrique Section de référence.

Pour utiliser un rappel, tu peux définir une fonction et l'ajouter au modèle avec la fonction add_callback méthode. Voici un exemple de la façon de renvoyer 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("yolov8n.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 de Ultralytics à l'aide de rappels ?

Pour personnaliser ta routine d'entraînement Ultralytics à l'aide de rappels, tu peux injecter ta logique à des étapes spécifiques du processus d'entraînement. Ultralytics YOLO fournit une variété de rappels d'entraînement tels que on_train_start, on_train_endet on_train_batch_end. Elles te permettent d'ajouter des mesures, des traitements ou des journaux personnalisés.

Voici un exemple de la façon d'enregistrer des mesures supplémentaires à la fin de chaque période d'apprentissage :

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)

Reporte-toi au Guide de la formation pour plus de détails sur la façon d'utiliser efficacement les rappels de formation.

Pourquoi dois-je utiliser des rappels lors de la validation dans Ultralytics YOLO ?

Utilisation rappels lors de la validation dans Ultralytics YOLO peut améliorer l'évaluation du modèle en permettant un traitement personnalisé, la journalisation ou le calcul de métriques. Les rappels tels que on_val_start, on_val_batch_endet 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, tu peux vouloir enregistrer des mesures de validation supplémentaires ou sauvegarder des résultats intermédiaires pour une analyse plus approfondie. Voici un exemple de la façon d'enregistrer des mesures personnalisées à la fin de la validation :

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")

Consulte le Guide de validation pour obtenir des informations supplémentaires sur l'intégration des rappels dans ton processus de validation.

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

Pour attacher un rappel personnalisé au mode de prédiction dans Ultralytics YOLO , tu définis une fonction de rappel et tu l'enregistres dans le processus de prédiction. Les rappels de prédiction les plus courants sont les suivants on_predict_start, on_predict_batch_endet on_predict_end. Ceux-ci permettent de modifier les résultats des prédictions et d'intégrer des fonctionnalités supplémentaires telles que l'enregistrement des données ou la transformation des résultats.

Voici un exemple où un rappel personnalisé est utilisé pour consigner les prédictions :

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")

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

Quels sont les exemples pratiques d'utilisation des rappels dans Ultralytics YOLO ?

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

1. Enregistrement de mesures personnalisées: Enregistre des métriques supplémentaires à différentes étapes, comme la fin de l'entraînement ou des époques de validation.
2. Augmentation des données: Mettre en œuvre des transformations ou des augmentations de données personnalisées pendant les lots de prédiction ou de formation.
3. Résultats intermédiaires: Sauvegarde les résultats intermédiaires tels que les prédictions ou les cadres pour une analyse ou une visualisation plus poussée.

Exemple : Combinaison d'images avec les résultats de la prédiction pendant 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("yolov8n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Explore la Référence complète des rappels pour trouver d'autres options et exemples.

Commentaires