Eine schrittweise Anleitung zum Training von YOLOv8 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 gutes Beispiel ist IBM Watsonx, eine fortschrittliche KI- und Datenplattform, die die Entwicklung, den Einsatz und die Verwaltung von KI-Modellen vereinfacht. Sie bietet eine komplette Suite für den gesamten KI-Lebenszyklus und eine nahtlose Integration mit IBM Cloud Services.

Du kannst Ultralytics YOLOv8 Modelle mit IBM Watsonx trainieren. Es ist eine gute Option für Unternehmen, die an effizientem Modelltraining, Feinabstimmung für bestimmte Aufgaben und Verbesserung der Modellleistung mit robusten Tools und einem benutzerfreundlichen Setup interessiert sind. In diesem Leitfaden zeigen wir dir, wie du YOLOv8 mit IBM Watsonx trainieren kannst - von der Einrichtung deiner Umgebung bis zur Auswertung 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 zusammen eine durchgängige, vertrauenswürdige KI-Plattform, die KI-Projekte zur Lösung von Geschäftsproblemen beschleunigen kann. Sie bietet leistungsstarke Werkzeuge für die Erstellung, das Training und den Einsatz von Machine-Learning-Modellen und erleichtert die Verbindung mit verschiedenen Datenquellen.

Die benutzerfreundliche Oberfläche und die kollaborativen Funktionen rationalisieren den Entwicklungsprozess und helfen bei der effizienten Verwaltung und Bereitstellung von Modellen. Ob für Computer Vision, Predictive Analytics, Natural Language Processing oder andere KI-Anwendungen, IBM Watsonx bietet die Werkzeuge und die Unterstützung, die du brauchst, um Innovationen voranzutreiben.

Hauptmerkmale 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 des Datenmanagements abdecken. Schauen wir sie uns näher an.

Watsonx.ai

Watsonx.ai bietet leistungsstarke Werkzeuge für die KI-Entwicklung und bietet Zugang zu von IBM unterstützten benutzerdefinierten Modellen, Modellen von Drittanbietern wie Llama 3 und IBMs eigenen Granite-Modellen. Es umfasst das Prompt Lab, um mit KI-Prompts zu experimentieren, das Tuning Studio, um die Modellleistung mit gelabelten Daten zu verbessern, und die Flows Engine, um die Entwicklung generativer KI-Anwendungen zu vereinfachen. Außerdem bietet es umfassende Tools zur Automatisierung des Lebenszyklus von KI-Modellen und zur Anbindung an verschiedene APIs und Bibliotheken.

Watsonx.data

Watsonx.data unterstützt sowohl Cloud- als auch On-Premises-Implementierungen durch die IBM Storage Fusion HCI-Integration. Die benutzerfreundliche Konsole ermöglicht den zentralen Zugriff auf Daten in verschiedenen Umgebungen und erleichtert die Datenexploration mit gängigem SQL. Watsonx.data optimiert Workloads mit effizienten Abfrage-Engines wie Presto und Spark, beschleunigt Dateneinblicke mit einer KI-gestützten semantischen Schicht, enthält eine Vektordatenbank für KI-Relevanz und unterstützt offene Datenformate für den einfachen Austausch von Analysen und KI-Daten.

Watsonx.governance

Watsonx.governance macht die Einhaltung von Vorschriften einfacher, indem es automatisch Änderungen der Vorschriften erkennt und Richtlinien durchsetzt. Es verknüpft Anforderungen mit internen Risikodaten und liefert aktuelle KI-Faktenblätter. Die Plattform unterstützt das Risikomanagement mit Warnmeldungen und Tools zur Erkennung von Problemen wie Verzerrungen und Abweichungen. Außerdem automatisiert sie die Überwachung und Dokumentation des KI-Lebenszyklus, organisiert die KI-Entwicklung mit einem Modellinventar und verbessert die Zusammenarbeit mit benutzerfreundlichen Dashboards und Berichtswerkzeugen.

Wie man YOLOv8 mit IBM Watsonx trainiert

Du kannst IBM Watsonx nutzen, um deinen YOLOv8 Modell-Trainingsworkflow zu beschleunigen.

Voraussetzungen

Du brauchst ein IBM Cloud-Konto, um ein watsonx.ai-Projekt zu erstellen, und du brauchst auch ein Kaggle-Konto, um den Datensatz zu laden.

Schritt 1: Richte deine Umgebung ein

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

Dann erstellst du ein watsonx.ai-Projekt und ein Jupyter-Notebook.

Sobald du das getan hast, öffnet sich eine Notebook-Umgebung, in die du deinen Datensatz laden kannst. Du kannst den Code aus diesem Lernprogramm verwenden, um ein einfaches Objekterkennungsmodell zu trainieren.

Schritt 2: Relevante Bibliotheken installieren und importieren

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

# Install the required packages
pip install torch torchvision torchaudio
pip install opencv-contrib-python-headless
pip install ultralytics==8.0.196

Ausführliche Anweisungen und bewährte Verfahren für den Installationsprozess findest du in unserem Ultralytics Installationsleitfaden. Wenn du bei der Installation der erforderlichen Pakete für YOLOv8 auf Schwierigkeiten stößt, findest du in unserem Leitfaden für häufige Probleme Lösungen und Tipps.

Dann kannst du die benötigten Pakete importieren.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Schritt 3: Laden der Daten

Für dieses Tutorial werden wir einen Datensatz über Meeresmüll verwenden, der auf Kaggle verfügbar ist. Mit diesem Datensatz werden wir ein YOLOv8 Modell trainieren, um Müll und biologische Objekte in Unterwasserbildern zu erkennen und zu klassifizieren.

Wir können den Datensatz über die Kaggle-API direkt in das Notizbuch laden. Erstelle zunächst ein kostenloses Kaggle-Konto. Sobald du ein Konto erstellt hast, musst du einen API-Schlüssel generieren. Eine Anleitung zur Erstellung deines Schlüssels findest du in der Kaggle-API-Dokumentation unter dem Abschnitt "API-Anmeldeinformationen".

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

# Install kaggle
pip install kaggle

Nachdem wir Kaggle installiert haben, 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 ausgedruckt und gespeichert. Wir haben auch den Inhalt unseres Arbeitsverzeichnisses ausgedruckt, um zu bestätigen, dass der Datensatz "trash_ICRA19" richtig geladen wurde.

Wenn du "trash_ICRA19" unter den Inhalten des Verzeichnisses siehst, wurde es erfolgreich geladen. Du solltest drei Dateien/Ordner sehen: a config.yaml Datei, eine videos_for_testing Verzeichnis, und ein dataset Verzeichnis. Wir ignorieren die videos_for_testing Verzeichnis, du kannst es also gerne löschen.

Wir werden die Datei config.yaml und den Inhalt des Verzeichnisses dataset verwenden, um unser Modell zur Objekterkennung zu trainieren. Hier ist ein Beispielbild aus unserem Datensatz für Meeresmüll.

Schritt 4: Vorverarbeitung der Daten

Glücklicherweise sind alle Beschriftungen im Datensatz der Meeresabfälle bereits als YOLO .txt-Dateien formatiert. Allerdings müssen wir die Struktur der Verzeichnisse für Bilder und Beschriftungen neu ordnen, damit unser Modell die Bilder und Beschriftungen besser verarbeiten kann. Im Moment hat das Verzeichnis unseres geladenen Datensatzes diese Struktur:

Die Modelle von YOLO benötigen jedoch standardmäßig getrennte Bilder und Beschriftungen in Unterverzeichnissen innerhalb der Unterteilung train/val/test. Wir müssen das Verzeichnis in die folgende Struktur umstrukturieren:

Um das Verzeichnis des Datensatzes 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 ändern. Das ist das Setup, das wir in unserer .yaml-Datei verwenden werden. Die Nummern der 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 Datei config.yaml zu löschen und durch den obigen Inhalt zu ersetzen, der die neue Verzeichnisstruktur unseres Datensatzes widerspiegelt. Ersetze den work_dir-Teil des Stammverzeichnisses in Zeile 4 durch deinen eigenen Arbeitsverzeichnispfad, den wir zuvor ermittelt haben. Die Definitionen der Unterverzeichnisse train, val und test bleiben erhalten. Ändere auch nicht {work_dir} in Zeile 23 des Codes.

# Contents of new confg.yaml file
def update_yaml_file(file_path):
    data = {
        "path": "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 YOLOv8 Modell

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

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

Hier ein genauerer Blick auf die Parameter des Befehls "Modelltraining":

• Aufgabe: Hier wird die Bildverarbeitungsaufgabe angegeben, für die du das angegebene YOLO Modell und den Datensatz verwendest.
• Modus: Bezeichnet den Zweck, für den du das angegebene Modell und die Daten lädst. Da wir ein Modell trainieren, wird es auf "train" gesetzt. Später, wenn wir die Leistung unseres Modells testen, stellen wir ihn auf "Vorhersage".
• Epochen: Hier wird festgelegt, wie oft YOLOv8 unseren gesamten Datensatz durchläuft.
• Batch: Der numerische Wert legt die Größe der Trainingsstapel 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 der Trainings- und Bewertungskennzahlen unseres Modells zu erstellen und zu speichern.

Ein detailliertes Verständnis des Modelltrainings und der besten Methoden findest du im LeitfadenYOLOv8 Modelltraining. Dieser Leitfaden hilft dir, das Beste aus deinen Experimenten herauszuholen und sicherzustellen, dass du YOLOv8 effektiv nutzt.

Schritt 6: Teste das Modell

Wir können nun Inferenzen durchfü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 für jedes Bild in unserem Testsatz vorhergesagte Beschriftungen sowie neue Ausgabebilddateien, die die vorhergesagte Bounding Box über das Originalbild legen.

Die vorhergesagten .txt-Beschriftungen für jedes Bild werden über die save_txt=True Argument und die Ausgabebilder mit Bounding-Box-Overlays werden durch das save=True Argument.
Der Parameter conf=0.5 teilt dem Modell mit, dass es alle Vorhersagen mit einem Konfidenzniveau von weniger als 50 % ignoriert.

Zum Schluss, iou=.5 weist das Modell an, Boxen der gleichen Klasse mit einer Überlappung von 50% oder mehr zu ignorieren. Dies hilft dabei, die Anzahl der für dasselbe Objekt erzeugten doppelten Kästen zu reduzieren.
können wir die Bilder mit vorhergesagten Bounding Box Overlays laden, um zu sehen, wie unser Modell bei einer Handvoll Bilder 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 der Testmenge mit ihren vorhergesagten Bounding Boxes an, zusammen mit den Klassennamen und den Vertrauensstufen.

Schritt 7: Das Modell auswerten

Wir können Visualisierungen der Genauigkeit und der Wiedererkennung des Modells für jede Klasse erstellen. Diese Visualisierungen werden im Home-Verzeichnis unter dem Ordner train gespeichert. Das Ergebnis der Genauigkeit wird in der Datei P_curve.png angezeigt:

Die Grafik zeigt einen exponentiellen Anstieg der Genauigkeit, wenn das Konfidenzniveau des Modells für Vorhersagen steigt. Allerdings hat sich die Modellgenauigkeit nach zwei Epochen noch nicht auf ein bestimmtes Vertrauensniveau eingependelt.

Die Rückrufkurve (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 geringerem Vertrauen und einen niedrigeren Recall bei Instanzen mit höherem Vertrauen. Dies ist ein treffendes Beispiel für den Kompromiss zwischen Präzision und Recall bei Klassifizierungsmodellen.

Schritt 8: Berechnung von Schnittpunkt über Union

Du kannst die Vorhersagegenauigkeit messen, indem du den 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 unter YOLOv8.

Zusammenfassung

Wir haben die wichtigsten Funktionen von IBM Watsonx kennengelernt und erfahren, wie man mit IBM Watsonx ein YOLOv8 Modell trainiert. Außerdem haben wir gesehen, wie IBM Watsonx deine KI-Workflows mit fortschrittlichen Tools für die Modellerstellung, das Datenmanagement und die Einhaltung von Vorschriften verbessern kann.

Weitere Details zur Nutzung findest du in der offiziellen IBM Watsonx-Dokumentation.

Schau dir auch den Integrationsleitfaden aufUltralytics an, um mehr über verschiedene spannende Integrationen zu erfahren.

FAQ

Wie trainiere ich ein YOLOv8 Modell mit IBM Watsonx?

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

1. Richte deine Umgebung ein: Erstelle ein IBM Cloud-Konto und richte ein Watsonx.ai-Projekt ein. Verwende ein Jupyter Notebook für deine Programmierumgebung.
2. Bibliotheken installieren: Installiere die notwendigen Bibliotheken wie torch, opencv, und ultralytics.
3. Daten laden: Nutze die Kaggle-API, um deinen Datensatz in Watsonx zu laden.
4. Daten vorverarbeiten: Organisiere deinen Datensatz in der gewünschten Verzeichnisstruktur und aktualisiere die .yaml Konfigurationsdatei.
5. Das Modell trainieren: Benutze die YOLO Befehlszeilenschnittstelle, um dein Modell mit bestimmten Parametern zu trainieren, wie epochs, batch size, und learning rate.
6. Testen und Auswerten: Führe Inferenzen durch, um das Modell zu testen und seine Leistung anhand von Kennzahlen wie Precision und Recall zu bewerten.

Detaillierte Anweisungen findest du in unserem YOLOv8 Modellschulungsleitfaden.

Was sind die wichtigsten Funktionen von IBM Watsonx für das Training von KI-Modellen?

IBM Watsonx bietet mehrere wichtige Funktionen für das Training von KI-Modellen:

• Watsonx.ai: Bietet Werkzeuge für die KI-Entwicklung, einschließlich des Zugriffs auf von IBM unterstützte eigene Modelle und Modelle von Drittanbietern wie Llama 3. Es umfasst das Prompt Lab, das Tuning Studio und die Flows Engine für ein umfassendes KI-Lebenszyklusmanagement.
• Watsonx.data: Unterstützt Cloud- und On-Premises-Implementierungen und bietet einen zentralen Datenzugriff, effiziente Abfrage-Engines wie Presto und Spark sowie eine KI-gestützte semantische Schicht.
• Watsonx.governance: Automatisiert die Einhaltung von Vorschriften, verwaltet Risiken mit Warnmeldungen und bietet Werkzeuge zur Erkennung von Problemen wie Verzerrungen und Abweichungen. Außerdem enthält es Dashboards und Reporting-Tools für die Zusammenarbeit.

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

Warum sollte ich IBM Watsonx für das Training von Ultralytics YOLOv8 Modellen verwenden?

IBM Watsonx ist eine ausgezeichnete Wahl für das Training von Ultralytics YOLOv8 Modellen, da es eine umfassende Suite von Tools bietet, die den KI-Lebenszyklus optimieren. Die wichtigsten Vorteile sind:

• Skalierbarkeit: Skaliere dein Modelltraining ganz einfach mit den IBM Cloud Services.
• Integration: Nahtlose Integration mit verschiedenen Datenquellen und APIs.
• Benutzerfreundliches Interface: Vereinfacht den Entwicklungsprozess mit einer kollaborativen und intuitiven Schnittstelle.
• Erweiterte Tools: Zugang zu leistungsstarken Tools wie dem Prompt Lab, dem Tuning Studio und der Flows Engine zur Verbesserung der Modellleistung.

Erfahre mehr über Ultralytics YOLOv8 und wie du mit IBM Watsonx Modelle trainierst, erfährst du in unserem Integrationsleitfaden.

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

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

1. Ordne die Verzeichnisse: Achte darauf, dass dein Datensatz der Verzeichnisstruktur YOLO folgt, mit separaten Unterverzeichnissen für Bilder und Labels innerhalb der Aufteilung train/val/test.
2. .yaml-Datei aktualisieren: Ändern Sie die .yaml Konfigurationsdatei, um die neue Verzeichnisstruktur und die Klassennamen zu berücksichtigen.
3. Preprocessing-Skript ausführen: Verwende ein Python Skript, um deinen Datensatz zu reorganisieren und die .yaml Datei entsprechend anpassen.

Hier ist ein Beispielskript, um deinen Datensatz zu organisieren:

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 Informationen findest du in unserem Leitfaden zur Datenvorverarbeitung.

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

Bevor du mit der Schulung eines YOLOv8 Modells auf IBM Watsonx beginnst, musst du sicherstellen, dass du die folgenden Voraussetzungen erfüllst:

• IBM Cloud-Konto: Erstelle ein Konto bei IBM Cloud, um auf Watsonx.ai zuzugreifen.
• Kaggle-Konto: Um Datensätze zu laden, brauchst du ein Kaggle-Konto und einen API-Schlüssel.
• Jupyter Notebook: Richte eine Jupyter-Notebook-Umgebung in Watsonx.ai für die Codierung und das Modelltraining ein.

Weitere Informationen zum Einrichten deiner Umgebung findest du in unserer Ultralytics Installationsanleitung.

📅 Created 1 month ago ✏️ Updated 10 days ago

Kommentare