Stima della posa con Ultralytics YOLO#
La stima della posa è un'attività che consiste nell'identificare 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], 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, generalmente accompagnati dai punteggi di confidenza per ogni punto. La stima della posa è una buona scelta quando devi identificare parti specifiche di un oggetto in una scena e la loro posizione reciproca.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
I modelli pose di YOLO26 utilizzano il suffisso -pose, ovvero 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 pose predefinito di YOLO26 sono presenti 17 keypoint, ognuno dei quali rappresenta una parte diversa del corpo umano. Ecco la corrispondenza tra ogni indice e la rispettiva articolazione del corpo:
- 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#
Qui sono mostrati i modelli Pose di Ultralytics YOLO26 preaddestrati. 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'ultima 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 di mAPval si riferiscono a un singolo modello e a una singola scala sul dataset COCO Keypoints val2017.
Riproduci conyolo val pose data=coco-pose.yaml device=0 nms=False - La velocità è calcolata come media sulle immagini COCO val utilizzando un'istanza Amazon EC2 P4d.
Riproduci conyolo val pose data=coco-pose.yaml batch=1 device=0|cpu nms=False - I valori di Params e FLOPs si riferiscono a modelli fusi dopo il folding di Conv/BatchNorm e la rimozione del ramo di rilevamento non utilizzato. I checkpoint preaddestrati mantengono l'intera architettura di addestramento e potrebbero mostrare conteggi superiori.
Consulta l'anteprima non rilasciata di YOLO27 per i risultati preliminari sui punti chiave di COCO.
Addestramento#
Addestra un modello YOLO26-pose sul dataset COCO8-pose. Il dataset COCO8-pose è un piccolo dataset di esempio, perfetto per testare e correggere i problemi 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 essere addestrati anche con l'addestramento cloud di Ultralytics Platform.
Formato del dataset#
Il formato del dataset di stima della posa di YOLO può essere trovato in dettaglio nella Guida ai dataset. Per convertire un dataset JSON di punti chiave COCO esistente nel formato YOLO, usa la funzione integrata convert_coco con use_keypoints=True, come descritto nella Guida da COCO a YOLO. L'annotazione della piattaforma Ultralytics supporta anche le etichette di posa con modelli di scheletro integrati per persona, mano, viso e layout di punti chiave personalizzati.
Per le 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.
Val#
Convalida l'accuratezza del modello YOLO26n-pose addestrato sul dataset COCO8-pose. Non sono necessari argomenti, poiché model conserva il proprio 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 FNPredizione#
Utilizza un modello YOLO26n-pose addestrato per eseguire previsioni sulle immagini. La modalità predict ti consente di eseguire l'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)Consulta la pagina Predict per tutti i dettagli sulla modalità predict.
Output dei risultati#
La stima della posa restituisce un oggetto Results per ogni immagine. I principali campi della previsione sono result.keypoints per le coordinate della posa e result.boxes per le istanze rilevate a cui appartengono tali keypoint.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Keypoint. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y più visibilità/confidenza facoltativa. |
result.keypoints.xy | torch.float32 | (N,K,2) | Keypoint in pixel. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Keypoint normalizzati. |
result.boxes | Boxes | (N) | Box delle istanze. |
Per i campi Results specifici dell'attività in tutte le attività, consulta la sezione Risultati delle predizioni per attività.
Esportazione#
Esporta un modello YOLO26n Pose in un formato diverso, come ONNX, CoreML ecc. Questo ti consente di distribuire il 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 YOLO26-pose disponibili sono riportati nella tabella seguente. Puoi esportare in qualsiasi formato utilizzando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi eseguire previsioni o convalide direttamente sui modelli esportati, ad esempio yolo predict model=yolo26n-pose.onnx. Al termine dell'esportazione vengono mostrati esempi di utilizzo 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 |
| 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 utilizza i valori predefiniti per gli output grezzi per la NMS esterna. Imposta nms=False per selezionare una testa senza NMS disponibile; i formati non supportati ricorrono al loro percorso di output nativo. Le voci nms sopra indicano i formati che possono incorporare la NMS con nms=True.
Consulta la pagina Export per tutti i dettagli su export.
FAQ#
La stima della posa con Ultralytics YOLO26 consiste nell'identificare punti specifici, noti come punti chiave, in un'immagine. Questi punti chiave rappresentano generalmente articolazioni o altre caratteristiche importanti dell'oggetto. L'output include le coordinate
[x, y]e i punteggi di confidenza per ogni 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 diverse attività di stima della posa. Per ulteriori informazioni, visita la pagina sulla stima della posa.L'addestramento di un modello YOLO26-pose su un dataset personalizzato consiste nel caricare un modello, nuovo e definito da un file YAML oppure 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 informazioni complete sull'addestramento, consulta la sezione Train. Puoi anche utilizzare l'addestramento cloud della Ultralytics Platform per adottare un approccio senza codice all'addestramento di modelli personalizzati di stima della posa.
La convalida di un modello YOLO26-pose consiste nel valutarne l'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 ulteriori informazioni, visita la sezione Val.
Sì, puoi esportare un modello YOLO26-pose in diversi formati, tra cui ONNX, CoreML, TensorRT e altri. Puoi farlo utilizzando Python oppure l'interfaccia della riga di comando (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")Per ulteriori dettagli, consulta la sezione Export. I modelli esportati possono essere distribuiti su dispositivi edge per applicazioni in tempo reale, come il monitoraggio del fitness, l'analisi sportiva o la robotica.
Ultralytics YOLO26 offre diversi modelli di posa preaddestrati, come YOLO26n-pose, YOLO26s-pose e YOLO26m-pose, oltre ad altri. Questi modelli differiscono per dimensioni, accuratezza (mAP) e velocità. Ad esempio, il modello YOLO26n-pose raggiunge un valore mAPpose50-95 pari a 57.2 e un valore mAPpose50 pari a 83.3. Per un elenco completo e i dettagli sulle prestazioni, visita la sezione Models.