Comment entraîner de manière personnalisée YOLO26 d'Ultralytics pour la segmentation d'instances

Grâce aux avancées technologiques récentes, de nombreux systèmes intelligents qui jouent un rôle silencieux mais déterminant dans nos vies sont alimentés par l'IA. Par exemple, lorsqu'une voiture grille un feu rouge et qu'une caméra enregistre automatiquement l'infraction, ou lorsqu'un système d'inspection de qualité automatisé repère un défaut de fabrication sur une ligne de production, l'IA travaille 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 des mouvements et d'analyser des détails visuels en temps réel, ce qui la rend essentielle pour des applications telles que la surveillance du trafic, l'inspection industrielle et la robotique.

Ces capacités sont rendues possibles grâce à des modèles de vision par ordinateur tels qu'Ultralytics YOLO26, qui prend en charge diverses tâches de vision, y compris la détection d'objets et la segmentation d'instances. Alors que la détection d'objets identifie les objets à l'aide de simples boîtes englobantes, la segmentation d'instances va plus loin en détourant chaque objet au niveau du pixel, permettant des résultats plus précis et fiables dans des scénarios réels.

Fig 1. Segmentation d'objets dans une image à l'aide de YOLO26

Les modèles comme YOLO26 sont pré-entraînés et peuvent segmenter des objets du quotidien tels que des personnes, des voitures et des animaux dès leur mise en service. Cependant, pour des applications plus spécifiques, ils peuvent également être entraînés sur mesure. En d'autres termes, les modèles peuvent apprendre à comprendre à quoi ressemblent les objets et comment les détourer avec précision.

Dans cet article, nous allons parcourir les étapes pour entraîner sur mesure Ultralytics YOLO26 pour la segmentation d'instances. Commençons !

Link to this sectionQu'est-ce que la segmentation d'instance ?#

Avant de nous lancer 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 trouver chaque objet individuel dans une image et de détourer sa forme exacte. Au lieu d'identifier seulement qu'un objet existe, le modèle examine chaque pixel de l'image et décide s'il appartient à un objet spécifique.

Cela signifie qu'il peut séparer les objets même lorsqu'ils se chevauchent ou sont très proches les uns des autres. Un concept clé qui facilite la visualisation de la segmentation d'instances est le masque.

Un masque est un contour au niveau du pixel qui ne couvre que la zone d'un objet. Tu peux imaginer cela comme colorier l'objet avec un surligneur tout en laissant tout le reste intact.

Chaque objet obtient 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 debout l'une à côté de l'autre.

Fig 2. Un aperçu de la segmentation d'instances

Pour mieux comprendre ce qu'est la segmentation d'instances, nous pouvons la comparer à d'autres tâches de vision par ordinateur courantes. La détection d'objets utilise des boîtes englobantes, qui sont de simples rectangles dessinés autour des objets. Les boîtes englobantes sont rapides et utiles, mais elles ne capturent pas la forme exacte d'un objet.

Pendant ce temps, la segmentation sémantique étiquette chaque pixel de l'image par catégorie, mais elle ne distingue pas les objets séparés d'une même classe. La segmentation d'instances combine le meilleur des deux approches en identifiant les catégories d'objets et en attribuant un masque séparé à chaque objet individuel.

Puisque la segmentation d'instances fournit des informations si détaillées, elle est particulièrement utile dans des applications réelles comme l'inspection de qualité automatisée, l'imagerie médicale et la robotique. Les tâches nécessitant des mesures précises, des limites exactes ou la séparation d'objets peuvent bénéficier de cette compréhension au niveau du pixel.

Link to this sectionUltralytics 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 NMS, conçu pour gérer rapidement et efficacement les tâches de vision réelles. Il appartient à la famille des modèles de détection Ultralytics YOLO, capable de traiter des images et des vidéos en temps réel tout en fournissant des résultats précis.

YOLO26 prend en charge plusieurs tâches de vision au sein d'un seul 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.

Dès sa sortie, YOLO26 est pré-entraîné, ce qui signifie qu'il a déjà appris à reconnaître des objets courants tels que des personnes, des véhicules et des articles du quotidien à partir de grands jeux de données largement utilisés comme le jeu de données COCO et le jeu de données ImageNet. Tu peux commencer à utiliser le modèle immédiatement sans aucun entraînement supplémentaire.

Cependant, lorsque ton application implique des objets uniques, des environnements spécifiques ou des conditions d'éclairage inhabituelles, l'entraînement de modèle sur mesure peut améliorer considérablement les résultats. En entraînant YOLO26 sur tes propres images étiquetées, tu peux enseigner au modèle exactement ce qu'il doit chercher et comment détourer les objets avec plus de précision pour ton cas d'usage spécifique.

Ce processus est également appelé réglage fin (fine-tuning). Au lieu d'entraîner un modèle à partir de zéro, le réglage fin commence avec un modèle YOLO26 pré-entraîné et l'adapte en douceur en utilisant tes propres données. Parce que le modèle comprend déjà les modèles visuels généraux comme les bords, les formes et les textures, il a besoin de beaucoup moins d'images étiquetées et beaucoup moins de temps pour apprendre tes objets spécifiques.

En termes simples, le réglage fin est plus rapide, plus efficace et plus accessible que l'entraînement d'un modèle à partir de zéro. L'entraînement sur mesure de YOLO26 est une option pratique même pour les débutants ou les équipes travaillant avec des données et des ressources informatiques limitées.

Link to this sectionExplorer les applications de segmentation d'instances de YOLO26#

Alors, où la segmentation d'instances peut-elle avoir un impact ? Dans les situations où il est important de distinguer les objets les uns des autres et de comprendre leurs formes exactes, surtout lorsque les choses deviennent encombrées ou se chevauchent.

Voici quelques flux de travail courants où la segmentation d'instances fait une réelle différence :

• Imagerie aérienne et par drone : Cette tâche permet aux drones de séparer les objets tels que les bâtiments, les véhicules et la végétation dans les images aériennes pour la cartographie, l'inspection et la surveillance.
• Analyse sportive : La segmentation d'instances aide à analyser les mouvements et les interactions des joueurs en séparant les athlètes individuels de l'arrière-plan pendant les jeux ou les sessions d'entraînement.
• Surveillance de la construction et des infrastructures : Elle aide à identifier les éléments structurels, les fissures ou les zones endommagées dans les bâtiments, les ponts et les routes pour la planification de la maintenance.
• Soins de santé et imagerie médicale : La segmentation d'instances permet de détourer précisément les cellules, les tissus ou les outils médicaux, favorisant une analyse et un diagnostic plus précis.
• Agriculture et surveillance environnementale : Elle peut identifier et séparer les cultures, les fruits ou les maladies des plantes, facilitant l'estimation des rendements et l'application de traitements ciblés.

Fig 3. Un exemple de segmentation des mauvaises herbes à l'aide de YOLO26 (Source)

Link to this sectionComment fonctionne l'entraînement sur mesure de YOLO26 pour la segmentation d'instances#

Ensuite, discutons de la façon dont fonctionne l'entraînement sur mesure. Bien que l'entraînement d'un modèle puisse sembler technique, le processus global est simple.

Tu peux préparer tes images, étiqueter les objets que tu veux que le modèle apprenne, configurer un petit fichier de paramètres, puis entraîner YOLO26 en utilisant le package Python Ultralytics. Le package Python Ultralytics est une bibliothèque logicielle qui fournit des outils prêts à l'emploi pour l'entraînement, le test et le déploiement de modèles YOLO sans avoir besoin de tout construire à partir de zéro.

Link to this sectionÉ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 une collection d'images qui présentent les objets que tu veux que le modèle apprenne.

Essaie d'inclure des images qui reflètent des conditions réelles, telles que différents angles, éclairages, arrière-plans et tailles d'objets. Plus tes images seront variées, plus ton modèle sera performant.

Pour la segmentation d'instances, tes images ont également besoin d'annotations. L'annotation implique d'étiqueter les objets dans chaque image pour que le modèle sache ce qu'il doit apprendre. Au lieu de dessiner de simples boîtes, tu dessineras des contours détaillés (polygones) autour de chaque objet pour marquer sa forme exacte. Ces contours deviennent les masques que le modèle apprend à prédire.

Il existe plusieurs outils d'annotation open-source que tu peux utiliser pour créer ces étiquettes. Beaucoup de ces outils fournissent des interfaces conviviales où tu peux télécharger des images et dessiner des contours d'objets directement dessus.

Une fois tes images et annotations prêtes, tu peux les organiser dans des dossiers d'entraînement et de validation. Une répartition typique est de 80 % des images pour l'entraînement et 20 % pour la validation, bien que 70 % pour l'entraînement et 30 % pour la validation soit également courant, selon la taille de ton jeu de données. L'ensemble d'entraînement apprend au modèle, tandis que l'ensemble de validation est utilisé pour mesurer ses performances sur des images qu'il n'a jamais vues auparavant.

Il est important de garder cette répartition équilibrée et de s'assurer que les deux dossiers contiennent une variété d'exemples. Un jeu de données propre et bien étiqueté, avec une répartition correcte pour l'entraînement et la validation, forme la base d'un modèle de segmentation d'instances solide.

Link to this sectionÉtape 2 : Créer un fichier YAML de jeu de données#

Après avoir préparé tes images et annotations, l'étape suivante consiste à créer un fichier YAML de 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 classe. Les noms de classe doivent être listé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, tu peux te référer à la documentation officielle Ultralytics pour plus de détails.

Link to this sectionÉ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 inclut les outils nécessaires pour entraîner, valider, effectuer des inférences et exporter des modèles YOLO26. Il offre un moyen simplifié de travailler avec les modèles YOLO sans construire de pipelines d'entraînement complexes à partir de zéro.

Avant d'installer le package Python Ultralytics, il est également important de choisir où tu veux exécuter ton code. Tu peux travailler avec le package Ultralytics dans plusieurs environnements de développement différents, comme :

• Interface de ligne de commande (CLI) : C'est un environnement textuel où tu interagis avec ton ordinateur en tapant des commandes. Au lieu de cliquer sur des boutons ou de naviguer dans des menus comme tu le ferais dans une interface graphique, tu entres des instructions écrites pour exécuter des programmes et effectuer des tâches directement.
• Jupyter Notebooks : Un environnement interactif où tu écris et exécutes du code par petites sections et vois immédiatement le résultat. C'est utile pour l'expérimentation et l'apprentissage.
• Google Colab : Une plateforme de notebook basée sur le cloud qui ne nécessite aucune installation locale et offre un accès optionnel aux unités de traitement graphique (GPU). C'est souvent l'option la plus simple pour les débutants.

Une fois que tu as choisi ton environnement, tu peux installer le package Python Ultralytics. Pour l'installer, exécute la commande suivante :

pip install ultralytics

Si tu utilises un environnement basé sur un notebook tel que Google Colab ou Jupyter Notebook, ajoute un point d'exclamation au début de la commande. Si tu rencontres des problèmes d'installation, tu peux te référer à la documentation Ultralytics ou au guide de dépannage pour les correctifs courants et les conseils de configuration de l'environnement.

Après l'installation, tu seras prêt à charger un modèle de segmentation YOLO26 pré-entraîné et à commencer l'entraînement.

Link to this sectionÉtape 4 : Entraîner YOLO26 pour la segmentation d'instances#

Avant de commencer l'entraînement, tu devras choisir une taille de modèle. Les modèles YOLO26 sont disponibles en différentes tailles : Nano (n), Small (s), Medium (m), Large (l) et Extra Large (x).

Les modèles plus petits s'entraînent plus rapidement et s'exécutent plus efficacement sur des unités centrales (CPU) ou des appareils en périphérie (edge), tandis que les modèles plus grands offrent généralement une précision plus élevée mais nécessitent plus de mémoire et bénéficient de l'accélération GPU. Si tu débutes ou si tu travailles avec du matériel limité, la version Nano (YOLO26n) est un choix pratique.

Une fois que tu as sélectionné une taille de modèle, l'étape suivante consiste à charger un modèle de segmentation pré-entraîné et à commencer à l'entraîner sur ton jeu de données personnalisé. Pour ce faire, tu devras spécifier le fichier de modèle pré-entraîné, le chemin vers ton fichier YAML de jeu de données, le nombre d'époques et la taille de l'image 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'intégralité du jeu de données d'entraînement. À chaque époque, le modèle fait 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, tu verras la configuration du modèle, l'analyse du jeu de données et la progression de l'entraînement affichées dans ton terminal ou ton notebook. Au fur et à mesure que l'entraînement se poursuit, les valeurs de perte et les métriques d'évaluation seront mises à jour après chaque époque, montrant comment le modèle s'améliore au fil du temps.

Link to this sectionÉtape 5 : Évaluer les performances du modèle entraîné sur mesure#

Une fois le processus d'entraînement terminé, tu peux examiner et valider les métriques de performance du modèle. Dans Google Colab, tu peux naviguer vers le dossier « runs », puis vers le dossier « segment », et enfin vers le dossier « train », où tu trouveras des journaux affichant les indicateurs de performance clés.

Pour les utilisateurs travaillant 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 cycle d'entraînement crée un nouveau sous-répertoire, tel que runs/train/exp ou runs/train/exp2, où tu peux trouver des journaux, des poids enregistrés et d'autres sorties liées à 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 de voir ou de modifier les chemins et les configurations liés aux journaux d'entraînement et aux détails de l'expérience.

Parmi les sorties enregistrées, tu trouveras également des graphiques générés pendant l'entraînement. Ces graphiques montrent comment le modèle s'est amélioré au fil du temps. Par exemple, ils affichent comment la perte a diminué à mesure que le modèle apprenait et comment les métriques d'évaluation telles que la précision, le rappel et la précision moyenne (mAP) ont augmenté au fil des époques.

Fig 4. Le type 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é avec succès et à quel point il s'est amélioré du début à la fin de l'entraînement. Examiner à la fois les métriques numériques et les graphiques te donne une image plus claire de la performance de ton modèle de segmentation d'instances avant de passer aux tests avec de nouvelles images.

Link to this sectionÉtape 6 : Tester ton modèle et exécuter des inférences#

Après avoir validé ton modèle, l'étape finale consiste à le tester sur de nouvelles images. Ce processus est appelé inférence, ce qui signifie simplement utiliser ton modèle entraîné pour faire des prédictions sur des données non vues.

Tu peux exécuter l'inférence en Python comme suit :

results = model.predict("path/to/image.jpg", save=True, conf=0.3)

Dans cet exemple, "path/to/image.jpg" peut être remplacé par le chemin vers 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 qui inclut les masques de segmentation prédits dessinés sur l'image originale.

Le paramètre « conf=0.3 » contrôle le seuil de confiance, ce qui signifie que le modèle n'affichera que les prédictions dont il est sûr à au moins 30 % qu'elles sont correctes. Abaisser cette valeur peut montrer plus de détections, tandis que l'augmenter rendra le modèle plus sélectif.

Après avoir exécuté la commande, le modèle crée un nouveau dossier à l'intérieur du répertoire runs où il enregistre l'image de sortie. Tu peux ouvrir cette image enregistrée pour vérifier visuellement si les masques de segmentation suivent bien les limites des objets et si les objets qui se chevauchent sont correctement séparés.

Tester le modèle sur différentes images, arrière-plans et conditions d'éclairage peut te donner une compréhension plus claire de la façon dont il se comporte en dehors du jeu de données d'entraînement. Une fois que les résultats semblent cohérents et précis, le modèle est prêt à être exporté et déployé.

Link to this sectionÉtape 7 : Exporter et déployer ton modèle#

Après avoir testé ton modèle et confirmé qu'il fonctionne bien, l'étape finale consiste à l'exporter et à le déployer. L'exportation convertit ton modèle YOLO26 entraîné dans un format qui peut s'exécuter dans différents environnements, tels que des serveurs de production, des appareils en périphérie ou des applications mobiles.

Ultralytics prend en charge plusieurs formats d'exportation, te permettant de choisir celui qui correspond le mieux à ta configuration de déploiement. Par exemple, tu peux exporter vers ONNX pour une large compatibilité entre les plateformes, TensorRT pour des performances GPU optimisées sur le matériel NVIDIA, ou OpenVINO pour un déploiement efficace basé sur CPU sur les appareils Intel. Ces intégrations facilitent l'exécution de ton modèle en dehors de l'environnement d'entraînement et permettent d'obtenir de solides performances en temps réel.

Tu peux exporter ton modèle en Python en utilisant 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é dans des applications telles que des services web, des systèmes de vision embarqués, des plateformes de robotique ou des systèmes d'inspection industrielle. À ce stade, ton modèle de segmentation d'instances YOLO26 entraîné sur mesure peut passer de l'expérimentation au déploiement réel.

Link to this sectionPoints clés#

L'entraînement sur mesure d'Ultralytics YOLO26 pour la segmentation d'instances te donne la flexibilité de construire un modèle qui correspond vraiment à ton cas d'usage spécifique. En préparant un jeu de données clair, en configurant ton fichier YAML, en t'entraînant avec des poids de segmentation pré-entraînés et en examinant les résultats, tu peux enseigner au modèle à détourer 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 multi-échelles.

Rejoins notre communauté et jette un œil à notre dépôt GitHub pour en découvrir plus sur l'IA. Si tu cherches à construire ton propre projet d'IA de vision, consulte nos options de licence. Explore davantage les applications comme l'IA dans les soins de santé et l'IA de vision dans le commerce de détail en visitant nos pages de solutions.