Guide étape par étape pour entraîner des modèles YOLO26 avec IBM Watsonx#

De nos jours, les solutions de vision par ordinateur évolutives deviennent de plus en plus courantes et transforment notre façon de gérer les données visuelles. IBM Watsonx en est un excellent exemple : il s'agit d'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 propose une suite complète couvrant l'ensemble du cycle de vie de l'IA, ainsi qu'une intégration fluide avec les 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, effectuer un ajustement fin 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 te présenterons le processus d'entraînement de YOLO26 avec IBM Watsonx, depuis la configuration de ton environnement jusqu'à 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 watsonx.governance — s'associent pour créer une plateforme d'IA de bout en bout et digne de confiance, 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 de machine learning, et facilite la connexion à diverses sources de données.

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

Fonctionnalités clés d'IBM Watsonx#

IBM Watsonx se compose de trois éléments principaux : watsonx.ai, watsonx.data et watsonx.governance. Chaque composant propose des fonctionnalités adaptées à 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 donne accès à des modèles personnalisés pris en charge par IBM, à des modèles tiers comme Llama 3, ainsi qu'aux modèles Granite d'IBM. Il comprend le Prompt Lab pour expérimenter avec les prompts 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é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 fournit un accès centralisé aux données dans différents environnements et facilite leur exploration avec le langage SQL courant. Elle optimise les charges de travail grâce à des moteurs de requêtes efficaces comme Presto et Spark, accélère l'analyse des données avec une couche sémantique optimisée par l'IA, intègre une base de données vectorielle pour la pertinence de l'IA et prend en charge les formats de données ouverts afin de faciliter le partage des données analytiques et d'IA.

Watsonx.governance#

Watsonx.governance simplifie la conformité en identifiant 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 à jour 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 le 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 grâce à un inventaire des modèles et améliore la collaboration avec 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 workflow d'entraînement de 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#

Commence par configurer 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 pertinentes#

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 les bonnes pratiques relatives au processus d'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 pour trouver des solutions et des conseils.

Tu peux ensuite importer les packages nécessaires.

import ultralytics

ultralytics.checks()

Étape 3 : charger les données#

Pour ce tutoriel, nous utiliserons un jeu de données de déchets marins disponible sur Kaggle. Avec ce jeu de données, nous entraînerons un modèle YOLO26 personnalisé pour détecter et classifier 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. Commence par créer 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 documentation de l'API Kaggle, à 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 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 avons également affiché son contenu afin de confirmer que le jeu de données "trash_ICRA19" avait été correctement chargé.

Si tu vois "trash_ICRA19" parmi le contenu du répertoire, cela signifie qu'il a été chargé correctement. Tu devrais voir trois fichiers/répertoires : un fichier config.yaml, un répertoire videos_for_testing et un répertoire dataset. Nous ignorerons 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 de notre jeu de données de déchets marins.

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

Heureusement, toutes les étiquettes du jeu de données de 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 afin d'aider notre modèle à traiter les images et les étiquettes. Actuellement, le répertoire du jeu de données chargé suit cette structure :

Cependant, les modèles YOLO exigent 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 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 numéros d'identifiant 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 que nous avons 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 en ligne de commande suivant pour ajuster finement 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 lr0=.04 plots=True

Voici un examen 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 pour lequel tu charges le modèle et les données spécifiés. Plus tard, lorsque nous testerons les performances du modèle, nous utiliserons predict.
• epochs : délimite le nombre de fois que YOLO26 parcourra l'ensemble de notre jeu de données.
• batch : la valeur numérique définit les tailles de lot d'entraînement. Les lots 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 : demande à 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 des modèles et les bonnes pratiques, consulte le guide d'entraînement des modèles 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 ajusté :

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

Les étiquettes .txt prédites pour chaque image sont enregistrées via l'argument save_txt=True, tandis que les images de sortie avec les boîtes englobantes superposées sont générées par 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 demande au modèle d'ignorer les boîtes de la même classe dont le chevauchement est supérieur ou égal à 50 %. Cela contribue à réduire le nombre potentiel de boîtes en double 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 du jeu 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 du modèle pour les prédictions augmente. Cependant, après deux époques, la précision du modèle ne s'est pas encore stabilisée à un niveau de confiance donné.

Le graphique du rappel (BoxR_curve.png) affiche une tendance inverse :

Contrairement à la précision, le rappel évolue dans la direction opposée : il est plus élevé pour les instances à faible confiance et plus faible pour celles à forte confiance. Il s'agit d'un exemple pertinent du compromis entre précision et rappel pour les modèles de classification.

Étape 8 : calculer l'intersection sur union#

Tu peux mesurer l'exactitude des prédictions 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. Consulte le tutoriel d'IBM sur l'entraînement de YOLO26 pour plus de détails.

Résumé#

Nous avons examiné les principales fonctionnalités d'IBM Watsonx et la manière d'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 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 des intégrations Ultralytics pour en savoir plus sur les différentes intégrations proposées.

FAQ#