A Step-by-Step Guide to Training YOLO11 Models with IBM Watsonx

De nos jours, les solutions de vision par ordinateur évolutives deviennent plus courantes et transforment la façon dont nous traitons les données visuelles. Un excellent exemple est IBM Watsonx, une plateforme avancée d'IA et de données qui simplifie le développement, le déploiement et la gestion des modèles d'IA. Elle offre une suite complète pour l'ensemble du cycle de vie de l'IA et une intégration transparente avec les services cloud d'IBM.

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!

Qu'est-ce que 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.

Principales caractéristiques d'IBM Watsonx

IBM Watsonx est constitué de trois composants principaux : watsonx.ai, watsonx.data et watsonx.governance. Chaque composant offre des fonctionnalités qui répondent à différents aspects de l'IA et de la gestion des données. Examinons-les de plus près.

Watsonx.ai

Watsonx.ai fournit de puissants outils pour le développement de l'IA et offre un accès aux modèles personnalisés soutenus par IBM, aux modèles tiers comme Llama 3, et aux propres modèles Granite d'IBM. Il comprend le Prompt Lab pour expérimenter les invites d'IA, le Tuning Studio pour améliorer les performances des modèles avec des données étiquetées, et le Flows Engine pour simplifier le développement d'applications d'IA génératives. Il offre également des outils complets pour automatiser le cycle de vie des modèles d'IA et se connecter à diverses API et bibliothèques.

Watsonx.data

Watsonx.data prend en charge les déploiements dans le nuage et sur site grâce à l'intégration IBM Storage Fusion HCI. Sa console conviviale offre un accès centralisé aux données dans tous les environnements et facilite l'exploration des données grâce à un SQL courant. Elle optimise les charges de travail avec des moteurs de requête efficaces comme Presto et Spark, accélère la connaissance des données avec une couche sémantique alimentée par l'IA, inclut une base de données vectorielle pour la pertinence de l'IA et prend en charge les formats de données ouverts pour faciliter le partage des données d'analyse et d'IA.

Watsonx.governance

Watsonx.governance facilite la conformité en identifiant automatiquement les changements réglementaires et en appliquant les politiques. Il relie les exigences aux données internes sur les risques et fournit des fiches d'information actualisées sur l'IA. La plateforme aide à gérer les risques grâce à des alertes et des outils permettant de détecter des problèmes tels que les biais et les dérives. Elle automatise également le suivi et la documentation du cycle de vie de l'IA, organise le développement de l'IA avec un inventaire des modèles et améliore la collaboration avec des tableaux de bord et des outils de reporting conviviaux.

How to Train YOLO11 Using IBM Watsonx

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

Conditions préalables

Tu as besoin d'un compte IBM Cloud pour créer un projet watsonx.ai, et tu auras également besoin d'un compte Kaggle pour charger l'ensemble de données.

Étape 1 : Configurer ton environnement

Tout d'abord, tu devras configurer un compte IBM pour pouvoir utiliser un carnet Jupyter. Connecte-toi à watsonx.ai à l'aide de ton compte IBM Cloud.

Ensuite, crée un projet watsonx.ai, et un carnet Jupyter.

Une fois que tu l'auras fait, un environnement notebook s'ouvrira pour que tu puisses charger ton ensemble de données. Tu peux utiliser le code de ce tutoriel pour t'attaquer à une tâche simple de formation d'un modèle de détection d'objets.

Étape 2 : Installer et importer les bibliothèques pertinentes

Ensuite, tu peux installer et importer les bibliothèques Python nécessaires.

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

Ensuite, tu peux importer les paquets nécessaires.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Étape 3 : Charger les données

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.

Nous pouvons charger l'ensemble de données directement dans le notebook à l'aide de l'API Kaggle. Tout d'abord, crée un compte Kaggle gratuit. Une fois que tu auras créé un compte, tu devras générer une clé API. Les instructions pour générer ta clé se trouvent dans la documentation de l'API Kaggle, dans la section "API credentials".

Copie et colle ton nom d'utilisateur Kaggle et ta clé API dans le code suivant. Exécute ensuite le code pour installer l'API et charger l'ensemble de données dans Watsonx.

# Install kaggle
pip install kaggle

Après avoir installé Kaggle, nous pouvons charger le jeu de données dans Watsonx.

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

Après avoir chargé l'ensemble de données, nous avons imprimé et sauvegardé notre répertoire de travail. Nous avons également imprimé le contenu de notre répertoire de travail pour confirmer que l'ensemble de données "trash_ICRA19" a été chargé correctement.

Si tu vois "trash_ICRA19" dans le contenu du répertoire, c'est qu'il a été chargé avec succès. Tu devrais voir trois fichiers/dossiers : un config.yaml un fichier videos_for_testing et un répertoire dataset répertoire. Nous ne tiendrons pas compte du videos_for_testing alors n'hésite pas à le supprimer.

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.

Étape 4 : Prétraitement des données

Heureusement, toutes les étiquettes de l'ensemble de données sur les déchets marins sont déjà formatées sous forme de fichiers .txt à l'adresse YOLO . Cependant, nous devons réorganiser la structure des répertoires d'images et d'étiquettes afin d'aider notre modèle à traiter les images et les étiquettes. À l'heure actuelle, le répertoire de l'ensemble des données chargées suit cette structure :

Mais, par défaut, les modèles YOLO nécessitent des images et des étiquettes séparées dans des sous-répertoires au sein de la division train/val/test. Nous devons réorganiser le répertoire dans la structure suivante :

Pour réorganiser le répertoire des ensembles de données, nous pouvons exécuter le script suivant :

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

Ensuite, nous devons modifier le fichier .yaml pour l'ensemble de données. Voici la configuration que nous utiliserons dans notre fichier .yaml. Les numéros d'identification des classes commencent à 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

Exécute le script suivant pour supprimer le contenu actuel de config.yaml et le remplacer par le contenu ci-dessus qui reflète la nouvelle structure de répertoire de notre ensemble de données. Assure-toi de remplacer la partie work_dir du chemin du répertoire racine à la ligne 4 par le chemin de ton propre répertoire de travail que nous avons récupéré plus tôt. Laisse les définitions des sous-répertoires train, val et test. Ne modifie pas non plus {work_dir} à la ligne 23 du code.

# 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

Voici un examen plus approfondi des paramètres de la commande d'apprentissage du modèle :

• task: It specifies the computer vision task for which you are using the specified YOLO model and data set.
• mode: Indique l'objectif pour lequel tu charges le modèle et les données spécifiés. Puisque nous formons un modèle, il est réglé sur "former". Plus tard, lorsque nous testerons les performances de notre modèle, nous le réglerons sur "prédire".
• 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: Demande à YOLO de générer et d'enregistrer des graphiques des mesures d'entraînement et d'évaluation de notre modèle.

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.

Étape 6 : Tester le modèle

Nous pouvons maintenant lancer l'inférence pour tester les performances de notre modèle affiné :

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

Les étiquettes .txt prédites pour chaque image sont sauvegardées via le fichier save_txt=True et les images de sortie avec les superpositions de boîtes de délimitation sont générées par le biais de l'argument save=True argument.
Le paramètre conf=0.5 informe le modèle d'ignorer toutes les prédictions dont le niveau de confiance est inférieur à 50 %.

Enfin, iou=.5 demande au modèle d'ignorer les boîtes de la même classe dont le chevauchement est égal ou supérieur à 50 %. Cela permet de réduire les potentielles boîtes en double générées pour le même objet.
nous pouvons charger les images avec les superpositions de boîtes de délimitation prédites pour voir comment notre modèle fonctionne sur une poignée d'images.

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

Le code ci-dessus affiche dix images de l'ensemble de test avec leurs boîtes de délimitation prédites, accompagnées des étiquettes des noms de classe et des niveaux de confiance.

Étape 7 : Évaluer le modèle

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:

Contrairement à la précision, le rappel évolue dans la direction opposée, montrant un rappel plus important avec des instances de faible confiance et un rappel plus faible avec des instances de confiance plus élevée. C'est un bon exemple du compromis entre la précision et le rappel pour les modèles de classification.

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.

Résumé

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.

Pour plus de détails sur l'utilisation, consulte la documentation officielle d'IBM Watsonx.

N'oublie pas non plus de consulter la page du guide d'intégration deUltralytics , pour en savoir plus sur différentes intégrations passionnantes.

FAQ

How do I train a YOLO11 model using IBM Watsonx?

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

1. Configure ton environnement: Crée un compte IBM Cloud et configure un projet Watsonx.ai. Utilise un carnet Jupyter pour ton environnement de codage.
2. Installer les bibliothèques: Installe les bibliothèques nécessaires comme torch, opencvet ultralytics.
3. Charger les données: Utilise l'API de Kaggle pour charger ton jeu de données dans Watsonx.
4. Prétraitement des données: Organise ton jeu de données dans la structure de répertoire requise et mets à jour le. .yaml fichier de configuration.
5. Forme le modèle: Utilise l'interface de ligne de commande YOLO pour entraîner ton modèle avec des paramètres spécifiques tels que epochs, batch sizeet learning rate.
6. Tester et évaluer: Exécute l'inférence pour tester le modèle et évaluer ses performances à l'aide de mesures telles que la précision et le rappel.

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

Quelles sont les principales caractéristiques d'IBM Watsonx pour l'entraînement des modèles d'IA ?

IBM Watsonx offre plusieurs fonctionnalités clés pour l'entraînement des modèles d'IA :

• Watsonx.ai: Fournit des outils pour le développement de l'IA, y compris l'accès aux modèles personnalisés soutenus par IBM et aux modèles tiers comme Llama 3. Il comprend le Prompt Lab, le Tuning Studio et le Flows Engine pour une gestion complète du cycle de vie de l'IA.
• Watsonx.data: Prend en charge les déploiements dans le cloud et sur site, offrant un accès centralisé aux données, des moteurs de requête efficaces comme Presto et Spark, et une couche sémantique alimentée par l'IA.
• Watsonx.governance: Automatise la conformité, gère les risques à l'aide d'alertes et fournit des outils pour détecter des problèmes tels que les biais et les dérives. Il comprend également des tableaux de bord et des outils de reporting pour la collaboration.

Pour plus d'informations, consulte la documentation officielle d'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:

• Évolutivité: Fais facilement évoluer ton modèle de formation grâce aux services IBM Cloud.
• Intégration: Intégration transparente avec diverses sources de données et API.
• Interface conviviale: Simplifie le processus de développement grâce à une interface collaborative et intuitive.
• Outils avancés: Accès à des outils puissants tels que Prompt Lab, Tuning Studio et Flows Engine pour améliorer les performances du modèle.

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. Organise les répertoires: Assure-toi que ton jeu de données suit la structure de répertoire YOLO avec des sous-répertoires séparés pour les images et les étiquettes dans la division train/val/test.
2. Mise à jour du fichier .yaml: Modifie le .yaml pour refléter la nouvelle structure de répertoire et les nouveaux noms de classe.
3. Exécuter le script de prétraitement: Utilise un script Python pour réorganiser ton jeu de données et mettre à jour les données. .yaml en conséquence.

Voici un exemple de script pour organiser ton ensemble de données :

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)

Pour plus de détails, reporte-toi à notre guide de prétraitement des données.

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:

• Compte IBM Cloud: Crée un compte sur IBM Cloud pour accéder à Watsonx.ai.
• Compte Kaggle: Pour charger des ensembles de données, tu auras besoin d'un compte Kaggle et d'une clé API.
• Jupyter Notebook: Configure un environnement Jupyter Notebook au sein de Watsonx.ai pour le codage et l'entraînement des modèles.

Pour plus d'informations sur la configuration de ton environnement, visite notre guide d'installationUltralytics .

📅 Created 2 months ago ✏️ Updated 12 days ago

Commentaires