Estimação de Pose com Ultralytics YOLO#
A estimativa de pose é uma tarefa que envolve identificar a localização de pontos específicos em uma imagem, geralmente chamados de keypoints. Os keypoints podem representar várias partes do objeto, como articulações, marcos ou outras características distintivas. As localizações dos keypoints são geralmente 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 keypoints em um objeto na imagem, geralmente junto com as pontuações de confiança para cada ponto. A estimativa de pose é uma boa escolha quando você precisa identificar partes específicas de um objeto em uma cena e sua localização em relação umas às outras.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
Os modelos de pose YOLO26 usam o sufixo -pose, ou seja, yolo26n-pose.pt. Esses modelos são treinados no conjunto de dados COCO keypoints e são adequados para uma variedade de tarefas de estimativa de pose.
No modelo de pose padrão do YOLO26, existem 17 keypoints, cada um representando uma parte diferente do corpo humano. Aqui está o mapeamento de cada índice para sua respectiva articulação corporal:
- Nariz
- Olho Esquerdo
- Olho Direito
- Orelha Esquerda
- Orelha Direita
- Ombro Esquerdo
- Ombro Direito
- Cotovelo Esquerdo
- Cotovelo Direito
- Pulso Esquerdo
- Pulso Direito
- Quadril Esquerdo
- Quadril Direito
- Joelho Esquerdo
- Joelho Direito
- Tornozelo Esquerdo
- Tornozelo Direito
Modelos#
Os modelos Pose pré-treinados do Ultralytics 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.
| Modelo | tamanho (pixels) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocidade CPU ONNX (ms) | Velocidade T4 TensorRT10 (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n-pose | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.5 |
| YOLO26s-pose | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 23.9 |
| YOLO26m-pose | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.1 |
| YOLO26l-pose | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.3 |
| YOLO26x-pose | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 201.7 |
- Os valores de mAPval são para modelo único e escala única no conjunto de dados COCO Keypoints val2017.
Reproduza comyolo val pose data=coco-pose.yaml device=0 - Speed calculada como média nas imagens de validação do COCO usando uma instância Amazon EC2 P4d.
Reproduza comyolo val pose data=coco-pose.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.
Treinar#
Treine um modelo YOLO26-pose no conjunto de dados COCO8-pose. O conjunto de dados COCO8-pose é um pequeno conjunto de dados de amostra que é perfeito para testar e depurar seus 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)Veja os detalhes completos do modo train na página Train. Os modelos de pose também podem ser treinados com o treinamento em nuvem do Ultralytics Platform.
Formato do conjunto de dados#
O formato do conjunto de dados de pose do YOLO pode ser encontrado em detalhes no Guia de Conjuntos de Dados. Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, utilize a ferramenta JSON2YOLO da Ultralytics. A anotação do Ultralytics Platform também suporta rótulos de pose com modelos de esqueleto integrados para pessoa, mão, rosto e layouts de keypoints personalizados.
Para tarefas personalizadas de estimativa de pose, você também pode explorar conjuntos de dados especializados como Tiger-Pose para estimativa de pose em animais, Hand Keypoints para rastreamento de mãos ou Dog-Pose para análise de pose canina.
Validar#
Valide a precisão do modelo YOLO26n-pose treinado no conjunto de dados COCO8-pose. Nenhum argumento é necessário, pois o model retém seus data e argumentos de treinamento 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 FNPrever#
Use um modelo YOLO26n-pose treinado para executar previsões em imagens. O modo de previsão permite realizar inferência em imagens, vídeos ou transmissões 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 Prever.
Saída de Resultados#
A estimativa de pose retorna um objeto Results por imagem. Os principais campos de previsão são result.keypoints para coordenadas de pose e result.boxes para as instâncias detectadas às quais esses keypoints pertencem.
| Atributo | Tipo | Forma | Descrição |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Pontos-chave. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y mais visibilidade/confiança opcional. |
result.keypoints.xy | torch.float32 | (N,K,2) | Pontos-chave em pixels. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Pontos-chave normalizados. |
result.boxes | Boxes | (N) | Caixas de instância. |
Para campos de Results específicos de tarefas em cada tarefa, consulta a seção Resultados de Previsão por Tarefa.
Exportar#
Exporte um modelo Pose YOLO26n para um formato diferente, como ONNX, CoreML, etc. Isso permite implantar seu 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 disponíveis para YOLO26-pose estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento format, ou seja, format='onnx' ou format='engine'. Você pode prever ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-pose.onnx. Exemplos de uso são mostrados para o seu 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 |
Consulta todos os detalhes de export na página Exportar.
FAQ#
A estimativa de pose com o Ultralytics YOLO26 envolve a identificação de pontos específicos, conhecidos como keypoints, em uma imagem. Esses keypoints normalmente representam articulações ou outros recursos importantes do objeto. A saída inclui as coordenadas
[x, y]e pontuações de confiança para cada ponto. Os modelos YOLO26-pose são projetados especificamente para esta tarefa e usam o sufixo-pose, comoyolo26n-pose.pt. Esses modelos são pré-treinados em conjuntos de dados como COCO keypoints e podem ser usados para várias tarefas de estimativa de pose. Para mais informações, visite a Página de Estimativa de Pose.Treinar um modelo YOLO26-pose em um conjunto de dados personalizado envolve carregar um modelo, seja um novo modelo definido por um arquivo YAML ou um modelo pré-treinado. Você pode então iniciar o processo de treinamento usando seu conjunto de dados e 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 detalhes abrangentes sobre o treinamento, consulte a Seção Train. Você também pode usar o treinamento em nuvem do Ultralytics Platform para uma abordagem sem código para treinar modelos personalizados de estimativa de pose.
A validação de um modelo YOLO26-pose envolve avaliar sua precisão usando os mesmos parâmetros de conjunto de dados retidos durante o treinamento. Aqui está 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 obter mais informações, visite a Seção Val.
Sim, você pode exportar um modelo YOLO26-pose para vários formatos como ONNX, CoreML, TensorRT, entre outros. Isso pode ser feito usando Python ou a Interface de Linha de Comando (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")Consulte a Seção Export para mais detalhes. Os modelos exportados podem ser implantados em dispositivos de borda para aplicações em tempo real, como monitoramento de condicionamento físico, análise esportiva ou robótica.
O Ultralytics YOLO26 oferece vários modelos de pose pré-treinados, como YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, entre outros. Esses 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 uma lista completa e detalhes de desempenho, visite a Seção de Modelos.