Ultralytics YOLO27:
Get Started

Stima della posa con Ultralytics YOLO#

Ultralytics YOLO pose estimation with human body keypoint detection

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

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.

Modellodimensione
(pixel)
mAPpose
50-95(e2e)
mAPpose
50(e2e)
Velocità
CPU ONNX
(ms)
Velocità
T4 TensorRT10
(ms)
parametri
(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
  • I valori mAPval si riferiscono a un singolo modello con scala singola sul dataset COCO Keypoints val2017.
    Riproduci con yolo 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 con yolo 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.

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

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

Predici#

Usa un modello YOLO26n-pose addestrato per eseguire previsioni sulle immagini.

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

AttributoTipoFormaDescrizione
result.keypointsKeypoints(N)Punti chiave.
result.keypoints.datatorch.float32(N,K,2/3)x,y più visibilità/confidenza facoltativa.
result.keypoints.xytorch.float32(N,K,2)Punti chiave in pixel.
result.keypoints.xyntorch.float32(N,K,2)Punti chiave normalizzati.
result.boxesBoxes(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:

  1. Naso
  2. Occhio sinistro
  3. Occhio destro
  4. Orecchio sinistro
  5. Orecchio destro
  6. Spalla sinistra
  7. Spalla destra
  8. Gomito sinistro
  9. Gomito destro
  10. Polso sinistro
  11. Polso destro
  12. Anca sinistra
  13. Anca destra
  14. Ginocchio sinistro
  15. Ginocchio destro
  16. Caviglia sinistra
  17. Caviglia destra

Esporta#

Esporta un modello YOLO26n-pose in un altro formato, come ONNX, CoreML ecc.

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

FormatoArgomento formatModelloMetadatiArgomenti
PyTorch-yolo26n-pose.pt✅-
TorchScripttorchscriptyolo26n-pose.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-pose.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-pose_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-pose.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-pose.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n-pose.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n-pose_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-pose.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-pose_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n-pose.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n-pose_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n-pose.mnn✅imgsz, 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.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n-pose_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n-pose_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n-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 esempio yolo26n-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.

    Esempio
    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)
    
    # 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:

    Esempio
    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

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

    Esempio
    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")

    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.

Commenti