Link to this sectionYOLO26-Training verbessern: Vereinfache deinen Logging-Prozess mit Comet#

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

Ultralytics YOLO26 lässt sich nahtlos mit Comet (ehemals Comet ML) integrieren und erfasst sowie 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, damit 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, schneller zu iterieren, verbessert Transparenz und Reproduzierbarkeit und unterstützt die Entwicklung von Produktionsmodellen.

Link to this sectionDie Leistungsfähigkeit von YOLO26 und Comet nutzen#

Durch die Kombination von Ultralytics YOLO26 mit Comet erschließt du dir eine Reihe von Vorteilen. Dazu gehören ein vereinfachtes Experiment-Management, 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 befähigt dich, 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 aus:

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

Link to this sectionComet 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 Key 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, fordert dich der obige Code zur Eingabe deines API-Keys für die Initialisierung auf.

Link to this sectionVerwendung#

Bevor du in die Nutzungsanweisungen eintauchst, schau dir unbedingt die Auswahl an YOLO26 models offered by Ultralytics an. Dies hilft dir, 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-Arbeitsbereich, um den Lauf zu verfolgen. Du erhältst dann einen Link, um das detaillierte Logging 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, interaktive Konfusionsmatrix und Bild-bounding box-Vorhersagen.

Link to this sectionDie Modellleistung 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 Aktionen stattfinden und eine Reihe automatisch protokollierter Informationen 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 und ihre Metriken, wie z. B. Segment-Maskenverlust, Klassenverlust, Präzision und mean average precision.

Metriken

Im Metriken-Bereich hast du zudem die Option, die Metriken in einem tabellarischen Format zu untersuchen, was wie hier dargestellt in einem eigenen Bereich angezeigt wird.

Interaktive Confusion Matrix

Die Konfusionsmatrix, die du im Tab Confusion Matrix findest, bietet eine interaktive Möglichkeit, die Klassifizierungs-accuracy des Modells zu bewerten. Sie zeigt korrekte und inkorrekte Vorhersagen im Detail an, sodass du die Stärken und Schwächen deines Modells verstehen kannst.

Systemmetriken

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

Link to this sectionComet-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. Der Ultralytics-Callback liest die folgenden Umgebungsvariablen (setze diese, bevor das Training beginnt):

Link to this sectionBildvorhersagen protokollieren#

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

In einigen Fällen möchtest du die Konfusionsmatrix möglicherweise nicht nach jeder epoch aus deinem Validierungsset 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 an 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 der 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 project-Trainingsargument an Comet (oder None, wenn das Argument nicht gesetzt ist; in diesem Fall verwendet Comet deinen Arbeitsbereich-Standard). Überschreibe dies mit COMET_PROJECT_NAME, um alle Experimente unabhängig vom YOLO-Trainingsargument an ein spezifisches Comet-Arbeitsbereich-Projekt zu senden:

import os

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

Link to this sectionModell-Artefaktname#

COMET_MODEL_NAME setzt den Namen, den Comet für das protokollierte Modell-Artefakt registriert (Standard ist Ultralytics). Verwende ihn, um Modellvarianten in einem gemeinsamen Arbeitsbereich zu unterscheiden:

import os

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

Link to this sectionSkalierung von Konfidenzwerten#

Konfidenzwerte der Erkennung 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 dem Logging mit COMET_MAX_CONFIDENCE_SCORE (Standard 100.0). Passe dies an, wenn du Rohwahrscheinlichkeiten oder eine andere Skalierung 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 Experiment-Management zu optimieren, Echtzeit-Einblicke zu gewinnen und das Logging an die Bedürfnisse deines Projekts anzupassen.

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

Darüber hinaus, falls du tiefer in die praktischen Anwendungen von YOLO26 eintauchen möchtest, speziell für image segmentation-Aufgaben, bietet dieser detaillierte Leitfaden zum Feintuning von YOLO26 mit Comet wertvolle Einblicke und Schritt-für-Schritt-Anleitungen, um die Leistung deines Modells zu steigern.

Um zudem andere spannende Integrationen mit Ultralytics zu erkunden, sieh dir die Integrationsleitfaden-Seite an, die eine Fülle an 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 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-Konfiguration.

Link to this sectionWas sind die Vorteile der Verwendung 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.
• Umfassende Metriken protokollieren: Erfasse automatisch essentielle 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.

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

Comet ermöglicht eine umfangreiche Anpassung seines 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"

• Setze den Comet-Projekt-Namen:

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

• Setze den Namen des protokollierten Modell-Artefakts:

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

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

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

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: Sieh dir verschiedene Läufe und ihre Metriken an, einschließlich Segment-Maskenverlust, Klassenverlust und mean average precision.
• Metriken: Untersuche Metriken zur detaillierten Analyse im tabellarischen Format.
• Interaktive Konfusionsmatrix: Bewerte die Klassifizierungsgenauigkeit mit einer interaktiven Konfusionsmatrix.
• Systemmetriken: Überwache GPU- und CPU-Auslastung, Speichernutzung und andere Systemmetriken.

Für einen detaillierten Überblick über diese Funktionen besuche den Abschnitt Die Modellleistung mit Comet-Visualisierungen verstehen.

Link to this sectionKann ich Comet für Offline-Logging beim Trainieren von YOLO26-Modellen verwenden?#

Ja. Setze COMET_START_ONLINE=0, bevor das Training beginnt, 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 bei verfügbarer Verbindung zu Comet hochgeladen werden. Die frühere Variable COMET_MODE="offline" funktioniert weiterhin, gibt aber eine Veraltungswarnung aus. Weitere Details findest du im Abschnitt Online- und Offline-Modus.