A Step-by-Step Guide to Training YOLO11 Models with 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.

You can train Ultralytics YOLO11 models using IBM Watsonx. It's a good option for enterprises interested in efficient model training, fine-tuning for specific tasks, and improving model performance with robust tools and a user-friendly setup. In this guide, we'll walk you through the process of training YOLO11 with IBM Watsonx, covering everything from setting up your environment to evaluating your trained models. Let's get started!

Was ist IBM Watsonx?

Watsonx is IBM's cloud-based platform designed for commercial generative AI and scientific data. IBM Watsonx's three components - watsonx.ai, watsonx.data, and watsonx.governance - come together to create an end-to-end, trustworthy AI platform that can accelerate AI projects aimed at solving business problems. It provides powerful tools for building, training, and deploying machine learning models and makes it easy to connect with various data sources.

Its user-friendly interface and collaborative capabilities streamline the development process and help with efficient model management and deployment. Whether for computer vision, predictive analytics, natural language processing, or other AI applications, IBM Watsonx provides the tools and support needed to drive innovation.

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.

How to Train YOLO11 Using IBM Watsonx

You can use IBM Watsonx to accelerate your YOLO11 model training workflow.

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

For detailed instructions and best practices related to the installation process, check our Ultralytics Installation guide. While installing the required packages for YOLO11, if you encounter any difficulties, consult our Common Issues guide for solutions and tips.

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

For this tutorial, we will use a marine litter dataset available on Kaggle. With this dataset, we will custom-train a YOLO11 model to detect and classify litter and biological objects in underwater images.

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.

We will use the config.yaml file and the contents of the dataset directory to train our object detection model. Here is a sample image from our marine litter data set.

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

Step 5: Train the YOLO11 model

Run the following command-line code to fine tune a pretrained default YOLO11 model.

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

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

• task: It specifies the computer vision task for which you are using the specified YOLO model and data set.
• 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".
• epochs: This delimits the number of times YOLO11 will pass through our entire data set.
• batch: The numerical value stipulates the training batch sizes. Batches are the number of images a model processes before it updates its parameters.
• lr0: Specifies the model's initial learning rate.
• plots: Weist YOLO an, Diagramme der Trainings- und Bewertungskennzahlen unseres Modells zu erstellen und zu speichern.

For a detailed understanding of the model training process and best practices, refer to the YOLO11 Model Training guide. This guide will help you get the most out of your experiments and ensure you're using YOLO11 effectively.

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

This brief script generates predicted labels for each image in our test set, as well as new output image files that overlay the predicted bounding box atop the original image.

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

We can produce visualizations of the model's precision and recall for each class. These visualizations are saved in the home directory, under the train folder. The precision score is displayed in the P_curve.png:

The graph shows an exponential increase in precision as the model's confidence level for predictions increases. However, the model precision has not yet leveled out at a certain confidence level after two epochs.

The recall graph (R_curve.png) displays an inverse 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.

Step 8: Calculating Intersection Over Union

You can measure the prediction accuracy by calculating the IoU between a predicted bounding box and a ground truth bounding box for the same object. Check out IBM's tutorial on training YOLO11 for more details.

Zusammenfassung

We explored IBM Watsonx key features, and how to train a YOLO11 model using IBM Watsonx. We also saw how IBM Watsonx can enhance your AI workflows with advanced tools for model building, data management, and compliance.

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

How do I train a YOLO11 model using IBM Watsonx?

To train a YOLO11 model using IBM Watsonx, follow these steps:

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.

For detailed instructions, refer to our YOLO11 Model Training guide.

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.

Why should I use IBM Watsonx for training Ultralytics YOLO11 models?

IBM Watsonx is an excellent choice for training Ultralytics YOLO11 models due to its comprehensive suite of tools that streamline the AI lifecycle. Key benefits include:

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

Learn more about Ultralytics YOLO11 and how to train models using IBM Watsonx in our integration guide.

How can I preprocess my dataset for YOLO11 training on IBM Watsonx?

To preprocess your dataset for YOLO11 training on IBM Watsonx:

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.

What are the prerequisites for training a YOLO11 model on IBM Watsonx?

Before you start training a YOLO11 model on IBM Watsonx, ensure you have the following prerequisites:

• 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 2 months ago ✏️ Updated 12 days ago

Kommentare