Aperçu des ensembles 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 les objets individuels dans une image. Ce guide donne un aperçu 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 façon de préparer, de convertir et d'utiliser ces jeux de données pour l'entraînement de vos modèles.
Formats de jeux de données pris en charge
Format Ultralytics YOLO
Le format d'étiquette de l'ensemble de données utilisé pour l'entraînement des modèles de segmentation YOLO est le suivant :
- 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 ».
- Une ligne par objet : chaque ligne du fichier texte correspond à une instance d'objet dans l'image.
- Informations sur l'objet par ligne : Chaque ligne contient les informations suivantes sur l'instance d'objet :
- Indice de la classe de l'objet : Un entier représentant la classe de l'objet (par exemple, 0 pour personne, 1 pour voiture, etc.).
- Coordonnées de la boîte englobante de l'objet : Les coordonnées de la boîte englobante autour de la zone du masque, normalisées pour être entre 0 et 1.
Le format d'une seule ligne dans le fichier de l'ensemble 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 de l'objet, et <x1> <y1> <x2> <y2> ... <xn> <yn>
sont les coordonnées de délimitation du masque de segmentation de l'objet. Les coordonnées sont séparées par des espaces.
Voici un exemple du format de dataset 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 ne doit pas nécessairement être égale.
- Chaque étiquette de segmentation doit avoir un minimum de 3 points xy:
<class-index> <x1> <y1> <x2> <y2> <x3> <y3>
Format YAML de l'ensemble de données
Le framework Ultralytics utilise un format de fichier YAML pour définir la configuration de l'ensemble 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 ensemble 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
L'argument train
et val
champs spécifient les chemins d'accès aux répertoires contenant les images d'entraînement et de validation, respectivement.
names
est un dictionnaire de noms de classes. L'ordre des noms doit correspondre à l'ordre des indices de classe d'objet dans les fichiers de l'ensemble de données YOLO.
Utilisation
Exemple
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
# Start training from a pretrained *.pt model
yolo segment train data=coco8-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
Ensembles de données pris en charge
Ultralytics YOLO prend en charge divers ensembles de données pour les tâches de segmentation d’instance. Voici une liste des plus couramment utilisés :
- COCO : Un ensemble de données complet pour la détection d'objets, la segmentation et le légendage, comprenant plus de 200 000 images étiquetées dans un large éventail de catégories.
- COCO8-seg: Un sous-ensemble compact de 8 images de COCO conçu pour tester rapidement l'entraînement d'un modèle de segmentation, idéal pour les vérifications CI et la validation du flux de travail dans le
ultralytics
référentiel. - COCO128-seg : Un ensemble 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.
- Carparts-seg : Un ensemble de données spécialisé axé sur la segmentation des pièces automobiles, idéal pour les applications automobiles. Il comprend une variété de véhicules avec des annotations détaillées des composants automobiles individuels.
- Crack-seg : Un ensemble de données conçu pour la segmentation des fissures dans diverses surfaces. Essentiel pour la maintenance des infrastructures et le contrôle de la qualité, il fournit des images détaillées pour la formation de modèles afin d'identifier les faiblesses structurelles.
- Package-seg : Un ensemble 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.
Ajouter votre propre ensemble de données
Si vous possédez votre propre jeu de données et que vous souhaitez l'utiliser pour entraîner des modèles de segmentation avec le format Ultralytics YOLO, assurez-vous qu'il respecte le format spécifié ci-dessus sous « Format Ultralytics YOLO ». Convertissez vos annotations au format requis et spécifiez les chemins d'accès, le nombre de classes et les noms de classes dans le fichier de configuration YAML.
Transférer ou convertir les formats d'étiquettes
Conversion du format de l'ensemble de données COCO au format YOLO
Vous pouvez facilement convertir les étiquettes du format de jeu de données COCO populaire au format YOLO à l'aide de 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 au format Ultralytics YOLO.
N'oubliez pas de vérifier si le jeu de données que vous souhaitez utiliser est compatible avec votre modèle et respecte les conventions de format nécessaires. Des jeux de données correctement formatés sont essentiels pour entraîner des modèles de détection d'objets performants.
Auto-Annotation
L'auto-annotation est une fonctionnalité essentielle qui vous permet de générer un ensemble de données de segmentation en utilisant un modèle de détection pré-entraîné. Elle vous permet d'annoter rapidement et précisément un grand nombre d'images sans avoir besoin d'un étiquetage manuel, ce qui vous fait gagner du temps et des efforts.
Générer un ensemble de données de segmentation à l'aide d'un modèle de détection
Pour annoter automatiquement votre ensemble de données à l'aide du framework Ultralytics, vous pouvez utiliser le auto_annotate
fonction comme indiqué ci-dessous :
Exemple
from ultralytics.data.annotator import auto_annotate
auto_annotate(data="path/to/images", det_model="yolo11x.pt", sam_model="sam_b.pt")
Argument | Type | Par défaut | Description |
---|---|---|---|
data |
str |
requis | Chemin d'accès au répertoire contenant les images cibles pour l'annotation ou la segmentation. |
det_model |
str |
'yolo11x.pt' |
Chemin du modèle de détection YOLO pour la détection d'objets initiale. |
sam_model |
str |
'sam_b.pt' |
Chemin d'accès au modèle SAM pour la segmentation (prend en charge les variantes SAM, SAM2 et les modèles mobile_sam). |
device |
str |
'' |
Dispositif de calcul (par exemple, « cuda:0 », « cpu » ou « » pour la détection automatique du dispositif). |
conf |
float |
0.25 |
Seuil de confiance de détection YOLO pour filtrer les détections faibles. |
iou |
float |
0.45 |
Seuil IoU pour la suppression non maximale afin de filtrer les boîtes qui se chevauchent. |
imgsz |
int |
640 |
Taille d'entrée pour le redimensionnement des images (doit être un multiple de 32). |
max_det |
int |
300 |
Nombre maximal de détections par image pour l’efficacité de la mémoire. |
classes |
list[int] |
None |
Liste des indices de classe à détecter (par exemple, [0, 1] pour les personnes et les vélos). |
output_dir |
str |
None |
Répertoire d'enregistrement des annotations (par défaut, '.\labels' par rapport au chemin des données). |
L'argument auto_annotate
fonction prend le chemin d'accès à vos images, ainsi que des arguments optionnels pour spécifier les modèles de détection pré-entraînés, c'est-à-dire YOLO11, YOLOv8 ou autre modèles et les modèles de segmentation, c'est-à-dire, SAM, SAM2 ou MobileSAM, l'appareil sur lequel exécuter les modèles et le répertoire de sortie pour 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 d'ensembles de données de segmentation de haute qualité. Cette fonctionnalité est particulièrement utile pour les chercheurs et les 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 de l'ensemble de données
Avant d'entraîner votre modèle, il est souvent utile de visualiser les annotations de votre jeu de données pour s'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 des noms de classe et ajuste la couleur du texte pour une meilleure lisibilité, vous aidant à identifier et à corriger toute erreur d'annotation avant l'entraînement.
Conversion des masques de segmentation au format YOLO
Si vous avez des masques de segmentation au format binaire, vous pouvez 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é.
FAQ
Quels formats de jeu de données Ultralytics YOLO prend-il en charge pour la segmentation d’instance ?
Ultralytics YOLO prend en charge plusieurs formats d'ensembles de données pour la segmentation d'instances, le format principal étant son propre format Ultralytics YOLO. Chaque image de votre ensemble 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'index de classe et les coordonnées de délimitation normalisées. Pour des instructions plus détaillées sur le format d'ensemble de données YOLO, consultez la présentation des ensembles de données de segmentation d'instances.
Comment puis-je convertir les annotations de l'ensemble de données COCO au format YOLO ?
La conversion des annotations au format COCO vers le format YOLO est simple grâce aux outils Ultralytics. Vous pouvez utiliser le convert_coco
fonction de la ultralytics.data.converter
module :
from ultralytics.data.converter import convert_coco
convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)
Ce script convertit les annotations de votre ensemble de données COCO au format YOLO requis, le rendant approprié pour l'entraînement de vos modèles YOLO. Pour plus de détails, consultez Port or Convert Label Formats.
Comment préparer un fichier YAML pour l'entraînement des modèles Ultralytics YOLO ?
Pour préparer un fichier YAML pour l'entraînement des modèles YOLO avec Ultralytics, vous devez définir les chemins d'accès aux ensembles de données et les noms de classe. 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
Assurez-vous de mettre à jour les chemins et les noms de classes en fonction de votre ensemble de données. Pour plus d'informations, consultez la section Format YAML de l'ensemble de données.
Qu'est-ce que la fonctionnalité d'annotation automatique dans Ultralytics YOLO ?
L'auto-annotation dans Ultralytics YOLO vous permet de générer des annotations de segmentation pour votre ensemble de données en utilisant un modèle de détection pré-entraîné. Cela réduit considérablement le besoin d'étiquetage manuel. Vous pouvez utiliser le auto_annotate
fonction comme suit :
from ultralytics.data.annotator import auto_annotate
auto_annotate(data="path/to/images", det_model="yolo11x.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, explorez la Auto-Annotate Reference.