Segmentación semántica#
Semantic segmentation asigna una etiqueta de clase a cada píxel de una imagen, produciendo un mapa de clases denso que cubre toda la escena. A diferencia de la instance segmentation, que separa los objetos individuales, la segmentación semántica agrupa todos los píxeles de la misma clase sin importar cuántos objetos distintos estén presentes.
Watch: Semantic Segmentation with Ultralytics YOLO26 | Quickstart Tutorial
La salida de un modelo de segmentación semántica es un único mapa de clases de altura por anchura, donde cada valor de píxel corresponde a una ID de clase predicha. Esto hace que la segmentación semántica sea ideal para tareas de análisis de escenas, como la conducción autónoma, la imagenología médica y la cartografía de cobertura terrestre.
Usa task=semantic o la tarea de la CLI yolo semantic para la segmentación semántica. Los archivos de modelos de segmentación semántica de YOLO26 usan el sufijo -sem, como yolo26n-sem.pt.
Modelos#
A continuación se muestran los modelos de segmentación semántica de YOLO26 preentrenados en el conjunto de datos Cityscapes.
Los Modelos se descargan automáticamente de la última versión de Ultralytics en su primer uso.
| Modelo | tamaño (píxeles) | mIoUval | Velocidad 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 |
- Los valores de mIoUval corresponden a un único modelo y una única escala en el conjunto de validación de Cityscapes.
Reproduce conyolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Las métricas de Speed se promedian utilizando imágenes de validación de Cityscapes con una instancia RTX3090.
Reproduce conyolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 - Los valores de Params y FLOPs son para el modelo fusionado después de
model.fuse(), que combina las capas Conv y BatchNorm. Los puntos de control preentrenados conservan toda la arquitectura de entrenamiento y pueden mostrar recuentos más altos.
A continuación se muestran los modelos de segmentación semántica de YOLO26 preentrenados en el conjunto de datos ADE20K.
Los Modelos se descargan automáticamente de la última versión de Ultralytics en su primer uso.
| Modelo | tamaño (píxeles) | mIoUval | Velocidad RTX3090 PyTorch (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem-ade20k | 640 | 38.8 | 3.9 ± 0.2 | 1.6 | 4.4 |
| YOLO26s-sem-ade20k | 640 | 45.6 | 4.2 ± 0.3 | 6.5 | 17.4 |
| YOLO26m-sem-ade20k | 640 | 47.4 | 4.7 ± 0.3 | 14.3 | 59.5 |
| YOLO26l-sem-ade20k | 640 | 49.7 | 8.3 ± 0.2 | 17.9 | 75.0 |
| YOLO26x-sem-ade20k | 640 | 51.5 | 9.9 ± 0.3 | 40.2 | 168.1 |
- Los valores de mIoUval corresponden a un único modelo y una única escala en el conjunto de validación de ADE20K.
Reproduce conyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, reemplazandoyolo26n-sem-ade20k.ptcon el punto de controlyolo26*-sem-ade20k.ptdeseado. - Las métricas de Speed se promedian utilizando imágenes de validación de ADE20K con una instancia RTX3090.
Reproduce conyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, reemplazandoyolo26n-sem-ade20k.ptcon el punto de controlyolo26*-sem-ade20k.ptdeseado. - Los valores de Params y FLOPs son para el modelo fusionado después de
model.fuse(), que combina las capas Conv y BatchNorm. Los puntos de control preentrenados conservan toda la arquitectura de entrenamiento y pueden mostrar recuentos más altos.
Entrenar#
Entrena YOLO26n-sem en el conjunto de datos Cityscapes8 durante 100 epochs con un tamaño de imagen de 1024. Para ver una lista completa de los argumentos disponibles, consulta la página 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)Consulta todos los detalles del modo train en la página Train. Los modelos de segmentación semántica también se pueden entrenar con Ultralytics Platform cloud training.
Formato del conjunto de datos#
Los conjuntos de datos de segmentación semántica utilizan imágenes de máscaras de un solo canal, normalmente PNG, donde cada valor de píxel representa un ID de clase. Los píxeles con el valor 255 se tratan como "ignorar" y se excluyen del cálculo de la pérdida. El YAML del conjunto de datos debe especificar las rutas a las imágenes y sus directorios de máscaras correspondientes. Consulta la Semantic Segmentation Dataset Guide para conocer los detalles del formato. Los conjuntos de datos compatibles incluyen Cityscapes y ADE20K. Puedes gestionar y etiquetar conjuntos de datos semánticos con Ultralytics Platform annotation.
Validar#
Valida la accuracy del modelo YOLO26n-sem entrenado en un conjunto de datos de segmentación semántica. Pasa data explícitamente para que la validación utilice el YAML del conjunto de datos previsto.
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 accuracyPredecir#
Usa un modelo YOLO26n-sem entrenado para ejecutar predicciones en imágenes.
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 countConsulta todos los detalles del modo predict en la página Predict.
Resultado de la salida#
La segmentación semántica de YOLO devuelve un objeto Results por imagen. Cada resultado almacena un mapa de clases denso para toda la imagen en lugar de una lista de máscaras de objetos. Los píxeles con la misma clase predicha comparten el mismo ID de clase, incluso cuando pertenecen a objetos separados.
| Atributo | Tipo | Forma | Descripción |
|---|---|---|---|
result.semantic_mask | SemanticMask | (H,W) | Mapa de clases denso. |
result.semantic_mask.data | torch.uint8torch.int16torch.int32 | (H,W) | IDs de clase; dtype seleccionado por recuento de clases. |
result.masks | - | - | Sin máscaras de instancia. |
result.boxes | - | - | Sin cajas/confianzas de instancia. |
result.masks.xy | - | - | Sin polígonos predeterminados. |
Para ver los campos de Results específicos de cada tarea en todas ellas, consulta la sección Predict Results by Task.
La segmentación semántica predice un mapa de clases denso y luego redimensiona ese mapa al tamaño de la imagen para su visualización y uso posterior. Por lo tanto, las estructuras muy delgadas, como las marcas viales, las líneas de la pista, los postes o los cables, pueden parecer escalonadas cuando la inferencia se ejecuta a un imgsz mucho menor que la resolución de la imagen original. Si los bordes parecen dentados, vuelve a probar primero el modelo nativo de PyTorch .pt con un imgsz más grande, como 1024, 1280 o el valor práctico más cercano al tamaño de la imagen de origen. Utiliza los modelos exportados solo después de confirmar que la salida de .pt es aceptable, ya que las entradas de menor resolución no pueden recuperar detalles finos que no estaban presentes en el mapa de clases predicho.
Segmentación de instancias frente a semántica#
| Aspecto | Instance Segmentation (task="segment") | Semantic Segmentation (task="semantic") |
|---|---|---|
| Objetivo de predicción | Segmentar cada objeto detectado por separado | Asignar una ID de clase a cada píxel |
| Campo de salida | result.masks | result.semantic_mask |
| Datos principales | result.masks.data | result.semantic_mask.data |
| Forma | (N,H,W) | (H,W) |
| Valores de píxeles | Valores de máscara binaria: 0 o 1 | IDs de clase: 0, 1, 2, ... |
| Dtype | torch.uint8 | torch.uint8torch.int16torch.int32 |
| Objetos de la misma clase | Se mantienen como instancias separadas | Fusionados en la misma región de clase |
| Polígonos | Sí, a través de result.masks.xy y result.masks.xyn | No hay salida de polígono por defecto |
| Cajas y confianza | Sí, a través de result.boxes | No hay cajas ni puntuaciones de confianza por instancia |
| Uso típico | Conteo, seguimiento, recorte, medición a nivel de objeto | Etiquetado denso de escenas, área transitable, cobertura terrestre, regiones médicas |
Exportar#
Exporta un modelo YOLO26n-sem a un formato diferente como 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")Los formatos de exportación de segmentación semántica de YOLO26 disponibles se encuentran en la tabla siguiente. Puedes exportar a cualquier formato usando el argumento format, es decir, format='onnx' o format='engine'. Puedes predecir o validar directamente en modelos exportados, es decir, yolo predict model=yolo26n-sem.onnx. Se muestran ejemplos de uso para tu modelo una vez que se complete la exportación.
| Formato | Argumento de format | Modelo | Metadatos | Argumentos |
|---|---|---|---|---|
| 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 |
| TF SavedModel | saved_model | yolo26n-sem_saved_model/ | ✅ | imgsz, keras, 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 |
| 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 |
| LiteRT | litert | yolo26n-sem.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| Hailo | hailo | yolo26n-sem_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou |
| Huawei Ascend | ascend | yolo26n-sem_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms |
| Apple Core AI | coreai | yolo26n-sem.aimodel | ✅ | imgsz, batch, quantize |
Consulta todos los detalles de export en la página Export.
FAQ#
Para entrenar un modelo de segmentación semántica YOLO26 en un conjunto de datos personalizado, necesitas preparar imágenes de máscara PNG donde cada valor de píxel represente una ID de clase (0, 1, 2, ...) y los píxeles con valor 255 se ignoren durante el entrenamiento. Crea un archivo YAML de conjunto de datos que apunte a tus directorios de imágenes y máscaras, luego entrena el modelo:
Ejemplofrom 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)Consulta la página Configuration para ver más argumentos disponibles.
La segmentación de instancias y la segmentación semántica son tareas a nivel de píxel, pero difieren en un aspecto clave:
- Semantic segmentation asigna una etiqueta de clase a cada píxel, pero no distingue entre objetos individuales de la misma clase. Por ejemplo, todos los coches de una escena comparten la misma etiqueta de clase.
- Instance segmentation identifica cada objeto individual por separado, produciendo máscaras distintas para cada objeto, incluso si pertenecen a la misma clase.
La segmentación semántica es la más adecuada para tareas de comprensión de escenas como la conducción autónoma y la cartografía de cobertura terrestre, mientras que la segmentación de instancias se prefiere cuando importa el conteo o el seguimiento de objetos individuales.
Sí. Si tu conjunto de datos utiliza etiquetas de polígonos de Ultralytics YOLO (un
.txtpor imagen), omitemasks_dirdel YAML del conjunto de datos y asegúrate de que no exista ninguna carpetamasks/junto a tus imágenes en la raíz del conjunto de datos (su sola presencia activa el modo de máscara PNG incluso sin quemasks_diresté configurado). El cargador convierte entonces los polígonos en máscaras semánticas por imagen sobre la marcha. Para conjuntos de datos multiclase (N > 1), se añade automáticamente una clase adicionalbackgroundanames. Para conjuntos de datos de una sola clase (N == 1), el entrenamiento se mantiene en 1 clase: tu clase declarada se convierte en1en la máscara y los píxeles no cubiertos se convierten en0. Consulta la Semantic Segmentation Dataset Guide para obtener más detalles.Ultralytics YOLO26 proporciona configuraciones integradas para varios conjuntos de datos de segmentación semántica:
- Cityscapes: Escenas callejeras urbanas con 19 clases, ampliamente utilizadas para la investigación de conducción autónoma.
- ADE20K: Un conjunto de datos de análisis de escenas a gran escala con 150 clases.
También puedes utilizar cualquier conjunto de datos personalizado que proporcione anotaciones de máscara PNG donde los valores de píxel correspondan a las IDs de clase.
Valida un modelo de segmentación semántica YOLO26 preentrenado con el YAML del conjunto de datos utilizado para la evaluación:
Ejemplofrom 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)Estos pasos te proporcionarán métricas de validación como la intersección sobre unión media (mIoU) y la precisión de píxeles, que son medidas estándar para evaluar el rendimiento de la segmentación semántica.
Exporta un modelo de segmentación semántica YOLO26 al formato ONNX con comandos de Python o CLI:
Ejemplofrom ultralytics import YOLO # Load a pretrained model model = YOLO("yolo26n-sem.pt") # Export the model to ONNX format model.export(format="onnx")Para obtener más detalles sobre la exportación a varios formatos, consulta la página Export.