Estimativa de pose com Ultralytics YOLO#
A estimativa de pose é uma tarefa que envolve identificar a localização de pontos específicos numa imagem, normalmente chamados de pontos-chave. Os pontos-chave podem representar várias partes do objeto, como articulações, marcos ou outras características distintas. As localizações dos pontos-chave são normalmente representadas como um conjunto de coordenadas 2D [x, y], opcionalmente com um sinalizador de visibilidade [x, y, visible].
A saída de um modelo de estimativa de pose é um conjunto de pontos que representam os pontos-chave de um objeto na imagem, normalmente acompanhado pelas pontuações de confiança de cada ponto. A estimativa de pose é uma boa escolha quando precisas de identificar partes específicas de um objeto numa cena e a respetiva localização em relação umas às outras.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
Os modelos pose do YOLO26 usam o sufixo -pose, ou seja, yolo26n-pose.pt. Estes modelos são treinados no conjunto de dados de pontos-chave COCO e são adequados para várias tarefas de estimativa de pose.
No modelo de pose YOLO26 predefinido, existem 17 pontos-chave, cada um representando uma parte diferente do corpo humano. Eis o mapeamento de cada índice para a respetiva articulação corporal:
- Nariz
- Olho esquerdo
- Olho direito
- Orelha esquerda
- Orelha direita
- Ombro esquerdo
- Ombro direito
- Cotovelo esquerdo
- Cotovelo direito
- Pulso esquerdo
- Pulso direito
- Anca esquerda
- Anca direita
- Joelho esquerdo
- Joelho direito
- Tornozelo esquerdo
- Tornozelo direito
Modelos#
Os modelos de pose pré-treinados do Ultralytics YOLO26 são apresentados 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 descarregados automaticamente da versão mais recente da Ultralytics na primeira utilização.
| Modelo | tamanho (píxeis) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocidade CPU ONNX (ms) | Velocidade T4 TensorRT10 (ms) | parâmetros (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n-pose | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.6 |
| YOLO26s-pose | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 24.1 |
| YOLO26m-pose | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.3 |
| YOLO26l-pose | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.7 |
| YOLO26x-pose | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 202.3 |
- Os valores de mAPval correspondem a um único modelo e a uma única escala no conjunto de dados COCO Keypoints val2017.
Reproduz comyolo val pose data=coco-pose.yaml device=0 nms=False - A velocidade é calculada como a média das imagens COCO val utilizando uma instância Amazon EC2 P4d.
Reproduza comyolo val pose data=coco-pose.yaml batch=1 device=0|cpu nms=False - Os valores de Params e FLOPs são para modelos fundidos após a dobragem de Conv/BatchNorm e a remoção da ramificação de deteção não utilizada. Os pontos de controlo pré-treinados retêm a arquitetura de treino completa e podem apresentar contagens mais elevadas.
Vê a pré-visualização não lançada do YOLO27 para resultados preliminares de pontos-chave COCO.
Treinar#
Treina um modelo YOLO26-pose no conjunto de dados COCO8-pose. O conjunto de dados COCO8-pose é um pequeno conjunto de dados de exemplo, perfeito para testar e depurar os teus modelos de estimativa de pose.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-pose.yaml") # build a new model from YAML
model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training)
model = YOLO("yolo26n-pose.yaml").load("yolo26n-pose.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)Consulta todos os detalhes do modo train na página Train. Também podes treinar modelos de pose com o treino na nuvem da Ultralytics Platform.
Formato do dataset#
O formato do conjunto de dados de pose YOLO pode ser encontrado em detalhe no Dataset Guide. Para converter um conjunto de dados JSON do COCO keypoints existente para o formato YOLO, usa a função convert_coco integrada com use_keypoints=True, conforme descrito no COCO to YOLO guide. A Ultralytics Platform annotation também suporta rótulos de pose com modelos de esqueleto integrados para pessoa, mão, rosto e layouts de pontos-chave personalizados.
Para tarefas personalizadas de estimativa de pose, também podes explorar conjuntos de dados especializados, como Tiger-Pose para estimativa de pose animal, Hand Keypoints para rastreamento de mãos ou Dog-Pose para análise de pose canina.
Validação#
Valida a precisão do modelo YOLO26n-pose treinado no conjunto de dados COCO8-pose. Não são necessários argumentos, pois model mantém os seus data de treino e os argumentos como atributos do modelo.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-pose.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
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # a list containing mAP50-95 for each category
metrics.box.image_metrics # per-image metrics dictionary for box with precision, recall, F1, TP, FP, and FN
metrics.pose.map # map50-95(P)
metrics.pose.map50 # map50(P)
metrics.pose.map75 # map75(P)
metrics.pose.maps # a list containing mAP50-95(P) for each category
metrics.pose.image_metrics # per-image metrics dictionary for pose with precision, recall, F1, TP, FP, and FNPrevisão#
Utiliza um modelo YOLO26n-pose treinado para executar previsões em imagens. O modo predict permite fazer inferência em imagens, vídeos ou fluxos em tempo real.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-pose.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.keypoints.xy # x and y coordinates
xyn = result.keypoints.xyn # normalized
kpts = result.keypoints.data # x, y, visibility (if available)Consulta todos os detalhes do modo predict na página Predict.
Saída dos resultados#
A estimativa de pose devolve um objeto Results por imagem. Os principais campos de previsão são result.keypoints para as coordenadas de pose e result.boxes para as instâncias detetadas às quais esses pontos-chave pertencem.
| Atributo | Tipo | Forma | Descrição |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Pontos-chave. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y além de visibilidade/confiança opcional. |
result.keypoints.xy | torch.float32 | (N,K,2) | Pontos-chave de pixels. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Pontos-chave normalizados. |
result.boxes | Boxes | (N) | Caixas de instância. |
Para consultar os campos Results específicos da tarefa em todas as tarefas, vê a secção Resultados de Previsão por Tarefa.
Exportação#
Exporta um modelo YOLO26n Pose para um formato diferente, como ONNX, CoreML, entre outros. Isto permite implementar o teu modelo em várias plataformas e dispositivos para inferência em tempo real.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n-pose.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-pose disponíveis encontram-se na tabela abaixo. Podes exportar para qualquer formato utilizando o argumento format, ou seja, format='onnx' ou format='engine'. Podes fazer previsões ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-pose.onnx. Os exemplos de utilização são apresentados para o teu modelo após a conclusão da exportação.
| Formato | Argumento format | Modelo | Metadados | Argumentos |
|---|---|---|---|---|
| PyTorch | - | yolo26n-pose.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-pose.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n-pose.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n-pose_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-pose.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-pose.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| TF SavedModel | saved_model | yolo26n-pose_saved_model/ | ✅ | imgsz, keras, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-pose.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n-pose_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-pose_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-pose.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n-pose_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n-pose_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n-pose_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n-pose_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-pose_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n-pose_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n-pose_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| LiteRT | litert | yolo26n-pose.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| Hailo | hailo | yolo26n-pose_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou |
| Huawei Ascend | ascend | yolo26n-pose_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms |
| Apple Core AI | coreai | yolo26n-pose.aimodel | ✅ | imgsz, batch, quantize |
nms=None por padrão utiliza saídas brutas para NMS externo. Define nms=False para selecionar uma cabeça livre de NMS disponível; os formatos não suportados recorrem ao seu caminho de saída nativo. As entradas nms acima identificam formatos que podem incorporar NMS com nms=True.
Consulta todos os detalhes de export na página Export.
Perguntas frequentes#
A estimativa de pose com o Ultralytics YOLO26 envolve a identificação de pontos específicos numa imagem, conhecidos como pontos-chave. Estes pontos-chave representam normalmente articulações ou outras características importantes do objeto. A saída inclui as coordenadas
[x, y]e as pontuações de confiança de cada ponto. Os modelos YOLO26-pose foram especificamente concebidos para esta tarefa e utilizam o sufixo-pose, comoyolo26n-pose.pt. Estes modelos são pré-treinados em conjuntos de dados como os pontos-chave COCO e podem ser utilizados em várias tarefas de estimativa de pose. Para mais informações, visita a Página de estimativa de pose.Treinar um modelo YOLO26-pose num conjunto de dados personalizado envolve carregar um modelo, que pode ser um modelo novo definido por um ficheiro YAML ou um modelo pré-treinado. Depois, podes iniciar o processo de treino utilizando o conjunto de dados e os parâmetros especificados.
from ultralytics import YOLO # Load a model model = YOLO("yolo26n-pose.yaml") # build a new model from YAML model = YOLO("yolo26n-pose.pt") # load a pretrained model (recommended for training) # Train the model results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)Para obteres informações completas sobre o treino, consulta a Secção Train. Também podes utilizar o treino na nuvem da Ultralytics Platform para uma abordagem sem código ao treino de modelos personalizados de estimativa de pose.
A validação de um modelo YOLO26-pose envolve avaliar a sua precisão utilizando os mesmos parâmetros do conjunto de dados mantidos durante o treino. Eis um exemplo:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n-pose.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 rememberedPara mais informações, visita a Secção Val.
Sim, podes exportar um modelo YOLO26-pose para vários formatos, como ONNX, CoreML, TensorRT, entre outros. Isto pode ser feito utilizando Python ou a Interface de Linha de Comandos (CLI).
from ultralytics import YOLO # Load a model model = YOLO("yolo26n-pose.pt") # load an official model model = YOLO("path/to/best.pt") # load a custom-trained model # Export the model model.export(format="onnx")Consulta a Secção Export para obteres mais informações. Os modelos exportados podem ser implementados em dispositivos de edge para aplicações em tempo real, como acompanhamento de fitness, análise desportiva ou robótica.
O Ultralytics YOLO26 disponibiliza vários modelos de pose pré-treinados, como YOLO26n-pose, YOLO26s-pose e YOLO26m-pose, entre outros. Estes modelos diferem em tamanho, precisão (mAP) e velocidade. Por exemplo, o modelo YOLO26n-pose alcança um mAPpose50-95 de 57,2 e um mAPpose50 de 83,3. Para obteres a lista completa e os detalhes de desempenho, visita a Secção Models.