Segmentação de Instância

A segmentação de instâncias vai um passo além da detecção de objetos e envolve a identificação de objetos individuais em uma imagem e sua segmentação do restante da imagem.
O resultado 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 é sua forma exata.
Assista: Execute Segmentação com Modelo YOLO Ultralytics Pré-treinado em Python.
Dica
Os modelos YOLO26 Segment usam o -seg sufixo, ou seja, yolo26n-seg.pt, e são pré-treinados em COCO.
Modelos
Os modelos YOLO26 Segment pré-treinados são mostrados aqui. Os modelos detect, Segment e Pose são pré-treinados no conjunto de dados COCO, enquanto os modelos classify são pré-treinados no conjunto de dados ImageNet.
Os Modelos são baixados automaticamente da versão mais recente do Ultralytics no primeiro uso.
| Modelo | tamanho (pixels) | mAPbox 50-95(e2e) | mAPmask 50-95(e2e) | Velocidade CPU ONNX (ms) | Velocidade T4 TensorRT10 (ms) | parâmetros (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 |
- mAPval Os valores são para modelo único, em escala única, em COCO val2017 dataset.
Reproduzir poryolo val segment data=coco.yaml device=0 - Velocidade com média sobre imagens COCO val usando um Amazon EC2 P4d instância.
Reproduzir poryolo val segment data=coco.yaml batch=1 device=0|cpu
Treinar
Treine YOLO26n-seg no conjunto de dados COCO8-seg por 100 épocas com tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, consulte a página de Configuração.
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.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.yaml epochs=100 imgsz=640
# Start training from a pretrained *.pt model
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
# Build a new model from YAML, transfer pretrained weights to it and start training
yolo segment train data=coco8-seg.yaml model=yolo26n-seg.yaml pretrained=yolo26n-seg.pt epochs=100 imgsz=640
Formato do conjunto de dados
O formato do conjunto de dados de segmentação YOLO pode ser encontrado em detalhes no Guia do Conjunto de Dados. Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, use a ferramenta JSON2YOLO da Ultralytics.
Validar
Valide o modelo YOLO26n-seg treinado precisão no dataset COCO8-seg. Não são necessários argumentos, pois o model mantém seu treinamento data e argumentos 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.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
yolo segment val model=yolo26n-seg.pt # val official model
yolo segment val model=path/to/best.pt # val custom model
Prever
Use um modelo YOLO26n-seg treinado para executar prediçõ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 in polygon format
xyn = result.masks.xyn # normalized
masks = result.masks.data # mask in matrix format (num_objects x H x W)
yolo segment predict model=yolo26n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
Veja todos os detalhes do modo predict na Prever página.
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")
yolo export model=yolo26n-seg.pt format=onnx # export official model
yolo export model=path/to/best.pt format=onnx # export custom-trained model
Os formatos de exportação YOLO26-seg disponíveis estão na tabela abaixo. Você pode exportar para qualquer formato usando o format argumento, ou seja, format='onnx' ou format='engine'. É possível prever ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-seg.onnxExemplos de uso são mostrados para seu modelo após a conclusão da exportação.
| Formato | format Argumento | Modelo | Metadados | 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, 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, device |
| TF.js | tfjs | yolo26n-seg_web_model/ | ✅ | imgsz, half, int8, nms, batch, 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, device |
| RKNN | rknn | yolo26n-seg_rknn_model/ | ✅ | imgsz, batch, name, device |
| ExecuTorch | executorch | yolo26n-seg_executorch_model/ | ✅ | imgsz, device |
| Axelera | axelera | yolo26n-seg_axelera_model/ | ✅ | imgsz, int8, data, fraction, device |
Veja todos os detalhes do modo export detalhes em Exportar página.
FAQ
Como eu treino um modelo de segmentação YOLO26 em um conjunto de dados personalizado?
Para treinar um modelo de segmentação YOLO26 em um conjunto de dados personalizado, você primeiro precisa preparar seu conjunto de dados no formato de segmentação YOLO. Você pode usar ferramentas como JSON2YOLO para converter conjuntos de dados de outros formatos. Uma vez que seu conjunto de dados esteja pronto, você pode treinar o modelo usando comandos python ou 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)
yolo segment train data=path/to/your_dataset.yaml model=yolo26n-seg.pt epochs=100 imgsz=640
Verifique a página de Configuração para obter mais argumentos disponíveis.
Qual é a diferença entre detecção de objetos e segmentação de instâncias no YOLO26?
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 delineia 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 imagens médicas ou direção autônoma.
Por que usar YOLO26 para segmentação de instâncias?
Ultralytics YOLO26 é um modelo de ponta reconhecido por 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 em uma variedade de objetos. Além disso, o YOLO suporta funcionalidades de treinamento, validação, predição e exportação com integração perfeita, tornando-o altamente versátil para aplicações de pesquisa e indústria.
Como faço para carregar e validar um modelo de segmentação YOLO pré-treinado?
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)
yolo segment val model=yolo26n-seg.pt
Essas etapas fornecerão métricas de validação como Precisão Média Média (mAP), cruciais para avaliar o desempenho do modelo.
Como posso exportar um modelo de segmentação YOLO para o formato ONNX?
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")
yolo export model=yolo26n-seg.pt format=onnx
Para obter mais detalhes sobre como exportar para vários formatos, consulte a página de Exportação.