Rappel

Comprendre les rappels dans l'apprentissage automatique

Au cours de l'apprentissage d'un modèle, divers événements se produisent de manière séquentielle : l'apprentissage commence, un époque commence, un lot est traité, la validation a lieu, une époque se termine et enfin, la formation se termine. Les rappels te permettent de déclencher des actions spécifiques liées à ces événements. Par exemple, tu pourrais vouloir enregistrer les poids du modèle chaque fois que la précision de la validation s'améliore, enregistrer les métriques dans un outil de visualisation tel que TensorBoardou arrêter la formation avant la fin si le modèle ne s'améliore plus. Des cadres comme Keras et des bibliothèques telles que le ultralytics Les paquets Python utilisent fortement les rappels pour offrir de la flexibilité et de l'extensibilité.

Rappels dans Ultralytics

Le moteur de formation Ultralytics fournit un système de rappels qui sont déclenchés à différents moments au cours de la formation. formation, validation, prédictionet exporter processus. Ces événements comprennent on_train_start, on_epoch_end, on_fit_epoch_end (ce qui inclut la validation), on_batch_end, on_train_endet bien d'autres encore. Les utilisateurs peuvent définir des rappels personnalisés pour effectuer des actions telles que l'enregistrement détaillé, l'envoi de notifications ou l'interaction avec des plates-formes telles que Ultralytics HUB.

from ultralytics import YOLO
from ultralytics.engine.callbacks import BaseCallback

# Define a simple custom callback

class MyCallback(BaseCallback):
def on_epoch_end(self, trainer): # This code will run at the end of each epoch
print(f"Epoch {trainer.epoch + 1} finished.") # Example: Access metrics like validation loss
if trainer.metrics:
val_loss = trainer.metrics.get('val/loss', None) # Example metric key, adjust as needed
if val_loss is not None:
print(f"Validation loss: {val_loss:.4f}")

# Load a model

model = YOLO('yolov8n.yaml').load('yolov8n.pt') # build from YAML and transfer weights

# Initialize your callback

my_callback = MyCallback()

# Add the callback to the training process

# Note: Direct addition via API might vary; often done via configuration or extending Trainer

# For demonstration, assume a mechanism exists like adding to a list or overriding methods.

# In Ultralytics, callbacks are often managed internally or via specific integrations.

# A conceptual example of how one might use it if Trainer exposed callbacks directly:

# trainer.add_callback(my_callback) # Hypothetical method

# Train the model (the callback methods are triggered automatically by the Trainer)

# The actual mechanism involves the Trainer checking for registered callbacks for specific events.

try: # This is a simplified representation. Callbacks are typically integrated deeper. # We can simulate adding callback logic by overriding trainer methods or using signals if available. # The Ultralytics framework automatically handles registered internal and integration callbacks. # To add custom behaviour like this, you might need to modify the source or use provided extension points.
print("Training started (callback logic would be triggered internally)...") # Example: Manually trigger for demonstration if needed for testing callback logic # my_callback.on_epoch_end(trainer_mock_object)
results = model.train(data='coco128.yaml', epochs=3, imgsz=640) # Training triggers internal events
print("Training finished.")

except Exception as e:
print(f"An error occurred: {e}")

# Example of using an existing integration callback (e.g., TensorBoard)

# This is usually enabled via arguments or configuration:

# results = model.train(data='coco128.yaml', epochs=3, imgsz=640, tensorboard=True)




Applications dans le monde réel

Les rappels permettent de nombreuses fonctionnalités utiles pendant le développement d'un modèle ML :

• Point de contrôle du modèle : Sauvegarde automatiquement le modèle (ou seulement ses poids) périodiquement ou chaque fois que les performances sur un ensemble de données de validation s'améliorent. Cela te permet de ne pas perdre de progrès et de récupérer la meilleure version de ton modèle. Les structures fournissent souvent des rappels intégrés pour cela.
• Arrêt précoce : Surveillance d'une mesure spécifique (par exemple, la perte de validation ou la précision) et arrêt du processus de formation si la mesure cesse de s'améliorer pendant un nombre prédéfini d'époques (patience). Cela permet d'éviter le surajustement et d'économiser les ressources informatiques.
• Programmation du taux d'apprentissage : Ajustement dynamique du taux d'apprentissage pendant la formation. Par exemple, la réduction du taux d'apprentissage lorsque l'amélioration du modèle atteint un plateau peut l'aider à converger plus efficacement.
• Journalisation et visualisation : Envoi de journaux et de métriques (comme la perte et la précision) à des outils de surveillance tels que TensorBoard ou à des plateformes en nuage comme... Weights & Biases pour une visualisation en temps réel et un suivi des expériences. Ultralytics offre des intégrations transparentes pour W&B et Comet ML.
• Surveillance des ressources : Suivi de l'utilisation du matérielGPUutilisation du CPU , mémoire) pendant l'entraînement pour identifier les goulots d'étranglement ou optimiser l'allocation des ressources, ce qui est particulièrement important dans les environnements de cloud computing.

Les rappels sont fondamentaux pour créer des flux de travail d'apprentissage automatique flexibles, automatisés et observables, permettant aux développeurs d'étendre et de personnaliser efficacement les processus de formation. Ils diffèrent légèrement des auditeurs d'événements logiciels généraux en étant étroitement intégrés aux étapes spécifiques du cycle de vie de la formation et de l'évaluation ML.