Un guide étape par étape pour l'entraînement des modèles YOLO11 avec IBM Watsonx

De nos jours, les solutions de vision par ordinateur évolutives sont de plus en 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 IBM Cloud.

Vous pouvez entraîner des modèles Ultralytics YOLO11 en utilisant IBM Watsonx. C'est une bonne option pour les entreprises intéressées par un entraînement de modèle efficace, un réglage fin pour des tâches spécifiques et une amélioration des performances du modèle avec des outils robustes et une configuration conviviale. Dans ce guide, nous vous guiderons à travers le processus d'entraînement de YOLO11 avec IBM Watsonx, en couvrant tout, de la configuration de votre environnement à l'évaluation de vos modèles entraînés. Commençons !

Qu'est-ce qu'IBM Watsonx ?

Watsonx est la plateforme cloud d'IBM conçue pour un usage commercial IA générative et les données scientifiques. Les trois composantes d'IBM Watsonx - watsonx.ai, watsonx.data, et watsonx.governance - s'associent pour créer une plateforme d'IA de bout en bout et fiable, capable d'accélérer les projets d'IA visant à résoudre des problèmes commerciaux. Elle fournit des outils puissants pour la construction, la formation et la déploiement de modèles d'apprentissage automatique et facilite la connexion à diverses sources de données.

Son interface conviviale et ses capacités de collaboration rationalisent le processus de développement et facilitent la gestion et le déploiement efficaces des modèles. Que ce soit pour la vision par ordinateur, l'analyse prédictive, le traitement du langage naturel ou d'autres applications d'IA, IBM Watsonx fournit les outils et le support nécessaires pour stimuler l'innovation.

Principales caractéristiques d'IBM Watsonx

IBM Watsonx est composé de trois composantes principales : 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 des outils puissants pour le développement de l'IA et offre un accès aux modèles personnalisés pris en charge par IBM, aux modèles tiers comme Llama 3 et aux modèles Granite d'IBM. Il comprend le Prompt Lab pour expérimenter avec les invites d'IA, le Tuning Studio pour améliorer les performances du modèle avec des données étiquetées et le Flows Engine pour simplifier le développement d'applications d'IA générative. De plus, il offre 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 sur le cloud 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 avec SQL commun. Il optimise les charges de travail avec des moteurs de requête efficaces comme Presto et Spark, accélère les informations sur les données avec une couche sémantique basée sur l'IA, comprend 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 de risque internes et fournit des fiches d'information à jour sur l'IA. La plateforme aide à gérer les risques grâce à des alertes et des outils permettant de détecter les problèmes tels que les biais et la dérive. Elle automatise également la surveillance 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 grâce à des tableaux de bord conviviaux et des outils de reporting.

Comment entraîner YOLO11 en utilisant IBM Watsonx

Vous pouvez utiliser IBM Watsonx pour accélérer votre flux de travail d'entraînement de modèles YOLO11.

Prérequis

Vous avez besoin d'un compte IBM Cloud pour créer un projet watsonx.ai, et vous aurez également besoin d'un compte Kaggle pour charger l'ensemble de données.

Étape 1 : Configurer votre environnement

Tout d'abord, vous devrez créer un compte IBM pour utiliser un Jupyter Notebook. Connectez-vous à watsonx.ai en utilisant votre compte IBM Cloud.

Ensuite, créez un projet watsonx.ai, et un Jupyter Notebook.

Une fois que vous l'avez fait, un environnement de notebook s'ouvrira pour vous permettre de charger votre ensemble de données. Vous pouvez utiliser le code de ce tutoriel pour aborder une tâche simple d'entraînement de modèle de détection d'objets.

Étape 2 : Installer et importer les bibliothèques appropriées

Ensuite, vous pouvez 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

Pour des instructions détaillées et les meilleures pratiques relatives au processus d'installation, consultez notre guide d'installation Ultralytics. Si vous rencontrez des difficultés lors de l'installation des packages requis pour YOLO11, consultez notre guide des problèmes courants pour obtenir des solutions et des conseils.

Ensuite, vous pouvez importer les packages nécessaires.

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Étape 3 : Charger les données

Pour ce tutoriel, nous utiliserons un ensemble de données sur les déchets marins disponible sur Kaggle. Avec cet ensemble de données, nous allons entraîner sur mesure un modèle YOLO11 pour détecter et classer les déchets et les objets biologiques dans les images sous-marines.

Nous pouvons charger l'ensemble de données directement dans le notebook en utilisant l'API Kaggle. Tout d'abord, créez un compte Kaggle gratuit. Une fois que vous avez créé un compte, vous devrez générer une clé API. Les instructions pour générer votre clé se trouvent dans la documentation de l'API Kaggle sous la section "API credentials".

Copiez et collez votre nom d'utilisateur Kaggle et votre clé API dans le code suivant. Exécutez 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 l'ensemble 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 enregistré 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é correctement chargé.

Si vous voyez « trash_ICRA19 » parmi le contenu du répertoire, cela signifie qu'il a été chargé avec succès. Vous devriez voir trois fichiers/dossiers : un config.yaml fichier, un videos_for_testing répertoire, et un dataset répertoire. Nous allons ignorer le videos_for_testing répertoire, alors n'hésitez pas à le supprimer.

Nous utiliserons le config.yaml fichier et le contenu du répertoire de l'ensemble de données pour entraîner notre détection d'objets modèle. Voici un exemple d'image de notre ensemble de données sur les déchets marins.

Étape 4 : Prétraiter les données

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

Cependant, les modèles YOLO nécessitent par défaut 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 selon la structure suivante :

Pour réorganiser le répertoire de l’ensemble 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'ID de classe commencent à partir de 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écutez le script suivant pour supprimer le contenu actuel de config.yaml et remplacez-le par le contenu ci-dessus qui reflète la nouvelle structure de répertoire de notre ensemble de données. Assurez-vous de remplacer la partie work_dir du chemin du répertoire racine à la ligne 4 par votre propre chemin de répertoire de travail que nous avons récupéré précédemment. Conservez les définitions des sous-répertoires train, val et test. De plus, ne modifiez pas {work_dir} à la ligne 23 du code.

# Contents of new config.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.")

Étape 5 : Entraîner le modèle YOLO11

Exécutez le code de ligne de commande suivant pour affiner un modèle YOLO11 par défaut pré-entraîné.

!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 aperçu plus détaillé des paramètres de la commande d'entraînement du modèle :

• tâche : Elle spécifie la tâche de vision par ordinateur pour laquelle vous utilisez le modèle YOLO et l’ensemble de données spécifiés.
• mode: Indique le but pour lequel vous chargez le modèle et les données spécifiés. Puisque nous entraînons un modèle, il est défini sur "train". Plus tard, lorsque nous testerons les performances de notre modèle, nous le définirons sur "predict".
• epochs : Ceci délimite le nombre de fois que YOLO11 passera à travers l'ensemble de nos données.
• batch : La valeur numérique stipule les tailles de batch d'entraînement. Les batchs correspondent au nombre d'images qu'un modèle traite avant de mettre à jour ses paramètres.
• lr0 : Spécifie le taux d'apprentissage initial du modèle.
• plots : Ordonne à YOLO de générer et d'enregistrer des graphiques des mesures d'entraînement et d'évaluation de notre modèle.

Pour une compréhension détaillée du processus d'entraînement du modèle et des meilleures pratiques, consultez le guide d'entraînement du modèle YOLO11. Ce guide vous aidera à tirer le meilleur parti de vos expériences et à vous assurer que vous utilisez YOLO11 efficacement.

Étape 6 : Tester le modèle

Nous pouvons maintenant exécuter 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

Ce bref script génère des étiquettes prédites pour chaque image de notre ensemble de test, ainsi que de nouveaux fichiers d'image de sortie qui superposent la boîte englobante prédite sur l'image originale.

Les étiquettes .txt prédites pour chaque image sont enregistrées via le save_txt=True argument et les images de sortie avec des superpositions de cadres de délimitation sont générées par le biais de save=True l'argument. Le paramètre conf=0.5 indique au modèle d'ignorer toutes les prédictions avec un niveau de confiance 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 le nombre de boîtes en double générées pour le même objet. nous pouvons charger les images avec les superpositions de boîtes englobantes 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 englobantes prédites, accompagnées des étiquettes de nom de classe et des niveaux de confiance.

Étape 7 : Évaluer le modèle

Nous pouvons produire des visualisations de la précision et du rappel du modèle pour chaque classe. Ces visualisations sont enregistrées dans le répertoire de base, sous le dossier train. Le score de précision est affiché dans le fichier P_curve.png :

Le graphique montre une augmentation exponentielle de la précision à mesure que le niveau de confiance du modèle pour les prédictions augmente. Cependant, la précision du modèle ne s'est pas encore stabilisée à un certain niveau de confiance après deux epochs.

Le graphique de rappel (R_curve.png) affiche une tendance inverse :

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

Étape 8 : Calcul de l'Intersection Over Union

Vous pouvez mesurer la précision de la prédiction en calculant l'IoU entre une boîte englobante prédite et une boîte englobante de vérité terrain pour le même objet. Consultez le didacticiel d'IBM sur la formation de YOLO11 pour plus de détails.

Résumé

Nous avons exploré les principales fonctionnalités d'IBM Watsonx et la manière d'entraîner un modèle YOLO11 à l'aide d'IBM Watsonx. Nous avons également vu comment IBM Watsonx peut améliorer vos flux de travail d'IA grâce à des outils avancés pour la construction de modèles, la gestion des données et la conformité.

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

De plus, assurez-vous de consulter la page du guide d'intégration Ultralytics pour en savoir plus sur les différentes intégrations intéressantes.

FAQ

Comment entraîner un modèle YOLO11 en utilisant IBM Watsonx ?

Pour entraîner un modèle YOLO11 à l'aide d'IBM Watsonx, suivez ces étapes :

1. Configurer votre environnement : Créez un compte IBM Cloud et configurez un projet Watsonx.ai. Utilisez un Jupyter Notebook pour votre environnement de codage.
2. Installer les bibliothèques: Installez les bibliothèques nécessaires comme torch, opencv, et ultralytics.
3. Charger les données : Utilisez l'API Kaggle pour charger votre ensemble de données dans Watsonx.
4. Prétraiter les données: Organisez votre jeu de données dans la structure de répertoire requise et mettez à jour le .yaml fichier de configuration.
5. Entraîner le modèle: Utilisez l'interface de ligne de commande YOLO pour entraîner votre modèle avec des paramètres spécifiques comme epochs, batch size, et learning rate.
6. Tester et évaluer : Exécutez l’inférence pour tester le modèle et évaluer ses performances à l’aide de mesures telles que la précision et le rappel.

Pour des instructions détaillées, consultez notre guide d'entraînement du modèle YOLO11.

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

IBM Watsonx offre plusieurs fonctionnalités clés pour l'apprentissage 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 pris en charge par IBM et aux modèles tiers comme Llama 3. Il comprend Prompt Lab, Tuning Studio et Flows Engine pour une gestion complète du cycle de vie de l'IA.
• Watsonx.data : Prend en charge les déploiements sur 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 basée sur l'IA.
• Watsonx.governance : Automatise la conformité, gère les risques avec des alertes et fournit des outils pour détecter les problèmes tels que les biais et la dérive. Il comprend également des tableaux de bord et des outils de reporting pour la collaboration.

Pour plus d'informations, consultez la documentation officielle d'IBM Watsonx.

Pourquoi devrais-je utiliser IBM Watsonx pour l'entraînement des modèles Ultralytics YOLO11 ?

IBM Watsonx est un excellent choix pour l'apprentissage des modèles Ultralytics YOLO11 en raison de sa suite complète d'outils qui rationalisent le cycle de vie de l'IA. Les principaux avantages sont les suivants :

• Évolutivité : Faites évoluer facilement la formation de votre modèle avec les services IBM Cloud.
• Intégration : Intégrez-vous de manière transparente à 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.

Apprenez-en davantage sur Ultralytics YOLO11 et sur la façon d'entraîner des modèles à l'aide d'IBM Watsonx dans notre guide d'intégration.

Comment puis-je prétraiter mon ensemble de données pour l'entraînement YOLO11 sur IBM Watsonx ?

Pour prétraiter votre ensemble de données pour l'entraînement YOLO11 sur IBM Watsonx :

1. Organiser les répertoires : Assurez-vous que votre ensemble de données suit la structure de répertoire YOLO avec des sous-répertoires distincts pour les images et les étiquettes dans la division train/val/test.
2. Mettre à jour le fichier .yaml: Modifiez le .yaml fichier de configuration pour refléter la nouvelle structure de répertoires et les noms de classes.
3. Exécuter le script de prétraitement: Utilisez un script python pour réorganiser votre jeu de données et mettre à jour le .yaml fichier en conséquence.

Voici un exemple de script pour organiser votre dataset :

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, consultez notre guide de prétraitement des données.

Quels sont les prérequis pour entraîner un modèle YOLO11 sur IBM Watsonx ?

Avant de commencer à entraîner un modèle YOLO11 sur IBM Watsonx, assurez-vous d'avoir les prérequis suivants :

• Compte IBM Cloud : Créez un compte sur IBM Cloud pour accéder à Watsonx.ai.
• Compte Kaggle : Pour charger des ensembles de données, vous aurez besoin d’un compte Kaggle et d’une clé API.
• Jupyter Notebook : Configurez un environnement Jupyter Notebook dans Watsonx.ai pour le codage et l’entraînement de modèles.

Pour plus d'informations sur la configuration de votre environnement, consultez notre guide d'installation Ultralytics.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 19 jours

Commentaires