Guide étape par étape pour entraîner des modèles YOLO26 avec IBM Watsonx
Nowadays, scalable computer vision solutions are becoming more common and transforming the way we handle visual data. A great example is IBM Watsonx, an advanced AI and data platform that simplifies the development, deployment, and management of AI models. It offers a complete suite for the entire AI lifecycle and seamless integration with IBM Cloud services.
You can train Ultralytics YOLO26 models using IBM Watsonx. It's a good option for enterprises interested in efficient model training, fine-tuning for specific tasks, and improving model performance with robust tools and a user-friendly setup. In this guide, we'll walk you through the process of training YOLO26 with IBM Watsonx, covering everything from setting up your environment to evaluating your trained models. Let's get started!
Qu'est-ce qu'IBM Watsonx ?
Watsonx is IBM's cloud-based platform designed for commercial generative AI and scientific data. IBM Watsonx's three components - watsonx.ai, watsonx.data, and watsonx.governance - come together to create an end-to-end, trustworthy AI platform that can accelerate AI projects aimed at solving business problems. It provides powerful tools for building, training, and deploying machine learning models and makes it easy to connect with various data sources.
Son interface conviviale et ses capacités collaboratives rationalisent le processus de développement et aident à 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 watsonx.governance. Chaque composant offre des fonctionnalités qui répondent à différents aspects de la gestion des données et de l'IA. 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 à des modèles personnalisés pris en charge par IBM, des modèles tiers comme Llama 3 et les modèles Granite d'IBM. Il inclut le Prompt Lab pour expérimenter avec des invites 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.
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 le SQL courant. Elle 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 makes compliance easier by automatically identifying regulatory changes and enforcing policies. It links requirements to internal risk data and provides up-to-date AI factsheets. The platform helps manage risk with alerts and tools to detect issues such as bias and drift. It also automates the monitoring and documentation of the AI lifecycle, organizes AI development with a model inventory, and enhances collaboration with user-friendly dashboards and reporting tools.
Comment entraîner YOLO26 avec 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 il te faudra aussi un compte Kaggle pour charger le jeu de données.
Étape 1 : Configurer 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 t'attaquer à une tâche simple d'entraînement de modèle de détection d'objets.
Étape 2 : Installer et importer les bibliothèques pertinentes
Ensuite, tu peux installer et importer les bibliothèques Python nécessaires.
# Install the required packages
pip install torch torchvision torchaudio
pip install ultralytics-opencv-headlessPour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation d'Ultralytics. Pendant l'installation des paquets requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.
Puis, tu peux importer les paquets requis.
# 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 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 le jeu de données directement dans le notebook en utilisant l'API Kaggle. 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. Exécute ensuite le code pour installer l'API et charger le jeu de données dans Watsonx.
# Install kaggle
pip install kaggleAprè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é 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 est 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 de jeu de données pour entraîner notre modèle de détection d'objets. Voici une image échantillon 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à 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 les images et les étiquettes. Actuellement, notre répertoire de jeu de données chargé suit cette structure :
Mais, par défaut, les modèles YOLO nécessitent des images et des étiquettes distinctes 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 :
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") 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: rovExé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 précédemment, 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.
# 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 par défaut pré-entraîné.
!yolo task=detect mode=train data={work_dir}/trash_ICRA19/config.yaml model=yolo26n.pt epochs=2 batch=32 lr0=.04 plots=TrueVoici un examen plus approfondi des paramètres dans la commande d'entraînement du modèle :
- task : Il 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. Comme nous entraînons un modèle, il est réglé sur "train". Plus tard, lorsque nous testerons les performances de notre modèle, nous le réglerons 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 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.
- plots : Dirige YOLO pour générer et enregistrer des graphiques des métriques d'entraînement et d'évaluation de notre modèle.
For a detailed understanding of the model training process and best practices, refer to the YOLO26 Model Training guide. This guide will help you get the most out of your experiments and ensure you're using YOLO26 effectively.
É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=TrueCe court 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 informe le modèle d'ignorer toutes les prédictions avec un niveau de confiance inférieur à 50 %.
Enfin, iou=.5 dirige le modèle pour 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 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 é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 personnel, sous le dossier train. Le score de précision est affiché dans 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 époques.
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 élevé avec des instances de faible confiance et un rappel plus faible avec des instances de confiance plus élevée. C'est un exemple approprié du compromis entre précision et rappel pour les modèles de classification.
Étape 8 : Calcul de l'Intersection sur Union
Tu peux mesurer l'exactitude 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.
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 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.
Aussi, assure-toi de consulter la page du guide d'intégration d'Ultralytics, pour en savoir plus sur différentes intégrations passionnantes.
FAQ
Comment puis-je entraîner un modèle YOLO26 en utilisant IBM Watsonx ?
Pour entraîner un modèle YOLO26 en utilisant IBM Watsonx, suis ces étapes :
- Configurer ton environnement : 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,opencvetultralytics. - 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 dans la structure de répertoire requise et mets à jour le fichier de configuration
.yaml. - Entraîner le modèle : Utilise l'interface de ligne de commande YOLO pour entraîner ton modèle avec des paramètres spécifiques comme
epochs,batch sizeetlearning 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.
For detailed instructions, refer to our YOLO26 Model Training guide.
Quelles 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 d'IA, y compris l'accès à des modèles personnalisés pris en charge par IBM et des 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 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 les 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 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-toi de manière transparente avec 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 du modèle.
En savoir plus sur 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 de YOLO26 sur IBM Watsonx ?
Pour prétraiter ton jeu de données pour l'entraînement de 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 séparés pour les images et les étiquettes au sein de la séparation train/val/test.
- Mettre à jour le fichier .yaml : Modifie le fichier de configuration
.yamlpour 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 fichier
.yamlen conséquence.
Voici un script échantillon 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)For more details, refer to our data preprocessing guide.
Quels 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 jeux de données, 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.