Stima dei pose con Ultralytics YOLO#
La stima della posa è un'attività che consiste nell'identificare la posizione di punti specifici in un'immagine, solitamente denominati keypoints. I keypoints possono rappresentare varie parti dell'oggetto come articolazioni, punti di riferimento o altre caratteristiche distintive. Le posizioni dei keypoints sono solitamente rappresentate come un insieme di coordinate 2D [x, y], facoltativamente con un flag di visibilità [x, y, visible].
L'output di un modello di stima della posa è un insieme di punti che rappresentano i keypoint su un oggetto nell'immagine, solitamente accompagnati dai punteggi di confidenza per ciascun punto. La stima della posa è una buona scelta quando hai bisogno di identificare parti specifiche di un oggetto in una scena e la loro posizione l'una rispetto all'altra.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
I modelli pose di YOLO26 utilizzano il suffisso -pose, ad es. yolo26n-pose.pt. Questi modelli sono addestrati sul dataset COCO keypoints e sono adatti a una varietà di attività di stima della posa.
Nel modello di posa predefinito YOLO26 ci sono 17 keypoint, ognuno dei quali rappresenta una parte diversa del corpo umano. Ecco la mappatura di ogni indice rispetto alla rispettiva articolazione corporea:
- Naso
- Occhio sinistro
- Occhio destro
- Orecchio sinistro
- Orecchio destro
- Spalla sinistra
- Spalla destra
- Gomito sinistro
- Gomito destro
- Polso sinistro
- Polso destro
- Anca sinistra
- Anca destra
- Ginocchio sinistro
- Ginocchio destro
- Caviglia sinistra
- Caviglia destra
Modelli#
I modelli Pose pretrained di Ultralytics YOLO26 sono mostrati qui. I modelli Detect, Segment e Pose sono preaddestrati sul dataset COCO, i modelli Semantic sono preaddestrati su Cityscapes e i modelli Classify sono preaddestrati sul dataset ImageNet.
I Modelli vengono scaricati automaticamente dall'ultimo rilascio di Ultralytics al primo utilizzo.
| Modello | dimensione (pixel) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocità CPU ONNX (ms) | Velocità 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 |
- I valori di mAPval si riferiscono a modello singolo e scala singola sul dataset COCO Keypoints val2017.
Riproduci conyolo val pose data=coco-pose.yaml device=0 - Speed mediata sulle immagini di validazione di COCO utilizzando un'istanza Amazon EC2 P4d.
Riproduci tramiteyolo val pose data=coco-pose.yaml batch=1 device=0|cpu - I valori di Params e FLOPs si riferiscono al modello fuso dopo
model.fuse(), che unisce i layer Conv e BatchNorm e, per i modelli end2end, rimuove la testa di rilevamento ausiliaria one-to-many. I checkpoint preaddestrati mantengono l'architettura di addestramento completa e potrebbero mostrare conteggi più elevati.
Addestramento#
Addestra un modello YOLO26-pose sul dataset COCO8-pose. Il dataset COCO8-pose è un piccolo dataset di esempio perfetto per testare e fare il debug dei tuoi modelli di stima della posa.
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 i dettagli completi della modalità train nella pagina Train. I modelli Pose possono anche essere addestrati con l'addestramento cloud Ultralytics Platform.
Formato del dataset#
Il formato del dataset YOLO pose può essere trovato in dettaglio nella Guida ai dataset. Per convertire il tuo dataset esistente da altri formati (come COCO ecc.) nel formato YOLO, utilizza lo strumento JSON2YOLO di Ultralytics. Le annotazioni di Ultralytics Platform supportano anche le etichette di posa con template di scheletro integrati per persona, mano, viso e layout di keypoints personalizzati.
Per attività di stima della posa personalizzate, puoi anche esplorare dataset specializzati come Tiger-Pose per la stima della posa degli animali, Hand Keypoints per il tracciamento delle mani o Dog-Pose per l'analisi della posa dei cani.
Valutazione#
Valida l'accuratezza del modello YOLO26n-pose addestrato sul dataset COCO8-pose. Non sono necessari argomenti poiché model mantiene il suo data di addestramento e gli argomenti come attributi del modello.
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 FNPrevisione#
Usa un modello YOLO26n-pose addestrato per eseguire predizioni sulle immagini. La modalità predict ti permette di eseguire inferenza su immagini, video o flussi in tempo reale.
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)Visualizza i dettagli completi della modalità predict nella pagina Predict.
Output dei risultati#
La stima della posa restituisce un oggetto Results per immagine. I campi di predizione principali sono result.keypoints per le coordinate della posa e result.boxes per le istanze rilevate a cui appartengono quei keypoints.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Punti chiave. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y più visibilità/confidenza opzionale. |
result.keypoints.xy | torch.float32 | (N,K,2) | Punti chiave in pixel. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Punti chiave normalizzati. |
result.boxes | Boxes | (N) | Box di istanza. |
Per i campi specifici dell'attività Results relativi a ogni attività, consulta la sezione Risultati di predizione per attività.
Esportazione#
Esporta un modello YOLO26n Pose in un formato diverso come ONNX, CoreML, ecc. Questo ti consente di distribuire il tuo modello su varie piattaforme e dispositivi per l'inferenza in tempo reale.
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")I formati di esportazione disponibili per YOLO26-pose sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando l'argomento format, ad es. format='onnx' o format='engine'. Puoi prevedere o validare direttamente sui modelli esportati, ad es. yolo predict model=yolo26n-pose.onnx. Gli esempi di utilizzo vengono mostrati per il tuo modello al termine dell'esportazione.
| Formato | Argomento format | Modello | Metadati | Argomenti |
|---|---|---|---|---|
| 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 |
Visualizza i dettagli completi di export nella pagina Export.
FAQ#
La stima della posa con Ultralytics YOLO26 consiste nell'identificare punti specifici, noti come keypoints, in un'immagine. Questi keypoints rappresentano tipicamente articolazioni o altre caratteristiche importanti dell'oggetto. L'output include le coordinate
[x, y]e i punteggi di confidenza per ciascun punto. I modelli YOLO26-pose sono progettati specificamente per questo compito e utilizzano il suffisso-pose, comeyolo26n-pose.pt. Questi modelli sono preaddestrati su dataset come COCO keypoints e possono essere utilizzati per varie attività di stima della posa. Per maggiori informazioni, visita la pagina di stima della posa.L'addestramento di un modello YOLO26-pose su un dataset personalizzato comporta il caricamento di un modello, che sia un nuovo modello definito da un file YAML o un modello preaddestrato. Puoi quindi avviare il processo di addestramento utilizzando il dataset e i parametri specificati.
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)Per dettagli completi sull'addestramento, fai riferimento alla sezione Train. Puoi anche usare l'addestramento cloud Ultralytics Platform per un approccio senza codice all'addestramento di modelli di stima della posa personalizzati.
La convalida di un modello YOLO26-pose comporta la valutazione della sua accuratezza utilizzando gli stessi parametri del dataset mantenuti durante l'addestramento. Ecco un esempio:
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 rememberedPer maggiori informazioni, visita la sezione Val.
Sì, puoi esportare un modello YOLO26-pose in vari formati come ONNX, CoreML, TensorRT e altri. Questo può essere fatto utilizzando Python o la Command Line Interface (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")Fai riferimento alla sezione Export per maggiori dettagli. I modelli esportati possono essere distribuiti su dispositivi edge per applicazioni in tempo reale come il fitness tracking, l'analisi sportiva o la robotica.
Ultralytics YOLO26 offre vari modelli pose preaddestrati come YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, tra gli altri. Questi modelli differiscono per dimensioni, accuratezza (mAP) e velocità. Ad esempio, il modello YOLO26n-pose raggiunge un mAPpose50-95 di 57,2 e un mAPpose50 di 83,3. Per un elenco completo e dettagli sulle prestazioni, visita la sezione Modelli.