Callback

Dans le domaine du génie logiciel et de l'intelligence artificielle (IA), un rappel (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 du modèle sans modifier le code d'entraînement de base 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, telles que le début ou la fin d'une époque (epoch), d'un lot (batch) d'entraînement ou de toute la session d'entraînement.

Le 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 les callbacks, le processus d'entraînement est essentiellement une « boîte noire » qui s'exécute jusqu'à son terme, nécessitant souvent une supervision manuelle. Les callbacks introduisent de l'observabilité et du contrôle, permettant au système de s'autoréguler sur la base de métriques de performance en temps réel.

When using high-level libraries like PyTorch or TensorFlow, callbacks provide a way to inject logic into the optimization algorithm. For instance, if a model is learning well, a callback might save the current state; if it stops learning, a callback might halt the process to save resources. This makes the machine learning (ML) workflow more efficient and robust.

Applications courantes et exemples concrets#

Les callbacks sont polyvalents et peuvent être utilisés pour un large éventail de tâches lors de la surveillance des modèles et de l'optimisation.

• Arrêt anticipé (Early Stopping) : L'une des utilisations les plus courantes est l'arrêt anticipé. Ce callback surveille une métrique spécifique, telle que la perte (loss) 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 (overfitting), garantissant que le modèle se généralise bien aux nouvelles données plutôt que de mémoriser les données d'entraînement.
• Points de contrôle du modèle (Model Checkpointing) : Lors de longs entraînements, les pannes matérielles peuvent être catastrophiques. Un callback de points de contrôle enregistre les poids du modèle à intervalles réguliers (par exemple, à chaque époque) ou uniquement lorsque le modèle atteint un nouveau score « optimal » sur des métriques telles que l'exactitude (accuracy) ou la précision moyenne mAP (mean average precision). Cela garantit que tu as toujours une version enregistrée du modèle le plus performant.
• Planification du taux d'apprentissage (Learning Rate Scheduling) : Le taux d'apprentissage contrôle l'ampleur des modifications apportées au modèle en réponse à l'erreur estimée à chaque mise à jour des poids. Un callback peut ajuster dynamiquement ce taux, le réduisant lorsque l'apprentissage stagne pour aider le modèle à converger vers une solution optimale, une technique souvent appelée décroissance du taux d'apprentissage.
• Journalisation (Logging) et visualisation : Les callbacks sont fréquemment utilisés pour s'intégrer à des outils de suivi d'expériences. Ils diffusent des 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.

Mise 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.

Voici un exemple concis de la manière 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)

Callbacks vs Hooks#

Bien qu'ils soient liés, il est utile de distinguer les callbacks des hooks. Dans des frameworks comme PyTorch, les hooks sont généralement des fonctions de plus bas niveau attachées à des opérations de tenseur (tensor) spécifiques ou à des couches de réseaux de neurones pour inspecter ou modifier les gradients et les sorties pendant la passe avant (forward) ou arrière (backward). En revanche, les callbacks sont généralement des abstractions de plus haut niveau liées aux événements de la boucle d'entraînement (début, fin, traitement par lots) plutôt qu'au graphe de calcul mathématique lui-même.

Lectures complémentaires et ressources#

Pour ceux qui cherchent à approfondir leur compréhension de l'optimisation des flux de travail d'entraînement, explorer l'optimisation des hyperparamètres est une prochaine étape logique. De plus, comprendre les tâches sous-jacentes de computer vision (CV) telles que la détection d'objets et la segmentation d'instances fournira le contexte nécessaire pour comprendre pourquoi un contrôle précis de l'entraînement par le biais de callbacks est nécessaire. Pour une gestion de niveau entreprise de ces processus, la plateforme Ultralytics offre des solutions intégrées qui automatisent bon nombre de ces comportements pilotés par des callbacks.