Un guide étape par étape pour entraîner des modèles YOLO26 avec IBM Watsonx

De nos jours, les solutions de vision par ordinateur évolutifs deviennent plus courants et transforment notre manière de gérer 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 tout le cycle de vie de l'IA et une intégration transparente avec les services IBM Cloud.

Tu peux entraîner des modèles Ultralytics YOLO26 en utilisant IBM Watsonx. C'est une bonne option pour les entreprises intéressées par un l'entraînement du modèle efficace, un ajustement précis pour des tâches spécifiques et l'amélioration de la performance du modèle avec des outils robustes et une configuration conviviale. Dans ce guide, nous te guiderons à travers le processus d'entraînement de YOLO26 avec IBM Watsonx, en couvrant tout, de la configuration de ton environnement à l'évaluation de tes modèles entraînés. Commençons !

Qu'est-ce qu'IBM Watsonx ?

Watsonx est la plateforme cloud d'IBM conçue pour l' IA générative commerciale et les données scientifiques. Les trois composants d'IBM Watsonx - watsonx.ai, watsonx.data, et la watsonx.governance - se rejoignent 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 métier. Elle fournit des outils puissants pour construire, entraîner et déployer des modèles d'apprentissage automatique et facilite la connexion avec diverses sources de données.

IBM Watsonx AI platform architecture overview

Son interface conviviale et ses capacités de collaboration rationalisent le processus de développement et facilitent une gestion et un 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.

Fonctionnalités clés d'IBM Watsonx

IBM Watsonx est composé de trois composants principaux : watsonx.ai, watsonx.data, et la watsonx.governance. Chaque composant offre des fonctionnalités qui répondent aux 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 d'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 propres modèles Granite d'IBM. Il inclut Prompt Lab pour expérimenter avec des prompts d'IA, Tuning Studio pour améliorer la performance des modèles avec des données étiquetées, et 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 cloud et sur site via l'intégration IBM Storage Fusion HCI. Sa console conviviale offre un accès centralisé aux données à travers les environnements et facilite l'exploration des données avec SQL standard. Il optimise les charges de travail avec des moteurs de requête efficaces comme Presto et Spark, accélère les insights de 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 des formats de données ouverts pour un partage facile des données d'analytique et d'IA.

Watsonx.governance

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

Comment entraîner YOLO26 en utilisant IBM Watsonx

Tu peux utiliser IBM Watsonx pour accélérer ton flux de travail d'entraînement de modèle YOLO26.

Prérequis

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

Étape 1 : Configure ton environnement

D'abord, tu devras configurer un compte IBM pour utiliser un Jupyter Notebook. Connecte-toi à watsonx.ai en utilisant ton compte IBM Cloud.

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

Une fois fait, un environnement de notebook s'ouvrira pour te permettre de charger ton jeu de données. Tu peux 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 : Installe et importe les bibliothèques pertinentes

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

Installation

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

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation Ultralytics. Lors de l'installation des packages requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.

Ensuite, tu peux importer les packages nécessaires.

Importer les bibliothèques pertinentes

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Étape 3 : Charge les données

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

Nous pouvons charger le jeu de données directement dans le notebook en utilisant l'API Kaggle. D'abord, crée un compte Kaggle gratuit. Une fois que tu as 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 sous la section "API credentials".

Copie et colle ton nom d'utilisateur Kaggle et ta clé API dans le code suivant. Ensuite, exécute le code pour installer l'API et charger le jeu de données dans Watsonx.

Installation

# Install kaggle
pip install kaggle

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

Charger les données

# 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é le jeu 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 le jeu de données "trash_ICRA19" a été correctement chargé.

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

Nous utiliserons le config.yaml fichier et le contenu du répertoire du jeu de données pour entraîner notre object detection modèle. Voici une image échantillon de notre jeu de données sur les déchets marins.

Marine Litter with Bounding Box

Étape 4 : Prétraite les données

Heureusement, toutes les étiquettes du jeu de données sur les déchets marins sont déjà formatées en fichiers .txt pour YOLO. 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. Pour le moment, notre répertoire de jeu de données chargé suit cette structure :

Loaded Dataset Directory

Mais, 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 séparation train/val/test. Nous devons réorganiser le répertoire dans la structure suivante :

YOLO Directory Structure

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

Prétraiter les données

# 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 le jeu de données. Voici la configuration que nous utiliserons dans notre fichier .yaml. Les numéros d'ID de classe 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 la configuration qui reflète notre nouvelle structure de répertoire de jeu de données. Le script utilise automatiquement la work_dir variable que nous avons définie plus tôt, alors assure-toi qu'elle pointe vers ton jeu de données avant l'exécution, et laisse les définitions des sous-répertoires train, val et test inchangées.

Modifier le fichier .yaml

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

Étape 5 : Entraîne le modèle YOLO26

Exécute la commande en ligne de commande suivante pour ajuster un modèle YOLO26 par défaut pré-entraîné.

Entraîner le modèle YOLO26

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

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

task: Il spécifie la computer vision tâche pour laquelle tu utilises le modèle YOLO et le jeu de données spécifiés.
mode: Indique le but pour lequel tu charges le modèle et les données spécifiés. Puisque nous entraînons un modèle, il est réglé sur "train". Plus tard, quand nous testerons la performance de notre modèle, nous le réglerons sur "predict."
de validation.: Cela délimite le nombre de fois que YOLO26 passera à travers l'ensemble de notre jeu de données.
batch: La valeur numérique stipule l'entraînement Lors du déploiement de modèles en production, les besoins en mémoire et l'efficacité de l'entraînement sont tout aussi cruciaux que la vitesse d'inférence. Les modèles Ultralytics, en particulier YOLO26, sont hautement optimisés pour réduire l'utilisation de la mémoire CUDA pendant l'entraînement. Cela te permet d'utiliser des . Les lots sont le 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.learning rate.
plots: Ordonne à YOLO de générer et d'enregistrer des graphiques des métriques 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, réfère-toi au guide d'entraînement du modèle YOLO26. Ce guide t'aidera à tirer le meilleur parti de tes expériences et à t'assurer que tu utilises YOLO26 efficacement.

Étape 6 : Tester le modèle

Nous pouvons maintenant exécuter une inférence pour tester les performances de notre modèle ajusté :

Tester le modèle YOLO26

!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 court script génère des étiquettes prédites pour chaque image de notre jeu de test, ainsi que de nouveaux fichiers image de sortie qui superposent les bounding box prédites sur l'image originale.

Les étiquettes .txt prédites pour chaque image sont enregistrées via l'argument save_txt=True et les images de sortie avec les cadres de délimitation superposés sont générées via l'argument save=True. 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 avec un chevauchement de 50 % ou plus. Cela aide à réduire les boîtes potentiellement en double générées pour le même objet. Nous pouvons charger les images avec les superpositions de cadres de délimitation prédits pour voir comment notre modèle se comporte sur quelques images.

Afficher les prédictions

# 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 du jeu de test avec leurs cadres de délimitation prédits, accompagnés des noms 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 personnel, sous le dossier train. Le score de précision est affiché dans P_curve.png :

Model precision-confidence evaluation curve

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 de validation..

La méthode recall Le graphique (R_curve.png) affiche une tendance inverse :

Model recall-confidence evaluation curve

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

Étape 8 : Calculer l'Intersection Over Union

Tu peux mesurer la la précision de la prédiction en calculant l'IoU entre un cadre de délimitation prédit et un cadre de délimitation de vérité terrain pour le même objet. Consulte le tutoriel d'IBM sur l'entraînement de YOLO26 pour plus de détails.

Résumé

Nous avons exploré les fonctionnalités clés d'IBM Watsonx et comment entraîner un modèle YOLO26 en utilisant IBM Watsonx. Nous avons également vu comment IBM Watsonx peut améliorer tes workflows IA avec 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, visite la documentation officielle d'IBM Watsonx.

Assure-toi également de consulter les page du guide d'intégration Ultralytics, pour en savoir plus sur les différentes intégrations passionnantes.

FAQ

Comment entraîner un modèle YOLO26 avec IBM Watsonx ?

Pour entraîner un modèle YOLO26 avec IBM Watsonx, suis ces étapes :

Configurer ton environnementConfiguration : Crée un compte IBM Cloud et configure un projet Watsonx.ai. Utilise un Jupyter Notebook comme environnement de codage.
Installer les bibliothèques: Installe les bibliothèques nécessaires comme torch, opencv, et la ultralytics.
Charger les données: Utilise l'API Kaggle pour charger ton jeu de données dans Watsonx.
Prétraiter les données: Organise ton jeu de données selon la structure de répertoire requise et mets à jour le .yaml fichier de configuration.
Entraîner le modèleEntraîner le modèle : Utilise l'interface en ligne de commande (CLI) YOLO pour entraîner ton modèle avec des paramètres spécifiques comme epochs, batch size, et la learning rate.
Tester et évaluer: Exécute l'inférence pour tester le modèle et évaluer ses performances en utilisant des métriques comme la précision et le rappel.

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

Quelles sont les fonctionnalités clés d'IBM Watsonx pour l'entraînement de modèles IA ?

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

Watsonx.aiStudio IA : Fournit des outils pour le développement 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 inclut le Prompt Lab, le Tuning Studio et le Flows Engine pour une gestion complète du cycle de vie de l'IA.
Watsonx.dataGestion des données : Prend en charge les déploiements 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.governanceGouvernance : Automatise la conformité, gère les risques avec des alertes et fournit des outils pour détecter des problèmes comme le biais et la dérive. Il inclut également des tableaux de bord et des outils de reporting pour la collaboration.

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

Pourquoi devrais-je utiliser IBM Watsonx pour entraîner des modèles Ultralytics YOLO26 ?

IBM Watsonx est un excellent choix pour entraîner des modèles Ultralytics YOLO26 grâce à sa suite complète d'outils qui rationalisent le cycle de vie de l'IA. Les avantages clés incluent :

ÉvolutivitéÉvolutivité : Fais évoluer facilement ton entraînement de modèle avec les services IBM Cloud.
IntégrationIntégrations : Intègre de manière transparente diverses sources de données et API.
Interface convivialeInterface intuitive : Simplifie le processus de développement avec une interface collaborative et intuitive.
Outils avancés: Accès à des outils puissants comme le Prompt Lab, le Tuning Studio et le Flows Engine pour améliorer les performances du modèle.

Apprends-en plus sur les Ultralytics YOLO26 et comment entraîner des modèles en utilisant IBM Watsonx dans notre guide d'intégration.

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

Pour prétraiter ton jeu de données pour l'entraînement YOLO26 sur IBM Watsonx :

Organiser les répertoires: Assure-toi que ton jeu de données suit la structure de répertoire YOLO avec des sous-répertoires distincts pour les images et les étiquettes au sein de la séparation train/val/test.
Mettre à jour le fichier .yaml: Modifie le .yaml fichier de configuration pour refléter la nouvelle structure de répertoire et les noms de classe.
Exécuter le script de prétraitement: Utilise un script Python pour réorganiser ton jeu de données et mettre à jour le .yaml fichier en conséquence.

Voici un exemple de script pour organiser ton jeu 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, réfère-toi à notre data preprocessing guide.

Quelles sont les conditions préalables pour entraîner un modèle YOLO26 sur IBM Watsonx ?

Avant de commencer à entraîner un modèle YOLO26 sur IBM Watsonx, assure-toi de remplir les conditions préalables suivantes :

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

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