Estimación de pose con Ultralytics YOLO#
La estimación de poses es una tarea que implica identificar la ubicación de puntos específicos en una imagen, habitualmente denominados puntos clave. Los puntos clave pueden representar varias partes del objeto, como articulaciones, puntos de referencia u otras características distintivas. Las ubicaciones de los puntos clave se representan normalmente como un conjunto de coordenadas 2D [x, y], opcionalmente con un indicador de visibilidad [x, y, visible].
El resultado de un modelo de estimación de poses es un conjunto de puntos que representan los puntos clave de un objeto en la imagen, habitualmente junto con las puntuaciones de confianza para 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 en relación con los demás.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
Los modelos de pose de YOLO26 utilizan el sufijo -pose, es decir, yolo26n-pose.pt. Estos modelos están entrenados con el conjunto de datos COCO keypoints y son adecuados para una variedad de tareas de estimación de poses.
En el modelo de pose YOLO26 por defecto, hay 17 puntos clave, cada uno de los cuales representa una parte diferente del cuerpo humano. Aquí tienes el mapeo de cada índice con su respectiva 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 Pose preentrenados de Ultralytics YOLO26. Los modelos de Detección (Detect), Segmentación (Segment) y Pose están preentrenados en el conjunto de datos COCO, los modelos Semantic están preentrenados en Cityscapes, y los modelos de Clasificación (Classify) están preentrenados en el conjunto de datos ImageNet.
Los Modelos se descargan automáticamente de la última versión de Ultralytics en su primer uso.
| Modelo | tamaño (píxeles) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocidad CPU ONNX (ms) | Velocidad 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 |
- Los valores de mAPval corresponden a un modelo único y a escala única en el conjunto de datos COCO Keypoints val2017.
Reproduce medianteyolo val pose data=coco-pose.yaml device=0 - La velocidad se calcula como un promedio en las imágenes de validación de COCO utilizando una instancia Amazon EC2 P4d.
Reprodúcelo conyolo val pose data=coco-pose.yaml batch=1 device=0|cpu - Los valores de Params y FLOPs corresponden al modelo fusionado después de
model.fuse(), el cual combina las capas Conv y BatchNorm y, para los modelos end2end, elimina la cabeza de detección auxiliar de uno a muchos. Los puntos de control preentrenados conservan toda la arquitectura de entrenamiento y pueden mostrar recuentos mayores.
Entrenar#
Entrena un modelo YOLO26-pose en el conjunto de datos COCO8-pose. El conjunto de datos COCO8-pose es un pequeño conjunto de datos de muestra 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 los detalles completos del modo train en la página Train. Los modelos de pose también se pueden entrenar con el entrenamiento en la nube de Ultralytics Platform.
Formato del conjunto de datos#
El formato del conjunto de datos de pose de YOLO se puede consultar en detalle en la Guía de conjuntos de datos. Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta JSON2YOLO de Ultralytics. La anotación de Ultralytics Platform también admite etiquetas de pose con plantillas de esqueleto integradas para personas, manos, rostros y diseños de puntos clave personalizados.
Para tareas de estimación de poses personalizadas, también puedes explorar conjuntos de datos especializados como Tiger-Pose para la estimación de poses en animales, Hand Keypoints para el seguimiento de manos, o Dog-Pose para el análisis de poses caninas.
Validar#
Valida la precisión del modelo YOLO26n-pose entrenado en el conjunto de datos COCO8-pose. No se necesitan argumentos, ya que el model conserva su data y sus argumentos de entrenamiento 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 predict te permite realizar inferencias en imágenes, vídeos o transmisiones 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 Predict.
Resultado de la salida#
La estimación de poses devuelve un objeto Results por imagen. Los principales campos de predicción son result.keypoints para las coordenadas de la pose y result.boxes para las instancias detectadas a las que pertenecen dichos 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 instancia. |
Para ver los campos de Results específicos de cada tarea en todas ellas, consulta la sección Predict Results by Task.
Exportar#
Exporta un modelo YOLO26n Pose a un formato diferente como ONNX, CoreML, etc. Esto te permite implementar tu modelo en varias plataformas y dispositivos para inferencia 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 encuentran 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 en los modelos exportados, es decir, yolo predict model=yolo26n-pose.onnx. Los ejemplos de uso se muestran para tu modelo una vez finalizada la exportación.
| Formato | Argumento de 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 |
Consulta todos los detalles de export en la página Export.
FAQ#
La estimación de poses con Ultralytics YOLO26 implica identificar puntos específicos, conocidos como puntos clave, en una imagen. Estos puntos clave representan normalmente articulaciones u otras características importantes del objeto. El resultado incluye las coordenadas
[x, y]y las puntuaciones de confianza para 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 en conjuntos de datos como COCO keypoints y se pueden utilizar para diversas tareas de estimación de poses. Para obtener más información, visita la página de estimación de poses.El entrenamiento de un modelo YOLO26-pose en un conjunto de datos personalizado implica cargar un modelo, ya sea un modelo nuevo definido por un archivo YAML o un modelo preentrenado. Luego, 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 detalles completos sobre el entrenamiento, consulta la sección Train. También puedes utilizar el entrenamiento en la nube de Ultralytics Platform para un enfoque sin código (no-code) para entrenar modelos de estimación de poses personalizados.
La validación de un modelo YOLO26-pose implica evaluar su precisión utilizando los mismos parámetros de 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 Val.
Sí, puedes exportar un modelo YOLO26-pose a varios formatos como ONNX, CoreML, TensorRT y más. Esto se puede hacer 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 Export para obtener más detalles. Los modelos exportados se pueden implementar en dispositivos periféricos (edge devices) para aplicaciones en tiempo real como seguimiento de fitness, análisis deportivo o robótica.
Ultralytics YOLO26 ofrece varios modelos de pose preentrenados, como YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, entre otros. Estos modelos difieren 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 ver una lista completa y los detalles de rendimiento, visita la sección de modelos.