Segmentation sémantique avec Ultralytics YOLO#
La segmentation sémantique attribue une étiquette de classe à chaque pixel d’une image, produisant une carte de classes dense qui couvre toute la scène. Contrairement à la segmentation d’instances, qui distingue les objets individuels, la segmentation sémantique regroupe tous les pixels d’une même classe, quel que soit le nombre d’objets distincts présents.
Regarder : Segmentation sémantique avec Ultralytics YOLO26 | Tutoriel de démarrage rapide
La sortie d’un modèle de segmentation sémantique est une carte de classes unique, de hauteur et de largeur égales à celles de l’image, où chaque valeur de pixel correspond à un ID de classe prédit. La segmentation sémantique est donc idéale pour les tâches d’analyse de scène, comme la conduite autonome, l’imagerie médicale et la cartographie de la couverture terrestre.
Utilise task=semantic ou la tâche CLI yolo semantic pour la segmentation sémantique. Les fichiers des modèles de segmentation sémantique YOLO26 utilisent le suffixe -sem, par exemple yolo26n-sem.pt.
Modèles#
Les modèles YOLO26 Semantic préentraînés sur le jeu de données Cityscapes sont présentés ci-dessous.
Les modèles sont automatiquement téléchargés depuis la dernière version d’Ultralytics lors de leur première utilisation.
| Modèle | taille (pixels) | mIoUval | Vitesse RTX3090 PyTorch (ms) | paramètres (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 23.8 |
| YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 91.0 |
| YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 305.5 |
| YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.8 | 388.2 |
| YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.1 | 866.9 |
- Les valeurs mIoUval correspondent à une évaluation à échelle unique avec un seul modèle sur l’ensemble de validation Cityscapes.
Reproduis les résultats avecyolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Les métriques de vitesse sont calculées en moyenne sur les images de validation Cityscapes avec une instance RTX3090.
Reproduis les résultats avecyolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 - Les valeurs de Params et de FLOPs correspondent au modèle fusionné après
model.fuse(), qui fusionne les couches Conv et BatchNorm. Les checkpoints préentraînés conservent l’architecture d’entraînement complète et peuvent donc afficher des valeurs plus élevées.
Les modèles YOLO26 Semantic préentraînés sur le jeu de données ADE20K sont présentés ci-dessous.
| Modèle | taille (pixels) | mIoUval | Vitesse RTX3090 PyTorch (ms) | paramètres (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem-ade20k | 640 | 38.8 | 3.9 ± 0.2 | 1.6 | 4.5 |
| YOLO26s-sem-ade20k | 640 | 45.6 | 4.2 ± 0.3 | 6.5 | 17.5 |
| YOLO26m-sem-ade20k | 640 | 47.4 | 4.7 ± 0.3 | 14.4 | 59.6 |
| YOLO26l-sem-ade20k | 640 | 49.7 | 8.3 ± 0.2 | 17.9 | 75.2 |
| YOLO26x-sem-ade20k | 640 | 51.5 | 9.9 ± 0.3 | 40.2 | 168.4 |
- Les valeurs mIoUval correspondent à une évaluation à échelle unique avec un seul modèle sur l’ensemble de validation ADE20K.
Reproduis les résultats avecyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, en remplaçantyolo26n-sem-ade20k.ptpar le checkpointyolo26*-sem-ade20k.ptsouhaité. - Les métriques de vitesse sont calculées en moyenne sur les images de validation ADE20K avec une instance RTX3090.
Reproduis les résultats avecyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, en remplaçantyolo26n-sem-ade20k.ptpar le checkpointyolo26*-sem-ade20k.ptsouhaité. - Les valeurs de Params et de FLOPs correspondent au modèle fusionné après
model.fuse(), qui fusionne les couches Conv et BatchNorm. Les checkpoints préentraînés conservent l’architecture d’entraînement complète et peuvent donc afficher des valeurs plus élevées.
Consulte l’aperçu non publié de YOLO27 pour découvrir les résultats préliminaires de mIoU sur Cityscapes.
Entraînement#
Entraîne YOLO26n-sem sur le jeu de données Cityscapes8 pendant 100 époques, avec une taille d’image de 1024. Pour consulter la liste complète des arguments disponibles, voir la page Configuration.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n-sem.yaml") # créer un nouveau modèle à partir du fichier YAML
model = YOLO("yolo26n-sem.pt") # charger un modèle préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n-sem.yaml").load("yolo26n-sem.pt") # créer à partir du fichier YAML et transférer les poids
# Entraîner le modèle
results = model.train(data="cityscapes8.yaml", epochs=100, imgsz=1024)Consulte la page Entraînement pour obtenir tous les détails du mode train. Tu peux également entraîner les modèles de segmentation sémantique avec l’entraînement cloud d’Ultralytics Platform.
Format du jeu de données#
Les jeux de données de segmentation sémantique utilisent des images de masque à un seul canal, généralement au format PNG, où chaque valeur de pixel représente un ID de classe. Les pixels de valeur 255 sont considérés comme « à ignorer » et exclus du calcul de la perte. Le fichier YAML du jeu de données doit indiquer les chemins vers les images et leurs répertoires de masques correspondants. Les jeux de données avec des étiquettes de polygone YOLO sont utilisés directement pour l’entraînement, puis convertis en masques à la volée (voir ci-dessous Puis-je utiliser des données de segmentation d’instances ?). Consulte le guide des jeux de données de segmentation sémantique pour les détails sur le format. Les jeux de données pris en charge incluent Cityscapes et ADE20K. Tu peux gérer et annoter des jeux de données sémantiques avec l’annotation Ultralytics Platform.
Validation#
Valide l’exactitude du modèle YOLO26n-sem entraîné sur un jeu de données de segmentation sémantique. Indique explicitement data afin que la validation utilise le fichier YAML prévu pour le jeu de données.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n-sem.pt") # charger un modèle officiel
model = YOLO("path/to/best.pt") # charger un modèle personnalisé
# Valider le modèle
metrics = model.val(data="cityscapes.yaml")
metrics.miou # intersection sur union moyenne
metrics.pixel_accuracy # précision globale au niveau des pixelsPrédiction#
Utilise un modèle YOLO26n-sem entraîné pour effectuer des prédictions sur des images.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n-sem.pt") # charger un modèle officiel
model = YOLO("path/to/best.pt") # charger un modèle personnalisé
# Effectuer des prédictions avec le modèle
results = model("https://ultralytics.com/images/bus.jpg") # effectuer une prédiction sur une image
# Accéder aux résultats
for result in results:
semantic_mask = result.semantic_mask.data # carte de classes, forme (H,W), dtype entier choisi selon le nombre de classesConsulte les détails complets du mode predict sur la page Predict.
Sortie des résultats#
La segmentation sémantique YOLO renvoie un objet Results par image. Chaque résultat stocke une carte de classes dense pour l’image entière, plutôt qu’une liste de masques d’objets. Les pixels ayant la même classe prédite partagent le même ID de classe, même s’ils appartiennent à des objets distincts.
| Attribut | Type | Forme | Description |
|---|---|---|---|
result.semantic_mask | SemanticMask | (H,W) | Carte de classes dense. |
result.semantic_mask.data | torch.uint8torch.int16torch.int32 | (H,W) | ID de classe ; type de données choisi selon le nombre de classes. |
result.masks | - | - | Aucun masque d’instance. |
result.boxes | - | - | Aucune boîte ni confiance d’instance. |
Pour connaître les champs Results propres à chaque tâche, consulte la section Résultats des prédictions par tâche.
La segmentation sémantique prédit une carte de classes dense, puis redimensionne cette carte à la taille de l’image pour la visualisation et son utilisation en aval. Les structures très fines, comme les marquages au sol, les lignes de terrain, les poteaux ou les fils, peuvent donc sembler crénelées lorsque l’inférence s’exécute avec une valeur imgsz bien inférieure à la résolution d’origine de l’image. Si les limites semblent irrégulières, commence par retester le modèle PyTorch natif .pt avec un imgsz plus élevé, par exemple 1024, 1280 ou la valeur pratique la plus proche de la taille de l’image source. N’utilise les modèles exportés qu’après avoir confirmé que la sortie .pt est acceptable, car des entrées de résolution inférieure ne peuvent pas restituer les détails fins absents de la carte de classes prédite.
Segmentation d’instances et segmentation sémantique#
| Aspect | Segmentation d’instances (task="segment") | Segmentation sémantique (task="semantic") |
|---|---|---|
| Objectif de la prédiction | Segmenter séparément chaque objet détecté | Attribuer un ID de classe à chaque pixel |
| Champ de sortie | result.masks | result.semantic_mask |
| Données principales | result.masks.data | result.semantic_mask.data |
| Forme | (N,H,W) | (H,W) |
| Valeurs des pixels | Valeurs du masque binaire : 0 ou 1 | IDs de classe : 0, 1, 2, ... |
| Type de données | torch.uint8 | torch.uint8torch.int16torch.int32 |
| Objets de même classe | Conservés comme instances distinctes | Fusionnés dans la même région de classe |
| Polygones | Oui, via result.masks.xy et result.masks.xyn | Aucune sortie polygonale par défaut |
| Boîtes et scores de confiance | Oui, via result.boxes | Aucune boîte ni aucun score de confiance par instance |
| Utilisation typique | Comptage, suivi, recadrage, mesures au niveau des objets | Étiquetage dense de scènes, zones accessibles à la conduite, couverture terrestre, régions médicales |
Export#
Exporte un modèle YOLO26n-sem dans un autre format, comme ONNX, CoreML, etc.
from ultralytics import YOLO
# Charger un modèle
model = YOLO("yolo26n-sem.pt") # charger un modèle officiel
model = YOLO("path/to/best.pt") # charger un modèle personnalisé
# Exporter le modèle
model.export(format="onnx")Les formats d’export disponibles pour la segmentation sémantique YOLO26 sont indiqués dans le tableau ci-dessous. Tu peux exporter dans n’importe quel format avec l’argument format, par exemple format='onnx' ou format='engine'. Tu peux effectuer des prédictions ou des validations directement avec les modèles exportés, par exemple yolo predict model=yolo26n-sem.onnx. Des exemples d’utilisation de ton modèle s’affichent une fois l’export terminé.
| Format | Argument format | Modèle | Métadonnées | Arguments |
|---|---|---|---|---|
| PyTorch | - | yolo26n-sem.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-sem.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n-sem.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n-sem_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-sem.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-sem.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n-sem.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n-sem_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-sem.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n-sem_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n-sem.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-sem_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-sem.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n-sem_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n-sem_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n-sem_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n-sem_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-sem_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n-sem_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n-sem_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n-sem_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n-sem_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n-sem_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
nms=None produit par défaut des sorties brutes pour la NMS externe. Définis nms=False pour sélectionner une tête disponible sans NMS ; les formats non pris en charge utilisent leur voie de sortie native. Les entrées nms ci-dessus désignent les formats qui peuvent intégrer la NMS avec nms=True.
Consulte tous les détails de export sur la page Exportation.
FAQ#
Pour entraîner un modèle de segmentation sémantique YOLO26 sur un jeu de données personnalisé, tu dois préparer des images de masques PNG où chaque valeur de pixel représente un ID de classe (0, 1, 2, ...) et où les pixels de valeur 255 sont ignorés pendant l'entraînement. Crée un fichier YAML de jeu de données qui pointe vers tes répertoires d'images et de masques, puis entraîne le modèle :
Exemplefrom ultralytics import YOLO # Charger un modèle de segmentation sémantique YOLO26 préentraîné model = YOLO("yolo26n-sem.pt") # Entraîner le modèle results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=1024)Consulte la page Configuration pour découvrir d’autres arguments disponibles.
La segmentation d'instances et la segmentation sémantique sont toutes deux des tâches au niveau du pixel, mais elles diffèrent sur un point essentiel :
- La segmentation sémantique attribue une étiquette de classe à chaque pixel, mais ne distingue pas les objets individuels d'une même classe. Par exemple, toutes les voitures d'une scène partagent la même étiquette de classe.
- La segmentation d'instances identifie chaque objet individuellement et produit des masques distincts pour chaque objet, même s'ils appartiennent à la même classe.
La segmentation sémantique convient le mieux aux tâches de compréhension de scènes, comme la conduite autonome et la cartographie de l'occupation des sols, tandis que la segmentation d'instances est préférable lorsqu'il est important de compter ou de suivre des objets individuels.
Oui. Si ton jeu de données utilise des étiquettes polygonales Ultralytics YOLO (un
.txtpar image), ometmasks_dirdu YAML du jeu de données et assure-toi qu'aucun dossiermasks/n'existe à côté de tes images à la racine du jeu de données (sa seule présence déclenche le mode masque PNG, même sansmasks_dirdéfini). Le chargeur convertit alors les polygones en masques sémantiques par image à la volée. Pour les jeux de données multiclasse (N > 1), une classebackgroundsupplémentaire est automatiquement ajoutée ànames. Pour les jeux de données à classe unique (N == 1), l'entraînement reste à 1 classe : la classe que tu as déclarée devient1dans le masque et les pixels non couverts deviennent0. Consulte le Guide des jeux de données de segmentation sémantique pour en savoir plus.Ultralytics YOLO26 propose des configurations intégrées pour plusieurs jeux de données de segmentation sémantique :
- Cityscapes : des scènes de rues urbaines avec 19 classes, largement utilisées dans la recherche sur la conduite autonome.
- ADE20K : un jeu de données à grande échelle pour l'analyse de scènes, avec 150 classes.
Tu peux également utiliser n'importe quel jeu de données personnalisé fournissant des annotations de masques PNG dont les valeurs de pixel correspondent aux ID de classe.
Valide un modèle de segmentation sémantique YOLO26 préentraîné avec le YAML du jeu de données utilisé pour l'évaluation :
Exemplefrom ultralytics import YOLO # Charger un modèle préentraîné model = YOLO("yolo26n-sem.pt") # Valider le modèle metrics = model.val(data="cityscapes.yaml") print("Mean IoU:", metrics.miou) print("Pixel Accuracy:", metrics.pixel_accuracy)Ces étapes te fourniront des métriques de validation comme l'intersection moyenne sur l'union (mIoU) et la précision au niveau du pixel, qui sont des mesures standard pour évaluer les performances en segmentation sémantique.
Exporte un modèle de segmentation sémantique YOLO26 au format ONNX à l'aide de commandes Python ou CLI :
Exemplefrom ultralytics import YOLO # Charger un modèle préentraîné model = YOLO("yolo26n-sem.pt") # Exporter le modèle au format ONNX model.export(format="onnx")Pour plus de détails sur l’exportation vers différents formats, consulte la page Exportation.