Schritt-für-Schritt-Anleitung zum Trainieren von YOLO26-Modellen mit IBM Watsonx#

Heutzutage werden skalierbare Computer-Vision-Lösungen immer häufiger eingesetzt und verändern den Umgang mit visuellen Daten. Ein gutes Beispiel ist IBM Watsonx, eine fortschrittliche KI- und Datenplattform, die die Entwicklung, Bereitstellung und Verwaltung von KI-Modellen vereinfacht. Sie bietet eine vollständige Suite für den gesamten KI-Lebenszyklus und eine nahtlose Integration mit IBM Cloud-Diensten.

Du kannst Ultralytics YOLO26-Modelle mit IBM Watsonx trainieren. Das ist eine gute Option für Unternehmen, die an effizientem Modelltraining, der Feinabstimmung für bestimmte Aufgaben und der Verbesserung der Modellleistung mit robusten Tools und einer benutzerfreundlichen Einrichtung interessiert sind. In dieser Anleitung führen wir dich durch den Prozess zum Trainieren von YOLO26 mit IBM Watsonx – von der Einrichtung deiner Umgebung bis zur Bewertung deiner trainierten Modelle. Legen wir los!

Was ist IBM Watsonx?#

Watsonx ist die cloudbasierte Plattform von IBM für kommerzielle generative KI und wissenschaftliche Daten. Die drei Komponenten von IBM Watsonx – watsonx.ai, watsonx.data und watsonx.governance – bilden gemeinsam eine durchgängige, vertrauenswürdige KI-Plattform, die KI-Projekte zur Lösung geschäftlicher Probleme beschleunigen kann. Sie bietet leistungsstarke Tools zum Erstellen, Trainieren und Bereitstellen von Machine-Learning-Modellen und erleichtert die Verbindung mit verschiedenen Datenquellen.

Die benutzerfreundliche Oberfläche und die Funktionen für die Zusammenarbeit optimieren den Entwicklungsprozess und unterstützen eine effiziente Modellverwaltung und -bereitstellung. Ob für Computer Vision, prädiktive Analysen, Verarbeitung natürlicher Sprache oder andere KI-Anwendungen – IBM Watsonx bietet die erforderlichen Tools und Unterstützung, um Innovationen voranzutreiben.

Wichtige Funktionen von IBM Watsonx#

IBM Watsonx besteht aus drei Hauptkomponenten: watsonx.ai, watsonx.data und watsonx.governance. Jede Komponente bietet Funktionen für unterschiedliche Bereiche der KI und des Datenmanagements. Sehen wir sie uns genauer an.

Watsonx.ai#

Watsonx.ai bietet leistungsstarke Tools für die KI-Entwicklung und Zugriff auf von IBM unterstützte benutzerdefinierte Modelle, Modelle von Drittanbietern wie Llama 3 sowie die Granite-Modelle von IBM. Die Plattform umfasst das Prompt Lab zum Experimentieren mit KI-Prompts, das Tuning Studio zur Verbesserung der Modellleistung mit gelabelten Daten und die Flows Engine zur Vereinfachung der Entwicklung generativer KI-Anwendungen. Außerdem bietet sie umfassende Tools zur Automatisierung des KI-Modelllebenszyklus und zur Verbindung mit verschiedenen APIs und Bibliotheken.

Watsonx.data#

Watsonx.data unterstützt über die Integration mit IBM Storage Fusion HCI sowohl Cloud- als auch On-Premises-Bereitstellungen. Die benutzerfreundliche Konsole bietet zentralen Zugriff auf Daten in verschiedenen Umgebungen und erleichtert die Datenexploration mit gängigem SQL. Sie optimiert Workloads mit effizienten Abfrage-Engines wie Presto und Spark, beschleunigt Datenerkenntnisse mit einer KI-gestützten semantischen Ebene, umfasst eine Vektordatenbank für KI-Relevanz und unterstützt offene Datenformate zum einfachen Teilen von Analyse- und KI-Daten.

Watsonx.governance#

Watsonx.governance erleichtert die Compliance, indem es regulatorische Änderungen automatisch erkennt und Richtlinien durchsetzt. Die Plattform verknüpft Anforderungen mit internen Risikodaten und stellt aktuelle KI-Faktenblätter bereit. Sie unterstützt das Risikomanagement mit Warnungen und Tools zur Erkennung von Problemen wie Verzerrungen und Drift. Außerdem automatisiert sie die Überwachung und Dokumentation des KI-Lebenszyklus, organisiert die KI-Entwicklung mit einem Modellbestand und verbessert die Zusammenarbeit durch benutzerfreundliche Dashboards und Berichtstools.

So trainierst du YOLO26 mit IBM Watsonx#

Du kannst IBM Watsonx verwenden, um deinen Workflow für das Training von YOLO26-Modellen zu beschleunigen.

Voraussetzungen#

Du benötigst ein IBM Cloud-Konto, um ein watsonx.ai-Projekt zu erstellen. Außerdem brauchst du ein Kaggle-Konto, um den Datensatz zu laden.

Schritt 1: Richte deine Umgebung ein#

Zuerst musst du ein IBM-Konto einrichten, um ein Jupyter Notebook zu verwenden. Melde dich mit deinem IBM Cloud-Konto bei watsonx.ai an.

Erstelle anschließend ein watsonx.ai-Projekt und ein Jupyter Notebook.

Danach wird eine Notebook-Umgebung geöffnet, in die du deinen Datensatz laden kannst. Mit dem Code aus diesem Tutorial kannst du eine einfache Aufgabe zum Training eines Objekterkennungsmodells bearbeiten.

Schritt 2: Installiere und importiere die erforderlichen Bibliotheken#

Als Nächstes kannst du die erforderlichen Python-Bibliotheken installieren und importieren.

# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headless

Ausführliche Anweisungen und bewährte Vorgehensweisen zur Installation findest du in unserem Installationsleitfaden von Ultralytics. Sollten bei der Installation der für YOLO26 erforderlichen Pakete Schwierigkeiten auftreten, findest du in unserem Leitfaden zu häufigen Problemen Lösungen und Tipps.

Anschließend kannst du die benötigten Pakete importieren.

import ultralytics

ultralytics.checks()

Schritt 3: Lade die Daten#

Für dieses Tutorial verwenden wir einen auf Kaggle verfügbaren Datensatz zu Meeresmüll. Mit diesem Datensatz trainieren wir ein YOLO26-Modell speziell darauf, Müll und biologische Objekte in Unterwasserbildern zu erkennen und zu klassifizieren.

Wir können den Datensatz direkt über die Kaggle API in das Notebook laden. Erstelle zunächst ein kostenloses Kaggle-Konto. Nach der Kontoerstellung musst du einen API-Schlüssel generieren. Eine Anleitung zum Generieren des Schlüssels findest du in der Kaggle API-Dokumentation im Abschnitt „API credentials“.

Kopiere deinen Kaggle-Benutzernamen und den API-Schlüssel in den folgenden Code und füge sie dort ein. Führe den Code anschließend aus, um die API zu installieren und den Datensatz in Watsonx zu laden.

# Install kaggle
pip install kaggle

Nach der Installation von Kaggle können wir den Datensatz in Watsonx laden.

# Replace "username" string with your username
os.environ["KAGGLE_USERNAME"] = "username"
# Replace "apiKey" string with your key
os.environ["KAGGLE_KEY"] = "apiKey"

# Load dataset
os.system("kaggle datasets download atiqishrak/trash-dataset-icra19 --unzip")

# Store working directory path as work_dir
work_dir = os.getcwd()

# Print work_dir path
print(os.getcwd())

# Print work_dir contents
print(os.listdir(f"{work_dir}"))

# Print trash_ICRA19 subdirectory contents
print(os.listdir(f"{work_dir}/trash_ICRA19"))

Nach dem Laden des Datensatzes haben wir unser Arbeitsverzeichnis ausgegeben und gespeichert. Außerdem haben wir den Inhalt unseres Arbeitsverzeichnisses ausgegeben, um zu bestätigen, dass der Datensatz „trash_ICRA19“ korrekt geladen wurde.

Wenn „trash_ICRA19“ im Verzeichnisinhalt angezeigt wird, wurde der Datensatz erfolgreich geladen. Du solltest drei Dateien bzw. Verzeichnisse sehen: eine config.yaml-Datei, ein videos_for_testing-Verzeichnis und ein dataset-Verzeichnis. Das videos_for_testing-Verzeichnis ignorieren wir, du kannst es also problemlos löschen.

Wir verwenden die Datei config.yaml und den Inhalt des Datensatzverzeichnisses, um unser Objekterkennungsmodell zu trainieren. Hier ist ein Beispielbild aus unserem Datensatz zu Meeresmüll.

Schritt 4: Verarbeite die Daten vor#

Glücklicherweise sind alle Labels im Datensatz zu Meeresmüll bereits als YOLO-.txt-Dateien formatiert. Wir müssen jedoch die Struktur der Bild- und Labelverzeichnisse neu ordnen, damit unser Modell die Bilder und Labels verarbeiten kann. Derzeit hat das geladene Datensatzverzeichnis folgende Struktur:

YOLO-Modelle erwarten standardmäßig jedoch separate Bilder und Labels in Unterverzeichnissen innerhalb der Aufteilung in train/val/test. Wir müssen das Verzeichnis in die folgende Struktur umorganisieren:

Um das Datensatzverzeichnis neu zu organisieren, können wir das folgende Skript ausführen:

# Function to reorganize dir
def organize_files(directory):
    for subdir in ["train", "test", "val"]:
        subdir_path = os.path.join(directory, subdir)
        if not os.path.exists(subdir_path):
            continue

        images_dir = os.path.join(subdir_path, "images")
        labels_dir = os.path.join(subdir_path, "labels")

        # Create image and label subdirs if non-existent
        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        # Move images and labels to respective subdirs
        for filename in os.listdir(subdir_path):
            if filename.endswith(".txt"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(labels_dir, filename))
            elif filename.endswith((".jpg", ".png", ".jpeg")):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))
            # Delete .xml files
            elif filename.endswith(".xml"):
                os.remove(os.path.join(subdir_path, filename))

if __name__ == "__main__":
    directory = f"{work_dir}/trash_ICRA19/dataset"
    organize_files(directory)

Als Nächstes müssen wir die .yaml-Datei für den Datensatz ändern. Diese Konfiguration verwenden wir in unserer .yaml-Datei. Die Klassen-ID-Nummern beginnen bei 0:

path: /path/to/dataset/directory # root directory for dataset
train: train/images # train images subdirectory
val: train/images # validation images subdirectory
test: test/images # test images subdirectory

# Classes
names:
    0: plastic
    1: bio
    2: rov

Führe das folgende Skript aus, um den aktuellen Inhalt von config.yaml zu löschen und durch die Konfiguration für die neue Verzeichnisstruktur des Datensatzes zu ersetzen. Das Skript verwendet automatisch die zuvor definierte Variable work_dir. Stelle daher vor der Ausführung sicher, dass sie auf deinen Datensatz verweist, und ändere die Definitionen der train-, val- und test-Unterverzeichnisse nicht.

# Contents of new config.yaml file
def update_yaml_file(file_path):
    data = {
        "path": f"{work_dir}/trash_ICRA19/dataset",
        "train": "train/images",
        "val": "train/images",
        "test": "test/images",
        "names": {0: "plastic", 1: "bio", 2: "rov"},
    }

    # Ensures the "names" list appears after the sub/directories
    names_data = data.pop("names")
    with open(file_path, "w") as yaml_file:
        yaml.dump(data, yaml_file)
        yaml_file.write("\n")
        yaml.dump({"names": names_data}, yaml_file)

if __name__ == "__main__":
    file_path = f"{work_dir}/trash_ICRA19/config.yaml"  # .yaml file path
    update_yaml_file(file_path)
    print(f"{file_path} updated successfully.")

Schritt 5: Trainiere das YOLO26-Modell#

Führe den folgenden Befehlszeilencode aus, um ein vortrainiertes YOLO26-Standardmodell fein abzustimmen.

!yolo detect train data={work_dir}/trash_ICRA19/config.yaml model=yolo26n.pt epochs=2 batch=32 lr0=.04 plots=True

Hier siehst du die Parameter im Befehl für das Modelltraining genauer:

• detect: Die Computer Vision-Aufgabe, für die du das angegebene YOLO-Modell und den Datensatz verwendest.
• train: Der Modus, der den Zweck angibt, für den du das angegebene Modell und die Daten lädst. Später, wenn wir die Leistung vom Modell testen, verwenden wir predict.
• epochs: Gibt an, wie oft YOLO26 den gesamten Datensatz durchläuft.
• batch: Dieser Zahlenwert legt die Batchgrößen für das Training fest. Batches geben an, wie viele Bilder ein Modell verarbeitet, bevor es seine Parameter aktualisiert.
• lr0: Gibt die anfängliche Lernrate des Modells an.
• plots: Weist YOLO an, Diagramme der Trainings- und Evaluierungsmetriken unseres Modells zu erstellen und zu speichern.

Eine ausführliche Beschreibung des Modelltrainingsprozesses und bewährter Vorgehensweisen findest du in der Anleitung zum Training von YOLO26-Modellen. Diese Anleitung hilft dir, das Beste aus deinen Experimenten herauszuholen und YOLO26 effektiv einzusetzen.

Schritt 6: Teste das Modell#

Jetzt können wir eine Inferenz ausführen, um die Leistung unseres fein abgestimmten Modells zu testen:

!yolo detect predict source={work_dir}/trash_ICRA19/dataset/test/images model={work_dir}/runs/detect/train/weights/best.pt conf=0.5 iou=.5 save=True save_txt=True

Dieses kurze Skript erzeugt vorhergesagte Labels für jedes Bild in unserem Testdatensatz sowie neue Ausgabebilddateien, in denen die vorhergesagene Bounding Box über dem Originalbild eingeblendet wird.

Die vorhergesagten .txt-Labels für jedes Bild werden über das Argument save_txt=True gespeichert. Die Ausgabebilder mit eingeblendeten Bounding Boxes werden über das Argument save=True erzeugt. Der Parameter conf=0.5 weist das Modell an, alle Vorhersagen mit einer Konfidenz von weniger als 50 % zu ignorieren.

Schließlich weist iou=.5 das Modell an, Boxen derselben Klasse mit einer Überlappung von mindestens 50 % zu ignorieren. Dadurch werden mögliche doppelte Boxen für dasselbe Objekt reduziert. Wir können die Bilder mit den eingeblendeten vorhergesagten Bounding Boxes laden, um die Leistung unseres Modells anhand einiger Bilder zu betrachten.

# Show the first ten images from the preceding prediction task
for pred_dir in glob.glob(f"{work_dir}/runs/detect/predict/*.jpg")[:10]:
    img = Image.open(pred_dir)
    display(img)

Der obige Code zeigt zehn Bilder aus dem Testdatensatz mit ihren vorhergesagten Bounding Boxes sowie Labels mit Klassennamen und Konfidenzwerten.

Schritt 7: Bewerte das Modell#

Wir können Visualisierungen der Precision und des Recalls für jede Klasse erstellen. Diese Visualisierungen werden im Verzeichnis des Trainingslaufs ({work_dir}/runs/detect/train/) gespeichert. Der Precision-Wert wird in BoxP_curve.png angezeigt:

Das Diagramm zeigt einen exponentiellen Anstieg der Precision, wenn die Konfidenz der Vorhersagen durch das Modell zunimmt. Nach zwei Epochen hat sich die Precision des Modells bei einem bestimmten Konfidenzwert jedoch noch nicht stabilisiert.

Das Recall-Diagramm (BoxR_curve.png) zeigt einen gegenläufigen Trend:

Im Gegensatz zur Precision bewegt sich der Recall in die entgegengesetzte Richtung: Bei Instanzen mit geringerer Konfidenz ist der Recall höher, bei Instanzen mit höherer Konfidenz dagegen niedriger. Dies ist ein anschauliches Beispiel für den Zielkonflikt zwischen Precision und Recall bei Klassifizierungsmodellen.

Schritt 8: Intersection over Union berechnen#

Du kannst die Genauigkeit der Vorhersage messen, indem du die IoU zwischen einer vorhergesagten Bounding Box und einer Ground-Truth-Bounding-Box für dasselbe Objekt berechnest. Weitere Informationen findest du im IBM-Tutorial zum Training von YOLO26.

Zusammenfassung#

Wir haben die wichtigsten Funktionen von IBM Watsonx und das Training eines YOLO26-Modells mit IBM Watsonx untersucht. Außerdem haben wir gesehen, wie IBM Watsonx deine KI-Workflows mit fortschrittlichen Tools für die Modellerstellung, das Datenmanagement und die Compliance verbessern kann.

Weitere Informationen zur Verwendung findest du in der offiziellen IBM-Watsonx-Dokumentation.

Sieh dir außerdem die Ultralytics-Integrationsübersicht an, um mehr über verschiedene spannende Integrationen zu erfahren.

FAQ#