Optimierung des YOLO26-Trainings: Vereinfache deinen Logging-Prozess mit Comet

Das Protokollieren wichtiger Trainingsdetails wie Parameter, Metriken, Bildvorhersagen und Modell-Checkpoints ist im Machine Learning unerlässlich – es hält dein Projekt transparent, deinen Fortschritt messbar und deine Ergebnisse reproduzierbar.

Ultralytics YOLO26 lässt sich nahtlos mit Comet (ehemals Comet ML) integrieren und erfasst und optimiert effizient jeden Aspekt des Trainingsprozesses deines YOLO26-Objekterkennungs-Modells. In diesem Leitfaden behandeln wir den Installationsprozess, die Comet-Einrichtung, Echtzeit-Einblicke, benutzerdefiniertes Logging und die Offline-Nutzung, damit dein YOLO26-Training gründlich dokumentiert und für hervorragende Ergebnisse optimiert ist.

Comet

Comet ist eine Plattform zum Verfolgen, Vergleichen, Erläutern und Optimieren von Machine-Learning-Modellen und Experimenten. Sie ermöglicht es dir, Metriken, Parameter, Medien und mehr während des Modelltrainings zu protokollieren und deine Experimente über eine ästhetisch ansprechende Weboberfläche zu überwachen. Comet hilft Data Scientists, schneller zu iterieren, verbessert Transparenz und Reproduzierbarkeit und unterstützt die Entwicklung von Produktionsmodellen.

Die Leistung von YOLO26 und Comet nutzen

Durch die Kombination von Ultralytics YOLO26 mit Comet erschließt du eine Reihe von Vorteilen. Dazu gehören ein vereinfachtes Experimentmanagement, Echtzeit-Einblicke für schnelle Anpassungen, flexible und maßgeschneiderte Logging-Optionen sowie die Möglichkeit, Experimente offline zu protokollieren, wenn der Internetzugang eingeschränkt ist. Diese Integration ermöglicht es dir, datengestützte Entscheidungen zu treffen, Leistungsmetriken zu analysieren und außergewöhnliche Ergebnisse zu erzielen.

Installation

Um die erforderlichen Pakete zu installieren, führe Folgendes aus:

# Install the required packages for YOLO26 and Comet
pip install ultralytics comet_ml torch torchvision

Comet konfigurieren

Nach der Installation der erforderlichen Pakete musst du dich registrieren, einen Comet API Key abrufen und diesen konfigurieren.

# Set your Comet API Key
export COMET_API_KEY=YOUR_API_KEY

Anschließend kannst du dein Comet-Projekt initialisieren. Comet erkennt den API-Schlüssel automatisch und setzt die Einrichtung fort.

import comet_ml

comet_ml.login(project_name="comet-example-yolo26-coco128")

Wenn du ein Google Colab Notebook verwendest, wirst du durch den oben genannten Code aufgefordert, deinen API-Schlüssel zur Initialisierung einzugeben.

Verwendung

Bevor du in die Nutzungshinweise eintauchst, schaue dir unbedingt die Auswahl an YOLO26-Modellen von Ultralytics an. Dies hilft dir bei der Auswahl des passenden Modells für deine Projektanforderungen.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Train the model
results = model.train(
    data="coco8.yaml",
    project="comet-example-yolo26-coco128",
    batch=32,
    save_period=1,
    save_json=True,
    epochs=3,
)

Nach dem Ausführen des Trainingscodes erstellt Comet ein Experiment in deinem Comet-Arbeitsbereich, um den Lauf automatisch zu verfolgen. Du erhältst dann einen Link, um die detaillierte Protokollierung deines YOLO26-Modelltrainings einzusehen.

Comet protokolliert automatisch die folgenden Daten ohne zusätzliche Konfiguration: Metriken wie mAP und Loss, Hyperparameter, Modell-Checkpoints, die interaktive Konfusionsmatrix und Vorhersagen von Bounding Boxes.

Die Leistung deines Modells mit Comet-Visualisierungen verstehen

Lass uns einen Blick darauf werfen, was du auf dem Comet-Dashboard siehst, sobald dein YOLO26-Modell mit dem Training beginnt. Das Dashboard ist der zentrale Ort, an dem alle Informationen automatisch durch Visualisierungen und Statistiken präsentiert werden. Hier ist ein kurzer Rundgang:

Experiment-Panels

Der Bereich für Experiment-Panels auf dem Comet-Dashboard organisiert und präsentiert die verschiedenen Läufe sowie deren Metriken, wie z. B. Segment Mask Loss, Class Loss, Präzision und Mean Average Precision.

Metriken

Im Bereich für Metriken hast du auch die Möglichkeit, die Daten in einem tabellarischen Format zu untersuchen, das wie hier dargestellt in einem eigenen Bereich angezeigt wird.

Interaktive Confusion Matrix

Die Konfusionsmatrix, die du im Reiter „Confusion Matrix“ findest, bietet eine interaktive Möglichkeit, die Klassifizierungs-Genauigkeit des Modells zu bewerten. Sie zeigt korrekte und fehlerhafte Vorhersagen im Detail, sodass du die Stärken und Schwächen des Modells nachvollziehen kannst.

System-Metriken

Comet protokolliert Systemmetriken, um Engpässe im Trainingsprozess zu identifizieren. Dazu gehören GPU-Auslastung, GPU-Speichernutzung, CPU-Auslastung und RAM-Nutzung. Diese sind wichtig, um die Effizienz der Ressourcennutzung während des Modelltrainings zu überwachen.

Comet-Logging anpassen

Comet bietet die Flexibilität, das Logging-Verhalten durch das Setzen von Umgebungsvariablen anzupassen. Diese Konfigurationen ermöglichen es dir, Comet auf deine spezifischen Bedürfnisse und Vorlieben zuzuschneiden. Hier sind einige nützliche Anpassungsoptionen:

Bildvorhersagen protokollieren

Du kannst die Anzahl der Bildvorhersagen steuern, die Comet während deiner Experimente protokolliert. Standardmäßig protokolliert Comet 100 Bildvorhersagen aus dem Validierungsdatensatz. Du kannst diese Zahl jedoch an deine Anforderungen anpassen. Um beispielsweise 200 Bildvorhersagen zu protokollieren, verwende den folgenden Code:

import os

os.environ["COMET_MAX_IMAGE_PREDICTIONS"] = "200"

Batch-Logging-Intervall

Comet ermöglicht es dir festzulegen, wie oft Batches von Bildvorhersagen protokolliert werden. Die Umgebungsvariable COMET_EVAL_BATCH_LOGGING_INTERVAL steuert diese Häufigkeit. Die Standardeinstellung ist 1, was Vorhersagen von jedem Validierungsbatch protokolliert. Du kannst diesen Wert anpassen, um Vorhersagen in einem anderen Intervall zu protokollieren. Zum Beispiel führt der Wert 4 dazu, dass Vorhersagen von jedem vierten Batch protokolliert werden.

import os

os.environ["COMET_EVAL_BATCH_LOGGING_INTERVAL"] = "4"

Logging der Konfusionsmatrix deaktivieren

In einigen Fällen möchtest du die Konfusionsmatrix deines Validierungsdatensatzes vielleicht nicht nach jeder Epoche protokollieren. Du kannst diese Funktion deaktivieren, indem du die Umgebungsvariable COMET_EVAL_LOG_CONFUSION_MATRIX auf „false“ setzt. Die Konfusionsmatrix wird dann nur einmal nach Abschluss des Trainings protokolliert.

import os

os.environ["COMET_EVAL_LOG_CONFUSION_MATRIX"] = "false"

Offline-Logging

Wenn du dich in einer Situation mit eingeschränktem Internetzugang befindest, bietet Comet eine Offline-Logging-Option. Du kannst die Umgebungsvariable COMET_MODE auf „offline“ setzen, um diese Funktion zu aktivieren. Deine Experimentdaten werden lokal in einem Verzeichnis gespeichert, das du später bei verfügbarer Internetverbindung zu Comet hochladen kannst.

import os

os.environ["COMET_MODE"] = "offline"

Zusammenfassung

Dieser Leitfaden hat dich durch die Integration von Comet mit Ultralytics YOLO26 geführt. Von der Installation bis zur Anpassung hast du gelernt, wie du dein Experimentmanagement optimierst, Echtzeit-Einblicke gewinnst und das Logging an die Anforderungen deines Projekts anpasst.

Erkunde die offizielle YOLOv8-Integrationsdokumentation von Comet, die auch für YOLO26-Projekte gilt.

Darüber hinaus, wenn du tiefer in die praktischen Anwendungen von YOLO26 eintauchen möchtest, speziell für Bildsegmentierungs-Aufgaben, bietet dieser detaillierte Leitfaden zur Feinabstimmung von YOLO26 mit Comet wertvolle Einblicke und Schritt-für-Schritt-Anleitungen zur Steigerung der Leistung deines Modells.

Um zudem weitere spannende Integrationen mit Ultralytics zu erkunden, schau dir die Seite mit dem Integrationsleitfaden an, die eine Fülle von Ressourcen und Informationen bietet.

FAQ

Wie integriere ich Comet mit Ultralytics YOLO26 für das Training?

Um Comet mit Ultralytics YOLO26 zu integrieren, folge diesen Schritten:

1. Installiere die erforderlichen Pakete:

   pip install ultralytics comet_ml torch torchvision

2. Richte deinen Comet API Key ein:

   export COMET_API_KEY=YOUR_API_KEY

3. Initialisiere dein Comet-Projekt in deinem Python-Code:

   import comet_ml
   
   comet_ml.login(project_name="comet-example-yolo26-coco128")

4. Trainiere dein YOLO26-Modell und protokolliere Metriken:

   from ultralytics import YOLO
   
   model = YOLO("yolo26n.pt")
   results = model.train(
       data="coco8.yaml",
       project="comet-example-yolo26-coco128",
       batch=32,
       save_period=1,
       save_json=True,
       epochs=3,
   )

Weitere detaillierte Anweisungen findest du im Abschnitt Comet konfigurieren.

Was sind die Vorteile der Nutzung von Comet mit YOLO26?

Durch die Integration von Ultralytics YOLO26 mit Comet kannst du:

• Echtzeit-Einblicke überwachen: Erhalte sofortiges Feedback zu deinen Trainingsergebnissen und nimm schnell Anpassungen vor.
• Umfangreiche Metriken protokollieren: Erfasse automatisch wichtige Metriken wie mAP, Loss, Hyperparameter und Modell-Checkpoints.
• Experimente offline verfolgen: Protokolliere deine Trainingsläufe lokal, wenn kein Internetzugang verfügbar ist.
• Verschiedene Trainingsläufe vergleichen: Nutze das interaktive Comet-Dashboard, um mehrere Experimente zu analysieren und zu vergleichen.

Durch die Nutzung dieser Funktionen kannst du deine Machine-Learning-Workflows für bessere Leistung und Reproduzierbarkeit optimieren. Weitere Informationen findest du im Comet-Integrationsleitfaden.

Wie kann ich das Logging-Verhalten von Comet während des YOLO26-Trainings anpassen?

Comet ermöglicht eine umfassende Anpassung des Logging-Verhaltens über Umgebungsvariablen:

• Anzahl der protokollierten Bildvorhersagen ändern:

  import os
  
  os.environ["COMET_MAX_IMAGE_PREDICTIONS"] = "200"

• Batch-Logging-Intervall anpassen:

  import os
  
  os.environ["COMET_EVAL_BATCH_LOGGING_INTERVAL"] = "4"

• Logging der Konfusionsmatrix deaktivieren:

  import os
  
  os.environ["COMET_EVAL_LOG_CONFUSION_MATRIX"] = "false"

Weitere Anpassungsoptionen findest du im Abschnitt Comet-Logging anpassen.

Wie kann ich detaillierte Metriken und Visualisierungen meines YOLO26-Trainings auf Comet ansehen?

Sobald dein YOLO26-Modell mit dem Training beginnt, kannst du auf eine Vielzahl von Metriken und Visualisierungen auf dem Comet-Dashboard zugreifen. Zu den wichtigsten Funktionen gehören:

• Experiment-Panels: Betrachte verschiedene Läufe und ihre Metriken, einschließlich Segment Mask Loss, Class Loss und Mean Average Precision.
• Metriken: Untersuche Metriken zur detaillierten Analyse im tabellarischen Format.
• Interaktive Konfusionsmatrix: Bewerte die Klassifizierungsgenauigkeit mit einer interaktiven Konfusionsmatrix.
• System-Metriken: Überwache GPU- und CPU-Auslastung, Speichernutzung und andere System-Metriken.

Einen detaillierten Überblick über diese Funktionen findest du im Abschnitt Die Leistung deines Modells mit Comet-Visualisierungen verstehen.

Kann ich Comet für Offline-Logging verwenden, wenn ich YOLO26-Modelle trainiere?

Ja, du kannst Offline-Logging in Comet aktivieren, indem du die Umgebungsvariable COMET_MODE auf „offline“ setzt:

import os

os.environ["COMET_MODE"] = "offline"

Diese Funktion ermöglicht es dir, deine Experimentdaten lokal zu protokollieren, die später bei verfügbarer Internetverbindung zu Comet hochgeladen werden können. Dies ist besonders nützlich bei der Arbeit in Umgebungen mit eingeschränktem Internetzugang. Weitere Details findest du im Abschnitt Offline-Logging.