Pose Estimation mit Ultralytics YOLO#
Pose Estimation ist eine Aufgabe, die darin besteht, die Position spezifischer Punkte in einem Bild zu identifizieren, die normalerweise als Keypoints bezeichnet werden. Die Keypoints können verschiedene Teile des Objekts wie Gelenke, Landmarken oder andere markante Merkmale repräsentieren. Die Positionen der Keypoints werden normalerweise als eine Menge von 2D-[x, y]-Koordinaten dargestellt, optional mit einem Sichtbarkeits-Flag [x, y, visible].
Die Ausgabe eines Pose-Estimation-Modells ist eine Menge von Punkten, die die Keypoints eines Objekts im Bild darstellen, normalerweise zusammen mit den Konfidenzwerten für jeden Punkt. Pose Estimation ist eine gute Wahl, wenn du bestimmte Teile eines Objekts in einer Szene sowie deren Position in Bezug zueinander identifizieren musst.
Watch: How to Run Real-Time Pose Estimation with Ultralytics YOLO26 | Tracking & Keypoints Extraction 🕺
YOLO26-Pose-Modelle verwenden das Suffix -pose, d. h. yolo26n-pose.pt. Diese Modelle werden auf dem Datensatz COCO keypoints trainiert und eignen sich für eine Vielzahl von Pose-Estimation-Aufgaben.
Im standardmäßigen YOLO26-Pose-Modell gibt es 17 Keypoints, von denen jeder einen anderen Teil des menschlichen Körpers repräsentiert. Hier ist die Zuordnung der einzelnen Indizes zu den jeweiligen Körpergelenken:
- Nase
- Linkes Auge
- Rechtes Auge
- Linkes Ohr
- Rechtes Ohr
- Linke Schulter
- Rechte Schulter
- Linker Ellbogen
- Rechter Ellbogen
- Linkes Handgelenk
- Rechtes Handgelenk
- Linke Hüfte
- Rechte Hüfte
- Linkes Knie
- Rechtes Knie
- Linker Knöchel
- Rechter Knöchel
Models#
Vertrainierte Pose-Modelle von Ultralytics YOLO26 werden hier angezeigt. Detect-, Segment- und Pose-Modelle sind auf dem COCO-Datensatz vorab trainiert, Semantic-Modelle auf Cityscapes und Classify-Modelle auf dem ImageNet-Datensatz.
Modelle werden bei der ersten Verwendung automatisch aus dem neuesten Ultralytics-Release heruntergeladen.
| Modell | Größe (Pixel) | mAPpose 50-95(e2e) | mAPpose 50(e2e) | Geschwindigkeit CPU ONNX (ms) | Geschwindigkeit T4 TensorRT10 (ms) | Parameter (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 |
- mAPval-Werte gelten für ein einzelnes Modell im Einzelskalierungsmodus auf dem Datensatz COCO Keypoints val2017.
Reproduzieren mityolo val pose data=coco-pose.yaml device=0 - Geschwindigkeit gemittelt über COCO-val-Bilder unter Verwendung einer Amazon EC2 P4d-Instanz.
Reproduzieren mityolo val pose data=coco-pose.yaml batch=1 device=0|cpu - Params- und FLOPs-Werte gelten für das fusionierte Modell nach
model.fuse(), welches Conv- und BatchNorm-Schichten zusammenführt und bei End-to-End-Modellen den zusätzlichen One-to-Many-Erkennungskopf entfernt. Vorab trainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können höhere Anzahlen aufweisen.
Trainieren#
Trainiere ein YOLO26-pose-Modell auf dem COCO8-pose-Datensatz. Der COCO8-pose dataset ist ein kleiner Beispieldatensatz, der sich perfekt zum Testen und Debuggen deiner Pose-Estimation-Modelle eignet.
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)Weitere Details zum Modus train findest du auf der Train-Seite. Pose-Modelle können auch mit dem Ultralytics Platform cloud training trainiert werden.
Datensatzformat#
Das Format des YOLO-Pose-Datensatzes wird detailliert im Dataset Guide beschrieben. Um deinen bestehenden Datensatz aus anderen Formaten (wie COCO usw.) in das YOLO-Format zu konvertieren, verwende bitte das JSON2YOLO-Tool von Ultralytics. Ultralytics Platform annotation unterstützt auch Pose-Labels mit integrierten Skelettvorlagen für Personen-, Hand-, Gesichts- und benutzerdefinierte Keypoint-Layouts.
Für benutzerdefinierte Pose-Estimation-Aufgaben kannst du auch spezialisierte Datensätze wie Tiger-Pose zur Tierschätzung, Hand Keypoints zur Handverfolgung oder Dog-Pose zur Hunde-Pose-Analyse erkunden.
Validieren#
Validiere die accuracy des trainierten YOLO26n-pose-Modells auf dem COCO8-pose-Datensatz. Es sind keine Argumente erforderlich, da model seine Trainings-data und -Argumente als Modellattribute beibehält.
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 FNVorhersagen#
Verwende ein trainiertes YOLO26n-pose-Modell, um Vorhersagen auf Bildern auszuführen. Der predict mode ermöglicht dir die Inferenz auf Bildern, Videos oder Echtzeit-Streams.
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)Weitere Details zum predict-Modus findest du auf der Predict-Seite.
Ergebnisausgabe#
Die Pose Estimation gibt ein Results-Objekt pro Bild zurück. Die primären Vorhersagefelder sind result.keypoints für Pose-Koordinaten und result.boxes für die detektierten Instanzen, zu denen diese Keypoints gehören.
| Attribut | Typ | Form | Beschreibung |
|---|---|---|---|
result.keypoints | Keypoints | (N) | Keypoints. |
result.keypoints.data | torch.float32 | (N,K,2/3) | x,y plus optionale Sichtbarkeit / Konfidenz. |
result.keypoints.xy | torch.float32 | (N,K,2) | Pixel-Keypoints. |
result.keypoints.xyn | torch.float32 | (N,K,2) | Normalisierte Keypoints. |
result.boxes | Boxes | (N) | Instanzboxen. |
Aufgabenspezifische Results-Felder für alle Aufgaben findest du im Abschnitt Predict Results by Task.
Exportieren#
Exportiere ein YOLO26n-Pose-Modell in ein anderes Format wie ONNX, CoreML usw. Dadurch kannst du dein Modell auf verschiedenen Plattformen und Geräten für die Echtzeit-Inferenz bereitstellen.
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")Die verfügbaren Exportformate für YOLO26-pose sind in der folgenden Tabelle aufgeführt. Du kannst in jedes Format exportieren, indem du das Argument format verwendest, d. h. format='onnx' oder format='engine'. Du kannst direkt an exportierten Modellen Vorhersagen treffen oder sie validieren, d. h. yolo predict model=yolo26n-pose.onnx. Anwendungsbeispiele werden nach Abschluss des Exports für dein Modell angezeigt.
| Format | format-Argument | Modell | Metadaten | Argumente |
|---|---|---|---|---|
| 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 |
Weitere Details zum export-Modus findest du auf der Export-Seite.
FAQ#
Pose Estimation mit Ultralytics YOLO26 beinhaltet die Identifizierung spezifischer Punkte, die als Keypoints bekannt sind, in einem Bild. Diese Keypoints repräsentieren typischerweise Gelenke oder andere wichtige Merkmale des Objekts. Die Ausgabe umfasst die
[x, y]-Koordinaten und Konfidenzwerte für jeden Punkt. YOLO26-pose-Modelle wurden speziell für diese Aufgabe entwickelt und verwenden das Suffix-pose, wie zum Beispielyolo26n-pose.pt. Diese Modelle sind auf Datensätzen wie COCO keypoints vorab trainiert und können für verschiedene Pose-Estimation-Aufgaben verwendet werden. Weitere Informationen findest du auf der Pose Estimation Page.Das Training eines YOLO26-pose-Modells auf einem benutzerdefinierten Datensatz beinhaltet das Laden eines Modells, entweder ein neues Modell, das durch eine YAML-Datei definiert ist, oder ein vortrainiertes Modell. Du kannst dann den Trainingsprozess mit deinem spezifizierten Datensatz und Parametern starten.
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)Ausführliche Details zum Training findest du im Abschnitt Train Section. Du kannst auch Ultralytics Platform cloud training für einen No-Code-Ansatz zum Training benutzerdefinierter Pose-Estimation-Modelle verwenden.
Die Validierung eines YOLO26-pose-Modells beinhaltet die Bewertung seiner Genauigkeit unter Verwendung der gleichen Datensatzparameter, die während des Trainings beibehalten wurden. Hier ist ein Beispiel:
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 rememberedWeitere Informationen findest du im Abschnitt Val Section.
Ja, du kannst ein YOLO26-pose-Modell in verschiedene Formate wie ONNX, CoreML, TensorRT und mehr exportieren. Dies kann entweder mit Python oder dem Command Line Interface (CLI) erfolgen.
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")Weitere Details findest du im Abschnitt Export Section. Exportierte Modelle können auf Edge-Geräten für Echtzeitanwendungen wie Fitnesstraining, Sportanalyse oder Robotik eingesetzt werden.
Ultralytics YOLO26 bietet verschiedene vortrainierte Pose-Modelle wie YOLO26n-pose, YOLO26s-pose, YOLO26m-pose und andere. Diese Modelle unterscheiden sich in Größe, Genauigkeit (mAP) und Geschwindigkeit. Zum Beispiel erreicht das YOLO26n-pose-Modell einen mAPpose50-95 von 57,2 und einen mAPpose50 von 83,3. Eine vollständige Liste und Leistungsdetails findest du im Abschnitt Models Section.