YOLO Vision 2026 :

Segmentation sémantique#

Semantic segmentation examples

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 sépare les objets individuels, la segmentation sémantique groupe tous les pixels d'une même classe ensemble, peu importe le nombre d'objets distincts présents.



Watch: Semantic Segmentation with Ultralytics YOLO26 | Quickstart Tutorial

La sortie d'un modèle de segmentation sémantique est une carte de classe unique hauteur par largeur où chaque valeur de pixel correspond à un ID de classe prédit. Cela rend la segmentation sémantique idéale pour les tâches d'analyse de scène telles que la conduite autonome, l'imagerie médicale et la cartographie de l'occupation des sols.

Astuce

Utilise task=semantic ou la tâche CLI yolo semantic pour la segmentation sémantique. Les fichiers de modèles de segmentation sémantique YOLO26 utilisent le suffixe -sem, tel que yolo26n-sem.pt.

Modèles#

Les modèles de segmentation sémantique YOLO26 pré-entraînés sur le jeu de données Cityscapes sont présentés ci-dessous.

Les modèles se téléchargent automatiquement à partir de la dernière version d'Ultralytics lors de la première utilisation.

Modèletaille
(pixels)
mIoUvalVitesse
RTX3090 PyTorch
(ms)
params
(M)
FLOPs
(B)
YOLO26n-sem1024 × 204878.34.4 ± 0.01.622.7
YOLO26s-sem1024 × 204880.88.4 ± 0.06.588.8
YOLO26m-sem1024 × 204882.019.9 ± 0.114.3304.5
YOLO26l-sem1024 × 204882.926.5 ± 0.117.9384.7
YOLO26x-sem1024 × 204883.648.9 ± 0.240.2861.7
  • Les valeurs de mIoUval correspondent à un modèle unique à échelle unique sur le jeu de validation de Cityscapes.
    Reproduis avec yolo semantic val data=cityscapes.yaml device=0 imgsz=2048
  • Les métriques de Speed sont moyennées sur les images de validation de Cityscapes en utilisant une instance RTX3090.
    Reproduis avec yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048
  • Les valeurs de Params et FLOPs concernent le modèle fusionné après model.fuse(), qui fusionne les couches Conv et BatchNorm. Les points de contrôle pré-entraînés conservent l'architecture d'entraînement complète et peuvent afficher des nombres plus élevés.

Les modèles de segmentation sémantique YOLO26 pré-entraînés sur le jeu de données ADE20K sont présentés ci-dessous.

Les modèles se téléchargent automatiquement à partir de la dernière version d'Ultralytics lors de la première utilisation.

Modèletaille
(pixels)
mIoUvalVitesse
RTX3090 PyTorch
(ms)
params
(M)
FLOPs
(B)
YOLO26n-sem-ade20k64038.83.9 ± 0.21.64.4
YOLO26s-sem-ade20k64045.64.2 ± 0.36.517.4
YOLO26m-sem-ade20k64047.44.7 ± 0.314.359.5
YOLO26l-sem-ade20k64049.78.3 ± 0.217.975.0
YOLO26x-sem-ade20k64051.59.9 ± 0.340.2168.1
  • Les valeurs de mIoUval correspondent à un modèle unique à échelle unique sur le jeu de validation ADE20K.
    Reproduis avec yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, en remplaçant yolo26n-sem-ade20k.pt par le point de contrôle souhaité yolo26*-sem-ade20k.pt.
  • Les métriques de Speed sont moyennées sur les images de validation d'ADE20K en utilisant une instance RTX3090.
    Reproduis avec yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, en remplaçant yolo26n-sem-ade20k.pt par le point de contrôle souhaité yolo26*-sem-ade20k.pt.
  • Les valeurs de Params et FLOPs concernent le modèle fusionné après model.fuse(), qui fusionne les couches Conv et BatchNorm. Les points de contrôle pré-entraînés conservent l'architecture d'entraînement complète et peuvent afficher des nombres plus élevés.

Entraîner (Train)#

Entraîne YOLO26n-sem sur le jeu de données Cityscapes8 pendant 100 époques à une taille d'image de 1024. Pour une liste complète des arguments disponibles, consulte la page Configuration.

Exemple
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-sem.yaml")  # build a new model from YAML
model = YOLO("yolo26n-sem.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-sem.yaml").load("yolo26n-sem.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="cityscapes8.yaml", epochs=100, imgsz=1024)

Consulte tous les détails du mode train sur la page Train. Les modèles de segmentation sémantique peuvent également être entraînés avec l'entraînement cloud Ultralytics Platform.

Format de jeu de données#

Les jeux de données de segmentation sémantique utilisent des images de masques à canal unique, généralement PNG, où chaque valeur de pixel représente un ID de classe. Les pixels avec la valeur 255 sont traités comme "ignorer" et exclus du calcul de la perte. Le YAML du jeu de données doit spécifier les chemins vers les images et leurs répertoires de masques correspondants. Consulte le guide du jeu de données de segmentation sémantique pour les détails du 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.

Valider (Val)#

Valide la précision du modèle YOLO26n-sem entraîné sur un jeu de données de segmentation sémantique. Passe explicitement data pour que la validation utilise le YAML de jeu de données prévu.

Exemple
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-sem.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val(data="cityscapes.yaml")
metrics.miou  # mean Intersection over Union
metrics.pixel_accuracy  # overall pixel accuracy

Prédire (Predict)#

Utilise un modèle YOLO26n-sem entraîné pour effectuer des prédictions sur des images.

Exemple
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-sem.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    semantic_mask = result.semantic_mask.data  # class map, shape (H,W), integer dtype selected by class count

Consulte tous les détails du mode predict dans la page Prédire.

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 au lieu d'une liste de masques d'objets. Les pixels avec la classe prédite identique partagent le même ID de classe, même lorsqu'ils appartiennent à des objets séparés.

AttributTypeFormeDescription
result.semantic_maskSemanticMask(H,W)Carte de classe dense.
result.semantic_mask.datatorch.uint8
torch.int16
torch.int32
(H,W)IDs de classe ; dtype sélectionné selon le nombre de classes.
result.masks--Aucun masque d'instance.
result.boxes--Aucune boîte/confiance d'instance.
result.masks.xy--Aucun polygone par défaut.

Pour les champs Results spécifiques à chaque tâche, consulte la section Résultats de prédiction par tâche.

Qualité des contours des masques

La segmentation sémantique prédit une carte de classes dense, puis redimensionne cette carte à la taille de l'image pour la visualisation et l'utilisation en aval. Les structures très minces, telles que les marquages de voie, les lignes de terrain, les poteaux ou les fils, peuvent donc paraître crénelées lorsque l'inférence s'exécute à un imgsz beaucoup plus bas que la résolution de l'image originale. Si les bordures apparaissent irrégulières, reteste d'abord le modèle PyTorch natif .pt avec un imgsz plus grand, tel que 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 les entrées à plus basse résolution ne peuvent pas récupérer les détails fins qui n'étaient pas présents dans la carte de classes prédite.

Segmentation d'instance vs Sémantique#

AspectSegmentation d'instances (task="segment")Segmentation sémantique (task="semantic")
Objectif de prédictionSegmenter chaque objet détecté séparémentAttribuer un ID de classe à chaque pixel
Champ de sortieresult.masksresult.semantic_mask
Données principalesresult.masks.dataresult.semantic_mask.data
Forme(N,H,W)(H,W)
Valeurs de pixelValeurs de masque binaire : 0 ou 1IDs de classe : 0, 1, 2, ...
Dtypetorch.uint8torch.uint8
torch.int16
torch.int32
Objets de même classeConservés comme instances séparéesFusionnés dans la même région de classe
PolygonesOui, via result.masks.xy et result.masks.xynAucune sortie de polygone par défaut
Boîtes et confianceOui, via result.boxesAucune boîte ou score de confiance par instance
Utilisation typiqueComptage, suivi, découpage, mesure au niveau de l'objetÉtiquetage de scène dense, zone roulable, occupation des sols, régions médicales

Exporter (Export)#

Exporte un modèle YOLO26n-sem vers un format différent comme ONNX, CoreML, etc.

Exemple
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-sem.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Export the model
model.export(format="onnx")

Les formats d'exportation de segmentation sémantique YOLO26 disponibles se trouvent dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, c'est-à-dire format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur les modèles exportés, c'est-à-dire yolo predict model=yolo26n-sem.onnx. Des exemples d'utilisation sont affichés pour ton modèle une fois l'exportation terminée.

FormatArgument formatModèleMétadonnéesArguments
PyTorch-yolo26n-sem.pt-
TorchScripttorchscriptyolo26n-sem.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-sem.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-sem_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-sem.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-sem.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n-sem_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-sem.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-sem_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n-sem_paddle_model/imgsz, batch, device
MNNmnnyolo26n-sem.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-sem_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n-sem_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-sem_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-sem_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n-sem_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-sem_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-sem_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n-sem.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n-sem_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n-sem_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms

Consulte tous les détails de export dans la page Exporter.

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 masque PNG où chaque valeur de pixel représente un ID de classe (0, 1, 2, ...) et les pixels avec une valeur de 255 sont ignorés pendant l'entraînement. Crée un fichier YAML de jeu de données pointant vers tes répertoires d'images et de masques, puis entraîne le modèle :

    Exemple
    from ultralytics import YOLO
    
    # Load a pretrained YOLO26 semantic segmentation model
    model = YOLO("yolo26n-sem.pt")
    
    # Train the model
    results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=512)

    Consulte la page Configuration pour découvrir d'autres arguments disponibles.

  • La segmentation d'instance et la segmentation sémantique sont toutes deux des tâches au niveau du pixel, mais diffèrent de manière clé :

    • 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 individuel séparément, produisant des masques distincts pour chaque objet même s'ils appartiennent à la même classe.

    La segmentation sémantique est la mieux adaptée aux tâches de compréhension de scène comme la conduite autonome et la cartographie de l'occupation des sols, tandis que la segmentation d'instance est préférée lorsque le comptage ou le suivi d'objets individuels est important.

  • Oui. Si ton jeu de données utilise des étiquettes de polygones Ultralytics YOLO (un .txt par image), omets masks_dir du YAML du jeu de données, et assure-toi qu'aucun dossier masks/ 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 sans masks_dir défini). Le chargeur convertit ensuite à la volée les polygones en masques sémantiques par image. Pour les jeux de données multi-classes (N > 1), un background de classe supplémentaire est ajouté automatiquement à names. Pour les jeux de données à classe unique (N == 1), l'entraînement reste à 1 classe — ta classe déclarée devient 1 dans le masque et les pixels non couverts deviennent 0. Consulte le guide du jeu de données de segmentation sémantique pour plus de détails.

  • Ultralytics YOLO26 fournit des configurations intégrées pour plusieurs jeux de données de segmentation sémantique :

    • Cityscapes : Scènes de rues urbaines avec 19 classes, largement utilisées pour la recherche sur la conduite autonome.
    • ADE20K : Un jeu de données d'analyse de scènes à grande échelle comportant 150 classes.

    Tu peux également utiliser tout jeu de données personnalisé fournissant des annotations de masque PNG où les valeurs de pixel correspondent aux IDs de classe.

  • Valide un modèle de segmentation sémantique YOLO26 pré-entraîné avec le YAML de jeu de données utilisé pour l'évaluation :

    Exemple
    from ultralytics import YOLO
    
    # Load a pretrained model
    model = YOLO("yolo26n-sem.pt")
    
    # Validate the model
    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 telles que l'intersection sur union moyenne (mIoU) et la précision par pixel, qui sont des mesures standard pour évaluer les performances de la segmentation sémantique.

  • Exporte un modèle de segmentation sémantique YOLO26 au format ONNX avec Python ou des commandes CLI :

    Exemple
    from ultralytics import YOLO
    
    # Load a pretrained model
    model = YOLO("yolo26n-sem.pt")
    
    # Export the model to ONNX format
    model.export(format="onnx")

    Pour plus de détails sur l'exportation vers différents formats, réfère-toi à la page Exporter.

Commentaires