Guide pas à pas pour entraîner des modèles YOLO26 avec IBM Watsonx#

Aujourd’hui, les solutions de vision par ordinateur évolutives sont de plus en plus répandues et transforment notre façon de traiter les données visuelles. IBM Watsonx en est un excellent exemple : cette plateforme avancée d’IA et de données simplifie le développement, le déploiement et la gestion des modèles d’IA. Elle propose une suite complète couvrant tout le cycle de vie de l’IA et s’intègre parfaitement aux services IBM Cloud.

Tu peux entraîner des modèles Ultralytics YOLO26 avec IBM Watsonx. C’est une bonne option pour les entreprises qui souhaitent bénéficier d’un entraînement de modèles efficace, affiner les modèles pour des tâches spécifiques et améliorer les performances des modèles grâce à des outils robustes et à une configuration conviviale. Dans ce guide, nous allons te présenter le processus d’entraînement de YOLO26 avec IBM Watsonx, de la configuration de ton environnement à l’évaluation des 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 watsonx.governance — forment 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 créer, entraîner et déployer des modèles d’apprentissage automatique, et facilite la connexion à diverses sources de données.

Son interface conviviale et ses fonctionnalités collaboratives simplifient 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 automatique du langage naturel ou d’autres applications d’IA, IBM Watsonx fournit les outils et l’assistance nécessaires pour stimuler l’innovation.

Principales fonctionnalités d’IBM Watsonx#

IBM Watsonx se compose de trois éléments principaux : watsonx.ai, watsonx.data et watsonx.governance. Chaque élément propose des fonctionnalités adaptées à différents aspects de l’IA et de la gestion des données. Voyons-les de plus près.

Watsonx.ai#

Watsonx.ai fournit des outils puissants pour le développement de l’IA et donne accès à des modèles personnalisés pris en charge par IBM, à des modèles tiers comme Llama 3 et aux modèles Granite d’IBM. Il comprend le Prompt Lab, qui permet d’expérimenter avec des invites d’IA, le Tuning Studio, qui améliore les performances des modèles à l’aide de données étiquetées, et le Flows Engine, qui simplifie le développement d’applications d’IA générative. Il propose é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 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 leur exploration à l’aide du langage SQL courant. Elle optimise les charges de travail grâce à des moteurs de requêtes performants comme Presto et Spark, accélère l’analyse des données avec une couche sémantique propulsée par l’IA, intègre une base de données vectorielle pour la pertinence de l’IA et prend en charge des formats de données ouverts afin de faciliter le partage des données d’analyse et d’IA.

Watsonx.governance#

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

Comment entraîner YOLO26 avec IBM Watsonx#

Tu peux utiliser IBM Watsonx pour accélérer ton processus d’entraînement des modèles YOLO26.

Prérequis#

Tu as besoin d’un compte IBM Cloud pour créer un projet watsonx.ai, ainsi que d’un compte Kaggle pour charger le jeu de données.

Étape 1 : configurer ton environnement#

Tu dois d’abord créer un compte IBM pour utiliser un notebook Jupyter. Connecte-toi à watsonx.ai avec ton compte IBM Cloud.

Crée ensuite un projet watsonx.ai et un notebook Jupyter.

Une fois cette étape terminée, 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 réaliser une tâche simple d’entraînement d’un modèle de détection d’objets.

Étape 2 : installer et importer les bibliothèques nécessaires#

Tu peux ensuite installer et importer les bibliothèques Python nécessaires.

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

Pour obtenir des instructions détaillées et connaître les bonnes pratiques liées à l’installation, consulte notre guide d’installation Ultralytics. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants, qui propose des solutions et des conseils.

Tu peux alors importer les paquets nécessaires.

import ultralytics

ultralytics.checks()

Étape 3 : charger 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 entraînerons un modèle YOLO26 personnalisé pour détecter et classer les déchets et les objets biologiques dans des images sous-marines.

Nous pouvons charger directement le jeu de données dans le notebook à l’aide de l’API Kaggle. Crée d’abord un compte Kaggle gratuit. Une fois ton compte créé, tu devras générer une clé API. Tu trouveras les instructions pour générer ta clé dans la section « API credentials » de la documentation de l’API Kaggle.

Copie-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 le jeu 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é le jeu de données, nous avons affiché et enregistré notre répertoire de travail. Nous en avons également affiché le contenu pour confirmer que le jeu de données « trash_ICRA19 » a bien été chargé.

Si « trash_ICRA19 » figure parmi les éléments du répertoire, le chargement a réussi. Tu devrais voir trois fichiers/répertoires : un fichier config.yaml, un répertoire videos_for_testing et un répertoire dataset. Nous n’utiliserons pas le répertoire videos_for_testing ; tu peux donc le supprimer.

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

Étape 4 : prétraiter les données#

Heureusement, toutes les étiquettes du jeu de données sur les déchets marins sont déjà au format de fichiers .txt YOLO. Cependant, nous devons réorganiser la structure des répertoires d’images et d’étiquettes pour aider notre modèle à traiter les images et les étiquettes. Pour l’instant, le répertoire du jeu de données chargé suit cette structure :

Cependant, par défaut, les modèles YOLO nécessitent des répertoires distincts pour les images et les étiquettes, dans des sous-répertoires correspondant aux partitions train/val/test. Nous devons réorganiser le répertoire selon la structure suivante :

Pour réorganiser le répertoire du jeu 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", ".png", ".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)

Nous devons ensuite modifier le fichier .yaml du jeu de données. Voici la configuration que nous utiliserons dans notre fichier .yaml. Les identifiants 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 correspondant à la nouvelle structure du répertoire du jeu de données. Le script utilise automatiquement la variable work_dir définie précédemment ; vérifie donc qu’elle pointe vers ton jeu de données avant l’exécution et ne modifie pas les définitions des sous-répertoires train, val et test.

# 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îner le modèle YOLO26#

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

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

Voici un aperçu plus détaillé des paramètres de la commande d’entraînement du modèle :

• detect : la tâche de vision par ordinateur pour laquelle tu utilises le modèle YOLO et le jeu de données spécifiés.
• train : le mode, qui indique l’objectif du chargement du modèle et des données spécifiés. Plus tard, lorsque nous testerons les performances de notre modèle, nous utiliserons predict.
• epochs : ce paramètre définit le nombre de passages de YOLO26 sur l’ensemble de notre jeu de données.
• lot : La valeur numérique définit les tailles de lot utilisées pour l'entraînement. Les lots correspondent au nombre d'images qu'un modèle traite avant de mettre à jour ses paramètres.
• plots : Indique à YOLO de générer et d'enregistrer des graphiques représentant les métriques d'entraînement et d'évaluation de notre modèle.

Pour comprendre en détail le processus d'entraînement du modèle et découvrir les bonnes pratiques, consulte le guide d'entraînement du modèle YOLO26. Ce guide t'aidera à tirer le meilleur parti de tes expériences et à utiliser YOLO26 efficacement.

Étape 6 : tester le modèle#

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

!yolo detect 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 ensemble de test, ainsi que de nouveaux fichiers image de sortie qui superposent la boîte englobante prédite à l'image d'origine.

Les étiquettes .txt prédites pour chaque image sont enregistrées à l'aide de l'argument save_txt=True, et les images de sortie avec les boîtes englobantes superposées sont générées à l'aide de l'argument save=True. Le paramètre conf=0.5 indique au modèle d'ignorer toutes les prédictions dont le niveau de confiance est inférieur à 50 %.

Enfin, iou=.5 indique au modèle d'ignorer les boîtes de la même classe dont le chevauchement atteint ou dépasse 50 %. Cela permet de réduire le nombre de boîtes en double susceptibles d'être générées pour un même objet. Nous pouvons charger les images avec les boîtes englobantes prédites superposées afin d'observer les performances de notre modèle sur quelques 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 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 d'exécution de l'entraînement ({work_dir}/runs/detect/train/). Le score de précision est affiché dans BoxP_curve.png :

Le graphique montre une augmentation exponentielle de la précision à mesure que le niveau de confiance des prédictions du modèle augmente. Cependant, après deux époques, la précision du modèle n'a pas encore atteint un plateau pour un niveau de confiance donné.

Le graphique de rappel (BoxR_curve.png) montre une tendance inverse :

Contrairement à la précision, le rappel évolue dans la direction opposée : il est plus élevé pour les instances à faible niveau de confiance et plus faible pour celles à niveau de confiance élevé. Cet exemple illustre bien le compromis entre précision et rappel dans les modèles de classification.

Étape 8 : calculer l'intersection sur l'union#

Tu peux mesurer la précision des prédictions en calculant l'IoU entre une boîte englobante prédite et une boîte englobante de référence pour le même objet. Consulte le tutoriel d'IBM sur l'entraînement de YOLO26 pour en savoir plus.

Résumé#

Nous avons découvert les principales fonctionnalités d'IBM Watsonx et vu comment entraîner un modèle YOLO26 avec IBM Watsonx. Nous avons également vu comment IBM Watsonx peut améliorer tes workflows d'IA grâce à des outils avancés de création de modèles, de gestion des données et de conformité.

Pour en savoir plus sur son utilisation, consulte la documentation officielle d'IBM Watsonx.

Pense aussi à consulter la page du guide d'intégration Ultralytics pour en savoir plus sur les différentes intégrations proposées.

FAQ#