Estimación de poses con Ultralytics YOLO#
La estimación de poses es una tarea que consiste en identificar la ubicación de puntos específicos de una imagen, normalmente denominados puntos clave. Los puntos clave pueden representar distintas partes del objeto, como articulaciones, referencias u otras características distintivas. Las ubicaciones de los puntos clave suelen representarse como un conjunto de coordenadas 2D [x, y], opcionalmente con un indicador de visibilidad [x, y, visible].
La salida de un modelo de estimación de poses es un conjunto de puntos que representan los puntos clave de un objeto en la imagen, normalmente junto con las puntuaciones de confianza de cada punto. La estimación de poses es una buena opción cuando necesitas identificar partes específicas de un objeto en una escena y su ubicación con respecto a las demás.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
Los modelos pose de YOLO26 utilizan el sufijo -pose, es decir, yolo26n-pose.pt. Estos modelos se entrenan con el conjunto de datos COCO keypoints y son adecuados para diversas tareas de estimación de poses.
En el modelo de poses YOLO26 predeterminado hay 17 puntos clave, cada uno de los cuales representa una parte distinta del cuerpo humano. Esta es la correspondencia entre cada índice y su articulación corporal:
- Nariz
- Ojo izquierdo
- Ojo derecho
- Oreja izquierda
- Oreja derecha
- Hombro izquierdo
- Hombro derecho
- Codo izquierdo
- Codo derecho
- Muñeca izquierda
- Muñeca derecha
- Cadera izquierda
- Cadera derecha
- Rodilla izquierda
- Rodilla derecha
- Tobillo izquierdo
- Tobillo derecho
Modelos#
Aquí se muestran los modelos de poses preentrenados de Ultralytics YOLO26. Los modelos de detección, segmentación y poses están preentrenados con el conjunto de datos COCO, los modelos semánticos están preentrenados con Cityscapes y los modelos de clasificación están preentrenados con el conjunto de datos ImageNet.
Los modelos se descargan automáticamente de la versión más reciente de Ultralytics durante el primer uso.
| Modelo | tamaño (píxeles) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocidad CPU ONNX (ms) | Velocidad 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 |
- Los valores de mAPval corresponden a un único modelo y una única escala en el conjunto de datos COCO Keypoints val2017.
Reprodúcelos conyolo val pose data=coco-pose.yaml device=0 nms=False - La velocidad se calcula como la media en las imágenes de validación de COCO utilizando una instancia Amazon EC2 P4d.
Reprodúcela conyolo val pose data=coco-pose.yaml batch=1 device=0|cpu nms=False - Los valores de Params y FLOPs corresponden a modelos fusionados después del plegado de Conv/BatchNorm y la eliminación de la rama de detección no utilizada. Los puntos de control preentrenados conservan la arquitectura de entrenamiento completa y pueden mostrar recuentos más altos.
Consulta la vista previa no publicada de YOLO27 para obtener resultados preliminares de puntos clave de COCO.
Entrenar#
Entrena un modelo YOLO26-pose con el conjunto de datos COCO8-pose. El conjunto de datos COCO8-pose es un conjunto de datos de muestra pequeño, perfecto para probar y depurar tus modelos de estimación de poses.
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 los detalles del modo train en la página Entrenar. También puedes entrenar modelos de poses con el entrenamiento en la nube de Ultralytics Platform.
Formato del conjunto de datos#
El formato de conjuntos de datos de pose de YOLO se puede consultar en detalle en la Guía de conjuntos de datos. Para convertir un conjunto de datos JSON de puntos clave de COCO existente al formato de YOLO, utiliza la función integrada convert_coco con use_keypoints=True, tal como se describe en la guía de COCO a YOLO. La anotación de la plataforma Ultralytics también admite etiquetas de pose con plantillas de esqueleto integradas para diseños de personas, manos, rostros y puntos clave personalizados.
Para tareas personalizadas de estimación de poses, también puedes explorar conjuntos de datos especializados como Tiger-Pose para la estimación de poses de animales, Hand Keypoints para el seguimiento de manos o Dog-Pose para el análisis de poses caninas.
Val#
Valida la precisión de un modelo YOLO26n-pose entrenado con el conjunto de datos COCO8-pose. No se necesitan argumentos, ya que model conserva su data de entrenamiento y los argumentos como atributos del 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 FNPredecir#
Utiliza un modelo YOLO26n-pose entrenado para ejecutar predicciones en imágenes. El modo de predicción permite realizar inferencias en imágenes, vídeos o flujos en tiempo 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 los detalles del modo predict en la página Predecir.
Salida de resultados#
La estimación de poses devuelve un objeto Results por imagen. Los campos principales de la predicción son result.keypoints para las coordenadas de pose y result.boxes para las instancias detectadas a las que pertenecen esos puntos clave.
| Atributo | Tipo | Forma | Descripción |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Puntos clave. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y más visibilidad/confianza opcional. |
result.keypoints.xy | torch.float32 | (N,K,2) | Puntos clave en píxeles. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Puntos clave normalizados. |
result.boxes | Boxes | (N) | Cajas de las instancias. |
Para consultar los campos específicos de la tarea de Results en todas las tareas, visita la sección Resultados de predicción por tarea.
Exportar#
Exporta un modelo YOLO26n Pose a otro formato, como ONNX, CoreML, etc. Esto te permite desplegar el modelo en diversas plataformas y dispositivos para realizar inferencias en tiempo 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")Los formatos de exportación disponibles para YOLO26-pose se muestran en la tabla siguiente. Puedes exportar a cualquier formato utilizando el argumento format, es decir, format='onnx' o format='engine'. Puedes predecir o validar directamente con los modelos exportados, es decir, yolo predict model=yolo26n-pose.onnx. Cuando finalice la exportación, se muestran ejemplos de uso para tu modelo.
| Formato | Argumento format | Modelo | Metadatos | 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 se establece por defecto en salidas sin procesar para la NMS externa. Configura nms=False para seleccionar una cabeza libre de NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden incrustar la NMS con nms=True.
Consulta todos los detalles de export en la página Exportar.
Preguntas frecuentes#
La estimación de poses con Ultralytics YOLO26 consiste en identificar puntos específicos, conocidos como puntos clave, en una imagen. Estos puntos clave suelen representar articulaciones u otras características importantes del objeto. El resultado incluye las coordenadas de
[x, y]y las puntuaciones de confianza de cada punto. Los modelos YOLO26-pose están diseñados específicamente para esta tarea y utilizan el sufijo-pose, comoyolo26n-pose.pt. Estos modelos están preentrenados con conjuntos de datos como puntos clave de COCO y pueden utilizarse para diversas tareas de estimación de poses. Para obtener más información, visita la página de estimación de poses.Entrenar un modelo YOLO26-pose con un conjunto de datos personalizado implica cargar un modelo, ya sea un modelo nuevo definido mediante un archivo YAML o un modelo preentrenado. A continuación, puedes iniciar el proceso de entrenamiento utilizando el conjunto de datos y los 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 obtener información detallada sobre el entrenamiento, consulta la sección de entrenamiento. También puedes utilizar el entrenamiento en la nube de Ultralytics Platform para entrenar modelos personalizados de estimación de poses sin escribir código.
La validación de un modelo YOLO26-pose consiste en evaluar su precisión utilizando los mismos parámetros del conjunto de datos conservados durante el entrenamiento. Aquí tienes un ejemplo:
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 obtener más información, visita la sección de validación.
Sí, puedes exportar un modelo YOLO26-pose a varios formatos, como ONNX, CoreML, TensorRT y otros. Puedes hacerlo utilizando Python o la interfaz de línea 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 la sección de exportación para obtener más información. Los modelos exportados pueden implementarse en dispositivos periféricos para aplicaciones en tiempo real, como el seguimiento de la actividad física, el análisis deportivo o la robótica.
Ultralytics YOLO26 ofrece varios modelos de poses preentrenados, como YOLO26n-pose, YOLO26s-pose y YOLO26m-pose, entre otros. Estos modelos se diferencian en tamaño, precisión (mAP) y velocidad. Por ejemplo, el modelo YOLO26n-pose alcanza un mAPpose50-95 de 57,2 y un mAPpose50 de 83,3. Para consultar la lista completa y los detalles de rendimiento, visita la sección de modelos.