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 des objets individuels dans une image. Ce guide présente les formats de jeux de données pris en charge par Ultralytics YOLO pour les tâches de segmentation d’instances et explique comment préparer, convertir et utiliser ces jeux de données pour 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 :
- 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 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- La longueur de chaque ligne n’a pas besoin d’être identique.
- Chaque annotation de segmentation doit contenir au moins 3 points
(x, y):<class-index> <x1> <y1> <x2> <y2> <x3> <y3> - Chaque objet doit avoir un polygone. Les lignes au format de détection (
<class-index> <x_center> <y_center> <width> <height>) n’en contiennent pas, et un jeu de données de segmentation dont le nombre de boîtes diffère du nombre de polygones est rejeté avec unValueErrorau chargement de ses étiquettes.
Format YAML du jeu de données#
Le framework Ultralytics utilise un fichier YAML pour définir le jeu de données et la configuration du modèle lors de l’entraînement de modèles de segmentation. Voici un exemple de format YAML permettant de 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.zipLes champs train, val et test désignent les images d’entraînement, de validation et de test. Chacun accepte un répertoire, un fichier image, une liste de répertoires ou de fichiers image, ou un fichier UTF-8 *.txt répertoriant un chemin d’image par ligne (les chemins commençant par ./ sont résolus par rapport au fichier *.txt). Un fichier *.txt est utile pour entraîner un modèle sur un sous-ensemble d’un répertoire, ignorer les images non annotées ou combiner des images provenant de plusieurs sources dans une même partition.
path: datasets/coco8-seg # dataset root
train: train.txt # a directory, an image, a list e.g. [images/a, images/b], or a *.txt file
val: val.txt
names:
0: personnames 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 petit jeu de données pour la 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 convertir les étiquettes du format populaire 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 génère un jeu de données de segmentation à partir d’un modèle de détection préentraîné. Tu peux ainsi annoter un grand nombre d’images sans dessiner chaque masque à la main. Pour annoter directement dans le navigateur, Ultralytics Platform propose SAM, YOLO et une annotation intelligente guidée par des classes. Le classement des VLM compare les modèles guidés selon leur précision de détection, leur coût et leur vitesse.
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")| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
data | str | obligatoire | Chemin vers le répertoire contenant les images à annoter ou à segmenter. |
det_model | str | 'yolo26x.pt' | Chemin vers le modèle de détection YOLO pour la détection initiale des objets. |
sam_model | str | 'sam_b.pt' | Chemin vers le modèle SAM pour la segmentation (prend en charge les poids SAM, SAM 2, MobileSAM et SAM 3). |
device | str | '' | Périphérique de calcul (par exemple, 'cuda:0', 'cpu' ou '' pour la détection automatique du périphérique). |
conf | float | 0.25 | Seuil de confiance de détection YOLO pour filtrer les détections peu fiables. |
iou | float | 0.5 | 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 (arrondie au multiple de 32 supérieur si nécessaire). |
max_det | int | 300 | Nombre maximal de détections par image pour limiter l’utilisation de la mémoire. |
classes | list[int] | None | Liste des indices de classes à détecter (par exemple, [0, 1] pour personne et vélo). |
output_dir | str | None | Répertoire d’enregistrement des annotations (par défaut : répertoire frère de <data>_auto_annotate_labels). |
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.
Avec des modèles préentraînés, l’annotation automatique réduit considérablement le temps et les efforts nécessaires à la création de jeux de données de segmentation de haute qualité. Cette méthode 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#
Ultralytics YOLO prend en charge plusieurs formats de jeux de données pour la segmentation d’instances, le format principal étant son propre format Ultralytics YOLO. Chaque image de ton jeu de données doit avoir un fichier texte correspondant contenant les informations sur les objets, réparties sur plusieurs lignes (une ligne par objet), avec l’indice de classe et les coordonnées normalisées des polygones.
La conversion des annotations du format COCO au format YOLO est simple avec les outils Ultralytics. Tu peux utiliser la fonction
convert_cocodu moduleultralytics.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, afin de pouvoir l’utiliser pour entraîner tes modèles YOLO. Pour en savoir plus, consulte Importer ou convertir des formats d’étiquettes.
Pour préparer un fichier YAML afin d’entraîner des modèles YOLO avec Ultralytics, tu dois définir les chemins des jeux 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.zipVeille à mettre à jour les chemins et les noms de classes en fonction de ton jeu de données. Pour en savoir plus, consulte la section Format YAML du jeu de données.
L’annotation automatique dans Ultralytics YOLO te permet de générer des annotations de segmentation pour ton jeu de données à l’aide d’un modèle de détection préentraîné. Elle réduit considérablement le besoin d’étiquetage manuel. Tu peux utiliser la fonction
auto_annotatecomme 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, qui devient ainsi plus rapide et plus efficace. Pour en savoir plus, consulte la référence sur l’annotation automatique.
Commentaires80
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
hp0716
Hello, currently my segmentation task requires multi-channel masking, which means that one pixel may belong to multiple categories. Is there any code that implements this feature? Looking forward to receiving your reply.
1kh-diab
hello i tried to convert coco format to yolo format in segmented images but the generated yolo files are empty
from ultralytics.data.converter import convert_coco
convert_coco(labels_dir="groupC/annotations", use_segments=True)
can you tell me
this is example of the original annotation file exported from CVAT to coco format knowing that I used SAM model to do the segmentation
{ "id": 16, "image_id": 10, "category_id": 1, "segmentation": { "counts": [ 2815839, 2, 1817, 5, 1814, 7, 1812, 8, 1810, 10, 1809, 11, 1807, 14, 1805, 15, 1803, 17, 1802, 18, 1801, 18, 1800, 19, 1800, 19, 1800, 19, 1800, 20, 1798, 21, 1798, 21, 1798, 22, 1796, 23, 1796, 23, 1797, 23, 1796, 23, 1796, 23, 1796, 23, 1796, 23, 1797, 23, 1796, 23, 1797, 22, 1797, 23, 1797, 22, 1797, 23, 1797, 22, 1797, 22, 1798, 22, 1798, 21, 1798, 22, 1798, 21, 1798, 22, 1798, 21, 1799, 21, 1798, 21, 1799, 21, 1800, 19, 1801, 18, 1803, 15, 1807, 10, 829643 ], "size": [ 1820, 2048 ] }, "area": 861.0, "bbox": [ 1547.0, 263.0, 46.0, 42.0 ], "iscrowd": 1, "attributes": { "occluded": false } },
1
Glenn JocherUltralytics@kh-diab it seems like the conversion process isn't working as expected. Please ensure that your COCO annotations are correctly formatted and that the
use_segments=Trueparameter is set. Also, make sure you're using the latest version of the Ultralytics package. If the issue persists, try running the conversion with a smaller subset of your data to isolate the problem. For more detailed guidance, you can refer to the Instance Segmentation Datasets Overview.
ratom
I have semantic segmentation data of 6 classes. But the dataset has one folder for images and another folder for segmentation mask. I have color maps for each mask and each class. In this case, I want to create a dataset for YOLO style segmentation. How can I do it.
rohith-aiunika
hi yolo team, can i perform object tracking for my segmentation model using this kind of annotation format ... or do i need x_center, y_center, width, height ... format?
Glenn JocherUltralytics@rohith-aiunika the annotation format
<class-index> <x1> <y1> <x2> <y2> ... <xn> <yn>is sufficient for segmentation tasks, including object tracking with segmentation models, as long as it aligns with the Ultralytics YOLO format. The additional fields for bounding boxes (e.g.,x_center, y_center, width, height) are not required unless explicitly specified for other tasks. For more details, you can refer to Instance Segmentation Datasets Overview.
mathrank
What should I do if the object has a hole in the center?
Glenn JocherUltralytics(modifié)@mathrank each row in a segmentation label file is a single polygon, so a hole cannot be a separate row (it would be read as a second object). Instead, join the outer and inner boundaries into one polygon by connecting them with a thin bridge between their closest points, which is how the COCO converter (
merge_multi_segment) merges multi-part segments. For details on the format, refer to Instance Segmentation Datasets Overview.
johnlockejrr
Finally I ended up with the following code, any opinion?
from ultralytics import YOLO import cv2 import numpy as np from pathlib import Path image_path = "/home/incognito/yolov8/datasets/sam_v1/images/a34e234a-76be-5392-9b39-4abdcd051719.jpg" # Load the YOLOv8 model model = YOLO('/home/incognito/yolov8/runs/segment/train/weights/best.pt') # Perform inference on an image results = model(image_path) img = cv2.imread(image_path) img_name = Path(image_path).stem # Extract bounding boxes, classes, names, and confidences boxes = results[0].boxes.xyxy.tolist() classes = results[0].boxes.cls.tolist() names = results[0].names confidences = results[0].boxes.conf.tolist() bboxes = [] # Iterate through the results for box, cls, conf in zip(boxes, classes, confidences): x1, y1, x2, y2 = box confidence = conf detected_class = cls name = names[int(cls)] bboxes.append(box) #print(f"class: {name}, box: {box}") bboxes.sort(key=lambda x: x[0]) for number, bbox in enumerate(bboxes): print(bbox) x1, y1, x2, y2 = bbox iso_crop = img[int(y1):int(y2), int(x1):int(x2)] cv2.imwrite(f"{img_name}_{number}.jpg", iso_crop)johnlockejrr
90% ok, most of the lines are in the correct position, some are not... I sorted by
x1, was I wrong?
Glenn JocherUltralytics@johnlockejrr sorting by
x1is fine if you want to order the bounding boxes from left to right. Ensure this aligns with your intended use case. If you need further assistance, feel free to ask! For more on dataset formats, visit the Ultralytics documentation.
johnlockejrr(modifié)
Yes, you are right, the solution is here https://docs.ultralytics.com/guides/isolating-segmentation-objects/#what-options-are-available-for-saving-the-isolated-objects-after-segmentation. Here is my code that does that (for anyone interested):
from pathlib import Path import cv2 import numpy as np from ultralytics import YOLO m = YOLO("/home/incognito/yolov8/runs/segment/train/weights/best.pt") res = m.predict("/home/incognito/yolov8/datasets/sam_v1/images/a34e234a-76be-5392-9b39-4abdcd051719.jpg") # Iterate detection results for r in res: img = np.copy(r.orig_img) img_name = Path(r.path).stem # Iterate each object contour for ci, c in enumerate(r): label = c.names[c.boxes.cls.tolist().pop()] b_mask = np.zeros(img.shape[:2], np.uint8) # Create contour mask contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2) _ = cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED) # Choose one: # OPTION-1: Isolate object with black background mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR) isolated = cv2.bitwise_and(mask3ch, img) # OPTION-2: Isolate object with transparent background (when saved as PNG) #isolated = np.dstack([img, b_mask]) # OPTIONAL: detection crop (from either OPT1 or OPT2) x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32) iso_crop = isolated[y1:y2, x1:x2] cv2.imwrite(f"{img_name}_{ci}.jpg", iso_crop)The only problem is that the lines in page are random and not top-down in order. Is there a way to have them in order? As I read the
ultralyticscode the result is sorted by confidence (torch.argsort(scores, descending=True)), this, for segmenting lines of text in a page isn't helping, I should be able to sort it by masks location, from top down and left to right or right to left.
Glenn JocherUltralytics@johnlockejrr to sort the results by mask location, you can modify your code to sort based on the bounding box coordinates. Extract the y-coordinate of the bounding boxes and sort the results accordingly. This will help you achieve a top-down order. If you need further assistance, feel free to ask!
johnlockejrr
Yes, I got it, but that I'm not sure how to do it, didn't find anything in the docs
Glenn JocherUltralyticsTo sort the segmented objects by their location, you can modify your code to sort based on the y-coordinate of the bounding boxes. This will help you achieve a top-down order. If you need further assistance, feel free to ask!
johnlockejrr
@glenn-jocher, thank you for your help! I trained the model already and works pretty well, right now trying to figure out how to predict with it, I mean how to get back polygons so I forward them to a line recognition HTR (like PyLaia) for text recognition. I need to use the segmentation so I can cut the lines of text from the segmented image.
My script:
from ultralytics import YOLO # https://docs.ultralytics.com/modes/predict/#inference-arguments # Load a model model = YOLO("/home/incognito/yolov8/runs/segment/train4/weights/best.pt") # pretrained YOLOv8n model # Run batched inference on a list of images results = model("29.jpg") # return a list of Results objects # Process results list for result in results: boxes = result.boxes # Boxes object for bounding box outputs masks = result.masks # Masks object for segmentation masks outputs keypoints = result.keypoints # Keypoints object for pose outputs probs = result.probs # Probs object for classification outputs obb = result.obb # Oriented boxes object for OBB outputs result.show() # display to screen result.save(filename="result.jpg") # save to diskMy
result.jpg
Glenn JocherUltralytics@johnlockejrr to extract polygons for line recognition, you can access the
masksattribute in your results. This will give you the segmentation masks, which you can then process to obtain the polygon coordinates needed for your HTR system. If you need further details, please refer to the documentation on segmentation results processing.
johnlockejrr
Thank you @glenn-jocher, I converted my data with
page2darknetto darknet format then I converted it to YOLO OBB.johnlockejrr(modifié)
I'm new to YOLO. I would like to convert my datasets for training a YOLOv8 model. My datasets are mainly in ALTO XML and PAGE XML formats (image/xml), the xml file contains polygons, any idea how to convert to YOLO format? Thank you!
Example:
<TextLine ID="eSc_line_48be6c40" TAGREFS="LT46" BASELINE="627 397 964 397 1713 373 2473 373" HPOS="625" VPOS="338" WIDTH="1848" HEIGHT="87"> <Shape><Polygon POINTS="2470 351 2454 351 2438 349 2422 349 2407 348 2391 348 2375 346 2359 346 2344 345 2328 345 2312 343 2296 343 2281 343 2274 342 2254 345 2184 338 2183 338 2181 338 2158 349 2156 349 2139 349 1986 342 1984 342 1983 342 1959 349 1868 338 1855 340 1839 340 1823 340 1808 342 1792 342 1776 342 1775 342 1700 346 1655 345 1650 346 1634 346 1618 346 1603 346 1587 348 1571 348 1555 348 1540 349 1524 349 1508 349 1492 351 1477 351 1461 351 1445 351 1429 353 1414 353 1398 353 1382 354 1366 354 1350 354 1335 356 1319 356 1303 356 1287 356 1272 357 1256 357 1240 357 1224 359 1209 359 1193 359 1179 359 1179 360 1161 365 966 365 956 367 941 367 925 367 909 368 893 368 878 368 862 370 846 370 830 370 815 370 799 368 788 365 646 365 641 368 625 370 627 397 627 425 734 423 736 423 780 412 846 420 848 420 1111 419 1112 417 1295 403 1377 409 1379 409 1380 409 1410 400 1741 397 1820 397 1842 406 1844 406 1845 406 1847 406 1886 406 2128 397 2148 401 2159 403 2161 403 2162 403 2167 401 2184 392 2470 395 2473 373 2471 351 2470 351"/></Shape> <String CONTENT="את הארון ואת בדיו ואת הכפרת ואת פרכת המסך" HPOS="625" VPOS="338" WIDTH="1848" HEIGHT="87"></String> </TextLine>EDIT: I think this should do it:
https://github.com/mittagessen/page2darknet
Glenn JocherUltralytics@johnlockejrr to convert your ALTO XML and PAGE XML datasets to the YOLO format, you'll need to extract the polygon coordinates and class indices, then format them as
<class-index> <x1> <y1> <x2> <y2> ... <xn> <yn>. You might find thepage2darknettool helpful for this conversion. Once converted, ensure your dataset follows the YOLO format with a corresponding YAML file for training. For more details, you can refer to the Ultralytics documentation on dataset formats.1
