Eine Schritt-für-Schritt-Anleitung zum Training von YOLO26-Modellen mit IBM Watsonx

Heutzutage werden skalierbare Computer-Vision-Lösungen immer häufiger eingesetzt und verändern die Art und Weise, wie wir mit visuellen Daten umgehen. Ein hervorragendes 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 sowie eine nahtlose Integration mit IBM Cloud-Diensten.

Du kannst Ultralytics YOLO26-Modelle mit IBM Watsonx trainieren. Es ist eine gute Option für Unternehmen, die an effizientem Modelltraining, Feinabstimmung für spezifische Aufgaben und der Verbesserung der Modellleistung mit robusten Tools und einer benutzerfreundlichen Einrichtung interessiert sind. In diesem Leitfaden führen wir dich durch den Prozess des YOLO26-Trainings mit IBM Watsonx, von der Einrichtung deiner Umgebung bis zur Bewertung deiner trainierten Modelle. Fangen wir an!

Was ist IBM Watsonx?

Watsonx ist die cloudbasierte Plattform von IBM, die für kommerzielle generative KI und wissenschaftliche Daten entwickelt wurde. Die drei Komponenten von IBM Watsonx – watsonx.ai, watsonx.data und watsonx.governance – bilden gemeinsam eine vertrauenswürdige End-to-End-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 ermöglicht eine einfache Anbindung verschiedener Datenquellen.

Die benutzerfreundliche Oberfläche und die Möglichkeiten zur Zusammenarbeit optimieren den Entwicklungsprozess und unterstützen ein effizientes Modellmanagement sowie Deployment. Ob für Computer Vision, prädiktive Analysen, Natural Language Processing oder andere KI-Anwendungen – IBM Watsonx bietet die nötigen Tools und Unterstützung, um Innovationen voranzutreiben.

Hauptfunktionen von IBM Watsonx

IBM Watsonx besteht aus drei Hauptkomponenten: watsonx.ai, watsonx.data und watsonx.governance. Jede Komponente bietet Funktionen, die verschiedene Aspekte des KI- und Datenmanagements abdecken. Schauen wir uns diese genauer an.

Watsonx.ai

Watsonx.ai bietet leistungsstarke Werkzeuge für die KI-Entwicklung und ermöglicht den Zugriff auf von IBM unterstützte benutzerdefinierte Modelle, Drittanbietermodelle wie Llama 3 sowie die eigenen Granite-Modelle von IBM. Es umfasst das Prompt Lab für Experimente mit KI-Prompts, das Tuning Studio zur Verbesserung der Modellleistung mit gelabelten Daten und die Flows Engine zur Vereinfachung der Entwicklung generativer KI-Anwendungen. Zudem bietet es umfassende Tools zur Automatisierung des KI-Modell-Lebenszyklus sowie zur Anbindung verschiedener APIs und Bibliotheken.

Watsonx.data

Watsonx.data unterstützt sowohl Cloud- als auch On-Premises-Deployments durch die IBM Storage Fusion HCI-Integration. Die benutzerfreundliche Konsole bietet einen zentralisierten Zugriff auf Daten über verschiedene Umgebungen hinweg und erleichtert die Datenexploration mit gängigem SQL. Sie optimiert Workloads mit effizienten Query-Engines wie Presto und Spark, beschleunigt Dateneinblicke mit einer KI-gestützten semantischen Ebene, enthält eine Vektordatenbank für KI-Relevanz 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. Es verknüpft Anforderungen mit internen Risikodaten und stellt aktuelle KI-Factsheets bereit. Die Plattform hilft beim Risikomanagement durch Warnmeldungen und Tools zur Erkennung von Problemen wie Bias und Drift. Zudem automatisiert sie die Überwachung und Dokumentation des KI-Lebenszyklus, organisiert die KI-Entwicklung mit einem Modellverzeichnis und verbessert die Zusammenarbeit durch benutzerfreundliche Dashboards und Berichterstattungstools.

So trainierst du YOLO26 mit IBM Watsonx

Du kannst IBM Watsonx nutzen, um deinen YOLO26-Modelltrainings-Workflow zu beschleunigen.

Voraussetzungen

Du benötigst ein IBM Cloud-Konto, um ein watsonx.ai-Projekt zu erstellen, sowie ein Kaggle-Konto, um den Datensatz zu laden.

Schritt 1: Einrichtung deiner Umgebung

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

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

Sobald du dies getan hast, öffnet sich eine Notebook-Umgebung, in der du deinen Datensatz laden kannst. Du kannst den Code aus diesem Tutorial verwenden, um eine einfache Aufgabe zum Trainieren eines Objekterkennungsmodells zu lösen.

Schritt 2: Installieren und Importieren relevanter Bibliotheken

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

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

Für detaillierte Anleitungen und Best Practices zur Installation, schau in unserem Ultralytics-Installationsleitfaden nach. Wenn du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, konsultiere unseren Leitfaden für allgemeine Probleme für Lösungen und Tipps.

Dann kannst du die erforderlichen Pakete importieren.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Schritt 3: Daten laden

Für dieses Tutorial verwenden wir einen Meeresmüll-Datensatz, der auf Kaggle verfügbar ist. Mit diesem Datensatz trainieren wir ein YOLO26-Modell individuell, um 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 zuerst ein kostenloses Kaggle-Konto. Sobald du ein Konto erstellt hast, musst du einen API-Schlüssel generieren. Anleitungen zur Generierung deines Schlüssels findest du in der Kaggle API-Dokumentation im Abschnitt "API credentials".

Kopiere deinen Kaggle-Benutzernamen und deinen API-Schlüssel in den folgenden Code. Führe dann den Code 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. Wir haben auch den Inhalt unseres Arbeitsverzeichnisses ausgegeben, um zu bestätigen, dass der "trash_ICRA19"-Datensatz korrekt geladen wurde.

Wenn du "trash_ICRA19" im Verzeichnisinhalt siehst, wurde er erfolgreich geladen. Du solltest drei Dateien/Ordner sehen: eine config.yaml-Datei, ein videos_for_testing-Verzeichnis und ein dataset-Verzeichnis. Wir werden das videos_for_testing-Verzeichnis ignorieren, also kannst du es gerne löschen.

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

Schritt 4: Daten vorverarbeiten

Glücklicherweise sind alle Labels im Meeresmüll-Datensatz bereits als YOLO-.txt-Dateien formatiert. Wir müssen jedoch die Struktur der Bild- und Label-Verzeichnisse anpassen, damit unser Modell die Bilder und Labels verarbeiten kann. Aktuell folgt unser geladenes Datensatzverzeichnis dieser Struktur:

YOLO-Modelle erfordern jedoch standardmäßig separate Bilder und Labels in Unterverzeichnissen innerhalb der Aufteilung für Training/Validierung/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") or filename.endswith(".png") or filename.endswith(".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. Dies ist das Setup, das wir in unserer .yaml-Datei verwenden werden. 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 der config.yaml zu löschen und durch die Konfiguration zu ersetzen, die unsere neue Datensatzverzeichnisstruktur widerspiegelt. Das Skript verwendet automatisch die work_dir-Variable, die wir zuvor definiert haben. Stelle also sicher, dass sie vor der Ausführung auf deinen Datensatz zeigt, und lasse die Definitionen der Unterverzeichnisse für Training, Validierung und Test unverändert.

# 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 Standard-YOLO26-Modell feinabzustimmen.

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

Hier ist ein genauerer Blick auf die Parameter im Modelltrainingsbefehl:

• task: Gibt die Computer Vision-Aufgabe an, für die du das angegebene YOLO-Modell und den Datensatz verwendest.
• mode: Gibt den Zweck an, für den du das angegebene Modell und die Daten lädst. Da wir ein Modell trainieren, ist er auf "train" gesetzt. Später, wenn wir die Modellleistung testen, setzen wir ihn auf "predict".
• epochs: Dies begrenzt die Anzahl der Durchläufe, die YOLO26 durch unseren gesamten Datensatz macht.
• batch: Der numerische Wert bestimmt die Batch-Größen für das Training. Batches sind die Anzahl der Bilder, die ein Modell verarbeitet, bevor es seine Parameter aktualisiert.
• lr0: Gibt die anfängliche Lernrate des Modells an.
• plots: Weist YOLO an, Plots unserer Trainings- und Bewertungsmetriken zu generieren und zu speichern.

Für ein detailliertes Verständnis des Modelltrainingsprozesses und bewährter Verfahren lies bitte den YOLO26-Modelltrainingsleitfaden. Dieser Leitfaden hilft dir, das Beste aus deinen Experimenten herauszuholen und sicherzustellen, dass du YOLO26 effektiv einsetzt.

Schritt 6: Modell testen

Wir können nun die Inferenz ausführen, um die Leistung unseres feinabgestimmten Modells zu testen:

!yolo task=detect mode=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 generiert vorhergesagte Labels für jedes Bild in unserem Test-Set sowie neue Ausgabebilddateien, bei denen die vorhergesagte Bounding Box über das Originalbild gelegt wird.

Vorhergesagte .txt-Labels für jedes Bild werden über das Argument save_txt=True gespeichert, und die Ausgabebilder mit Bounding-Box-Overlays werden durch das Argument save=True generiert. Der Parameter conf=0.5 weist das Modell an, alle Vorhersagen mit einem Konfidenzniveau von weniger als 50 % zu ignorieren.

Schließlich weist iou=.5 das Modell an, Boxen derselben Klasse mit einer Überlappung von 50 % oder mehr zu ignorieren. Dies hilft, mögliche doppelte Boxen für dasselbe Objekt zu reduzieren. Wir können die Bilder mit den vorhergesagten Bounding-Box-Overlays laden, um zu sehen, wie unser Modell bei einer Handvoll Bildern abschneidet.

# 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 Test-Set mit ihren vorhergesagten Bounding Boxen an, begleitet von Klassennamen-Labels und Konfidenzniveaus.

Schritt 7: Modell bewerten

Wir können Visualisierungen der Präzision und des Recalls des Modells für jede Klasse erstellen. Diese Visualisierungen werden im Home-Verzeichnis unter dem train-Ordner gespeichert. Der Präzisionswert wird in der P_curve.png angezeigt:

Die Grafik zeigt einen exponentiellen Anstieg der Präzision, wenn das Konfidenzniveau des Modells für Vorhersagen steigt. Die Modellpräzision hat sich jedoch nach zwei Epochen noch nicht bei einem bestimmten Konfidenzniveau eingepegelt.

Die Recall-Grafik (R_curve.png) zeigt einen umgekehrten Trend:

Im Gegensatz zur Präzision bewegt sich der Recall in die entgegengesetzte Richtung und zeigt einen höheren Recall bei Instanzen mit niedrigerer Konfidenz und einen niedrigeren Recall bei Instanzen mit höherer Konfidenz. Dies ist ein passendes Beispiel für den Zielkonflikt zwischen Präzision und Recall bei Klassifizierungsmodellen.

Schritt 8: Berechnung von Intersection Over Union

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

Zusammenfassung

Wir haben die Hauptfunktionen von IBM Watsonx untersucht und wie man ein YOLO26-Modell mit IBM Watsonx trainiert. Wir haben auch gesehen, wie IBM Watsonx deine KI-Workflows mit fortschrittlichen Tools für Modellbau, Datenmanagement und Compliance verbessern kann.

Für weitere Details zur Nutzung besuche die offizielle IBM Watsonx-Dokumentation.

Schau dir auch die Ultralytics-Integrationsleitfaden-Seite an, um mehr über verschiedene spannende Integrationen zu erfahren.

FAQ

Wie trainiere ich ein YOLO26-Modell mit IBM Watsonx?

Um ein YOLO26-Modell mit IBM Watsonx zu trainieren, befolge diese Schritte:

1. Einrichtung deiner Umgebung: Erstelle ein IBM Cloud-Konto und richte ein Watsonx.ai-Projekt ein. Verwende ein Jupyter Notebook als deine Programmierumgebung.
2. Bibliotheken installieren: Installiere notwendige Bibliotheken wie torch, opencv und ultralytics.
3. Daten laden: Verwende die Kaggle-API, um deinen Datensatz in Watsonx zu laden.
4. Daten vorverarbeiten: Organisiere deinen Datensatz in die erforderliche Verzeichnisstruktur und aktualisiere die .yaml-Konfigurationsdatei.
5. Modell trainieren: Verwende die YOLO-Befehlszeilenschnittstelle, um dein Modell mit spezifischen Parametern wie epochs, batch size und learning rate zu trainieren.
6. Testen und Bewerten: Führe eine Inferenz durch, um das Modell zu testen und seine Leistung anhand von Metriken wie Präzision und Recall zu bewerten.

Detaillierte Anweisungen findest du in unserem YOLO26-Modelltrainingsleitfaden.

Was sind die Hauptfunktionen von IBM Watsonx für das KI-Modelltraining?

IBM Watsonx bietet mehrere Hauptfunktionen für das KI-Modelltraining:

• Watsonx.ai: Bietet Tools für die KI-Entwicklung, einschließlich Zugriff auf von IBM unterstützte benutzerdefinierte Modelle und Drittanbietermodelle wie Llama 3. Es umfasst das Prompt Lab, Tuning Studio und die Flows Engine für ein umfassendes Lebenszyklusmanagement von KI.
• Watsonx.data: Unterstützt Cloud- und On-Premises-Deployments und bietet zentralisierten Datenzugriff, effiziente Query-Engines wie Presto und Spark sowie eine KI-gestützte semantische Ebene.
• Watsonx.governance: Automatisiert Compliance, verwaltet Risiken durch Warnmeldungen und bietet Tools zur Erkennung von Problemen wie Bias und Drift. Es enthält außerdem Dashboards und Berichtstools für die Zusammenarbeit.

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

Warum sollte ich IBM Watsonx zum Trainieren von Ultralytics YOLO26-Modellen verwenden?

IBM Watsonx ist eine exzellente Wahl für das Training von Ultralytics YOLO26-Modellen aufgrund seiner umfassenden Suite an Tools, die den KI-Lebenszyklus optimieren. Zu den wichtigsten Vorteilen gehören:

• Skalierbarkeit: Skaliere dein Modelltraining ganz einfach mit IBM Cloud-Diensten.
• Integration: Nahtlose Integration mit verschiedenen Datenquellen und APIs.
• Benutzerfreundliche Oberfläche: Vereinfacht den Entwicklungsprozess mit einer kollaborativen und intuitiven Schnittstelle.
• Fortschrittliche Tools: Zugriff auf leistungsstarke Werkzeuge wie das Prompt Lab, Tuning Studio und die Flows Engine zur Verbesserung der Modellleistung.

Erfahre mehr über Ultralytics YOLO26 und wie du Modelle mit IBM Watsonx in unserem Integrationsleitfaden trainierst.

Wie kann ich meinen Datensatz für das YOLO26-Training auf IBM Watsonx vorverarbeiten?

So bereitest du deinen Datensatz für das YOLO26-Training auf IBM Watsonx vor:

1. Verzeichnisse organisieren: Stelle sicher, dass dein Datensatz der YOLO-Verzeichnisstruktur folgt, mit separaten Unterverzeichnissen für Bilder und Labels innerhalb der Aufteilung für Training/Validierung/Test.
2. ** .yaml-Datei aktualisieren**: Ändere die .yaml-Konfigurationsdatei, um die neue Verzeichnisstruktur und die Klassennamen widerzuspiegeln.
3. Vorverarbeitungsskript ausführen: Verwende ein Python-Skript, um deinen Datensatz neu zu organisieren und die .yaml-Datei entsprechend zu aktualisieren.

Hier ist ein Beispielskript zur Organisation deines Datensatzes:

import os
import shutil

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

        os.makedirs(images_dir, exist_ok=True)
        os.makedirs(labels_dir, exist_ok=True)

        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") or filename.endswith(".png") or filename.endswith(".jpeg"):
                shutil.move(os.path.join(subdir_path, filename), os.path.join(images_dir, filename))

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

Weitere Details findest du in unserem Daten-Vorverarbeitungsleitfaden.

Was sind die Voraussetzungen für das Training eines YOLO26-Modells auf IBM Watsonx?

Bevor du mit dem Training eines YOLO26-Modells auf IBM Watsonx beginnst, stelle sicher, dass du die folgenden Voraussetzungen erfüllst:

• IBM Cloud-Konto: Erstelle ein Konto bei IBM Cloud, um auf Watsonx.ai zuzugreifen.
• Kaggle-Konto: Zum Laden von Datensätzen benötigst du ein Kaggle-Konto und einen API-Schlüssel.
• Jupyter Notebook: Richte eine Jupyter Notebook-Umgebung in Watsonx.ai für das Programmieren und das Modelltraining ein.

Weitere Informationen zur Einrichtung deiner Umgebung findest du in unserem Ultralytics Installationshandbuch.