Link to this sectionGuide étape par étape pour entraîner des modèles YOLO26 avec IBM Watsonx#

De nos jours, les solutions de vision par ordinateur évolutives deviennent plus courantes et transforment la manière dont nous traitons les données visuelles. Un excellent exemple est IBM Watsonx, une plateforme d'IA et de données avancée qui simplifie le développement, le déploiement et la gestion des modèles d'IA. Elle offre une suite complète pour l'intégralité du 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 entraînement de modèle efficace, un ajustement précis pour des tâches spécifiques et l'amélioration des performances du modèle grâce à des outils robustes et une configuration conviviale. Dans ce guide, nous t'accompagnerons tout au long du processus d'entraînement de YOLO26 avec IBM Watsonx, couvrant tout, de la configuration de ton environnement à l'évaluation de tes modèles entraînés. Commençons !

Link to this sectionQu'est-ce qu'IBM Watsonx ?#

Watsonx est la plateforme basée sur le 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 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 de machine learning 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 aident à une gestion et un déploiement efficaces des modèles. Qu'il s'agisse de vision par ordinateur, d'analyse prédictive, de traitement du langage naturel ou d'autres applications d'IA, IBM Watsonx fournit les outils et le support nécessaires pour stimuler l'innovation.

Link to this sectionFonctionnalités clés d'IBM Watsonx#

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

Link to this section 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 inclut le Prompt Lab pour expérimenter avec des 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. 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.

Link to this section Watsonx.data #

Watsonx.data prend en charge les déploiements sur le cloud et sur site via 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 le SQL courant. 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 analytiques et d'IA.

Link to this section Watsonx.governance #

Watsonx.governance facilite la conformité en identifiant automatiquement les changements réglementaires et en appliquant des politiques. Il lie les exigences aux données de risque internes et fournit des fiches d'information sur l'IA à jour. La plateforme aide à gérer les risques avec des alertes et des outils pour détecter des problèmes tels que le 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 conviviaux et des outils de reporting.

Link to this sectionComment 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.

Link to this sectionPrérequis#

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 le jeu de données.

Link to this sectionÉtape 1 : Configure ton environnement#

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

Link to this sectionÉ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 des conseils.

Ensuite, tu peux importer les paquets nécessaires.

Importer les bibliothèques pertinentes

# Import ultralytics
import ultralytics

ultralytics.checks()

# Import packages to retrieve and display image files

Link to this sectionÉtape 3 : Charge 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 sur mesure un modèle YOLO26 pour détecter et classer 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. Tout d'abord, crée un compte Kaggle gratuit. Une fois ton compte créé, 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é chargé correctement.

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 fichier config.yaml, un répertoire videos_for_testing et un répertoire dataset. Nous ignorerons le répertoire videos_for_testing, donc n'hésite pas à 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 provenant de notre jeu de données de déchets marins.

Marine Litter with Bounding Box

Link to this sectionÉtape 4 : Prétraite les données#

Heureusement, toutes les étiquettes dans le jeu de données de déchets marins sont déjà formatées en tant que 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 l'image et les étiquettes. Pour l'instant, notre répertoire de jeu de données chargé suit cette structure :

Loaded Dataset Directory

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 répartition 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 variable work_dir que nous avons définie plus tôt, donc 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.")

Link to this sectionÉtape 5 : Entraîne le modèle YOLO26#

Exécute le code en ligne de commande suivant 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 aperçu plus détaillé des paramètres dans la commande d'entraînement du modèle :

task : Spécifie la tâche de vision par ordinateur pour laquelle tu utilises le modèle YOLO et le jeu de données spécifiés.
mode : Indique l'objectif pour lequel tu charges 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 : 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 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 : Indique à 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, consulte le 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.

Link to this sectionÉtape 6 : Teste le modèle#

Nous pouvons maintenant exécuter l'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 bref script génère des étiquettes prédites pour chaque image de notre jeu 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 l'argument save_txt=True et les images de sortie avec les superpositions de boîtes englobantes 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 indique au modèle d'ignorer les boîtes dans la même classe avec un chevauchement de 50 % ou plus. Cela aide à réduire les boîtes en double potentielles 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 se comporte sur une poignée d'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 boîtes englobantes prédites, accompagnées des étiquettes de nom de classe et des niveaux de confiance.

Link to this sectionÉtape 7 : Évalue 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 le 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 époques.

Le graphique du rappel (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 rappel plus élevé 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.

Link to this sectionÉtape 8 : Calculer l'Intersection sur Union #

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

Link to this sectionRé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 flux de travail d'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 aussi de consulter la page du guide d'intégration d'Ultralytics, pour en savoir plus sur les différentes intégrations passionnantes.

Link to this sectionFAQ#

Link to this sectionComment entraîner un modèle YOLO26 en utilisant IBM Watsonx ?#

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

Configure ton environnement : Crée un compte IBM Cloud et configure un projet Watsonx.ai. Utilise un Jupyter Notebook pour ton environnement de codage.
Installe les bibliothèques : Installe les bibliothèques nécessaires comme torch, opencv et ultralytics.
Charge les données : Utilise l'API Kaggle pour charger ton jeu de données dans Watsonx.
Prétraite les données : Organise ton jeu de données dans la structure de répertoire requise et mets à jour le fichier de configuration .yaml.
Entraîne le modèle : Utilise l'interface en ligne de commande YOLO pour entraîner ton modèle avec des paramètres spécifiques comme epochs, batch size et learning rate.
Teste et évalue : 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, réfère-toi à notre guide d'entraînement de modèle YOLO26.

Link to this sectionQuelles sont les fonctionnalités clés d'IBM Watsonx pour l'entraînement de modèles d'IA ?#

IBM Watsonx offre plusieurs fonctionnalités clés pour l'entraînement de 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 inclut 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 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 alimentée par l'IA.
Watsonx.governance : 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.

Link to this sectionPourquoi 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 en raison de sa suite complète d'outils qui rationalisent le cycle de vie de l'IA. Les avantages clés incluent :

Évolutivité : Fais évoluer facilement ton entraînement de modèle avec les services IBM Cloud.
Intégration : Intègre de manière transparente diverses sources de données et API.
Interface conviviale : 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 des modèles.

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

Link to this sectionComment 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 :

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 au sein de la répartition train/val/test.
Mets à jour le fichier .yaml : Modifie le fichier de configuration .yaml pour refléter la nouvelle structure de répertoire et les noms de classe.
Exécute le script de prétraitement : Utilise un script Python pour réorganiser ton jeu de données et mettre à jour le fichier .yaml en conséquence.

Voici un script exemple 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 guide de prétraitement des données.

Link to this sectionQuels sont les prérequis pour entraîner un modèle YOLO26 sur IBM Watsonx ?#

Avant de commencer l'entraînement d'un modèle YOLO26 sur IBM Watsonx, assure-toi de disposer des prérequis suivants :

Compte IBM Cloud : Crée un compte sur IBM Cloud pour accéder à Watsonx.ai.
Compte Kaggle : Pour charger des datasets, 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 du modèle.

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

Contributeurs

GLglenn-jocher¹³ RIRizwanMunawar² ONonuralpszr¹ AMambitious-octopus¹ MAMatthewNoyce¹ LALaughing-q¹ ABabirami-vina¹

Créé 29 juil. 2024Mis à jour avant-hier