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

Heutzutage werden skalierbare Computer-Vision-Lösungen immer verbreiteter und verändern den Umgang mit visuellen Daten. Ein gutes Beispiel ist IBM Watsonx, eine fortschrittliche KI- und Datenplattform, 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 leistungsstarken Tools und einer benutzerfreundlichen Einrichtung interessiert sind. In dieser Anleitung führen wir dich durch das Training von YOLO26 mit IBM Watsonx – von der Einrichtung deiner Umgebung bis zur Bewertung deiner trainierten Modelle. Los geht's!

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 und Trainieren sowie zum Bereitstellen von Machine-Learning-Modellen und erleichtert die Anbindung an verschiedene Datenquellen.

Die benutzerfreundliche Oberfläche und die Funktionen zur Zusammenarbeit vereinfachen 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 nötigen 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 Datenverwaltung. 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 IBMs eigene Granite-Modelle. Die Plattform umfasst das Prompt Lab zum Experimentieren mit KI-Prompts, das Tuning Studio zur Verbesserung der Modellleistung mit annotierten 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 Anbindung an verschiedene APIs und Bibliotheken.

Watsonx.data#

Watsonx.data unterstützt sowohl Cloud- als auch lokale Bereitstellungen über die Integration mit IBM Storage Fusion HCI. Die benutzerfreundliche Konsole ermöglicht den zentralen Zugriff auf Daten aus verschiedenen Umgebungen und erleichtert die Datenexploration mit gängigen SQL-Abfragen. Die Plattform optimiert Arbeitslasten mit effizienten Abfrage-Engines wie Presto und Spark, beschleunigt die Gewinnung von Erkenntnissen aus Daten mithilfe einer KI-gestützten semantischen Ebene, enthält eine Vektordatenbank für KI-Anwendungen und unterstützt offene Datenformate für den einfachen Austausch von Analyse- und KI-Daten.

Watsonx.governance#

Watsonx.governance erleichtert die Einhaltung von Vorschriften, indem es regulatorische Änderungen automatisch erkennt und Richtlinien durchsetzt. Die Plattform verknüpft Anforderungen mit internen Risikodaten und stellt aktuelle KI-Factsheets bereit. Sie unterstützt das Risikomanagement mit Warnmeldungen 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 Modellinventar und verbessert die Zusammenarbeit durch benutzerfreundliche Dashboards und Berichtswerkzeuge.

YOLO26 mit IBM Watsonx trainieren#

Mit IBM Watsonx kannst du den Trainingsablauf deines YOLO26-Modells 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: Umgebung einrichten#

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 Trainingsaufgabe für ein Objekterkennungsmodell bearbeiten.

Schritt 2: Erforderliche Bibliotheken installieren und importieren#

Als Nächstes kannst du die benötigten 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 unserer Installationsanleitung von Ultralytics. Falls bei der Installation der für YOLO26 erforderlichen Pakete Probleme auftreten, findest du Lösungen und Tipps in unserer Anleitung zu häufigen Problemen.

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

import ultralytics

ultralytics.checks()

Schritt 3: Daten laden#

In diesem 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 mithilfe der Kaggle API direkt in das Notebook laden. Erstelle zuerst ein kostenloses Kaggle-Konto. Danach musst du einen API-Schlüssel generieren. Eine Anleitung dazu findest du im Abschnitt „API credentials“ der Kaggle-API-Dokumentation.

Kopiere deinen Kaggle-Benutzernamen und deinen 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

Nachdem Kaggle installiert ist, 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"))

Nachdem wir den Datensatz geladen hatten, haben wir unser Arbeitsverzeichnis ausgegeben und gespeichert. Außerdem haben wir den Inhalt des 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. Ordner sehen: eine Datei config.yaml, ein Verzeichnis videos_for_testing und ein Verzeichnis dataset. Das Verzeichnis videos_for_testing benötigen wir nicht und du kannst es löschen.

Wir verwenden die Datei config.yaml und den Inhalt des Datensatzverzeichnisses, um unser Modell zur Objekterkennung zu trainieren. Hier siehst du ein Beispielbild aus unserem Datensatz zu Meeresmüll.

Schritt 4: Daten vorverarbeiten#

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

YOLO-Modelle erwarten standardmäßig jedoch getrennte Bild- und Label-Unterverzeichnisse innerhalb der train/val/test-Aufteilung. Wir müssen das Verzeichnis daher wie folgt neu strukturieren:

Um das Datensatzverzeichnis neu zu strukturieren, 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 anpassen. So sieht die Konfiguration aus, die wir in unserer .yaml-Datei verwenden. Die Klassen-IDs 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. Ändere außerdem nicht die Definitionen der train-, val- und test-Unterverzeichnisse.

# 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: YOLO26-Modell trainieren#

Führe den folgenden Befehlszeilencode aus, um ein vortrainiertes YOLO26-Standardmodell weiter zu trainieren.

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

Hier findest du eine genauere Erläuterung der Parameter im Modelltrainingsbefehl:

• detect: Die Computer-Vision-Aufgabe, für die du das angegebene YOLO-Modell und den Datensatz verwendest.
• train: Der Modus, der angibt, zu welchem Zweck du das angegebene Modell und die Daten lädst. Wenn wir später die Modellleistung testen, verwenden wir predict.
• epochs: Gibt an, wie oft YOLO26 den gesamten Datensatz durchläuft.
• Stapel: Der Zahlenwert legt die Trainings-Stapelgrößen fest. Stapel geben an, wie viele Bilder ein Modell verarbeitet, bevor es seine Parameter aktualisiert.
• Diagramme: Weist YOLO an, Diagramme der Trainings- und Evaluierungsmetriken unseres Modells zu erstellen und zu speichern.

Ausführliche Informationen zum Modelltraining und zu bewährten 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: Modell testen#

Wir können nun eine Inferenz ausführen, um die Leistung unseres feinabgestimmten 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 Testsatz sowie neue Ausgabebilddateien, in denen die vorhergesagten Begrenzungsrahmen über das Originalbild gelegt werden.

Vorhergesagte .txt-Labels für jedes Bild werden mit dem Argument save_txt=True gespeichert. Die Ausgabebilder mit den eingeblendeten Begrenzungsrahmen werden über das Argument save=True erstellt. 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, Rahmen derselben Klasse bei einer Überlappung von mindestens 50 % zu ignorieren. Dadurch lassen sich mögliche doppelte Rahmen für dasselbe Objekt reduzieren. Wir können die Bilder mit eingeblendeten vorhergesagten Begrenzungsrahmen laden, um die Leistung unseres Modells anhand einiger Bilder zu prüfen.

# 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 Testsatz mit den vorhergesagten Begrenzungsrahmen sowie Klassenbezeichnungen und Konfidenzwerten.

Schritt 7: Modell auswerten#

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

Das Diagramm zeigt einen exponentiellen Anstieg der Präzision, wenn die Konfidenz der Modellvorhersagen zunimmt. Nach zwei Epochen hat sich die Präzision des Modells bei einem bestimmten Konfidenzwert jedoch noch nicht stabilisiert.

Das Diagramm für den Recall (BoxR_curve.png) zeigt einen gegenläufigen Trend:

Anders als die Präzision entwickelt sich der Recall in die entgegengesetzte Richtung: Bei geringer Konfidenz ist der Recall höher, bei hoher Konfidenz niedriger. Dies veranschaulicht den Zielkonflikt zwischen Präzision und Recall bei Klassifizierungsmodellen.

Schritt 8: Intersection over Union berechnen#

Du kannst die Genauigkeit der Vorhersage messen, indem du für dasselbe Objekt die IoU zwischen einem vorhergesagten Begrenzungsrahmen und einem Referenz-Begrenzungsrahmen berechnest. Weitere Informationen findest du in IBMs Anleitung zum Training von YOLO26.

Zusammenfassung#

Wir haben die wichtigsten Funktionen von IBM Watsonx erkundet und erfahren, wie sich ein YOLO26-Modell mit IBM Watsonx trainieren lässt. Außerdem haben wir gesehen, wie IBM Watsonx deine KI-Arbeitsabläufe mit fortschrittlichen Tools für Modellerstellung, Datenverwaltung und Compliance verbessern kann.

Weitere Informationen zur Nutzung findest du in der offiziellen Dokumentation zu IBM Watsonx.

Sieh dir auch die Integrationsanleitungsseite von Ultralytics an, um mehr über verschiedene spannende Integrationen zu erfahren.

Häufig gestellte Fragen#