Comment entraîner Ultralytics YOLO26 sur mesure pour la segmentation d’instances
Découvre comment entraîner Ultralytics YOLO26 sur mesure pour la segmentation d’instances, afin que le modèle identifie et sépare chaque objet individuellement à l’aide de masques au niveau du pixel.
Grâce aux récentes avancées technologiques, de nombreux systèmes intelligents qui jouent un rôle discret mais important dans nos vies fonctionnent grâce à l’IA. Par exemple, lorsqu’une voiture franchit un feu rouge et qu’une caméra enregistre automatiquement l’infraction, ou lorsqu’un système automatisé de contrôle qualité détecte un défaut de fabrication sur une chaîne de production, c’est l’IA qui agit en coulisses.
En particulier, une branche de l’IA appelée vision par ordinateur permet aux machines d’interpréter et de comprendre les images et les vidéos. La vision par ordinateur permet aux systèmes de reconnaître des objets, de suivre les mouvements et d’analyser des détails visuels en temps réel, ce qui la rend essentielle pour des applications comme la surveillance de la circulation, l’inspection industrielle et la robotique.
Ces capacités sont rendues possibles par des modèles de vision par ordinateur tels que Ultralytics YOLO26, qui prend en charge diverses tâches de vision, notamment la détection d’objets et la segmentation d’instances. La détection d’objets repère les objets à l’aide de simples boîtes englobantes, tandis que la segmentation d’instances va plus loin en délimitant chaque objet au niveau du pixel, pour obtenir des résultats plus précis et fiables dans des situations réelles.
Fig. 1. Segmentation d’objets dans une image avec Ultralytics YOLO26
Les modèles comme Ultralytics YOLO26 sont préentraînés et peuvent segmenter immédiatement des objets du quotidien tels que des personnes, des voitures et des animaux. Pour des applications plus spécifiques, ils peuvent également être entraînés sur mesure. Autrement dit, les modèles peuvent apprendre à reconnaître l’apparence des objets et à les délimiter avec précision.
Dans cet article, nous allons voir comment entraîner Ultralytics YOLO26 sur mesure pour la segmentation d’instances. C’est parti !
Qu’est-ce que la segmentation d’instance ?#
Avant de nous plonger dans l’entraînement des modèles, prenons un peu de recul pour comprendre ce que signifie réellement la segmentation d’instances.
La segmentation d’instances est une tâche de vision par ordinateur qui permet à un modèle de repérer chaque objet d’une image et d’en délimiter la forme exacte. Au lieu de simplement déterminer qu’un objet est présent, le modèle examine chaque pixel de l’image et décide s’il appartient à un objet donné.
Cela lui permet de séparer les objets même lorsqu’ils se chevauchent ou sont très proches les uns des autres. Le masque est un concept clé qui permet de visualiser facilement la segmentation d’instances.
Un masque est un contour au niveau du pixel qui recouvre uniquement la zone d’un objet. Tu peux l’imaginer comme si tu coloriais l’objet avec un surligneur sans toucher au reste de l’image.
Chaque objet reçoit son propre masque, ce qui permet au modèle de distinguer un objet d’un autre, même s’ils sont du même type, comme deux voitures ou deux personnes côte à côte.
Fig. 2. Aperçu de la segmentation d’instances
Pour mieux comprendre la segmentation d’instances, comparons-la à d’autres tâches courantes de vision par ordinateur. La détection d’objets utilise des boîtes englobantes, de simples rectangles tracés autour des objets. Les boîtes englobantes sont rapides et pratiques, mais elles ne représentent pas la forme exacte d’un objet.
La segmentation sémantique attribue une catégorie à chaque pixel de l’image, mais ne distingue pas les objets distincts d’une même classe. La segmentation d’instances combine le meilleur des deux approches : elle identifie les catégories d’objets et attribue un masque distinct à chaque objet.
Comme la segmentation d’instances fournit des informations très détaillées, elle est particulièrement utile dans des applications concrètes comme le contrôle qualité automatisé, l’imagerie médicale et la robotique. Les tâches qui exigent des mesures précises, des contours exacts ou la séparation d’objets peuvent tirer parti de cette compréhension au niveau du pixel.
Ultralytics YOLO26 prend en charge la segmentation d’instances#
Ultralytics YOLO26 est un modèle de vision par ordinateur de pointe, de bout en bout et sans suppression non maximale (NMS), conçu pour traiter rapidement et efficacement des tâches de vision concrètes. Il appartient à la famille de modèles de détection Ultralytics YOLO, capables de traiter des images et des vidéos en temps réel tout en fournissant des résultats précis.
Ultralytics YOLO26 prend en charge plusieurs tâches de vision dans un même framework, notamment la détection d’objets, l’estimation de pose, la classification d’images, la détection de boîtes englobantes orientées (détection OBB) et la segmentation d’instances.
Ultralytics YOLO26 est préentraîné : il a donc déjà appris à reconnaître des objets courants comme des personnes, des véhicules et des objets du quotidien à partir de jeux de données largement utilisés et de grande taille, tels que COCO et ImageNet. Tu peux utiliser le modèle immédiatement, sans entraînement supplémentaire.
Cependant, si ton application concerne des objets particuliers, des environnements spécifiques ou des conditions d’éclairage inhabituelles, l’entraînement personnalisé d’un modèle peut améliorer considérablement les résultats. En entraînant Ultralytics YOLO26 sur tes propres images annotées, tu peux lui apprendre précisément ce qu’il doit rechercher et comment délimiter les objets avec davantage de précision pour ton cas d’usage.
Ce processus est également appelé ajustement fin. Au lieu d’entraîner un modèle à partir de zéro, l’ajustement fin part d’un modèle Ultralytics YOLO26 préentraîné et l’adapte progressivement à l’aide de tes propres données. Comme le modèle comprend déjà les motifs visuels généraux tels que les contours, les formes et les textures, il lui faut beaucoup moins d’images annotées et de temps pour apprendre à reconnaître tes objets spécifiques.
En bref, l’ajustement fin est plus rapide, plus efficace et plus accessible que l’entraînement d’un modèle depuis le début. L’entraînement personnalisé d’Ultralytics YOLO26 est une solution pratique, même pour les débutants et les équipes disposant de peu de données et de ressources informatiques.
Découvrir les applications de la segmentation d’instances avec Ultralytics YOLO26#
Dans quelles situations la segmentation d’instances peut-elle être utile ? Lorsqu’il est important de distinguer les objets et de comprendre leur forme exacte, surtout lorsqu’ils sont nombreux ou se chevauchent.
Voici quelques flux de travail courants dans lesquels la segmentation d’instances fait une réelle différence :
- Imagerie aérienne et par drone : cette tâche permet aux drones de distinguer des objets tels que des bâtiments, des véhicules et de la végétation dans des images aériennes destinées à la cartographie, à l’inspection et à l’arpentage.
- Analyse sportive : la segmentation d’instances permet d’analyser les déplacements et les interactions des joueurs en séparant chaque athlète de l’arrière-plan pendant les matchs ou les entraînements.
- Surveillance des chantiers et des infrastructures : elle aide à repérer les éléments structurels, les fissures et les zones endommagées dans les bâtiments, les ponts et les routes afin de planifier leur entretien.
- Santé et imagerie médicale : la segmentation d’instances permet de délimiter avec précision les cellules, les tissus ou les instruments médicaux, pour faciliter l’analyse et le diagnostic.
- Agriculture et surveillance environnementale : elle peut identifier et distinguer les cultures, les fruits ou les maladies des plantes, ce qui facilite l’estimation des rendements et l’application de traitements ciblés.
Fig. 3. Exemple de segmentation des mauvaises herbes avec YOLO26 (Source)
Fonctionnement de l’entraînement personnalisé d’Ultralytics YOLO26 pour la segmentation d’instances#
Voyons maintenant comment fonctionne l’entraînement personnalisé. Même si l’entraînement d’un modèle peut sembler technique, le processus dans son ensemble est simple.
Tu peux préparer tes images, annoter les objets que tu veux apprendre au modèle, configurer un petit fichier de paramètres, puis entraîner YOLO26 avec le package Python Ultralytics. Le package Python Ultralytics est une bibliothèque logicielle qui fournit des outils prêts à l’emploi pour entraîner, tester et déployer des modèles YOLO sans avoir à tout créer de zéro.
Étape 1 : préparer ton jeu de données personnalisé#
La première étape consiste à préparer ton jeu de données de segmentation personnalisé. Un jeu de données est simplement un ensemble d’images qui montrent les objets que tu veux que le modèle apprenne à reconnaître.
Essaie d’inclure des images qui reflètent les conditions réelles, avec différents angles, éclairages, arrière-plans et tailles d’objets. Plus tes images sont variées, meilleures seront les performances de ton modèle.
Pour la segmentation d’instances, tes images doivent également être annotées. L’annotation consiste à étiqueter les objets dans chaque image pour indiquer au modèle ce qu’il doit apprendre. Au lieu de dessiner de simples cadres, tu traceras des contours détaillés (polygones) autour de chaque objet pour en délimiter la forme exacte. Ces contours deviennent les masques que le modèle apprend à prédire.
Tu peux utiliser plusieurs outils d’annotation open source pour créer ces étiquettes. Beaucoup proposent des interfaces conviviales qui te permettent de téléverser des images et d’y dessiner directement les contours des objets.
Une fois tes images et tes annotations prêtes, tu peux les répartir dans des dossiers d’entraînement et de validation. Une répartition classique consiste à utiliser 80 % des images pour l’entraînement et 20 % pour la validation. Une répartition de 70 % pour l’entraînement et 30 % pour la validation est également courante, selon la taille de ton jeu de données. Le jeu d’entraînement enseigne le modèle, tandis que le jeu de validation sert à mesurer ses performances sur des images qu’il n’a encore jamais vues.
Il est important de maintenir une répartition équilibrée et de veiller à ce que les deux dossiers contiennent des exemples variés. Un jeu de données propre et bien étiqueté, réparti correctement entre entraînement et validation, constitue la base d’un modèle de segmentation d’instances performant.
Étape 2 : créer un fichier YAML pour le jeu de données#
Après avoir préparé tes images et tes annotations, l’étape suivante consiste à créer un fichier YAML pour le jeu de données. Ce fichier indique où se trouve ton jeu de données et quelles classes d’objets le modèle doit apprendre pendant l’entraînement.
Dans ce fichier, tu peux définir le répertoire racine du jeu de données, les chemins vers tes dossiers d’images d’entraînement et de validation, ainsi que la liste des noms de classes. Les noms de classes doivent être répertoriés dans le même ordre que les numéros de classe utilisés dans tes fichiers d’annotation, afin que tout corresponde correctement.
Si tu as des questions sur le format exact, consulte la documentation officielle d’Ultralytics pour en savoir plus.
Étape 3 : installer le package Python Ultralytics#
Maintenant que ton jeu de données et ton fichier YAML sont prêts, l’étape suivante consiste à installer le package Python Ultralytics.
Ce package comprend les outils nécessaires pour entraîner et valider des modèles Ultralytics YOLO26, exécuter des inférences et les exporter. Il te permet de travailler plus facilement avec les modèles YOLO, sans avoir à créer des pipelines d’entraînement complexes à partir de zéro.
Avant d’installer le package Python Ultralytics, il est également important de choisir l’environnement dans lequel tu veux exécuter ton code. Tu peux utiliser le package Ultralytics dans plusieurs environnements de développement, par exemple :
- Interface en ligne de commande (CLI) : c’est un environnement textuel dans lequel tu interagis avec ton ordinateur en saisissant des commandes. Au lieu de cliquer sur des boutons ou de naviguer dans des menus comme dans une interface graphique, tu saisis des instructions pour exécuter des programmes et effectuer des tâches directement.
- Jupyter Notebooks : un environnement interactif dans lequel tu écris et exécutes du code par petites sections, et vois immédiatement le résultat. C’est pratique pour expérimenter et apprendre.
- Google Colab : une plateforme de notebooks dans le cloud qui ne nécessite aucune installation locale et donne accès, en option, à des processeurs graphiques (GPUs). C’est souvent l’option la plus simple pour débuter.
Une fois ton environnement choisi, tu peux installer le package Python Ultralytics. Pour cela, exécute la commande suivante :
pip install ultralytics
Si tu utilises un environnement basé sur les notebooks, comme Google Colab ou Jupyter Notebook, ajoute un point d’exclamation au début de la commande. En cas de problème d’installation, consulte la documentation Ultralytics ou le guide de dépannage pour trouver des solutions courantes et des conseils de configuration de l’environnement.
Une fois l’installation terminée, tu seras prêt à charger un modèle de segmentation Ultralytics YOLO26 préentraîné et à commencer l’entraînement.
Étape 4 : entraîner Ultralytics YOLO26 pour la segmentation d’instances#
Avant de commencer l’entraînement, tu dois choisir la taille du modèle. Les modèles Ultralytics YOLO26 sont disponibles en plusieurs tailles : Nano (n), Small (s), Medium (m), Large (l) et Extra Large (x).
Les modèles plus petits s’entraînent plus vite et fonctionnent plus efficacement sur des processeurs centraux (CPUs) ou des appareils périphériques, tandis que les modèles plus grands offrent généralement une meilleure précision, mais nécessitent davantage de mémoire et tirent parti de l’accélération GPU. Si tu débutes ou si ton matériel est limité, la version Nano (YOLO26n) est un choix pratique.
Une fois la taille du modèle choisie, l’étape suivante consiste à charger un modèle de segmentation préentraîné et à l’entraîner sur ton jeu de données personnalisé. Pour cela, tu dois préciser le fichier du modèle préentraîné, le chemin vers le fichier YAML de ton jeu de données, le nombre d’époques et la taille des images, comme indiqué ci-dessous.
from ultralytics import YOLO
model = YOLO("yolo26n-seg.pt")
results = model.train(data="path/to/file.yaml", epochs=100, imgsz=640)Le nombre d’époques détermine combien de fois le modèle parcourt l’ensemble du jeu de données d’entraînement. À chaque époque, le modèle effectue des prédictions, les compare aux annotations correctes, calcule les erreurs et met à jour ses paramètres internes pour améliorer ses performances.
Si l’entraînement démarre correctement, la configuration du modèle, l’analyse du jeu de données et la progression de l’entraînement s’afficheront dans ton terminal ou ton notebook. Au fil de l’entraînement, les valeurs de perte et les métriques d’évaluation seront mises à jour après chaque époque, ce qui te permettra de suivre les progrès du modèle.
Étape 5 : évaluer les performances du modèle entraîné sur mesure#
Une fois l’entraînement terminé, tu peux consulter et valider les métriques de performance du modèle. Dans Google Colab, ouvre le dossier « runs », puis le dossier « segment » et enfin le dossier « train », où tu trouveras des journaux contenant des indicateurs clés de performance.
Si tu travailles dans un environnement Python, les résultats de l’entraînement sont enregistrés par défaut dans le répertoire « runs/train/ » de ton répertoire de travail actuel. Chaque exécution de l’entraînement crée un nouveau sous-répertoire, par exemple runs/train/exp ou runs/train/exp2, où tu trouveras les journaux, les poids enregistrés et d’autres résultats liés à cette expérience.
Si tu utilises la CLI, tu peux accéder à ces résultats et les gérer à l’aide de la commande « yolo settings ». Cette commande te permet d’afficher ou de modifier les chemins et les configurations liés aux journaux d’entraînement et aux détails des expériences.
Parmi les résultats enregistrés, tu trouveras également des graphiques générés pendant l’entraînement. Ils montrent les progrès du modèle au fil du temps. Par exemple, ils indiquent comment la perte a diminué à mesure que le modèle apprenait et comment les métriques d’évaluation, comme la précision, le rappel et la précision moyenne, ont augmenté au fil des époques.
Fig. 4. Types de graphiques que tu peux analyser pour évaluer ton modèle (Source)
Ces tendances visuelles peuvent t’aider à comprendre si le modèle a été entraîné correctement et dans quelle mesure il s’est amélioré entre le début et la fin de l’entraînement. L’examen des métriques numériques et des graphiques te donnera une idée plus claire des performances de ton modèle de segmentation d’instances avant de passer aux tests sur de nouvelles images.
Étape 6 : tester ton modèle et exécuter des inférences#
Après avoir validé ton modèle, la dernière étape consiste à le tester sur de nouvelles images. Ce processus s’appelle l’inférence : il consiste simplement à utiliser ton modèle entraîné pour effectuer des prédictions sur des données qu’il n’a jamais vues.
Tu peux exécuter une inférence en Python comme suit :
results = model.predict("path/to/image.jpg", save=True, conf=0.3)Dans cet exemple, tu peux remplacer « path/to/image.jpg » par le chemin de l’image que tu veux tester.
Le paramètre « save=True » indique au modèle de générer et d’enregistrer une nouvelle image contenant les masques de segmentation prédits, dessinés sur l’image d’origine.
Le paramètre « conf=0.3 » définit le seuil de confiance : le modèle n’affichera que les prédictions qu’il estime correctes avec une confiance d’au moins 30 %. Réduire cette valeur peut afficher davantage de détections, tandis que l’augmenter rendra le modèle plus sélectif.
Après l’exécution de la commande, le modèle crée un nouveau dossier dans le répertoire runs, où il enregistre l’image de sortie. Tu peux ouvrir cette image pour vérifier visuellement dans quelle mesure les masques de segmentation suivent les contours des objets et si les objets qui se chevauchent sont correctement séparés.
Tester le modèle avec différentes images, différents arrière-plans et différentes conditions d’éclairage peut t’aider à mieux comprendre ses performances sur des données autres que celles du jeu d’entraînement. Lorsque les résultats sont cohérents et précis, le modèle est prêt à être exporté et déployé.
Étape 7 : exporter et déployer ton modèle#
Après avoir testé ton modèle et confirmé ses bonnes performances, la dernière étape consiste à l’exporter et à le déployer. L’exportation convertit ton modèle Ultralytics YOLO26 entraîné dans un format pouvant être exécuté dans différents environnements, tels que des serveurs de production, des appareils périphériques ou des applications mobiles.
Ultralytics prend en charge plusieurs formats d’exportation, afin que tu puisses choisir celui qui convient le mieux à ton environnement de déploiement. Par exemple, tu peux exporter au format ONNX pour une large compatibilité entre plateformes, TensorRT pour des performances GPU optimisées sur du matériel NVIDIA ou OpenVINO pour un déploiement efficace sur CPU sur des appareils Intel. Ces intégrations facilitent l’exécution de ton modèle hors de l’environnement d’entraînement et offrent de solides performances en temps réel.
Tu peux exporter ton modèle en Python à l’aide de la commande suivante :
model.export(format="onnx")Cette commande convertit ton modèle entraîné au format ONNX. Tu peux remplacer « onnx » par d’autres formats pris en charge, selon tes besoins de déploiement.
Une fois exporté, ton modèle peut être intégré à des applications telles que des services Web, des systèmes de vision embarqués, des plateformes robotiques ou des systèmes d’inspection industrielle. À ce stade, ton modèle Ultralytics YOLO26 personnalisé pour la segmentation d’instances peut passer de l’expérimentation au déploiement en conditions réelles.
Points clés à retenir#
Entraîner Ultralytics YOLO26 sur mesure pour la segmentation d’instances te donne la flexibilité nécessaire pour créer un modèle réellement adapté à ton cas d’usage. En préparant un jeu de données clair, en configurant ton fichier YAML, en entraînant le modèle avec des poids de segmentation préentraînés et en examinant les résultats, tu peux lui apprendre à délimiter précisément chaque objet au niveau du pixel. Une fois testé et exporté, ton modèle YOLO26 peut passer du développement à des applications réelles à différentes échelles.
Rejoins notre communauté et consulte notre dépôt GitHub pour en savoir plus sur l’IA. Si tu souhaites créer ton propre projet d’IA visuelle, découvre nos options de licence. Explore des applications comme l’IA dans les soins de santé et l’IA visuelle dans le commerce de détail en consultant nos pages consacrées aux solutions.
