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 d'étapes clés des opérations de modèle telles que l'entraînement, la validation, l'exportation et la prédiction. Ces rappels permettent une fonctionnalité personnalisée à des moments précis du processus, ce qui permet d'apporter des améliorations et des modifications au 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 les pages de référence BaseTrainer, BaseValidator et BasePredictor. 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 pendant la prédiction :

Comment puis-je personnaliser la routine d'entraînement Ultralytics à l'aide de rappels ?

Personnalise ta 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 d'entraînement, tels que on_train_start, on_train_end et on_train_batch_end, qui te permettent d'ajouter des métriques, des traitements ou des journaux personnalisés. Voici comment figer les statistiques de BatchNorm lors du gel des couches avec des rappels : Pour plus de détails sur l'utilisation efficace des rappels d'entraînement, consulte le guide d'entraînement.

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

L'utilisation de rappels 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. 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 des trois premiers : Pour plus d'informations sur l'intégration de rappels dans ton processus de validation, consulte le guide de validation.

Comment attacher un rappel 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é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 rappel personnalisé enregistre les prédictions selon qu'un objet d'une classe particulière est présent ou non : 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.

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

Ultralytics YOLO prend en charge diverses mises en œuvre pratiques de rappels pour améliorer et personnaliser différentes phases telles que l'entraînement, la validation et la prédiction. Quelques exemples pratiques incluent : Journalisation de métriques personnalisées : Enregistre des métriques supplémentaires à différentes étapes, par exemple à la fin des époques d'entraînement ou de validation. Augmentation de données : Mets en œuvre 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 d'images avec les résultats de prédiction pendant la prédiction à l'aide de on_predict_batch_end : Explore le code source des rappels pour plus d'options et d'exemples.

Rappels#

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

Watch: How to use Ultralytics Callbacks | Predict, Train, Validate and Export Callbacks | Ultralytics YOLO🚀

Exemples#

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

Dans cet exemple, nous montrons comment renvoyer l'image 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("yolo26n.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

Enregistrement des hooks PyTorch Forward avant l'entraînement#

model.train() construit un modèle d'entraînement à partir de la configuration du modèle et y transfère les poids chargés. Les hooks PyTorch enregistrés directement sur model.model avant cet appel constituent un état d'exécution, de sorte que le modèle d'entraînement rebâti ne les hérite pas. Enregistre les hooks d'entraînement dans on_pretrain_routine_end, une fois la configuration du modèle terminée :

from ultralytics import YOLO
from ultralytics.utils.torch_utils import unwrap_model

def preprocess_input(module, inputs):
    """Center each input channel before the first model layer."""
    images = inputs[0]
    return (images - images.mean(dim=(-2, -1), keepdim=True),)

def register_forward_pre_hook(trainer):
    """Attach preprocessing to the active training model."""
    train_model = unwrap_model(trainer.model)
    train_model.model[0].register_forward_pre_hook(preprocess_input)

model = YOLO("yolo26n.pt")
model.add_callback("on_pretrain_routine_end", register_forward_pre_hook)
model.train(data="coco8.yaml", epochs=1)

unwrap_model() gère à la fois l'entraînement sur un seul appareil et l'entraînement DistributedDataParallel. N'attache pas un hook défini localement à trainer.ema.ema, car les points de contrôle d'entraînement sérialisent le modèle EMA et un autre processus pourrait ne pas être en mesure d'importer le callback lors du chargement du point de contrôle. Si le même prétraitement doit s'exécuter pendant la validation de l'entraînement, implémente-le en tant composant de modèle importable plutôt qu'en tant que hook d'exécution.

model.val() autonome copie le modèle chargé pour chaque appel. La prédiction crée et met en cache une copie lors de son premier appel, alors enregistre les hooks sur model.model avant le premier appel à model.predict() ou model.track() ; les hooks ajoutés par la suite n'atteignent pas le prédécesseur mis en cache. Enregistre à nouveau les hooks d'exécution après avoir chargé un point de contrôle dans un nouveau processus.

Accède aux métriques du modèle à l'aide du rappel `on_model_save`#

Cet exemple montre comment récupérer les détails de l'entraînement, tels que le score best_fitness, total_loss et d'autres métriques après la sauvegarde d'un point de contrôle à l'aide du rappel on_model_save.

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo26n.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#

Tu trouveras ci-dessous tous les rappels pris en charge. Pour plus de détails, consulte le code source des rappels.

Rappels de l'entraîneur#

Rappel	Description
`on_pretrain_routine_start`	Déclenché au début de la routine de pré-entraînement, avant le chargement des données et la configuration du modèle.
`on_pretrain_routine_end`	Déclenché à la fin de la routine de pré-entraînement, après la fin du chargement des données et de la configuration du modèle.
`on_train_start`	Déclenché au démarrage de l'entraînement, avant le début de la première époque.
`on_train_epoch_start`	Déclenché au début de chaque époque d'entraînement, avant l'itération des lots.
`on_train_batch_start`	Déclenché au début de chaque lot d'entraînement, avant la passe avant.
`optimizer_step`	Déclenché pendant l'étape de l'optimiseur. Réservé aux intégrations personnalisées ; non appelé par la boucle d'entraînement par défaut.
`on_before_zero_grad`	Déclenché avant la mise à zéro des gradients. Réservé aux intégrations personnalisées ; non appelé par la boucle d'entraînement par défaut.
`on_train_batch_end`	Déclenché à la fin de chaque lot d'entraînement, après la passe arrière. L'étape de l'optimiseur peut être différée en raison de l'accumulation de gradients.
`on_train_epoch_end`	Déclenché à la fin de chaque époque d'entraînement, après le traitement de tous les lots mais avant la validation. Les métriques de validation et la pertinence peuvent ne pas être encore disponibles.
`on_model_save`	Déclenché lorsque le point de contrôle du modèle est sauvegardé, après la validation.
`on_fit_epoch_end`	Déclenché à la fin de chaque époque d'ajustement (entraînement + val), après la validation et toute sauvegarde de point de contrôle. Les métriques de validation sont disponibles, et la pertinence l'est pour l'appel d'entraînement par époque. Ce rappel est également appelé lors de l'évaluation finale du meilleur modèle, où aucune sauvegarde de point de contrôle ne se produit et où la pertinence peut être absente.
`on_train_end`	Déclenché lorsque le processus d'entraînement se termine, après l'évaluation finale du meilleur modèle.
`on_params_update`	Déclenché lorsque les paramètres du modèle sont mis à jour. Réservé aux intégrations personnalisées ; non appelé par la boucle d'entraînement par défaut.
`teardown`	Déclenché lors du nettoyage du processus d'entraînement.

Rappels du validateur#

Rappel	Description
`on_val_start`	Déclenché lorsque la validation commence.
`on_val_batch_start`	Déclenché au début de chaque lot de validation.
`on_val_batch_end`	Déclenché à la fin de chaque lot de validation.
`on_val_end`	Déclenché lorsque la validation se termine.

Rappels du prédicteur#

Rappel	Description
`on_predict_start`	Déclenché lorsque le processus de prédiction commence.
`on_predict_batch_start`	Déclenché au début de chaque lot de prédiction.
`on_predict_postprocess_end`	Déclenché à la fin du post-traitement de la prédiction.
`on_predict_batch_end`	Déclenché à la fin de chaque lot de prédiction.
`on_predict_end`	Déclenché lorsque le processus de prédiction se termine.

Rappels de l'exportateur#

Rappel	Description
`on_export_start`	Déclenché lorsque le processus d'exportation commence.
`on_export_end`	Déclenché lorsque le processus d'exportation se termine.

FAQ#

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 de modèle telles que l'entraînement, la validation, l'exportation et la prédiction. Ces rappels permettent une fonctionnalité personnalisée à des moments précis du processus, ce qui permet d'apporter des améliorations et des modifications au 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 les pages de référence BaseTrainer, BaseValidator et BasePredictor.

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 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("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 fournit 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, des traitements ou des journaux personnalisés.

Voici comment figer les statistiques de BatchNorm lors du gel des couches 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("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 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. 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 des 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 attacher un rappel personnalisé pour le 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 rappel personnalisé enregistre les prédictions selon qu'un objet d'une classe particulière est présent ou non :
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 mises en œuvre pratiques de rappels pour améliorer et personnaliser différentes phases telles que l'entraînement, la validation et la prédiction. Quelques exemples pratiques incluent :
- Journalisation de métriques personnalisées : Enregistre des métriques supplémentaires à différentes étapes, par exemple à la fin des époques d'entraînement ou de validation.
- Augmentation de données : Mets en œuvre 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 d'images avec les résultats de 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("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.

Contributeurs

GLglenn-jocher¹⁶ RIRizwanMunawar³ RAraimbekovm²A A Aswanth Raj¹Y-Y-T-G¹

Créé 12 nov. 2023Mis à jour il y a 4 jours