Segmentación de instancias
La segmentación de instancias va un paso más allá de la detección de objetos e implica identificar objetos individuales en una imagen y segmentarlos del resto de la imagen.
El resultado de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delinean cada objeto en la imagen, junto con etiquetas de clase y puntuaciones de confianza para cada uno. La segmentación de instancias es útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta.
Watch: Run Segmentation with Pretrained Ultralytics YOLO Model in Python.
Los modelos de segmentación de YOLO26 utilizan el sufijo -seg, es decir, yolo26n-seg.pt, y están preentrenados en COCO.
Modelos
Aquí se muestran los modelos de segmentación preentrenados de YOLO26. Los modelos de detección, segmentación y pose están preentrenados en el conjunto de datos COCO, mientras que los modelos de clasificación están preentrenados en el conjunto de datos ImageNet.
Los modelos se descargan automáticamente desde la última versión de Ultralytics en su primer uso.
| Modelo | tamaño (píxeles) | mAPbox 50-95(e2e) | mAPmask 50-95(e2e) | Velocidad CPU ONNX (ms) | Velocidad T4 TensorRT10 (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n-seg | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.1 |
| YOLO26s-seg | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.2 |
| YOLO26m-seg | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.5 |
| YOLO26l-seg | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 139.8 |
| YOLO26x-seg | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 313.5 |
- Los valores de mAPval son para un solo modelo a una sola escala en el conjunto de datos COCO val2017.
Reproduce esto medianteyolo val segment data=coco.yaml device=0 - La velocidad se promedió sobre imágenes de validación de COCO utilizando una instancia Amazon EC2 P4d.
Reproduce esto medianteyolo val segment data=coco.yaml batch=1 device=0|cpu - Los valores de Params y FLOPs corresponden al modelo fusionado tras
model.fuse(), que combina las capas Conv y BatchNorm y, para los modelos de extremo a extremo (end2end), elimina la cabeza de detección auxiliar de uno a muchos. Los puntos de control preentrenados conservan la arquitectura de entrenamiento completa y pueden mostrar recuentos más elevados.
Entrenar (Train)
Entrena YOLO26n-seg en el conjunto de datos COCO8-seg durante 100 épocas con un tamaño de imagen de 640. Para obtener una lista completa de los argumentos disponibles, consulta la página de Configuración.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-seg.yaml") # build a new model from YAML
model = YOLO("yolo26n-seg.pt") # load a pretrained model (recommended for training)
model = YOLO("yolo26n-seg.yaml").load("yolo26n-seg.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)Consulta los detalles completos del modo train en la página de Entrenamiento. Los modelos de segmentación también pueden entrenarse en GPUs en la nube a través de Ultralytics Platform.
Formato del conjunto de datos
El formato del conjunto de datos de segmentación de YOLO se puede encontrar en detalle en la Guía de conjuntos de datos. Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta JSON2YOLO de Ultralytics. También puedes crear máscaras de segmentación en Ultralytics Platform usando herramientas de polígonos y anotación inteligente impulsada por SAM.
Validar (Val)
Validate trained YOLO26n-seg model accuracy on the COCO8-seg dataset. No arguments are needed as the model retains its training data and arguments as model attributes.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-seg.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
metrics = model.val() # no arguments needed, dataset and settings remembered
metrics.box.map # map50-95(B)
metrics.box.map50 # map50(B)
metrics.box.map75 # map75(B)
metrics.box.maps # a list containing mAP50-95(B) for each category
metrics.box.image_metrics # per-image metrics dictionary for det with precision, recall, F1, TP, FP, and FN
metrics.seg.map # map50-95(M)
metrics.seg.map50 # map50(M)
metrics.seg.map75 # map75(M)
metrics.seg.maps # a list containing mAP50-95(M) for each category
metrics.seg.image_metrics # per-image metrics dictionary for seg with precision, recall, F1, TP, FP, and FNPredecir
Utiliza un modelo entrenado YOLO26n-seg para ejecutar predicciones en imágenes.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-seg.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:
xy = result.masks.xy # mask in polygon format
xyn = result.masks.xyn # normalized
masks = result.masks.data # mask in matrix format (num_objects x H x W)Consulta los detalles completos del modo predict en la página Predict.
Exportar (Export)
Exporta un modelo YOLO26n-seg a un formato diferente como ONNX, CoreML, etc.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-seg.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom-trained model
# Export the model
model.export(format="onnx")Los formatos de exportación disponibles para YOLO26-seg se encuentran en la siguiente tabla. 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-seg.onnx. Los ejemplos de uso se muestran para tu modelo una vez que se completa la exportación.
| Formato | Argumento format | Modelo | Metadatos | Argumentos |
|---|---|---|---|---|
| PyTorch | - | yolo26n-seg.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-seg.torchscript | ✅ | imgsz, half, dynamic, optimize, nms, batch, device |
| ONNX | onnx | yolo26n-seg.onnx | ✅ | imgsz, half, dynamic, simplify, opset, nms, batch, device |
| OpenVINO | openvino | yolo26n-seg_openvino_model/ | ✅ | imgsz, half, dynamic, int8, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-seg.engine | ✅ | imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-seg.mlpackage | ✅ | imgsz, dynamic, half, int8, nms, batch, device |
| TF SavedModel | saved_model | yolo26n-seg_saved_model/ | ✅ | imgsz, keras, int8, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-seg.pb | ❌ | imgsz, batch, device |
| TF Lite | tflite | yolo26n-seg.tflite | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| TF Edge TPU | edgetpu | yolo26n-seg_edgetpu.tflite | ✅ | imgsz, int8, data, fraction, device |
| TF.js | tfjs | yolo26n-seg_web_model/ | ✅ | imgsz, half, int8, nms, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-seg_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-seg.mnn | ✅ | imgsz, batch, int8, half, device |
| NCNN | ncnn | yolo26n-seg_ncnn_model/ | ✅ | imgsz, half, batch, device |
| IMX500 | imx | yolo26n-seg_imx_model/ | ✅ | imgsz, int8, data, fraction, nms, device |
| RKNN | rknn | yolo26n-seg_rknn_model/ | ✅ | imgsz, batch, name, device |
| ExecuTorch | executorch | yolo26n-seg_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-seg_axelera_model/ | ✅ | imgsz, batch, int8, data, fraction, device |
| DeepX | deepx | yolo26n-seg_deepx_model/ | ✅ | imgsz, int8, data, optimize, device |
Consulta todos los detalles de export en la página Export.
Preguntas frecuentes
¿Cómo entreno un modelo de segmentación YOLO26 en un conjunto de datos personalizado?
Para entrenar un modelo de segmentación YOLO26 en un conjunto de datos personalizado, primero debes preparar tu conjunto de datos en el formato de segmentación YOLO. Puedes utilizar herramientas como JSON2YOLO para convertir conjuntos de datos desde otros formatos. Una vez que tu conjunto de datos esté listo, puedes entrenar el modelo utilizando Python o comandos de CLI:
from ultralytics import YOLO
# Load a pretrained YOLO26 segment model
model = YOLO("yolo26n-seg.pt")
# Train the model
results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)Consulta la página de Configuración para ver más argumentos disponibles.
¿Cuál es la diferencia entre la detección de objetos y la segmentación de instancias en YOLO26?
La detección de objetos identifica y localiza objetos dentro de una imagen dibujando cajas delimitadoras a su alrededor, mientras que la segmentación de instancias no solo identifica las cajas delimitadoras, sino que también delinea la forma exacta de cada objeto. Los modelos de segmentación de instancias de YOLO26 proporcionan máscaras o contornos que perfilan cada objeto detectado, lo cual es particularmente útil para tareas donde es importante conocer la forma precisa de los objetos, como en imágenes médicas o conducción autónoma.
¿Por qué usar YOLO26 para la segmentación de instancias?
Ultralytics YOLO26 es un modelo de última generación reconocido por su alta precisión y rendimiento en tiempo real, lo que lo hace ideal para tareas de segmentación de instancias. Los modelos de segmentación YOLO26 vienen preentrenados en el conjunto de datos COCO, lo que garantiza un rendimiento robusto en una variedad de objetos. Además, YOLO admite funcionalidades de entrenamiento, validación, predicción y exportación con una integración perfecta, lo que lo hace altamente versátil tanto para investigación como para aplicaciones industriales.
¿Cómo cargo y valido un modelo de segmentación YOLO preentrenado?
Cargar y validar un modelo de segmentación YOLO preentrenado es sencillo. Aquí te mostramos cómo hacerlo utilizando tanto Python como CLI:
from ultralytics import YOLO
# Load a pretrained model
model = YOLO("yolo26n-seg.pt")
# Validate the model
metrics = model.val()
print("Mean Average Precision for boxes:", metrics.box.map)
print("Mean Average Precision for masks:", metrics.seg.map)Estos pasos te proporcionarán métricas de validación como Mean Average Precision (mAP), crucial para evaluar el rendimiento del modelo.
¿Cómo puedo exportar un modelo de segmentación YOLO al formato ONNX?
Exportar un modelo de segmentación YOLO al formato ONNX es simple y se puede hacer utilizando Python o comandos de CLI:
from ultralytics import YOLO
# Load a pretrained model
model = YOLO("yolo26n-seg.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 de Exportación.