YOLO Vision 2026:

Segmentação de instâncias com Ultralytics YOLO#

Ultralytics YOLO instance segmentation examples

A segmentação de instâncias vai um passo além da deteção de objetos e envolve a identificação de objetos individuais numa imagem e a sua segmentação do resto da imagem.

A saída de um modelo de segmentação de instâncias é um conjunto de máscaras ou contornos que delineiam cada objeto na imagem, juntamente com rótulos de classe e pontuações de confiança para cada objeto. A segmentação de instâncias é útil quando você precisa saber não apenas onde os objetos estão em uma imagem, mas também qual é a sua forma exata.



Watch: Run Segmentation with Pretrained Ultralytics YOLO Model in Python.
Dica

Os modelos YOLO26 Segment usam o sufixo -seg, ou seja, yolo26n-seg.pt, e são pré-treinados no COCO.

Modelos#

Os modelos Segment pré-treinados do YOLO26 são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados COCO, os modelos Semantic são pré-treinados no Cityscapes, e os modelos Classify são pré-treinados no conjunto de dados ImageNet.

Os Modelos são baixados automaticamente do lançamento mais recente do Ultralytics no primeiro uso.

Modelotamanho
(pixels)
mAPbox
50-95(e2e)
mAPmask
50-95(e2e)
Velocidade
CPU ONNX
(ms)
Velocidade
T4 TensorRT10
(ms)
params
(M)
FLOPs
(B)
YOLO26n-seg64039.633.953.3 ± 0.52.1 ± 0.02.79.1
YOLO26s-seg64047.340.0118.4 ± 0.93.3 ± 0.010.434.2
YOLO26m-seg64052.544.1328.2 ± 2.46.7 ± 0.123.6121.5
YOLO26l-seg64054.445.5387.0 ± 3.78.0 ± 0.128.0139.8
YOLO26x-seg64056.547.0787.0 ± 6.816.4 ± 0.162.8313.5
  • Os valores de mAPval são para modelo único e escala única no conjunto de dados COCO val2017.
    Reproduza com yolo val segment data=coco.yaml device=0
  • Speed calculada como média nas imagens de validação do COCO usando uma instância Amazon EC2 P4d.
    Reproduza com yolo val segment data=coco.yaml batch=1 device=0|cpu
  • Os valores de Params e FLOPs são para o modelo fundido após model.fuse(), que mescla as camadas Conv e BatchNorm e, para modelos end2end, remove o cabeçote de detecção auxiliar de um para muitos. Os checkpoints pré-treinados retêm a arquitetura de treinamento completa e podem apresentar contagens maiores.

Estes checkpoints segmentam as 80 classes do COCO. Para segmentar categorias fora dessa lista sem retreinar, consulta o YOLOE, que recebe as classes como um prompt de texto, um exemplo visual ou um vocabulário integrado.

Treinar#

Treina o YOLO26n-seg no conjunto de dados COCO8-seg durante 100 épocas com o tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, consulta a página Configuration.

Exemplo
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)

Vê os detalhes completos do modo train na página Train. Os modelos de segmentação também podem ser treinados com o treino em nuvem da Ultralytics Platform.

Formato do conjunto de dados#

O formato do conjunto de dados de segmentação YOLO pode ser encontrado em detalhe no Guia de Conjuntos de Dados. Para converter o teu conjunto de dados existente de outros formatos (como COCO, etc.) para o formato YOLO, usa a ferramenta JSON2YOLO da Ultralytics. Também podes criar máscaras de segmentação com a anotação da Ultralytics Platform usando ferramentas de polígonos e anotação inteligente potenciada por SAM.

Validar#

Valida a precisão do modelo YOLO26n-seg treinado no conjunto de dados COCO8-seg. Não são necessários argumentos, pois o model retém o seu data e argumentos de treino como atributos do modelo.

Exemplo
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 FN

Prever#

Use um modelo YOLO26n-seg treinado para executar previsões em imagens.

Exemplo
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 polygons in pixel coordinates
    xyn = result.masks.xyn  # normalized mask polygons
    masks = result.masks.data  # binary masks, shape (N,H,W), dtype torch.uint8

Consulta todos os detalhes do modo predict na página Prever.

Saída de Resultados#

A segmentação de instâncias YOLO devolve um objeto Results por imagem. Cada resultado armazena previsões ao nível do objeto, onde cada instância detetada tem a sua própria máscara binária, classe, confiança e caixa.

AtributoTipoFormaDescrição
result.masksMasks(N)Máscaras de instância.
result.masks.datatorch.uint8(N,H,W)Máscaras binárias, valores 0 ou 1.
result.masks.xynp.float32list[(P,2)]Polígonos de pixels.
result.masks.xynnp.float32list[(P,2)]Polígonos normalizados.
result.boxesBoxes(N)Caixas/classes/confianças de instância.
result.boxes.clstorch.float32(N,)IDs de classe; convertidos para int para nomes.

Para campos de Results específicos de tarefas em cada tarefa, consulta a seção Resultados de Previsão por Tarefa.

Como isso difere da segmentação semântica#

A segmentação de instâncias é uma segmentação ao nível do objeto: dois carros produzem duas máscaras, duas caixas e duas pontuações de confiança. A segmentação semântica é uma classificação ao nível do píxel: esses mesmos carros tornam-se píxeis com o mesmo ID de classe num mapa de classes com o tamanho da imagem, sem caixas por objeto, confianças ou lista de polígonos predefinida.

Exportar#

Exporte um modelo YOLO26n-seg para um formato diferente como ONNX, CoreML, etc.

Exemplo
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")

Os formatos de exportação YOLO26-seg disponíveis encontram-se na tabela abaixo. Podes exportar para qualquer formato utilizando o argumento format, ou seja, format='onnx' ou format='engine'. Podes prever ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-seg.onnx. Os exemplos de utilização são mostrados para o teu modelo após a conclusão da exportação.

Nota

Os pipelines NMS incorporados do CoreML (nms=True) apenas suportam modelos de deteção de objetos. As exportações de segmentação para o CoreML emitem um aviso e forçam nms=False, produzindo um modelo em bruto sem NMS.

FormatoArgumento formatModeloMetadadosArgumentos
PyTorch-yolo26n-seg.pt-
TorchScripttorchscriptyolo26n-seg.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-seg.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-seg_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-seg.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-seg.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n-seg_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-seg.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-seg_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n-seg_paddle_model/imgsz, batch, device
MNNmnnyolo26n-seg.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-seg_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n-seg_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-seg_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-seg_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n-seg_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-seg_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-seg_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n-seg.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n-seg_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n-seg_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms
Apple Core AIcoreaiyolo26n-seg.aimodelimgsz, batch, quantize

Consulta todos os detalhes de export na página Exportar.

FAQ#

  • Para treinar um modelo de segmentação YOLO26 num conjunto de dados personalizado, precisas primeiro de preparar o teu conjunto de dados no formato de segmentação YOLO. Podes usar ferramentas como o JSON2YOLO para converter conjuntos de dados de outros formatos. Assim que o teu conjunto de dados estiver pronto, podes treinar o modelo utilizando Python ou comandos da CLI:

    Exemplo
    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 a página de Configuração para ver mais argumentos disponíveis.

  • A detecção de objetos identifica e localiza objetos dentro de uma imagem desenhando caixas delimitadoras ao redor deles, enquanto a segmentação de instâncias não apenas identifica as caixas delimitadoras, mas também descreve a forma exata de cada objeto. Os modelos de segmentação de instâncias YOLO26 fornecem máscaras ou contornos que delineiam cada objeto detectado, o que é particularmente útil para tarefas onde conhecer a forma precisa dos objetos é importante, como em imagens médicas ou condução autônoma.

  • O Ultralytics YOLO26 é um modelo de última geração reconhecido pela sua alta precisão e desempenho em tempo real, tornando-o ideal para tarefas de segmentação de instâncias. Os modelos YOLO26 Segment vêm pré-treinados no conjunto de dados COCO, garantindo um desempenho robusto numa variedade de objetos. Além disso, o YOLO suporta funcionalidades de treino, validação, previsão e exportação com integração perfeita, tornando-o altamente versátil tanto para aplicações de investigação como industriais.

  • Carregar e validar um modelo de segmentação YOLO pré-treinado é simples. Veja como você pode fazer isso usando Python e CLI:

    Exemplo
    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)

    Estes passos fornecer-te-ão métricas de validação como a Mean Average Precision (mAP), cruciais para avaliar o desempenho do modelo.

  • Exportar um modelo de segmentação YOLO para o formato ONNX é simples e pode ser feito usando comandos Python ou CLI:

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

    Para obter mais detalhes sobre a exportação para vários formatos, consulta a página Exportar.

Comentários