Segmentation sémantique
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'instance, qui sépare 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.
La sortie d'un modèle de segmentation sémantique est une carte de classes unique dont la hauteur et la largeur correspondent à l'image, 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.
Utilise task=semantic ou la tâche CLI yolo semantic pour la segmentation sémantique. Les fichiers de modèle de segmentation sémantique YOLO26 utilisent le suffixe -sem, comme 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 depuis la dernière version d'Ultralytics lors de la première utilisation.
| Modèle | taille (pixels) | mIoUval | Vitesse RTX3090 PyTorch (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 22.7 |
| YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 88.8 |
| YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 304.5 |
| YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.9 | 384.7 |
| YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.2 | 861.7 |
- Les valeurs mIoUval sont pour un modèle unique à une seule échelle sur le jeu de validation Cityscapes.
Reproduis avecyolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Les métriques de vitesse sont moyennées sur les images de validation Cityscapes en utilisant une instance Amazon EC2 P4d.
Reproduis avecyolo 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 combine 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înement (Train)
Entraîne YOLO26n-sem sur le jeu de données Cityscapes8 pendant 100 époques avec une taille d'image de 1024. Pour une liste complète des arguments disponibles, consulte la page Configuration.
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)Vois les détails complets du mode train sur la page Train.
Format du jeu de données
Les jeux de données de segmentation sémantique utilisent des images de masque à canal unique, généralement au format PNG, où chaque valeur de pixel représente un ID de classe. Les pixels avec une valeur de 255 sont traités comme "ignore" et exclus du calcul de la perte. Le fichier YAML du jeu de données doit spécifier les chemins vers les images et leurs répertoires de masques correspondants. 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.
Validation (Val)
Valide la précision d'un modèle YOLO26n-sem entraîné sur un jeu de données de segmentation sémantique. Transmets explicitement data afin que la validation utilise le YAML du jeu de données prévu.
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 accuracyPrédiction
Utilise un modèle YOLO26n-sem entraîné pour effectuer des prédictions sur des images.
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 # height x width class map (torch.Tensor)Vois les détails complets du mode predict sur la page Predict.
Exportation (Export)
Exporte un modèle YOLO26n-sem vers un format différent comme ONNX, CoreML, etc.
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 disponibles pour la segmentation sémantique YOLO26 sont dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, par exemple format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur les modèles exportés, par exemple yolo predict model=yolo26n-sem.onnx. Des exemples d'utilisation sont affichés pour ton modèle une fois l'exportation terminée.
| Format | Argument format | Modèle | Métadonnées | Arguments |
|---|---|---|---|---|
| PyTorch | - | yolo26n-sem.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-sem.torchscript | ✅ | imgsz, half, dynamic, optimize, nms, batch, device |
| ONNX | onnx | yolo26n-sem.onnx | ✅ | imgsz, half, dynamic, simplify, opset, nms, batch, device |
| OpenVINO | openvino | yolo26n-sem_openvino_model/ | ✅ | imgsz, half, dynamic, int8, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-sem.engine | ✅ | imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-sem.mlpackage | ✅ | imgsz, dynamic, half, int8, nms, batch, device |
| TF SavedModel | saved_model | yolo26n-sem_saved_model/ | ✅ | imgsz, keras, int8, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-sem.pb | ❌ | imgsz, batch, device |
| TF Lite | tflite | yolo26n-sem.tflite | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| TF Edge TPU | edgetpu | yolo26n-sem_edgetpu.tflite | ✅ | imgsz, int8, data, fraction, device |
| TF.js | tfjs | yolo26n-sem_web_model/ | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-sem_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-sem.mnn | ✅ | imgsz, batch, int8, half, device |
| NCNN | ncnn | yolo26n-sem_ncnn_model/ | ✅ | imgsz, half, batch, device |
| IMX500 | imx | yolo26n-sem_imx_model/ | ✅ | imgsz, int8, data, fraction, nms, device |
| RKNN | rknn | yolo26n-sem_rknn_model/ | ✅ | imgsz, batch, name, device |
| ExecuTorch | executorch | yolo26n-sem_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-sem_axelera_model/ | ✅ | imgsz, batch, int8, data, fraction, device |
| DeepX | deepx | yolo26n-sem_deepx_model/ | ✅ | imgsz, int8, data, optimize, device |
Vois les détails complets de l'export sur la page Export.
FAQ
Comment entraîner un modèle de segmentation sémantique YOLO26 sur un jeu de données personnalisé ?
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 :
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 plus d'arguments disponibles.
Quelle est la différence entre la segmentation d'instance et la segmentation sémantique ?
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 essentielle :
- La segmentation sémantique attribue une étiquette de classe à chaque pixel mais ne distingue pas les objets individuels de la même classe. Par exemple, toutes les voitures dans une scène partagent la même étiquette de classe.
- La segmentation d'instance 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 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.
Puis-je utiliser des données de segmentation d'instance pour entraîner la segmentation sémantique ?
Oui. Si ton jeu de données utilise des étiquettes de polygone Ultralytics YOLO (un .txt par image), omets masks_dir du YAML du jeu de données et le chargeur convertira les polygones en masques sémantiques par image à la volée. Pour les jeux de données multi-classes (N > 1), une classe background supplémentaire est automatiquement ajoutée aux 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 des jeux de données de segmentation sémantique pour plus de détails.
Quels jeux de données sont pris en charge pour la segmentation sémantique ?
Ultralytics YOLO26 fournit des configurations intégrées pour plusieurs jeux de données de segmentation sémantique :
- Cityscapes : Scènes de rue urbaines avec 19 classes, largement utilisées pour la recherche en conduite autonome.
- ADE20K : Un jeu de données d'analyse de scène à grande échelle avec 150 classes.
Tu peux également utiliser n'importe quel jeu de données personnalisé qui fournit des annotations de masque PNG où les valeurs de pixel correspondent aux ID de classe.
Comment valider un modèle de segmentation sémantique YOLO26 pré-entraîné ?
Valide un modèle de segmentation sémantique YOLO26 pré-entraîné avec le YAML de jeu de données utilisé pour l'évaluation :
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 des pixels, qui sont des mesures standard pour évaluer les performances de la segmentation sémantique.
Comment puis-je exporter un modèle de segmentation sémantique YOLO26 au format ONNX ?
Exporte un modèle de segmentation sémantique YOLO26 au format ONNX avec des commandes Python ou CLI :
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 divers formats, reporte-toi à la page Export.