Rappels

Rappels

Ultralytics supporte les callbacks comme points d'entrée dans les étapes stratégiques des modes train, val, export et predict. Chaque callback accepte un Trainer, Validatorou Predictor en fonction du type d'opération. Toutes les propriétés de ces objets peuvent être trouvées dans la section Référence de la documentation.

Regarder : Mastering Ultralytics YOLO : Rappels

Exemples

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

Dans cet exemple, nous voulons renvoyer l'image originale avec chaque objet 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("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

Tous les rappels

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

Rappels du formateur

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 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'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 en fonction du type d'opération. Pour connaître les propriétés détaillées de ces objets, reportez-vous à la section Section de référence.

Pour utiliser un rappel, vous pouvez définir une fonction et l'ajouter au modèle à l'aide de la fonction add_callback méthode. Voici un exemple de retour 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("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 de Ultralytics à l'aide de rappels ?

Pour personnaliser votre routine de formation Ultralytics à l'aide de rappels, vous pouvez injecter votre logique à des étapes spécifiques du processus de formation. Ultralytics YOLO fournit une variété de rappels de formation tels que on_train_start, on_train_endet on_train_batch_end. Ils vous permettent d'ajouter des mesures, des traitements ou des enregistrements 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("yolo11n.pt")
model.add_callback("on_train_epoch_end", on_train_epoch_end)
model.train(data="coco.yaml", epochs=10)

Reportez-vous au Guide de la formation pour plus de détails sur la manière d'utiliser efficacement les rappels de formation.

Pourquoi utiliser des callbacks lors de la validation dans Ultralytics YOLO ?

Utilisation callbacks lors de la validation dans Ultralytics YOLO peuvent 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, vous pouvez souhaiter enregistrer des mesures de validation supplémentaires ou sauvegarder des résultats intermédiaires en vue d'une analyse ultérieure. Voici un exemple d'enregistrement de 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("yolo11n.pt")
model.add_callback("on_val_end", on_val_end)
model.val(data="coco.yaml")

Consultez le Guide de validation pour en savoir plus sur l'intégration des rappels dans votre processus de validation.

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

Pour attacher un rappel personnalisé à la fonction mode de prédiction dans Ultralytics YOLO , vous définissez une fonction de rappel et l'enregistrez dans le processus de prédiction. Les fonctions de rappel de prédiction les plus courantes sont les suivantes on_predict_start, on_predict_batch_endet on_predict_end. Ils permettent de modifier les résultats de la prédiction 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 enregistrer 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("yolo11n.pt")
model.add_callback("on_predict_end", on_predict_end)
results = model.predict(source="image.jpg")

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

Quels sont les exemples pratiques d'utilisation de callbacks 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: Enregistrez des mesures supplémentaires à différents stades, par exemple à la fin des périodes d'apprentissage ou de validation.
2. Augmentation des données: Mise en œuvre de transformations ou d'augmentations personnalisées des données au cours des lots de prédiction ou d'entraînement.
3. Résultats intermédiaires: Enregistrez les résultats intermédiaires, tels que les prédictions ou les cadres, en vue d'une analyse ou d'une visualisation plus poussée.

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

Consultez la référence complète sur les rappels pour découvrir d'autres options et exemples.

📅C réé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires