Stima della posa con Ultralytics YOLO#
La stima della posa è un'attività che consiste nell'individuare la posizione di punti specifici in un'immagine, generalmente chiamati keypoint. I keypoint possono rappresentare varie parti dell'oggetto, come articolazioni, punti di riferimento o altre caratteristiche distintive. Le posizioni dei keypoint sono generalmente rappresentate come un insieme di coordinate 2D [x, y], eventualmente accompagnate da un indicatore di visibilità [x, y, visible].
L'output di un modello di stima della posa è un insieme di punti che rappresentano i keypoint di un oggetto nell'immagine, solitamente accompagnati dai punteggi di confidenza di ciascun punto. La stima della posa è una buona scelta quando devi individuare parti specifiche di un oggetto in una scena e la loro posizione reciproca.
Guarda: Come eseguire la stima della posa in tempo reale con Ultralytics YOLO26 | Tracciamento ed estrazione dei punti chiave 🕺
I modelli YOLO26 Pose usano il suffisso -pose, ad esempio yolo26n-pose.pt, e sono pretrained sui keypoint COCO.
Modelli#
Di seguito sono mostrati i modelli YOLO26 Pose pretrained sul dataset dei keypoint COCO.
I modelli vengono scaricati automaticamente dalla più recente release di Ultralytics al primo utilizzo.
| Modello | dimensione (pixel) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Velocità CPU ONNX (ms) | Velocità T4 TensorRT10 (ms) | parametri (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 |
- I valori mAPval si riferiscono a un singolo modello con scala singola sul dataset COCO Keypoints val2017.
Riproduci conyolo pose val data=coco-pose.yaml device=0 nms=False - Velocità media sulle immagini COCO val con ONNX su CPU e TensorRT10 su una GPU NVIDIA T4.
Riproduci i risultati conyolo pose val data=coco-pose.yaml batch=1 device=0|cpu nms=False - I valori di Parametri e FLOPs si riferiscono ai modelli fusi dopo la fusione di Conv/BatchNorm e la rimozione del ramo di rilevamento inutilizzato. I checkpoint preaddestrati mantengono l’architettura di addestramento completa e possono riportare valori più elevati.
Consulta l'anteprima non ancora rilasciata di YOLO27 per i risultati preliminari sui keypoint COCO.
Addestra#
Addestra YOLO26n-pose sul dataset COCO8-pose per 100 epoche con una dimensione delle immagini di 640. Per l'elenco completo degli argomenti disponibili, consulta la pagina Configurazione.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-pose.yaml") # crea un nuovo modello dal file YAML
model = YOLO("yolo26n-pose.pt") # carica un modello preaddestrato (consigliato per l'addestramento)
model = YOLO("yolo26n-pose.yaml").load("yolo26n-pose.pt") # crea dal file YAML e trasferisci i pesi
# Addestra il modello
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)Consulta la pagina Addestramento per i dettagli completi sulla modalità train. Puoi addestrare i modelli di posa anche con l'addestramento cloud di Ultralytics Platform.
Formato del dataset#
Trovi tutti i dettagli sul formato dei dataset YOLO per la posa nella Guida ai dataset. Per convertire un dataset JSON esistente dei keypoint COCO nel formato YOLO, usa la funzione integrata convert_coco con use_keypoints=True, come descritto nella guida alla conversione da COCO a YOLO. Le annotazioni di Ultralytics Platform supportano anche le etichette di posa, con modelli di scheletro integrati per persone, mani e volti, oltre a configurazioni personalizzate di keypoint.
Per attività di stima della posa personalizzate, puoi provare anche 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.
Convalida#
Convalida l'accuratezza del modello YOLO26n-pose addestrato. Non servono argomenti, perché model conserva il proprio data di addestramento e gli argomenti come attributi del modello: path/to/best.pt dell'esempio di Addestramento esegue la convalida su COCO8-pose. I pesi ufficiali registrano un percorso del dataset di addestramento che potrebbe non esistere sul tuo computer; in tal caso, viene usato il valore predefinito dell'attività coco8-pose.yaml con un avviso. Passa data per convalidare un altro dataset.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-pose.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Convalida il modello
metrics = model.val() # non servono argomenti, il dataset e le impostazioni vengono ricordati
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # un elenco contenente mAP50-95 per ogni categoria
metrics.box.image_metrics # dizionario delle metriche per immagine relativo ai riquadri, con precisione, richiamo, F1, TP, FP e FN
metrics.pose.map # map50-95(P)
metrics.pose.map50 # map50(P)
metrics.pose.map75 # map75(P)
metrics.pose.maps # un elenco contenente mAP50-95(P) per ogni categoria
metrics.pose.image_metrics # dizionario delle metriche per immagine relativo alla posa, con precisione, richiamo, F1, TP, FP e FNPredici#
Usa un modello YOLO26n-pose addestrato per eseguire previsioni sulle immagini.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-pose.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esegui previsioni con il modello
results = model("https://ultralytics.com/images/bus.jpg") # esegui una previsione su un’immagine
# Accedi ai risultati
for result in results:
xy = result.keypoints.xy # coordinate x e y
xyn = result.keypoints.xyn # normalized
kpts = result.keypoints.data # x, y, visibilità (se disponibile)Consulta la pagina Previsione per i dettagli completi sulla modalità predict.
Output dei risultati#
La stima della posa restituisce un oggetto Results per immagine. I principali campi della previsione sono result.keypoints per le coordinate della posa e result.boxes per le istanze rilevate a cui appartengono quei keypoint.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Punti chiave. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y più visibilità/confidenza facoltativa. |
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) | Riquadri di istanza. |
Per consultare i campi Results specifici di ogni attività, visita la sezione Risultati delle previsioni per attività.
Mappa degli indici dei keypoint#
I modelli YOLO26 Pose predefiniti prevedono i 17 keypoint COCO, quindi l'indice k in result.keypoints.xy[:, k] corrisponde a:
- 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
Esporta#
Esporta un modello YOLO26n-pose in un altro formato, come ONNX, CoreML ecc.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-pose.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esporta il modello
model.export(format="onnx")I formati di esportazione disponibili per YOLO26-pose sono elencati nella tabella seguente. Puoi esportare in qualsiasi formato usando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi eseguire previsioni o convalidare direttamente i modelli esportati, ad esempio yolo predict model=yolo26n-pose.onnx. Al termine dell'esportazione, vengono mostrati esempi d'uso per il tuo modello.
| 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 |
| Apple Core AI | coreai | yolo26n-pose.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n-pose_saved_model/ | ✅ | imgsz, 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 |
| LiteRT | litert | yolo26n-pose.tflite | ✅ | imgsz, quantize, batch, 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 |
| Hailo | hailo | yolo26n-pose_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n-pose_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n-pose_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
nms=None restituisce per impostazione predefinita output grezzi per NMS esterno. Imposta nms=False per selezionare una head disponibile senza NMS; i formati non supportati utilizzano il proprio percorso di output nativo. Le voci nms qui sopra identificano i formati che possono integrare NMS con nms=True.
Consulta i dettagli completi di export nella pagina Esportazione.
Domande frequenti#
La stima della posa con Ultralytics YOLO26 consiste nell'individuare punti specifici, noti come keypoint, in un'immagine. Questi keypoint rappresentano in genere articolazioni o altre caratteristiche importanti dell'oggetto. L'output include le coordinate
[x, y]e i punteggi di confidenza di ciascun punto. I modelli YOLO26-pose sono progettati appositamente per questa attività e usano il suffisso-pose, ad esempioyolo26n-pose.pt. Questi modelli sono pretrained su dataset come i keypoint COCO e possono essere usati per varie attività di stima della posa. Per saperne di più, visita la pagina sulla stima della posa.Per addestrare un modello YOLO26-pose su un dataset personalizzato, carica un modello: puoi definirne uno nuovo tramite un file YAML oppure usare un modello pretrained. Puoi quindi avviare l'addestramento usando il dataset e i parametri specificati.
Esempiofrom ultralytics import YOLO # Carica un modello model = YOLO("yolo26n-pose.yaml") # crea un nuovo modello dal file YAML model = YOLO("yolo26n-pose.pt") # carica un modello preaddestrato (consigliato per l'addestramento) # Addestra il modello results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)Per informazioni complete sull'addestramento, consulta la sezione Addestramento. Puoi anche usare l'addestramento cloud di Ultralytics Platform per addestrare modelli personalizzati di stima della posa senza scrivere codice.
La convalida di un modello YOLO26-pose consiste nel valutarne l'accuratezza usando gli stessi parametri del dataset conservati durante l'addestramento. Ecco un esempio:
Esempiofrom ultralytics import YOLO # Carica un modello model = YOLO("yolo26n-pose.pt") # carica un modello ufficiale model = YOLO("path/to/best.pt") # carica un modello personalizzato # Convalida il modello metrics = model.val() # non servono argomenti, il dataset e le impostazioni vengono ricordatiPer saperne di più, visita la sezione Val.
Sì, puoi esportare un modello YOLO26-pose in vari formati, come ONNX, CoreML, TensorRT e altri. Puoi farlo con Python oppure tramite l'interfaccia a riga di comando (CLI).
Esempiofrom ultralytics import YOLO # Carica un modello model = YOLO("yolo26n-pose.pt") # carica un modello ufficiale model = YOLO("path/to/best.pt") # carica un modello personalizzato # Esporta il modello model.export(format="onnx")Per maggiori dettagli, consulta la sezione Esportazione. Puoi distribuire i modelli esportati su dispositivi edge per applicazioni in tempo reale, come il monitoraggio dell'attività fisica e l'analisi sportiva, oppure per la robotica.
Ultralytics YOLO26 offre diversi modelli di posa pretrained, tra cui YOLO26n-pose, YOLO26s-pose e YOLO26m-pose. I modelli differiscono per dimensioni, accuratezza (mAP) e velocità. Per l'elenco completo, con mAP sui keypoint COCO, velocità, numero di parametri e FLOPs per modello, consulta la sezione Modelli.