Présentation des jeux de données de segmentation d’instances#

La segmentation d’instances est une tâche de vision par ordinateur qui consiste à identifier et délimiter chaque objet individuellement dans une image. Ce guide présente les formats de jeu de données pris en charge par Ultralytics YOLO pour les tâches de segmentation d’instances, ainsi que les instructions pour préparer, convertir et utiliser ces jeux de données afin d’entraîner tes modèles.

Formats de jeux de données pris en charge#

Format Ultralytics YOLO#

Le format des annotations du jeu de données utilisé pour entraîner les modèles de segmentation YOLO est le suivant :

1. Un fichier texte par image : chaque image du jeu de données possède un fichier texte correspondant, portant le même nom que le fichier image et l’extension « .txt ».
2. Une ligne par objet : chaque ligne du fichier texte correspond à une instance d’objet dans l’image.
3. Informations sur l’objet par ligne : chaque ligne contient les informations suivantes sur l’instance d’objet :
   • Indice de classe de l’objet : un entier représentant la classe de l’objet (par exemple, 0 pour une personne, 1 pour une voiture, etc.).
   • Coordonnées du polygone de l’objet : les points (x, y) qui délimitent le masque de l’objet, normalisés entre 0 et 1.

Le format d’une ligne dans le fichier du jeu de données de segmentation est le suivant :

<class-index> <x1> <y1> <x2> <y2> ... <xn> <yn>

Dans ce format, <class-index> correspond à l’indice de classe de l’objet, et <x1> <y1> <x2> <y2> ... <xn> <yn> aux coordonnées normalisées du polygone du masque de segmentation de l’objet (les valeurs sont exprimées en [0, 1] par rapport à la largeur et à la hauteur de l’image). Les coordonnées sont séparées par des espaces.

Voici un exemple du format de jeu de données YOLO pour une image contenant deux objets, représentés respectivement par un segment à 3 points et un segment à 5 points.

0 0.681 0.485 0.670 0.487 0.676 0.487
1 0.504 0.000 0.501 0.004 0.498 0.004 0.493 0.010 0.492 0.0104

Format YAML du jeu de données#

Le framework Ultralytics utilise un fichier YAML pour définir la configuration du jeu de données et du modèle lors de l’entraînement des modèles de segmentation. Voici un exemple de format YAML utilisé pour définir un jeu de données de segmentation :

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg
# Example usage: yolo train data=coco8-seg.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco8-seg ← downloads here (1 MB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: coco8-seg # dataset root dir
train: images/train # train images (relative to 'path') 4 images
val: images/val # val images (relative to 'path') 4 images
test: # test images (optional)

# Classes
names:
  0: person
  1: bicycle
  2: car
  3: motorcycle
  4: airplane
  5: bus
  6: train
  7: truck
  8: boat
  9: traffic light
  10: fire hydrant
  11: stop sign
  12: parking meter
  13: bench
  14: bird
  15: cat
  16: dog
  17: horse
  18: sheep
  19: cow
  20: elephant
  21: bear
  22: zebra
  23: giraffe
  24: backpack
  25: umbrella
  26: handbag
  27: tie
  28: suitcase
  29: frisbee
  30: skis
  31: snowboard
  32: sports ball
  33: kite
  34: baseball bat
  35: baseball glove
  36: skateboard
  37: surfboard
  38: tennis racket
  39: bottle
  40: wine glass
  41: cup
  42: fork
  43: knife
  44: spoon
  45: bowl
  46: banana
  47: apple
  48: sandwich
  49: orange
  50: broccoli
  51: carrot
  52: hot dog
  53: pizza
  54: donut
  55: cake
  56: chair
  57: couch
  58: potted plant
  59: bed
  60: dining table
  61: toilet
  62: tv
  63: laptop
  64: mouse
  65: remote
  66: keyboard
  67: cell phone
  68: microwave
  69: oven
  70: toaster
  71: sink
  72: refrigerator
  73: book
  74: clock
  75: vase
  76: scissors
  77: teddy bear
  78: hair drier
  79: toothbrush

# Download script/URL (optional)
download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-seg.zip

Les champs train, val et test indiquent les images d’entraînement, de validation et de test. Chacun accepte un répertoire, une liste de répertoires ou un fichier *.txt répertoriant un chemin d’image par ligne (les chemins commençant par ./ sont résolus relativement au fichier *.txt). Un fichier *.txt est utile pour entraîner le modèle sur un sous-ensemble d’un répertoire, ignorer les images sans étiquette ou combiner des images de plusieurs sources dans une même partition.

path: datasets/coco8-seg # dataset root
train: train.txt # a directory, a list e.g. [images/a, images/b], or a *.txt file
val: val.txt
names:
  0: person

names est un dictionnaire de noms de classes. L’ordre des noms doit correspondre à celui des indices de classe des objets dans les fichiers du jeu de données YOLO.

Utilisation#

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-seg.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

Jeux de données pris en charge#

Ultralytics YOLO prend en charge différents jeux de données pour les tâches de segmentation d’instances. Voici une liste des plus couramment utilisés. La plupart de ces jeux de données sont également hébergés sur Ultralytics Platform, où tu peux parcourir les images et les annotations, consulter les statistiques des jeux de données et les cloner pour l’entraînement dans le cloud.

• Carparts-seg : un jeu de données spécialisé dans la segmentation des pièces automobiles, idéal pour les applications du secteur automobile. Il comprend divers véhicules avec des annotations détaillées de chaque composant.
• COCO : un jeu de données complet pour la détection d’objets, la segmentation et le légendage, avec plus de 200 000 images annotées couvrant un large éventail de catégories.
• COCO8-seg : un sous-ensemble compact de COCO composé de 8 images, conçu pour tester rapidement l’entraînement de modèles de segmentation, idéal pour les vérifications CI et la validation des workflows dans le dépôt ultralytics.
• COCO128-seg : un jeu de données plus petit pour les tâches de segmentation d’instances, contenant un sous-ensemble de 128 images COCO avec des annotations de segmentation.
• Crack-seg : un jeu de données conçu pour la segmentation des fissures sur différentes surfaces. Indispensable à la maintenance des infrastructures et au contrôle qualité, il fournit des images détaillées pour entraîner des modèles à détecter les faiblesses structurelles.
• Package-seg : un jeu de données consacré à la segmentation de différents types et formes d’emballages. Il est particulièrement utile pour l’automatisation de la logistique et des entrepôts, et facilite le développement de systèmes de manutention et de tri des colis.

Ajouter ton propre jeu de données#

Si tu disposes de ton propre jeu de données et souhaites l’utiliser pour entraîner des modèles de segmentation au format Ultralytics YOLO, vérifie qu’il respecte le format indiqué plus haut dans la section « Format Ultralytics YOLO ». Convertis tes annotations au format requis et indique les chemins, le nombre de classes et leurs noms dans le fichier de configuration YAML. Garde images/ et labels/ dans des dossiers distincts au même niveau, avec une structure de sous-dossiers correspondante ; placer les fichiers .txt d’étiquettes dans le dossier des images peut empêcher le modèle de détecter les étiquettes.

Porter ou convertir des formats d’étiquettes#

Convertir le format du jeu de données COCO au format YOLO#

Tu peux facilement convertir les étiquettes du célèbre format du jeu de données COCO au format YOLO à l’aide de l’extrait de code suivant :

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)

Cet outil de conversion permet de convertir le jeu de données COCO ou tout autre jeu de données au format COCO au format Ultralytics YOLO.

N’oublie pas de vérifier que le jeu de données que tu souhaites utiliser est compatible avec ton modèle et respecte les conventions de format requises. Un formatage correct des jeux de données est essentiel pour entraîner des modèles de segmentation performants.

Annotation automatique#

L’annotation automatique est une fonctionnalité essentielle qui te permet de générer un jeu de données de segmentation à l’aide d’un modèle de détection préentraîné. Elle te permet d’annoter rapidement et précisément un grand nombre d’images sans étiquetage manuel, ce qui réduit le temps et les efforts nécessaires.

Générer un jeu de données de segmentation à l’aide d’un modèle de détection#

Pour annoter automatiquement ton jeu de données avec le framework Ultralytics, tu peux utiliser la fonction auto_annotate comme indiqué ci-dessous :

from ultralytics.data.annotator import auto_annotate

auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")

La fonction auto_annotate prend le chemin vers tes images, ainsi que des arguments facultatifs permettant d’indiquer les modèles de détection préentraînés, par exemple YOLO26, YOLO11 ou d’autres modèles, et les modèles de segmentation, par exemple SAM, SAM 2, MobileSAM ou SAM 3, l’appareil sur lequel exécuter les modèles et le répertoire de sortie où enregistrer les résultats annotés.

En tirant parti de la puissance des modèles préentraînés, l’annotation automatique peut réduire considérablement le temps et les efforts nécessaires à la création de jeux de données de segmentation de haute qualité. Cette fonctionnalité est particulièrement utile aux chercheurs et aux développeurs qui travaillent avec de grandes collections d’images, car elle leur permet de se concentrer sur le développement et l’évaluation des modèles plutôt que sur l’annotation manuelle.

Visualiser les annotations d’un jeu de données#

Avant d’entraîner ton modèle, il est souvent utile de visualiser les annotations de ton jeu de données pour vérifier qu’elles sont correctes. Ultralytics fournit une fonction utilitaire à cet effet. Elle lit uniquement les étiquettes de boîtes au format de détection (<class-index> <x_center> <y_center> <width> <height>) et ne peut donc pas analyser les fichiers d’étiquettes de polygones de segmentation :

from ultralytics.data.utils import visualize_image_annotations

label_map = {  # Définir la correspondance des étiquettes avec toutes les étiquettes de classe annotées.
    0: "person",
    1: "car",
}

# Visualize
visualize_image_annotations(
    "path/to/image.jpg",  # Chemin de l’image d’entrée.
    "path/to/annotations.txt",  # Chemin du fichier d’annotation de l’image.
    label_map,
)

Cette fonction dessine des boîtes englobantes, étiquette les objets avec leurs noms de classe et ajuste la couleur du texte pour en améliorer la lisibilité, ce qui t’aide à repérer et corriger les erreurs d’annotation avant l’entraînement.

Convertir des masques de segmentation au format YOLO#

Si tu disposes d’images de masques en niveaux de gris où la valeur de chaque pixel correspond à l’indice de classe + 1 (0 correspond à l’arrière-plan), tu peux les convertir au format de segmentation YOLO à l’aide de la commande suivante :

from ultralytics.data.converter import convert_segment_masks_to_yolo_seg

# Pour les jeux de données comme COCO avec 80 classes
convert_segment_masks_to_yolo_seg(masks_dir="path/to/masks_dir", output_dir="path/to/output_dir", classes=80)

Cet utilitaire convertit les images de masques au format de segmentation YOLO et les enregistre dans le répertoire de sortie indiqué.

FAQ#