Comment entraîner Ultralytics sur mesure pour la segmentation d'instances

Grâce aux récentes avancées technologiques, de nombreux systèmes intelligents qui jouent un rôle discret mais important dans notre vie quotidienne 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 automatisé de contrôle qualité détecte un défaut de fabrication sur une chaîne de production, l'IA travaille en coulisses.

En particulier, une branche de l'IA connue sous le nom de 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, track et d'analyser des détails visuels en temps réel, ce qui la rend indispensable 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 que Ultralytics , qui prend en charge diverses tâches de vision, notamment la détection d'objets et la segmentation d'instances. Alors que la détection d'objets identifie les objets à l'aide de simples cadres de sélection, la segmentation d'instances va plus loin en délimitant chaque objet au niveau des pixels, ce qui permet d'obtenir des résultats plus précis et plus fiables dans des scénarios réels.

Les modèles tels que YOLO26 sont pré-entraînés et peuvent segment des objets segment tels que des personnes, des voitures et des animaux dès leur sortie de l'emballage. 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élimiter avec précision.

Dans cet article, nous allons vous expliquer comment personnaliser Ultralytics pour la segmentation d'instances. C'est parti !

Qu'est-ce que la segmentation d'instance ?

Avant de nous plonger dans les modèles d'entraînement, prenons un peu de recul et comprenons ce que signifie réellement la segmentation d'instance.

La segmentation d'instance est une tâche de vision par ordinateur qui permet à un modèle de trouver chaque objet individuel dans une image et d'en délimiter la forme exacte. Au lieu de se contenter d'identifier l'existence d'un objet, le modèle examine chaque pixel de l'image et détermine s'il appartient à un objet spécifique. 

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

Un masque est un contour au niveau des pixels qui ne recouvre que la zone d'un objet. Vous pouvez le considérer comme si vous coloriez l'objet avec un surligneur tout en laissant le reste intact. 

Chaque objet dispose de 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 se tenant côte à côte. 

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

Par ailleurs, la segmentation sémantique étiquette chaque pixel de l'image par catégorie, mais ne fait pas la distinction entre les objets distincts appartenant à la même classe. La segmentation d'instance combine le meilleur des deux approches en identifiant les catégories d'objets et en attribuant un masque distinct à chaque objet individuel.

Étant donné que la segmentation d'instance fournit des informations aussi détaillées, elle est particulièrement utile dans des applications concrètes telles que le contrôle qualité automatisé, l'imagerie médicale et la robotique. Les tâches qui nécessitent des mesures précises, des limites exactes ou la séparation d'objets peuvent tirer parti de cette compréhension au niveau du pixel.

Ultralytics prend en charge la segmentation d'instances. 

Ultralytics est un modèle de vision par ordinateur de pointe, de bout en bout, sans suppression non maximale (NMS), conçu pour traiter rapidement et efficacement des tâches de vision dans le monde réel. Il appartient à laYOLO de modèles de détection Ultralytics YOLO , qui peut 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 dans un cadre unique, notamment la détection d'objets, l'estimation de pose, la classification d'images, la détection de cadres de sélection orientés (obb ) et la segmentation d'instances. 

YOLO26 est livré 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 objets du quotidien à partir de grands ensembles de données largement utilisés, comme les ImageNet COCO et ImageNet . Vous pouvez commencer à utiliser le modèle immédiatement, sans formation supplémentaire.

Cependant, lorsque votre application implique des objets uniques, des environnements spécifiques ou des conditions d'éclairage inhabituelles, l'entraînement d'un modèle personnalisé peut considérablement améliorer les résultats. En entraînant YOLO26 sur vos propres images étiquetées, vous pouvez enseigner au modèle exactement ce qu'il doit rechercher et comment délimiter les objets avec plus de précision pour votre cas d'utilisation spécifique.

Ce processus est également appelé « réglage fin ». Au lieu de former un modèle à partir de zéro, le réglage fin commence par un modèle YOLO26 préformé et l'adapte progressivement à l'aide de vos 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 nécessite beaucoup moins d'images étiquetées et beaucoup moins de temps pour apprendre à reconnaître vos objets spécifiques.

En termes simples, le réglage fin est plus rapide, plus efficace et plus accessible que la formation d'un modèle à partir de zéro. La formation personnalisée 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.

Exploration des applications de segmentation d'instances YOLO26

Alors, dans quels cas la segmentation d'instance peut-elle être utile ? Dans les situations où il est important de distinguer les objets et de comprendre leurs formes exactes, en particulier lorsque ceux-ci sont nombreux ou se chevauchent.

Voici quelques workflows courants dans lesquels la segmentation d'instance fait vraiment la différence :

• Imagerie aérienne et par drone: cette tâche permet aux drones de séparer des objets tels que des bâtiments, des véhicules et de la végétation dans des images aériennes à des fins de cartographie, d'inspection et d'étude.
• Analyse sportive: la segmentation d'instance permet d'analyser les mouvements et les interactions des joueurs en séparant chaque athlète de l'arrière-plan pendant les matchs ou les séances d'entraînement.
• Surveillance des constructions et des infrastructures: elle permet d'identifier les éléments structurels, les fissures ou 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 outils médicaux, ce qui facilite une analyse et un diagnostic plus précis.
• Agriculture et surveillance environnementale: il peut identifier et séparer les cultures, les fruits ou les maladies des plantes, ce qui facilite l'estimation des rendements et l'application de traitements ciblés.

Comment fonctionne la formation personnalisée YOLO26 pour la segmentation d'instance

Ensuite, voyons comment fonctionne l'entraînement personnalisé. Bien que l'entraînement d'un modèle puisse sembler technique, le processus global est simple.

Vous pouvez préparer vos images, étiqueter les objets que vous souhaitez que le modèle apprenne, configurer un petit fichier de paramètres, puis entraîner YOLO26 à l'aide du Python Ultralytics . LePython Ultralytics est une bibliothèque logicielle qui fournit des outils prêts à l'emploi pour entraîner, tester et déployer YOLO sans avoir à tout créer à partir de zéro.

Étape 1 : Préparez votre ensemble de données personnalisé

La première étape consiste à préparer votre ensemble de données de segmentation personnalisé. Un ensemble de données est simplement une collection d'images qui présentent les objets que vous souhaitez que le modèle apprenne. 

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

Pour la segmentation, par exemple, vos images doivent également être annotées. L'annotation consiste à étiqueter les objets dans chaque image afin que le modèle sache ce qu'il doit apprendre. Au lieu de dessiner de simples rectangles, vous dessinerez des contours détaillés (polygones) autour de chaque objet afin d'indiquer sa forme exacte. Ces contours deviennent les masques que le modèle apprend à prédire.

Il existe plusieurs outils d'annotation open source que vous pouvez utiliser pour créer ces étiquettes. La plupart de ces outils offrent des interfaces conviviales qui vous permettent de télécharger des images et de dessiner directement les contours des objets dessus. 

Une fois vos images et annotations prêtes, vous pouvez 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 qu'une répartition de 70 % pour l'entraînement et 30 % pour la validation soit également courante, en fonction de la taille de votre ensemble de données. L'ensemble d'entraînement enseigne 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 maintenir cet équilibre et de veiller à ce que les deux dossiers contiennent une variété d'exemples. Un ensemble de données propre et bien étiqueté, avec une répartition adéquate entre l'entraînement et la validation, constitue la base d'un modèle de segmentation d'instances performant.

Étape 2 : Créer un fichier YAML contenant un ensemble de données

Après avoir préparé vos images et annotations, l'étape suivante consiste à créer un fichier YAML contenant votre ensemble de données. Ce fichier indique l'emplacement de votre ensemble de données et les classes d'objets que le modèle doit apprendre pendant l'entraînement.

Dans ce fichier, vous pouvez définir le répertoire racine de l'ensemble de données, les chemins d'accès à vos 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 classes utilisés dans vos fichiers d'annotation, afin que tout corresponde correctement.

Si vous avez des questions concernant le format exact, vous pouvez consulter la Ultralytics officielle Ultralytics pour plus de détails. 

Étape 3 : Installez lePython Ultralytics

Maintenant que votre ensemble de données et votre fichier YAML sont prêts, l'étape suivante consiste à installer lePython Ultralytics . 

Ce package comprend les outils nécessaires pour former, valider, exécuter des inférences et exporter des modèles YOLO26. Il offre un moyen simplifié de travailler avec YOLO sans avoir à créer de toutes pièces des pipelines de formation complexes.

Avant d'installer lePython Ultralytics , il est également important de choisir où vous souhaitez exécuter votre code. Vous pouvez travailler avec le Ultralytics dans plusieurs environnements de développement différents, tels que :

• Interface de ligne de commande (CLI): il s'agit d'un environnement textuel dans lequel vous interagissez avec votre ordinateur en saisissant des commandes. Au lieu de cliquer sur des boutons ou de naviguer dans des menus comme vous le feriez dans une interface graphique, vous entrez des instructions écrites pour exécuter des programmes et effectuer des tâches directement.
• Jupyter Notebooks: environnement interactif dans lequel vous pouvez écrire et exécuter du code par petites sections et voir immédiatement le résultat. Cela est utile pour l'expérimentation et l'apprentissage.
• Google : une plateforme de notebooks basée sur le cloud qui ne nécessite aucune installation locale et offre un accès optionnel à des processeurs graphiques (GPU). Il s'agit souvent de l'option la plus simple pour les débutants.

Une fois votre environnement choisi, vous pouvez installer lePython Ultralytics . Pour l'installer, exécutez la commande suivante :

pip install ultralytics

Si vous utilisez un environnement basé sur un notebook tel que Google ou Jupyter Notebook, ajoutez un point d'exclamation au début de la commande. Si vous rencontrez des problèmes d'installation, vous pouvez consulter la Ultralytics ou le guide de dépannage pour obtenir des solutions courantes et des conseils de configuration de l'environnement. 

Une fois l'installation terminée, vous serez prêt à charger un modèle de segmentation YOLO26 pré-entraîné et à commencer l'entraînement.

Étape 4 : Entraîner YOLO26 pour la segmentation d'instances

Avant de commencer la formation, vous devrez 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 fonctionnent plus efficacement sur les unités centrales de traitement (CPU) ou les périphériques périphériques, tandis que les modèles plus grands offrent généralement une plus grande précision, mais nécessitent plus de mémoire et bénéficient de GPU . Si vous débutez ou travaillez avec un matériel limité, la version Nano (YOLO26n) est un choix pratique.

Une fois que vous avez 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 votre ensemble de données personnalisé. Pour ce faire, vous devez spécifier le fichier du modèle pré-entraîné, le chemin d'accès à votre fichier YAML d'ensemble 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'époches détermine le nombre de fois où le modèle parcourt l'ensemble des 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 afin d'améliorer ses performances.

Si l'entraînement démarre correctement, vous verrez s'afficher la configuration du modèle, l'analyse de l'ensemble de données et la progression de l'entraînement dans votre terminal ou votre 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 ainsi comment le modèle s'améliore au fil du temps.

Étape 5 : Évaluer les performances du modèle personnalisé

Une fois le processus d'entraînement terminé, vous pouvez examiner et valider les indicateurs de performance du modèle. Dans Google , vous pouvez accéder au dossier « runs », puis au dossier «segmentet enfin au dossier « train », où vous trouverez des journaux affichant les indicateurs de performance clés.

Pour les utilisateurs travaillant dans un Python , les résultats de l'entraînement sont enregistrés par défaut dans le répertoire « runs/train/ » de votre 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, dans lequel vous pouvez trouver les journaux, les poids enregistrés et d'autres résultats liés à cette expérience.

Si vous utilisez l'interface CLI, vous pouvez accéder à ces résultats et les gérer à l'aide de la commande «yolo Cette commande vous permet d'afficher ou de modifier les chemins d'accès et les configurations liés aux journaux d'entraînement et aux détails des expériences.

Parmi les résultats enregistrés, vous trouverez é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 indiquent comment la perte a diminué à mesure que le modèle apprenait et comment les mesures d'évaluation telles que la précision, le rappel et la précision moyenne ont augmenté au fil des époques.

Ces tendances visuelles peuvent vous aider à comprendre si le modèle a été formé avec succès et dans quelle mesure il s'est amélioré entre le début et la fin de la formation. L'examen des mesures numériques et des graphiques vous donne une image plus claire des performances de votre modèle de segmentation d'instances avant de passer au test avec de nouvelles images.

Étape 6 : Testez votre modèle et effectuez des inférences

Après avoir validé votre modèle, la dernière étape consiste à le tester sur de nouvelles images. Ce processus s'appelle l'inférence, ce qui signifie simplement utiliser votre modèle entraîné pour faire des prédictions sur des données inconnues.

Vous pouvez exécuter l'inférence dans Python suit :

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

Dans cet exemple, « chemin/vers/image.jpg » peut être remplacé par le chemin d'accès à l'image que vous souhaitez tester. 

Le paramètre « save=True » indique au modèle de générer et de stocker 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. La réduction de cette valeur peut entraîner l'affichage d'un plus grand nombre de détections, tandis que son augmentation rendra le modèle plus sélectif.

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

Tester le modèle sur différentes images, différents arrière-plans et différentes conditions d'éclairage peut vous aider à mieux comprendre ses performances en dehors de l'ensemble 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é.

Étape 7 : Exportez et déployez votre modèle

Après avoir testé votre modèle et confirmé qu'il fonctionne correctement, la dernière étape consiste à l'exporter et à le déployer. L'exportation convertit votre modèle YOLO26 entraîné dans un format pouvant être exécuté dans différents environnements, tels que des serveurs de production, des périphériques de pointe ou des applications mobiles.

Ultralytics plusieurs formats d'exportation, ce qui vous permet de choisir celui qui correspond le mieux à votre configuration de déploiement. Par exemple, vous pouvez exporter vers ONNX une compatibilité étendue entre les plateformes, TensorRT GPU optimisées sur NVIDIA , ou OpenVINO un déploiement efficace CPU sur Intel . Ces intégrations facilitent l'exécution de votre modèle en dehors de l'environnement d'entraînement et offrent des performances en temps réel élevées.

Vous pouvez exporter votre modèle en Python la commande suivante :

model.export(format="onnx")

Cette commande convertit votre modèle entraîné au ONNX . Vous pouvez remplacer «onnx » par d'autres formats pris en charge en fonction de vos besoins de déploiement.

Une fois exporté, votre 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, votre modèle de segmentation d'instance YOLO26 personnalisé peut passer de la phase d'expérimentation à celle du déploiement dans le monde réel.

Principaux points à retenir

La formation personnalisée Ultralytics pour la segmentation d'instances vous offre la flexibilité nécessaire pour créer un modèle qui correspond parfaitement à votre cas d'utilisation spécifique. En préparant un ensemble de données clair, en configurant votre fichier YAML, en effectuant une formation avec des poids de segmentation pré-entraînés et en examinant les résultats, vous pouvez apprendre au modèle à délimiter avec précision chaque objet au niveau du pixel. Une fois testé et exporté, votre modèle YOLO26 peut passer du stade de développement à celui d'applications multi-échelles dans le monde réel.

Rejoignez notre communauté et consultez notre référentiel GitHub pour en savoir plus sur l'IA. Si vous souhaitez créer votre propre projet d'IA visuelle, consultez nos options de licence. Découvrez d'autres applications telles que l'IA dans le domaine de la santé et l'IA visuelle dans le commerce de détail en consultant nos pages Solutions.