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

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

Ultralytics YOLO26 integriert sich nahtlos in Comet (ehemals Comet ML) und erfasst sowie optimiert effizient jeden Aspekt deines YOLO26 Objekterkennungs Trainingsprozesses. In diesem Leitfaden behandeln wir den Installationsprozess, die Einrichtung von Comet, Echtzeit-Einblicke, benutzerdefiniertes Logging und die Offline-Nutzung, um sicherzustellen, dass dein YOLO26-Training gründlich dokumentiert und für hervorragende Ergebnisse feinabgestimmt ist.

Comet

Comet ist eine Plattform zum Nachverfolgen, 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 Web-Oberfläche zu überwachen. Comet hilft Data Scientists dabei, schneller zu iterieren, erhöht Transparenz und Reproduzierbarkeit und unterstützt die Entwicklung von Produktionsmodellen.

Die Leistungsfähigkeit 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 befähigt dich, datengestützte Entscheidungen zu treffen, Leistungsmetriken zu analysieren und außergewöhnliche Ergebnisse zu erzielen.

Installation

Um die erforderlichen Pakete zu installieren, führe 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 Keyerhalten und diesen konfigurieren.

# Set your Comet API Key
export COMET_API_KEY=YOUR_API_KEY

Danach 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, wird dich der obige Code zur Eingabe deines API Key für die Initialisierung auffordern.

Usage

Bevor du in die Nutzungsanweisungen eintauchst, schaue dir unbedingt die Auswahl an YOLO26-Modellen von Ultralytics an. Dies hilft dir bei der Auswahl des passendsten 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-Workspace, um den Durchlauf automatisch zu verfolgen. Du erhältst dann einen Link, um das detaillierte Logging deines YOLO26-Modelltrainings 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 boxvorhersagen.

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 Ort, an dem alles passiert, und präsentiert eine Reihe automatisch protokollierter Informationen durch Visualisierungen und Statistiken. Hier ist ein kurzer Rundgang:

Experiment-Panels

Der Abschnitt für Experiment-Panels des Comet-Dashboards organisiert und präsentiert die verschiedenen Durchläufe und deren Metriken, wie Segment-Mask-Loss, Class-Loss, Precision und mean average precision.

Metriken

Im Bereich für Metriken hast du auch die Option, die Metriken in einem tabellarischen Format zu untersuchen, was in einem dedizierten Bereich wie hier illustriert dargestellt wird.

Interaktive Konfusionsmatrix

Die Konfusionsmatrix, die sich im Reiter „Confusion Matrix“ befindet, bietet eine interaktive Möglichkeit, die Klassifizierungs-accuracy des Modells zu bewerten. Sie zeigt die korrekten und inkorrekten Vorhersagen detailliert an, sodass du die Stärken und Schwächen des 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 essenziell, um die Effizienz der Ressourcennutzung während des Modelltrainings zu überwachen.

Comet-Logging anpassen

Comet bietet die Flexibilität, sein 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 hilfreiche 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 Validierungsset. Du kannst diese Anzahl jedoch ändern, um sie besser an deine Anforderungen anzupassen. 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 COMET_EVAL_BATCH_LOGGING_INTERVAL Umgebungsvariable steuert diese Frequenz. Die Standardeinstellung ist 1, was Vorhersagen aus jedem Validierungs-Batch protokolliert. Du kannst diesen Wert anpassen, um Vorhersagen in einem anderen Intervall zu protokollieren. Zum Beispiel wird eine Einstellung auf 4 Vorhersagen aus jedem vierten Batch protokollieren.

import os

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

Logging der Konfusionsmatrix deaktivieren

In manchen Fällen möchtest du die Konfusionsmatrix deines Validierungssets nicht nach jedem Epoche protokollieren. Du kannst diese Funktion deaktivieren, indem du die COMET_EVAL_LOG_CONFUSION_MATRIX Umgebungsvariable 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

Falls du dich in einer Situation befindest, in der der Internetzugang eingeschränkt ist, bietet Comet eine Option für Offline-Logging. Du kannst die COMET_MODE Umgebungsvariable auf „offline“ setzen, um diese Funktion zu aktivieren. Deine Experimentdaten werden lokal in einem Verzeichnis gespeichert, das du später, wenn Internetverbindung verfügbar ist, in 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, das Experimentmanagement zu rationalisieren, Echtzeit-Einblicke zu gewinnen und das Logging an die Bedürfnisse deines Projekts anzupassen.

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

Wenn du zudem tiefer in die praktischen Anwendungen von YOLO26 eintauchen möchtest, speziell für Bildsegmentierungs Aufgaben, bietet dieser detaillierte Leitfaden zum Feinabstimmen von YOLO26 mit Comet wertvolle Einblicke und Schritt-für-Schritt-Anleitungen, um die Leistung deines Modells zu verbessern.

Schaue dir außerdem die Integrationsleitfaden-Seite an, um andere spannende Integrationen mit Ultralytics zu erkunden, 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, 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,
   )

Für detailliertere Anleitungen siehe die Comet-Konfigurationsabschnitt.

Was 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.
• Umfangreiche Metriken protokollieren: Erfasse automatisch essenzielle 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.

Indem du diese Funktionen nutzt, 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 umfangreiche Anpassung seines Logging-Verhaltens mithilfe von 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"

Du kannst den folgenden Befehl ausführen, um die Validierung zu starten:Comet-Logging anpassen Abschnitt für weitere Anpassungsoptionen.

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: Sieh dir verschiedene Durchläufe und ihre Metriken an, einschließlich Segment-Mask-Loss, Class-Loss und mean average präzisions-.
• Metriken: Untersuche Metriken im Tabellenformat für eine detaillierte Analyse.
• 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 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 COMET_MODE Umgebungsvariable auf „offline“ setzt:

import os

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

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