Meet YOLO26: next-gen vision AI.

Link to this sectionPrésentation des jeux de données de segmentation d'instance#

La segmentation d'instance est une tâche de vision par ordinateur qui consiste à identifier et à délimiter des objets individuels au sein d'une image. Ce guide fournit une vue d'ensemble des formats de jeux de données pris en charge par Ultralytics YOLO pour les tâches de segmentation d'instance, ainsi que des instructions sur la manière de préparer, convertir et utiliser ces jeux de données pour entraîner tes modèles.

Link to this sectionFormats de jeux de données pris en charge#

Link to this sectionFormat Ultralytics YOLO#

Le format d'étiquetage des jeux de données utilisé pour l'entraînement des 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 concernant 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 de délimitation de l'objet : Les coordonnées délimitant la zone du masque, normalisées pour être comprises entre 0 et 1.

Le format pour une seule ligne dans le fichier de jeu de données de segmentation est le suivant :

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

Dans ce format, <class-index> est l'indice de la classe pour l'objet, et <x1> <y1> <x2> <y2> ... <xn> <yn> sont les coordonnées normalisées du polygone du masque de segmentation de l'objet (les valeurs sont dans [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 seule image avec deux objets constitués d'un segment à 3 points et d'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
Astuce
  • La longueur de chaque ligne n'a pas besoin d'être égale.
  • Chaque étiquette de segmentation doit comporter un minimum de 3 points (x, y) : <class-index> <x1> <y1> <x2> <y2> <x3> <y3>

Link to this sectionFormat YAML du jeu de données#

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

ultralytics/cfg/datasets/coco8-seg.yaml
# 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 et val spécifient respectivement les chemins vers les répertoires contenant les images d'entraînement et de validation.

names est un dictionnaire de noms de classes. L'ordre des noms doit correspondre à l'ordre des indices de classe d'objets dans les fichiers de jeux de données YOLO.

Link to this sectionUtilisation#

Exemple
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

Link to this sectionJeux de données pris en charge#

Ultralytics YOLO prend en charge divers jeux de données pour les tâches de segmentation d'instance. Voici une liste des plus couramment utilisés :

  • Carparts-seg : Un jeu de données spécialisé axé sur la segmentation des pièces automobiles, idéal pour les applications automobiles. Il inclut une variété de véhicules avec des annotations détaillées des composants individuels des voitures.
  • COCO : Un jeu de données complet pour la détection d'objets, la segmentation et la génération de légendes, comprenant plus de 200 000 images étiquetées à travers une large gamme de catégories.
  • COCO8-seg : Un sous-ensemble compact de 8 images de COCO conçu pour tester rapidement l'entraînement de modèles de segmentation, idéal pour les vérifications CI et la validation de flux de travail dans le référentiel ultralytics.
  • COCO128-seg : Un jeu de données plus petit pour les tâches de segmentation d'instance, 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 diverses surfaces. Essentiel pour l'entretien des infrastructures et le contrôle qualité, il fournit une imagerie détaillée pour entraîner des modèles à identifier les faiblesses structurelles.
  • Package-seg : Un jeu de données dédié à la segmentation de différents types de matériaux et de formes d'emballage. Il est particulièrement utile pour la logistique et l'automatisation des entrepôts, aidant au développement de systèmes de manutention et de tri des colis.

Link to this sectionAjouter ton propre jeu de données#

Si tu as ton propre jeu de données et que tu souhaites l'utiliser pour entraîner des modèles de segmentation avec le format Ultralytics YOLO, assure-toi qu'il respecte le format spécifié ci-dessus sous "Format Ultralytics YOLO". Convertis tes annotations au format requis et spécifie les chemins, le nombre de classes et les noms des classes dans le fichier de configuration YAML. Garde images/ et labels/ comme dossiers séparés au même niveau, avec une structure de sous-dossiers correspondante ; placer les fichiers .txt d'étiquettes dans le dossier d'images peut amener le modèle à manquer des étiquettes.

Link to this sectionPorter ou convertir des formats d'étiquettes#

Link to this sectionFormat de jeu de données COCO vers format YOLO#

Tu peux facilement convertir les étiquettes du format populaire COCO vers le format YOLO en utilisant l'extrait de code suivant :

Exemple
from ultralytics.data.converter import convert_coco

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

Cet outil de conversion peut être utilisé pour convertir le jeu de données COCO ou tout jeu de données au format COCO vers le format Ultralytics YOLO.

N'oublie pas de vérifier si le jeu de données que tu souhaites utiliser est compatible avec ton modèle et suit les conventions de format nécessaires. Des jeux de données correctement formatés sont cruciaux pour entraîner des modèles de segmentation performants.

Link to this sectionAnnotation automatique#

L'auto-annotation est une fonctionnalité essentielle qui te permet de générer un jeu de données de segmentation en utilisant un modèle de détection pré-entraîné. Cela te permet d'annoter rapidement et précisément un grand nombre d'images sans avoir besoin d'étiquetage manuel, économisant ainsi du temps et des efforts.

Link to this sectionGénérer un jeu de données de segmentation en utilisant un modèle de détection#

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

Exemple
from ultralytics.data.annotator import auto_annotate

auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")
ArgumentTypePar défautDescription
datastrrequisChemin vers le répertoire contenant les images cibles pour l'annotation ou la segmentation.
det_modelstr'yolo26x.pt'Chemin du modèle de détection YOLO pour la détection initiale d'objets.
sam_modelstr'sam_b.pt'Chemin du modèle SAM pour la segmentation (prend en charge les poids SAM, SAM 2, MobileSAM et SAM 3).
devicestr''Périphérique de calcul (par ex., 'cuda:0', 'cpu' ou '' pour la détection automatique du périphérique).
conffloat0.25Seuil de confiance de détection YOLO pour filtrer les détections faibles.
ioufloat0.45Seuil IoU pour la suppression non-maximale (NMS) afin de filtrer les boîtes chevauchantes.
imgszint640Taille d'entrée pour redimensionner les images (doit être un multiple de 32).
max_detint300Nombre maximum de détections par image pour l'efficacité de la mémoire.
classeslist[int]NoneListe des indices de classe à détecter (par ex., [0, 1] pour personne & vélo).
output_dirstrNoneRépertoire de sauvegarde pour les annotations (par défaut : <data>_auto_annotate_labels frère).

La fonction auto_annotate prend le chemin vers tes images, ainsi que des arguments optionnels pour spécifier 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, le périphérique sur lequel exécuter les modèles, et le répertoire de sortie pour enregistrer les résultats annotés.

En exploitant la puissance des modèles pré-entraînés, l'auto-annotation 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 pour les chercheurs et les développeurs travaillant avec de grandes collections d'images, car elle leur permet de se concentrer sur le développement et l'évaluation du modèle plutôt que sur l'annotation manuelle.

Link to this sectionVisualiser les annotations du 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 t'assurer qu'elles sont correctes. Ultralytics fournit une fonction utilitaire à cet effet :

from ultralytics.data.utils import visualize_image_annotations

label_map = {  # Define the label map with all annotated class labels.
    0: "person",
    1: "car",
}

# Visualize
visualize_image_annotations(
    "path/to/image.jpg",  # Input image path.
    "path/to/annotations.txt",  # Annotation file path for the image.
    label_map,
)

Cette fonction dessine des boîtes englobantes, étiquette les objets avec les noms de classes, et ajuste la couleur du texte pour une meilleure lisibilité, t'aidant à identifier et corriger toute erreur d'annotation avant l'entraînement.

Link to this sectionConvertir des masques de segmentation au format YOLO#

Si tu as des masques de segmentation au format binaire, tu peux les convertir au format de segmentation YOLO en utilisant :

from ultralytics.data.converter import convert_segment_masks_to_yolo_seg

# For datasets like COCO with 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 masque binaire au format de segmentation YOLO et les enregistre dans le répertoire de sortie spécifié.

Link to this sectionFAQ#

Link to this sectionQuels formats de jeux de données Ultralytics YOLO prend-il en charge pour la segmentation d'instance ?#

Ultralytics YOLO prend en charge plusieurs formats de jeux de données pour la segmentation d'instance, le format principal étant son propre format Ultralytics YOLO. Chaque image de ton jeu de données a besoin d'un fichier texte correspondant avec des informations sur l'objet segmentées en plusieurs lignes (une ligne par objet), listant l'indice de la classe et les coordonnées normalisées de la boîte englobante. Pour des instructions plus détaillées sur le format de jeu de données YOLO, visite l'Instance Segmentation Datasets Overview.

Link to this sectionComment puis-je convertir les annotations du jeu de données COCO au format YOLO ?#

La conversion des annotations au format COCO vers le format YOLO est simple en utilisant les outils Ultralytics. Tu peux utiliser la fonction convert_coco du module ultralytics.data.converter :

from ultralytics.data.converter import convert_coco

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

Ce script convertit les annotations de ton jeu de données COCO au format YOLO requis, ce qui le rend approprié pour l'entraînement de tes modèles YOLO. Pour plus de détails, réfère-toi à Port or Convert Label Formats.

Link to this sectionComment préparer un fichier YAML pour entraîner des modèles Ultralytics YOLO ?#

Pour préparer un fichier YAML pour l'entraînement des modèles YOLO avec Ultralytics, tu dois définir les chemins du jeu de données et les noms des classes. Voici un exemple de configuration YAML :

# 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

Assure-toi de mettre à jour les chemins et les noms des classes selon ton jeu de données. Pour plus d'informations, consulte la section Dataset YAML Format.

Link to this sectionQu'est-ce que la fonctionnalité d'auto-annotation dans Ultralytics YOLO ?#

L'auto-annotation dans Ultralytics YOLO te permet de générer des annotations de segmentation pour ton jeu de données en utilisant un modèle de détection pré-entraîné. Cela réduit considérablement le besoin d'étiquetage manuel. Tu peux utiliser la fonction auto_annotate comme suit :

from ultralytics.data.annotator import auto_annotate

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

Cette fonction automatise le processus d'annotation, le rendant plus rapide et plus efficace. Pour plus de détails, explore l'Auto-Annotate Reference.

Contributeurs
GLglenn-jocher20JKjk4e3RAraimbekovm2SHshawnpavey1PDpderrenger1FCfcakyon1LALaughing-q1Y-Y-T-G1RIRizwanMunawar1MAMatthewNoyce1BUBurhan-Q1

Commentaires