Ultralytics YOLO27:

Estimativa de pose com Ultralytics YOLO#

Ultralytics YOLO pose estimation with human body keypoint detection

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 🕺
Dica

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:

  1. Nariz
  2. Olho esquerdo
  3. Olho direito
  4. Orelha esquerda
  5. Orelha direita
  6. Ombro esquerdo
  7. Ombro direito
  8. Cotovelo esquerdo
  9. Cotovelo direito
  10. Pulso esquerdo
  11. Pulso direito
  12. Anca esquerda
  13. Anca direita
  14. Joelho esquerdo
  15. Joelho direito
  16. Tornozelo esquerdo
  17. 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.

Modelotamanho
(píxeis)
mAPpose
50-95(e2e)
mAPpose
50(e2e)
Velocidade
CPU ONNX
(ms)
Velocidade
T4 TensorRT10
(ms)
parâmetros
(M)
FLOPs
(B)
YOLO26n-pose64057.283.340.3 ± 0.51.8 ± 0.02.97.6
YOLO26s-pose64063.086.685.3 ± 0.92.7 ± 0.010.424.1
YOLO26m-pose64068.889.6218.0 ± 1.55.0 ± 0.121.573.3
YOLO26l-pose64070.490.5275.4 ± 2.46.5 ± 0.125.991.7
YOLO26x-pose64071.691.6565.4 ± 3.012.2 ± 0.257.6202.3
  • Os valores de mAPval correspondem a um único modelo e a uma única escala no conjunto de dados COCO Keypoints val2017.
    Reproduz com yolo 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 com yolo 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.

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

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

Previsã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.

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

# 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.

AtributoTipoFormaDescrição
result.keypointsKeypoints(N)Pontos-chave.
result.keypoints.datatorch.float32(N,K,2/3)x,y além de visibilidade/confiança opcional.
result.keypoints.xytorch.float32(N,K,2)Pontos-chave de pixels.
result.keypoints.xyntorch.float32(N,K,2)Pontos-chave normalizados.
result.boxesBoxes(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.

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-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.

FormatoArgumento formatModeloMetadadosArgumentos
PyTorch-yolo26n-pose.pt-
TorchScripttorchscriptyolo26n-pose.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-pose.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-pose_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-pose.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-pose.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n-pose_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-pose.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-pose_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n-pose_paddle_model/imgsz, batch, device
MNNmnnyolo26n-pose.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-pose_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n-pose_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-pose_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-pose_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n-pose_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-pose_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-pose_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n-pose.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n-pose_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n-pose_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms
Apple Core AIcoreaiyolo26n-pose.aimodelimgsz, 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, como yolo26n-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 remembered

    Para 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.

Comentários