Segmentación de instancias con Ultralytics YOLO#

La segmentación de instancias va un paso más allá que la detección de objetos: consiste en identificar los objetos individuales de una imagen y separarlos del resto.

El resultado de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delimitan cada objeto de la imagen, junto con las etiquetas de clase y las puntuaciones de confianza de cada objeto. La segmentación de instancias resulta útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta.

Modelos#

A continuación se muestran los modelos YOLO26 Segment preentrenados con el conjunto de datos COCO.

Los modelos se descargan automáticamente desde la versión más reciente de Ultralytics al usarlos por primera vez.

• Los valores de mAP^val corresponden a un único modelo y una única escala en el conjunto de datos COCO val2017.
  Reprodúcelos con yolo segment val data=coco.yaml device=0 nms=False
• La velocidad es el promedio calculado con imágenes de COCO val usando ONNX en CPU y TensorRT10 en una GPU NVIDIA T4.
  Reprodúcela con yolo segment val data=coco.yaml batch=1 device=0|cpu nms=False
• Los valores de Params y FLOPs corresponden a modelos fusionados tras plegar Conv/BatchNorm y eliminar la rama de detección no utilizada. Los checkpoints preentrenados conservan toda la arquitectura de entrenamiento y pueden mostrar valores más altos.

Estos puntos de control segmentan las 80 clases de COCO. Para segmentar categorías que no estén en esa lista sin volver a entrenar, consulta YOLOE, que recibe las clases como una indicación de texto, un ejemplo visual o un vocabulario integrado.

Consulta la vista previa no publicada de YOLO27 para ver resultados preliminares de cajas y máscaras en COCO.

Entrenar#

Entrena YOLO26n-seg con el conjunto de datos COCO8-seg durante 100 épocas con un tamaño de imagen de 640. Consulta la página de Configuración para ver la lista completa de argumentos disponibles.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-seg.yaml")  # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n-seg.pt")  # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n-seg.yaml").load("yolo26n-seg.pt")  # Crea el modelo a partir de YAML y transfiere los pesos

# Entrenar el modelo
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

Consulta la página Entrenamiento para ver todos los detalles del modo train. También puedes entrenar modelos de segmentación con el entrenamiento en la nube de Ultralytics Platform.

Formato del conjunto de datos#

Encontrarás información detallada sobre el formato de los conjuntos de datos de segmentación YOLO en la Guía de conjuntos de datos. Para convertir un conjunto de datos COCO JSON existente al formato YOLO, usa la función integrada convert_coco con use_segments=True, tal como se explica en la guía de conversión de COCO a YOLO. También puedes crear máscaras de segmentación con la anotación de Ultralytics Platform mediante herramientas de polígonos y anotación inteligente con tecnología SAM.

Validar#

Valida la precisión del modelo YOLO26n-seg entrenado. No hacen falta argumentos, ya que model conserva data y los argumentos de entrenamiento como atributos del modelo: path/to/best.pt del ejemplo de Entrenamiento valida con COCO8-seg. Los pesos oficiales registran una ruta al conjunto de datos de entrenamiento que no existe en tu equipo, así que, tras mostrar un aviso, usan el valor predeterminado de la tarea coco8-seg.yaml. Pasa data para validar con otro conjunto de datos.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-seg.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Valida el modelo
metrics = model.val()  # no hacen falta argumentos; se recuerdan el conjunto de datos y los ajustes
metrics.box.map  # map50-95(B)
metrics.box.map50  # map50(B)
metrics.box.map75  # map75(B)
metrics.box.maps  # una lista que contiene mAP50-95(B) para cada categoría
metrics.box.image_metrics  # diccionario de métricas por imagen para det, con precisión, exhaustividad, F1, TP, FP y FN
metrics.seg.map  # map50-95(M)
metrics.seg.map50  # map50(M)
metrics.seg.map75  # map75(M)
metrics.seg.maps  # una lista que contiene mAP50-95(M) para cada categoría
metrics.seg.image_metrics  # diccionario de métricas por imagen para seg, con precisión, exhaustividad, F1, TP, FP y FN

Predecir#

Usa un modelo YOLO26n-seg entrenado para hacer predicciones sobre imágenes.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-seg.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Haz predicciones con el modelo
results = model("https://ultralytics.com/images/bus.jpg")  # haz una predicción sobre una imagen

# Accede a los resultados
for result in results:
    xy = result.masks.xy  # polígonos de máscaras en coordenadas de píxeles
    xyn = result.masks.xyn  # polígonos de máscaras normalizados
    masks = result.masks.data  # máscaras binarias, forma (N,H,W), tipo de datos torch.uint8

Consulta todos los detalles del modo predict en la página de predicción.

Resultados de salida#

La segmentación de instancias de YOLO devuelve un objeto Results por imagen. Cada resultado almacena predicciones por objeto: cada instancia detectada tiene su propia máscara binaria, clase, confianza y caja.

Para consultar los campos Results específicos de cada tarea, visita la sección resultados de predicción por tarea.

Segmentación de instancias frente a segmentación semántica#

La segmentación de instancias se realiza a nivel de objeto: dos coches generan dos máscaras, dos cajas y dos puntuaciones de confianza. La segmentación semántica clasifica a nivel de píxel: esos mismos coches pasan a ser píxeles con el mismo ID de clase en un mapa de clases del tamaño de la imagen, sin cajas ni puntuaciones de confianza por objeto, ni una lista de polígonos predeterminada. Consulta la comparación campo por campo en la página de segmentación semántica.

Exportar#

Exporta un modelo YOLO26n-seg a otro formato, como ONNX, CoreML, etc.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-seg.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Exporta el modelo
model.export(format="onnx")

Los formatos de exportación disponibles para YOLO26-seg aparecen en la tabla siguiente. Puedes exportar a cualquier formato con el argumento format, es decir, format='onnx' o format='engine'. También puedes hacer predicciones o validar directamente con modelos exportados, por ejemplo, yolo predict model=yolo26n-seg.onnx. Cuando termine la exportación, se mostrarán ejemplos de uso de tu modelo.

nms=None usa de forma predeterminada salidas sin procesar para NMS externa. Establece nms=False para seleccionar una cabeza sin NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden integrar NMS con nms=True.

Consulta todos los detalles de export en la página Exportar.

Preguntas frecuentes#