Rappels

Le cadre Ultralytics prend en charge les rappels, qui servent de points d'entrée à des étapes stratégiques du processus d'analyse. train, val, exportet predict modes. Chaque rappel accepte un Trainer, Validatorou Predictor en fonction du type d'opération. Toutes les propriétés de ces objets sont détaillées dans la section Section de 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 montrons comment renvoyer l'image originale avec chaque objet 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

Tous les rappels

Vous trouverez ci-dessous toutes les fonctions de rappel prises en charge. Pour plus de détails, reportez-vous au code source des callbacks.

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 ?

Les rappels 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 rappels permettent 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, définissez une fonction et ajoutez-la au modèle à l'aide de la fonction model.add_callback() méthode. 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("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 d'Ultralytics en utilisant des rappels ?

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 rappels de formation, tels que on_train_start, on_train_endet on_train_batch_endqui vous permettent d'ajouter des mesures, des traitements ou des enregistrements personnalisés.

Voici comment geler les statistiques BatchNorm lorsque l'on gèle des 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 de formation, voir le Guide de la formation.

Pourquoi utiliser des callbacks lors de 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é, 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, pour tracer tous les lots de validation au lieu des trois premiers seulement :

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 des rappels dans votre processus de validation, consultez le Guide de validation.

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

Pour attacher un rappel personnalisé au mode prédiction dans Ultralytics YOLO, définissez une fonction de rappel et enregistrez-la avec 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. 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 callback personnalisé enregistre des prédictions en fonction de la présence ou non 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 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 :

• 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.
• 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.
• Résultats intermédiaires: Enregistrez les résultats intermédiaires, tels que les prédictions ou les cadres, pour une analyse ou 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

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

📅C réé il y a 1 an ✏️ Mis à jour il y a 9 jours

Commentaires