Callback

Dans le domaine de l'ingénierie logicielle et de l'intelligence artificielle (IA), un callback est un morceau de code exécutable passé en argument à un autre code, qui est ensuite censé exécuter (rappeler) cet argument à un moment donné. Dans le contexte spécifique des frameworks de deep learning (DL), les callbacks sont des outils essentiels qui permettent aux développeurs de personnaliser le comportement de la boucle d'entraînement de modèle sans modifier le code d'entraînement central lui-même. Ils agissent comme des déclencheurs automatisés qui effectuent des actions spécifiques à différentes étapes du processus d'entraînement, comme le début ou la fin d'une époque, d'un lot d'entraînement, ou de toute la session d'entraînement.

Link to this sectionLe rôle des callbacks dans le machine learning#

L'entraînement d'un réseau de neurones complexe peut prendre des heures, voire des jours. Sans callbacks, le processus d'entraînement est essentiellement une « boîte noire » qui s'exécute jusqu'à la fin, nécessitant souvent une surveillance manuelle. Les callbacks introduisent de l'observabilité et du contrôle, permettant au système de s'autoréguler en fonction des mesures de performance en temps réel.

Lors de l'utilisation de bibliothèques de haut niveau comme PyTorch ou TensorFlow, les callbacks offrent un moyen d'injecter de la logique dans l'algorithme d'optimisation. Par exemple, si un modèle apprend bien, un callback pourrait sauvegarder l'état actuel ; s'il cesse d'apprendre, un callback pourrait interrompre le processus pour économiser des ressources. Cela rend le flux de travail de machine learning (ML) plus efficace et robuste.

Link to this sectionApplications courantes et exemples concrets#

Les callbacks sont polyvalents et peuvent être utilisés pour un large éventail de tâches pendant le suivi de modèle et l'optimisation.

• Early Stopping : L'une des utilisations les plus courantes est l'early stopping. Ce callback surveille une métrique spécifique, comme la perte sur les données de validation. Si la perte cesse de diminuer pendant un nombre défini d'époques, le callback arrête l'entraînement. Cela évite le surapprentissage, garantissant que le modèle généralise bien aux nouvelles données plutôt que de mémoriser les données d'entraînement.
• Checkpointing de modèle : Lors de longs cycles d'entraînement, les pannes matérielles peuvent être catastrophiques. Un callback de checkpointing sauvegarde les poids du modèle à intervalles réguliers (par exemple, à chaque époque) ou uniquement lorsque le modèle atteint un nouveau « meilleur » score sur des métriques telles que la précision ou la précision moyenne moyenne (mAP). Cela garantit que tu as toujours une version sauvegardée du modèle le plus performant.
• Planification du taux d'apprentissage : Le taux d'apprentissage contrôle l'ampleur des changements du modèle en réponse à l'erreur estimée à chaque mise à jour des poids. Un callback peut ajuster dynamiquement ce taux, en le réduisant lorsque l'apprentissage plafonne pour aider le modèle à converger vers une solution optimale, une technique souvent appelée décroissance du taux d'apprentissage.
• Journalisation et visualisation : Les callbacks sont fréquemment utilisés pour s'intégrer aux outils de suivi d'expérimentation. Ils diffusent les métriques vers des tableaux de bord comme TensorBoard ou MLflow, permettant aux data scientists de visualiser les fonctions de perte et les graphiques de performance en temps réel.

Link to this sectionMise en œuvre de callbacks avec Ultralytics YOLO#

The Ultralytics library supports a robust callback system, allowing users to hook into events during the training of models like YOLO26. This is particularly useful for users managing workflows on the Ultralytics Platform who need custom logging or control logic.

Tu trouveras ci-dessous un exemple concis de la façon de définir et d'enregistrer un callback personnalisé qui affiche un message à la fin de chaque époque d'entraînement en utilisant l'API Python :

from ultralytics import YOLO


# Define a custom callback function
def on_train_epoch_end(trainer):
    """Callback function to execute at the end of each training epoch."""
    print(f"Epoch {trainer.epoch + 1} complete. Current Fitness: {trainer.fitness}")


# Load the YOLO26 model (latest generation)
model = YOLO("yolo26n.pt")

# Register the custom callback to the model
model.add_callback("on_train_epoch_end", on_train_epoch_end)

# Train the model with the callback active
model.train(data="coco8.yaml", epochs=3)

Link to this sectionCallbacks vs Hooks#

While related, it is helpful to distinguish callbacks from hooks. In frameworks like PyTorch, hooks are generally lower-level functions attached to specific tensor operations or neural network layers to inspect or modify gradients and outputs during the forward or backward pass. In contrast, callbacks are typically higher-level abstractions tied to the training loop events (start, end, batch processing) rather than the mathematical computation graph itself.

Link to this sectionLectures complémentaires et ressources#

Pour ceux qui souhaitent approfondir leur compréhension de l'optimisation des flux de travail d'entraînement, explorer l'optimisation des hyperparamètres est une étape logique. De plus, comprendre les tâches de vision par ordinateur (CV) sous-jacentes, telles que la détection d'objets et la segmentation d'instance, donnera du contexte sur la raison pour laquelle un contrôle précis de l'entraînement via des callbacks est nécessaire. Pour une gestion de niveau entreprise de ces processus, la Plateforme Ultralytics propose des solutions intégrées qui automatisent bon nombre de ces comportements basés sur les callbacks.