Link to this sectionEine 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 und 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 dieser Anleitung führen wir dich durch den Prozess des Trainings von YOLO26 mit IBM Watsonx – von der Einrichtung deiner Umgebung bis zur Evaluierung deiner trainierten Modelle. Fangen wir an!

Link to this sectionWas 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 zusammen 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 erleichtert die Anbindung an verschiedene Datenquellen.

IBM Watsonx AI platform architecture overview

Die benutzerfreundliche Oberfläche und die kollaborativen Funktionen optimieren den Entwicklungsprozess und helfen bei einer effizienten Modellverwaltung und Bereitstellung. Ob für Computer Vision, prädiktive Analysen, Natural Language Processing oder andere KI-Anwendungen, IBM Watsonx bietet die notwendigen Tools und Unterstützung, um Innovationen voranzutreiben.

Link to this sectionHauptmerkmale von IBM Watsonx#

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

Link to this section Watsonx.ai #

Watsonx.ai bietet leistungsstarke Werkzeuge für die KI-Entwicklung und Zugriff auf IBM-unterstützte benutzerdefinierte Modelle, Drittanbietermodelle wie Llama 3 sowie IBMs eigene Granite-Modelle. Es 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. Zudem bietet es umfassende Tools zur Automatisierung des KI-Modelllebenszyklus und zur Anbindung verschiedener APIs und Bibliotheken.

Link to this section 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.

Link to this section Watsonx.governance #

Watsonx.governance erleichtert die Compliance, indem regulatorische Änderungen automatisch identifiziert und Richtlinien durchgesetzt werden. Es verknüpft Anforderungen mit internen Risikodaten und stellt aktuelle KI-Factsheets bereit. Die Plattform unterstützt das Risikomanagement mit 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 Reporting-Tools.

Link to this sectionWie man YOLO26 mit IBM Watsonx trainiert#

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

Link to this sectionVoraussetzungen#

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

Link to this sectionSchritt 1: Einrichtung deiner Umgebung#

Zuerst musst du ein IBM-Konto einrichten, um ein Jupyter Notebook nutzen zu können. Melde dich bei watsonx.ai mit deinem IBM Cloud-Konto 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.

Link to this sectionSchritt 2: Installieren und Importieren relevanter Bibliotheken#

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

Installation

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

Detaillierte Anweisungen und Best Practices für den Installationsprozess findest du in unserem Ultralytics-Installationsleitfaden. Wenn du bei der Installation der erforderlichen Pakete für YOLO26 auf Schwierigkeiten stößt, schau in unserem Leitfaden zu häufigen Problemen nach Lösungen und Tipps.

Dann kannst du die erforderlichen Pakete importieren.

Relevante Bibliotheken importieren

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Link to this sectionSchritt 3: Daten laden#

Für dieses Tutorial verwenden wir ein Marine-Müll-Dataset, das auf Kaggle verfügbar ist. Mit diesem Dataset trainieren wir ein YOLO26-Modell individuell, um Müll und biologische Objekte in Unterwasserbildern zu erkennen und zu klassifizieren.

Wir können das Dataset 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. Anweisungen zum Generieren 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 das Dataset in Watsonx zu laden.

Installation

# Install kaggle
pip install kaggle

Nach der Installation von Kaggle können wir das Dataset in Watsonx laden.

Daten 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 es 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 löschen.

Wir verwenden die config.yaml-Datei und den Inhalt des Dataset-Verzeichnisses, um unser Objekterkennungsmodell zu trainieren. Hier ist ein Beispielbild aus unserem Marine-Müll-Dataset.

Marine Litter with Bounding Box

Link to this sectionSchritt 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:

Loaded Dataset Directory

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:

YOLO Directory Structure

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

Daten vorverarbeiten

# 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 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 Dataset-Verzeichnisstruktur widerspiegelt. Das Skript verwendet automatisch die work_dir-Variable, die wir zuvor definiert haben. Stelle also sicher, dass sie vor der Ausführung auf dein Dataset zeigt, und belasse die Definitionen der train-, val- und test-Unterverzeichnisse unverändert.

Die .yaml-Datei bearbeiten

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

Link to this sectionSchritt 5: Das YOLO26-Modell trainieren#

Führe den folgenden Befehlszeilencode aus, um ein vortrainiertes Standard-YOLO26-Modell feinabzustimmen.

Das YOLO26-Modell trainieren

!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 Dataset 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.

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

Link to this sectionSchritt 6: Das Modell testen#

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

Das YOLO26-Modell 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 Testset sowie neue Ausgabebilddateien, die die vorhergesagte Bounding Box über das Originalbild legen.

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

Zuletzt weist iou=.5 das Modell an, Boxen in derselben Klasse mit einer Überlappung von 50% oder mehr zu ignorieren. Dies hilft, potenzielle 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.

Vorhersagen anzeigen

# 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.

Link to this sectionSchritt 7: Das Modell evaluieren#

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

Model precision-confidence evaluation curve

Das Diagramm 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 eingependelt.

Das recall-Diagramm (BoxR_curve.png) zeigt einen inversen Trend:

Model recall-confidence evaluation curve

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.

Link to this sectionSchritt 8: Berechnung der Intersection Over Union #

Du kannst die Vorhersage-Genauigkeit messen, indem du die IoU zwischen einer vorhergesagten Bounding Box und einer Ground-Truth-Bounding-Box für dasselbe Objekt berechnest. Schau dir IBMs Tutorial zum Training von YOLO26 für weitere Details an.

Link to this sectionZusammenfassung#

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.

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

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

Link to this sectionFAQ#

Link to this sectionWie trainiere ich ein YOLO26-Modell mit IBM Watsonx?#

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

Umgebung einrichten: Erstelle ein IBM Cloud-Konto und richte ein Watsonx.ai-Projekt ein. Verwende ein Jupyter Notebook für deine Programmierumgebung.
Bibliotheken installieren: Installiere notwendige Bibliotheken wie torch, opencv und ultralytics.
Daten laden: Verwende die Kaggle-API, um dein Dataset in Watsonx zu laden.
Daten vorverarbeiten: Organisiere dein Dataset in der erforderlichen Verzeichnisstruktur und aktualisiere die .yaml-Konfigurationsdatei.
Modell trainieren: Verwende die YOLO-Befehlszeilenschnittstelle, um dein Modell mit spezifischen Parametern wie epochs, batch size und learning rate zu trainieren.
Testen und Evaluieren: Führe die Inferenz aus, um das Modell zu testen und seine Leistung anhand von Metriken wie Präzision und Recall zu evaluieren.

Detaillierte Anweisungen findest du in unserem YOLO26-Modelltrainings-Guide.

Link to this sectionWas 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 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 der KI.
Watsonx.data: Unterstützt Cloud- und On-Premises-Bereitstellungen und bietet zentralen Datenzugriff, effiziente Query-Engines wie Presto und Spark sowie eine KI-gestützte semantische Ebene.
Watsonx.governance: Automatisiert die Compliance, verwaltet Risiken mit Warnmeldungen und bietet Tools zur Erkennung von Problemen wie Bias und Drift. Es enthält zudem Dashboards und Reporting-Tools für die Zusammenarbeit.

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

Link to this sectionWarum sollte ich IBM Watsonx für das Training von Ultralytics YOLO26-Modellen verwenden?#

IBM Watsonx ist eine exzellente Wahl für das Training von Ultralytics YOLO26-Modellen, dank seiner umfassenden Tools, die den KI-Lebenszyklus optimieren. Zu den wichtigsten Vorteilen zählen:

Skalierbarkeit: Skaliere dein Modelltraining mühelos mit IBM Cloud-Diensten.
Integration: Integriere nahtlos verschiedene Datenquellen und APIs.
Benutzerfreundliche Oberfläche: Vereinfacht den Entwicklungsprozess durch eine kollaborative und intuitive Benutzeroberfläche.
Fortschrittliche Tools: Zugriff auf leistungsstarke Werkzeuge wie das Prompt Lab, das Tuning Studio und die Flows Engine zur Verbesserung der Modellleistung.

Erfahre mehr über Ultralytics YOLO26 und wie man Modelle mit IBM Watsonx trainiert in unserem Integrations-Guide.

Link to this sectionWie kann ich mein Dataset für das YOLO26-Training auf IBM Watsonx vorverarbeiten?#

Um dein Dataset für das YOLO26-Training auf IBM Watsonx vorzuverarbeiten:

Verzeichnisse organisieren: Stelle sicher, dass dein Dataset der YOLO-Verzeichnisstruktur mit getrennten Unterverzeichnissen für Bilder und Labels innerhalb des train/val/test-Splits folgt.
.yaml-Datei aktualisieren: Ändere die .yaml-Konfigurationsdatei, um die neue Verzeichnisstruktur und Klassennamen widerzuspiegeln.
Vorverarbeitungsskript ausführen: Verwende ein Python-Skript, um dein Dataset neu zu organisieren und die .yaml-Datei entsprechend zu aktualisieren.

Hier ist ein Beispielskript zur Organisation deines Datasets:

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 Datenvorverarbeitungs-Guide.

Link to this sectionWas 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 Account: Erstelle ein Konto bei IBM Cloud, um auf Watsonx.ai zuzugreifen.
Kaggle Account: Zum Laden von Datensätzen benötigst du ein Kaggle-Konto und einen API-Key.
Jupyter Notebook: Richte eine Jupyter Notebook-Umgebung innerhalb von Watsonx.ai für die Programmierung und das Modelltraining ein.

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

Mitwirkende

GLglenn-jocher¹⁴ RIRizwanMunawar² RAraimbekovm¹ ONonuralpszr¹ AMambitious-octopus¹ MAMatthewNoyce¹ LALaughing-q¹ ABabirami-vina¹

Erstellt 29. Juli 2024Aktualisiert vor 3 Tagen