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

Heutzutage werden skalierbare Computer-Vision-Lösungen immer häufiger und verändern die Art und Weise, wie wir visuelle Daten verarbeiten. 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. Dies ist eine gute Option für Unternehmen, die an effizientem Modelltraining, Feinabstimmung für bestimmte 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 Trainings von YOLO26 mit IBM Watsonx und decken dabei alles von der Einrichtung deiner Umgebung bis zur Evaluierung deiner trainierten Modelle ab. Lass uns anfangen!

Was ist IBM Watsonx?#

Watsonx ist die Cloud-basierte 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 – greifen ineinander, um eine durchgängige, vertrauenswürdige KI-Plattform zu schaffen, die KI-Projekte zur Lösung geschäftlicher Probleme beschleunigen kann. Sie bietet leistungsstarke Tools zum Erstellen, Trainieren und Bereitstellen von Modellen für maschinelles Lernen und erleichtert die Verbindung mit verschiedenen Datenquellen.

Die benutzerfreundliche Oberfläche und die Funktionen für die Zusammenarbeit optimieren den Entwicklungsprozess und unterstützen ein effizientes Modellmanagement und eine effiziente Bereitstellung. Ob für Computer Vision, prädiktive Analysen, Verarbeitung natürlicher Sprache oder andere KI-Anwendungen – IBM Watsonx bietet die Werkzeuge und die Unterstützung, die zur Förderung von Innovationen erforderlich sind.

Hauptmerkmale von IBM Watsonx#

IBM Watsonx besteht aus drei Hauptkomponenten: watsonx.ai, watsonx.data und watsonx.governance. Jede Komponente bietet Funktionen, die auf verschiedene Aspekte der KI- und Datenverwaltung zugeschnitten sind. Werfen wir einen genaueren Blick darauf.

Watsonx.ai#

Watsonx.ai bietet leistungsstarke Tools für die KI-Entwicklung und ermöglicht den Zugriff auf von IBM unterstützte benutzerdefinierte Modelle, Modelle von Drittanbietern wie Llama 3 sowie die eigenen Granite-Modelle von IBM. Es umfasst das Prompt Lab zum Experimentieren mit KI-Prompts, das Tuning Studio zur Verbesserung der Modellleistung mit gekennzeichneten Daten und die Flows Engine zur Vereinfachung der Entwicklung generativer KI-Anwendungen. Darüber hinaus bietet es umfassende Tools zur Automatisierung des KI-Modell-Lebenszyklus und zum Verbinden mit verschiedenen APIs und Bibliotheken.

Watsonx.data#

Watsonx.data unterstützt sowohl Cloud- als auch On-Premises-Bereitstellungen durch die IBM Storage Fusion HCI-Integration. Die benutzerfreundliche Konsole bietet zentralen 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 Datenerkenntnisse durch eine KI-gestützte semantische Ebene, beinhaltet 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 durch die automatische Erkennung regulatorischer Änderungen und die Durchsetzung von Richtlinien. Es verknüpft Anforderungen mit internen Risikodaten und stellt aktuelle KI-Datenblätter zur Verfügung. Die Plattform hilft dabei, Risiken mit Warnungen und Tools zur Erkennung von Problemen wie Voreingenommenheit und Drift zu steuern. Sie automatisiert auch die Überwachung und Dokumentation des KI-Lebenszyklus, organisiert die KI-Entwicklung mit einem Modellverzeichnis und verbessert die Zusammenarbeit durch benutzerfreundliche Dashboards und Berichterstattungstools.

Wie man YOLO26 mit IBM Watsonx trainiert#

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

Voraussetzungen#

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

Schritt 1: Einrichtung deiner Umgebung#

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 dann ein watsonx.ai-Projekt und ein Jupyter Notebook.

Sobald du dies getan hast, öffnet sich eine Notebook-Umgebung, in der du dein Dataset laden kannst. Du kannst den Code aus diesem Tutorial verwenden, um eine einfache Objekterkennungs-Trainingsaufgabe zu bewältigen.

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

Detaillierte Anweisungen und bewährte Methoden zum Installationsprozess findest du in unserer Ultralytics-Installationsanleitung. Wenn während der Installation der erforderlichen Pakete für YOLO26 Schwierigkeiten auftreten, findest du in unserem Leitfaden zu häufigen Problemen 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 Datensatz zu Meeresmüll, der auf Kaggle verfügbar ist. Mit diesem Datensatz trainieren wir ein YOLO26-Modell benutzerdefiniert, um 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 zunächst ein kostenloses Kaggle-Konto. Sobald du ein Konto erstellt hast, musst du einen API-Schlüssel generieren. Anweisungen zum Generieren deines Schlüssels findest du in der Kaggle-API-Dokumentation im Abschnitt „API-Anmeldeinformationen“.

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 das Dataset in Watsonx zu laden.

# Install kaggle
pip install kaggle

Nach der Installation von Kaggle können wir das Dataset 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 Datasets haben wir unser Arbeitsverzeichnis ausgegeben und gespeichert. Wir haben auch den Inhalt unseres Arbeitsverzeichnisses ausgegeben, um zu bestätigen, dass das "trash_ICRA19"-Dataset 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 ignorieren das videos_for_testing-Verzeichnis, du kannst es also 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 Marine-Müll-Dataset 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 Dataset-Verzeichnis dieser Struktur:

YOLO-Modelle erfordern standardmäßig jedoch getrennte Bilder und Labels in Unterverzeichnissen innerhalb des train/val/test-Splits. Wir müssen das Verzeichnis in die folgende Struktur reorganisieren:

Um das Dataset-Verzeichnis 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 das Dataset ändern. Dies ist das Setup, das wir in unserer .yaml-Datei verwenden werden. 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 zu ersetzen, die unsere neue Verzeichnisstruktur des Datensatzes widerspiegelt. Das Skript verwendet automatisch die zuvor definierte Variable work_dir. Stelle also sicher, dass sie vor der Ausführung auf deinen Datensatz verweist, und belasse 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: Das 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: Sie legt die Computer-Vision-Aufgabe fest, für die du das angegebene YOLO-Modell und den Datensatz verwendest.
• mode: Bezeichnet den Zweck, 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 unser gesamtes Dataset macht.
• batch: Der numerische Wert legt die Trainings-Batch-Größen fest. 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, Diagramme unserer Modelltrainings- und Evaluierungsmetriken zu generieren und zu speichern.

Ein detailliertes Verständnis des Modelltrainingsprozesses und bewährter Methoden findest du im Leitfaden zum YOLO26-Modelltraining. Dieser Leitfaden hilft dir dabei, das Beste aus deinen Experimenten herauszuholen und sicherzustellen, dass du YOLO26 effektiv nutzt.

Schritt 6: Das 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 Beschriftungen für jedes Bild in unserem Testset sowie neue Ausgabebilddateien, die den vorhergesagten Bounding Box über das Originalbild legen.

Vorhergesagte .txt-Beschriftungen für jedes Bild werden über das Argument save_txt=True gespeichert, und die Ausgabebilder mit überlagerten Begrenzungsrahmen werden über das Argument save=True generiert. Der Parameter conf=0.5 weist das Modell an, alle Vorhersagen mit einem Konfidenzlevel 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 trägt dazu bei, potenzielle doppelte Boxen zu reduzieren, die für dasselbe Objekt generiert wurden. Wir können die Bilder mit den überlagerten vorhergesagten Begrenzungsrahmen laden, um zu sehen, wie sich unser Modell bei einigen wenigen Bildern schlägt.

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

Schritt 7: Das Modell evaluieren#

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

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

Das Recall-Diagramm (BoxR_curve.png) zeigt einen umgekehrten Trend:

Im Gegensatz zur Präzision bewegt sich der Recall in die entgegengesetzte Richtung, was einen höheren Recall bei Instanzen mit niedrigerer Konfidenz und einen niedrigeren Recall bei Instanzen mit höherer Konfidenz zeigt. 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 die IoU zwischen einer vorhergesagten Begrenzungsrahmen und einer Ground-Truth-Begrenzungsrahmen für dasselbe Objekt berechnest. Weitere Details findest du im Tutorial von IBM zum Training von YOLO26.

Zusammenfassung#

Wir haben die Hauptfunktionen von IBM Watsonx erkundet 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, Datenverwaltung und Compliance verbessern kann.

Weitere Details zur Verwendung findest du in der offiziellen Dokumentation von IBM Watsonx.

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

FAQ#