Rückruf

Rückrufe beim maschinellen Lernen verstehen

Während des Modelltrainings treten verschiedene Ereignisse nacheinander auf: Das Training beginnt, ein Epoche beginnt, ein Stapel verarbeitet wird, eine Validierung stattfindet, eine Epoche endet und schließlich das Training abgeschlossen wird. Mit Callbacks kannst du bestimmte Aktionen auslösen, die an diese Ereignisse gebunden sind. Du könntest z. B. die Gewichte des Modells speichern, wenn sich die Validierungsgenauigkeit verbessert, Metriken in einem Visualisierungstool wie TensorBoardoder das Training vorzeitig beenden, wenn sich das Modell nicht mehr verbessert. Frameworks wie Keras und Bibliotheken wie die ultralytics Python nutzen in hohem Maße Callbacks, um Flexibilität und Erweiterbarkeit zu bieten.

Rückrufe in Ultralytics

Die Ultralytics Trainings-Engine bietet ein System von Rückrufen, die an verschiedenen Punkten während des Trainings ausgelöst werden. Ausbildung, Validierung, Vorhersage, und exportieren Prozesse. Diese Ereignisse umfassen on_train_start, on_epoch_end, on_fit_epoch_end (was die Validierung einschließt), on_batch_end, on_train_endund viele andere. Benutzer können benutzerdefinierte Callbacks definieren, um Aktionen wie detaillierte Protokollierung, das Senden von Benachrichtigungen oder die Interaktion mit Plattformen wie 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)




Anwendungen in der realen Welt

Callbacks ermöglichen zahlreiche nützliche Funktionen bei der ML-Modellentwicklung:

• Modell-Checkpointing: Automatisches Speichern des Modells (oder nur seiner Gewichte) in regelmäßigen Abständen oder immer dann, wenn sich die Leistung in einem Validierungsdatensatz verbessert. Dadurch wird sichergestellt, dass du den Fortschritt nicht verlierst und die beste Version deines Modells abrufen kannst. Frameworks bieten dafür oft integrierte Callbacks.
• Frühzeitiges Stoppen: Überwachung einer bestimmten Kennzahl (z. B. Validierungsverlust oder Genauigkeit) und Anhalten des Trainingsprozesses, wenn sich die Kennzahl für eine vordefinierte Anzahl von Epochen (Geduld) nicht mehr verbessert. Dies verhindert eine Überanpassung und spart Rechenressourcen.
• Planen der Lernrate: Dynamische Anpassung der Lernrate während des Trainings. Zum Beispiel kann eine Verringerung der Lernrate, wenn sich das Modell nicht weiter verbessert, dazu beitragen, dass es effektiver konvergiert.
• Logging und Visualisierung: Senden von Protokollen und Metriken (wie Verlust und Genauigkeit) an Monitoring-Tools wie TensorBoard oder Cloud-Plattformen wie Weights & Biases für die Echtzeit-Visualisierung und die Verfolgung von Experimenten. Ultralytics bietet nahtlose Integrationen für W&B und Comet ML.
• Ressourcenüberwachung: Verfolgung der Hardware-AuslastungGPUCPU , Speicher) während des Trainings, um Engpässe zu erkennen oder die Ressourcenzuweisung zu optimieren, besonders wichtig in Cloud-Computing-Umgebungen.

Callbacks sind grundlegend für die Erstellung flexibler, automatisierter und beobachtbarer Workflows für maschinelles Lernen und ermöglichen es Entwicklern, Trainingsprozesse effizient zu erweitern und anzupassen. Sie unterscheiden sich leicht von allgemeinen Software-Ereignislisten, da sie eng in die spezifischen Lebenszyklusphasen des ML-Trainings und der Auswertung integriert sind.