Link to this sectionVerbesserung 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 in Comet (ehemals Comet ML) integrieren und erfasst und optimiert effizient jeden Aspekt des Trainingsprozesses deines YOLO26 object detection-Modells. In diesem Leitfaden behandeln wir den Installationsprozess, die Comet-Einrichtung, Echtzeit-Einblicke, benutzerdefiniertes Logging und die Offline-Nutzung, um sicherzustellen, dass dein YOLO26-Training gründlich dokumentiert und für herausragende Ergebnisse feinabgestimmt ist.

Link to this sectionComet#

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

Link to this sectionDie Nutzung der Power von YOLO26 und Comet#

Durch die Kombination von Ultralytics YOLO26 mit Comet erschließt du dir 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 begrenzt ist. Diese Integration versetzt dich in die Lage, datengestützte Entscheidungen zu treffen, Leistungsmetriken zu analysieren und außergewöhnliche Ergebnisse zu erzielen.

Link to this sectionInstallation#

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

Link to this sectionKonfiguration von Comet#

Nach der Installation der erforderlichen Pakete musst du dich anmelden, 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 fährt mit der 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.

Link to this sectionNutzung#

Bevor du in die Nutzungshinweise eintauchst, schau dir unbedingt die Reihe der YOLO26 models offered by Ultralytics an. Dies hilft dir dabei, das am besten geeignete Modell für deine Projektanforderungen auszuwählen.

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,
)

Nachdem du den Trainingscode ausgeführt hast, erstellt Comet automatisch ein Experiment in deinem Comet-Workspace, um den Lauf zu verfolgen. Du erhältst dann einen Link, um die detaillierte Protokollierung deines YOLO26 model's training-Prozesses einzusehen.

Comet protokolliert automatisch die folgenden Daten ohne zusätzliche Konfiguration: Metriken wie mAP und Loss, Hyperparameter, Modell-Checkpoints, eine interaktive Konfusionsmatrix und Bild-bounding box-Vorhersagen.

Link to this sectionVerständnis der Modell-Leistung mit Comet-Visualisierungen#

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 Ort, an dem alles passiert und eine Reihe automatisch protokollierter Informationen durch Visualisierungen und Statistiken präsentiert wird. 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 und deren Metriken, wie z. B. Segment-Masken-Loss, Klassen-Loss, Precision und mean average precision.

Metriken

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

Interaktive Confusion Matrix

Die Konfusionsmatrix, die sich im Tab „Confusion Matrix“ befindet, bietet eine interaktive Möglichkeit, die Klassifizierungs-accuracy des Modells zu bewerten. Sie führt die korrekten und inkorrekten Vorhersagen im Detail auf, sodass du die Stärken und Schwächen deines Modells verstehen kannst.

Systemmetriken

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

Link to this sectionAnpassung des Comet-Loggings#

Comet bietet die Flexibilität, das Logging-Verhalten durch das Setzen von Umgebungsvariablen anzupassen. Diese Konfigurationen ermöglichen es dir, Comet an deine spezifischen Bedürfnisse und Vorlieben anzupassen. Der Ultralytics-Callback liest die folgenden Umgebungsvariablen (setze diese vor Trainingsbeginn):

Link to this sectionProtokollierung von Bildvorhersagen#

Du kannst die Anzahl der Bildvorhersagen steuern, die Comet während deiner Experimente protokolliert. Standardmäßig protokolliert Comet 100 Bildvorhersagen aus dem Validierungssatz. 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"

Um das Logging von Bildvorhersagen vollständig zu deaktivieren (z. B. um das Upload-Volumen bei langsamen Verbindungen zu reduzieren), setze COMET_EVAL_LOG_IMAGE_PREDICTIONS auf "false":

import os

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

Link to this sectionBatch-Logging-Intervall#

Comet ermöglicht es dir, anzugeben, wie oft Batches von Bildvorhersagen protokolliert werden. Die Umgebungsvariable COMET_EVAL_BATCH_LOGGING_INTERVAL steuert diese Häufigkeit. Die Standardeinstellung ist 1, was Vorhersagen aus jedem Validierungs-Batch protokolliert. Du kannst diesen Wert anpassen, um Vorhersagen in einem anderen Intervall zu protokollieren. Wenn du ihn beispielsweise auf 4 setzt, werden Vorhersagen aus jedem vierten Batch protokolliert.

import os

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

Link to this sectionDeaktivierung des Konfusionsmatrix-Loggings#

In manchen Fällen möchtest du die Konfusionsmatrix aus deinem Validierungssatz möglicherweise nicht nach jeder epoch 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"

Link to this sectionOnline- und Offline-Modus#

Standardmäßig läuft Comet im Online-Modus und streamt Experimentdaten auf die Comet-Server. Wenn du ohne Internetzugang trainieren musst, setze COMET_START_ONLINE=0, bevor das Training beginnt. Experimentdaten werden lokal gespeichert und können später mit dem comet upload-CLI hochgeladen werden.

import os

os.environ["COMET_START_ONLINE"] = "0"  # 1 (default) = online, 0 = offline

Link to this sectionProjektname#

Standardmäßig übergibt der Comet-Callback das YOLO-Training-Argument project an Comet (oder None, wenn das Argument nicht gesetzt ist, wobei Comet in diesem Fall deinen Workspace-Standard verwendet). Überschreibe dies mit COMET_PROJECT_NAME, um alle Experimente unabhängig vom YOLO-Training-Argument an ein spezifisches Comet-Workspace-Projekt zu senden:

import os

os.environ["COMET_PROJECT_NAME"] = "my-yolo26-experiments"

Link to this sectionName des Modell-Artefakts#

COMET_MODEL_NAME legt den Namen fest, den Comet für das protokollierte Modell-Artefakt registriert (Standardwert ist Ultralytics). Nutze dies, um Modellvarianten in einem gemeinsam genutzten Workspace zu unterscheiden:

import os

os.environ["COMET_MODEL_NAME"] = "yolo26n-coco128"

Link to this sectionSkalierung von Konfidenzwerten#

Erkennungskonfidenzwerte werden im Bereich [0, 1] ausgegeben, aber die Comet-UI zeigt sie standardmäßig auf einer prozentualen Skala an. Der Callback multipliziert jeden Wert vor der Protokollierung mit COMET_MAX_CONFIDENCE_SCORE (Standardwert 100.0). Passe dies an, wenn du Rohwahrscheinlichkeiten oder eine andere Skala bevorzugst:

import os

os.environ["COMET_MAX_CONFIDENCE_SCORE"] = "1.0"  # log raw [0, 1] scores

Link to this sectionZusammenfassung#

Dieser Leitfaden hat dich durch die Integration von Comet mit Ultralytics' YOLO26 geführt. Von der Installation bis zur Anpassung hast du gelernt, das Experimentmanagement zu optimieren, Echtzeit-Einblicke zu gewinnen und das Logging an die Bedürfnisse deines Projekts anzupassen.

Erkunde die Comet's official YOLOv8 integration documentation, die auch für YOLO26-Projekte gilt.

Darüber hinaus, wenn du tiefer in die praktischen Anwendungen von YOLO26 eintauchen möchtest, insbesondere bei image segmentation-Aufgaben, bietet dieser detaillierte Leitfaden zum fine-tuning YOLO26 with Comet wertvolle Einblicke und Schritt-für-Schritt-Anleitungen zur Verbesserung der Leistung deines Modells.

Schau dir außerdem die integration guide page an, um weitere spannende Integrationen mit Ultralytics zu entdecken, die eine Fülle von Ressourcen und Informationen bietet.

Link to this sectionFAQ#

Link to this sectionWie integriere ich Comet mit Ultralytics YOLO26 für das Training?#

Um Comet mit Ultralytics YOLO26 zu integrieren, befolge diese Schritte:

1. Installiere die erforderlichen Pakete:

   pip install ultralytics comet_ml torch torchvision

2. Richte deinen Comet API-Schlüssel 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 Comet configuration section.

Link to this sectionWas 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, was schnelle Anpassungen ermöglicht.
• Umfangreiche Metriken protokollieren: Erfasse automatisch wesentliche 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 eine bessere Leistung und Reproduzierbarkeit optimieren. Weitere Informationen findest du im Comet integration guide.

Link to this sectionWie passe ich das Logging-Verhalten von Comet während des YOLO26-Trainings an?#

Comet ermöglicht eine umfassende Anpassung des Logging-Verhaltens mithilfe von Umgebungsvariablen:

• Ändere die Anzahl der protokollierten Bildvorhersagen:

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

• Passe das Batch-Logging-Intervall an:

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

• Deaktiviere das Logging der Konfusionsmatrix:

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

• Lege den Namen des Comet-Projekts fest:

  import os
  
  os.environ["COMET_PROJECT_NAME"] = "my-yolo26-experiments"

• Lege den Namen des protokollierten Modell-Artefakts fest:

  import os
  
  os.environ["COMET_MODEL_NAME"] = "yolo26n-coco128"

Siehe den Abschnitt Customizing Comet Logging für die vollständige Liste, einschließlich Umschaltern für Bildvorhersagen, Skalierung von Konfidenzwerten und Online-/Offline-Modus.

Link to this sectionWie kann ich detaillierte Metriken und Visualisierungen meines YOLO26-Trainings auf Comet ansehen?#

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

• Experiment-Panels: Betrachte verschiedene Durchläufe und deren Metriken, einschließlich Segment-Maskenverlust, Klassenverlust und mittlerer durchschnittlicher Genauigkeit.
• Metriken: Untersuche Metriken im tabellarischen Format für eine detaillierte Analyse.
• Interaktive Konfusionsmatrix: Bewerte die Klassifizierungsgenauigkeit mit einer interaktiven Konfusionsmatrix.
• Systemmetriken: Überwache die GPU- und CPU-Auslastung, Speichernutzung und andere Systemmetriken.

Für einen detaillierten Überblick über diese Funktionen besuche den Abschnitt Understanding Your Model's Performance with Comet Visualizations.

Link to this sectionKann ich Comet für die Offline-Protokollierung beim Training von YOLO26-Modellen verwenden?#

Ja. Setze COMET_START_ONLINE=0 vor Beginn des Trainings, um lokal zu protokollieren:

import os

os.environ["COMET_START_ONLINE"] = "0"

Experimentdaten werden auf der Festplatte gespeichert und können später mit der comet upload CLI hochgeladen werden, sobald eine Verbindung besteht. Die frühere Variable COMET_MODE="offline" funktioniert weiterhin, gibt aber eine Deprecation-Warnung aus. Weitere Details findest du im Abschnitt Online and Offline Mode.