Estimation de pose

L'estimation de pose est une tâche qui consiste à identifier l'emplacement de points spécifiques dans une image, généralement appelés points clés. Les points clés peuvent représenter diverses parties de l'objet, telles que les articulations, les points de repère ou d'autres caractéristiques distinctives. Les emplacements des points clés sont généralement représentés par un ensemble de 2D [x, y] ou 3D [x, y, visible] coordonnées.

La sortie d'un modèle d'estimation de pose est un ensemble de points qui représentent les points clés d'un objet dans l'image, généralement accompagnés des scores de confiance pour chaque point. L'estimation de pose est un bon choix lorsque vous devez identifier des parties spécifiques d'un objet dans une scène, et leur emplacement les unes par rapport aux autres.

Regarder : Tutoriel d'estimation de pose Ultralytics YOLO26 | Suivi d'objets en temps réel et détection de pose humaine

Modèles

Les modèles de pose pré-entraînés Ultralytics YOLO26 sont présentés ici. Les modèles detect, segment et pose sont pré-entraînés sur le jeu de données COCO, tandis que les modèles classify sont pré-entraînés sur le jeu de données ImageNet.

Les modèles sont téléchargés automatiquement depuis la dernière version d'Ultralytics lors de la première utilisation.

• mAP^val Les valeurs Points clés COCO val2017 dataset.
  Reproduire en utilisant yolo val pose data=coco-pose.yaml device=0
• Vitesse moyennée sur les images COCO val en utilisant un instance Amazon EC2 P4d. instance.
  Reproduire en utilisant yolo val pose data=coco-pose.yaml batch=1 device=0|cpu

Entraîner

Entraîner un modèle YOLO26-pose sur le jeu de données COCO8-pose. Le jeu de données COCO8-pose est un petit jeu de données d'échantillon qui est parfait pour tester et déboguer vos modèles d'estimation de pose.

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)

# Build a new model from YAML and start training from scratch
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.pt epochs=100 imgsz=640

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo pose train data=coco8-pose.yaml model=yolo26n-pose.yaml pretrained=yolo26n-pose.pt epochs=100 imgsz=640

Format du jeu de données

Le format du jeu de données de pose YOLO est décrit en détail dans le Guide des jeux de données. Pour convertir votre jeu de données existant d'autres formats (comme COCO, etc.) au format YOLO, veuillez utiliser l'outil JSON2YOLO d'Ultralytics.

Pour les tâches personnalisées d'estimation de pose, vous pouvez également explorer des ensembles de données spécialisés comme Tiger-Pose pour l'estimation de la pose animale, Hand Keypoints pour le suivi des mains, ou Dog-Pose pour l'analyse de la pose canine.

Valider

Valider un modèle YOLO26n-pose entraîné précision sur l'ensemble de données COCO8-pose. Aucun argument n'est nécessaire car le model conserve son entraînement data et ses arguments en tant qu'attributs du modèle.

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

yolo pose val model=yolo26n-pose.pt # val official model
yolo pose val model=path/to/best.pt # val custom model

Prédire

Utilisez un modèle YOLO26n-pose entraîné pour exécuter des prédictions sur des images. Le mode prédiction vous permet d'effectuer des inférences sur des images, des vidéos ou des flux en temps réel.

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)

yolo pose predict model=yolo26n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model

Voir tous les predict détails du mode dans la Prédire page.

Exporter

Exportez un modèle YOLO26n Pose vers un format différent comme ONNX, CoreML, etc. Cela vous permet de déployer votre modèle sur diverses plateformes et appareils pour l'inférence en temps réel.

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

yolo export model=yolo26n-pose.pt format=onnx # export official model
yolo export model=path/to/best.pt format=onnx # export custom-trained model

Les formats d'exportation YOLO26-pose disponibles sont présentés dans le tableau ci-dessous. Vous pouvez exporter vers n'importe quel format en utilisant le format argument, c'est-à-dire format='onnx' ou format='engine'. Vous pouvez prédire ou valider directement sur les modèles exportés, c'est-à-dire, yolo predict model=yolo26n-pose.onnx. Des exemples d'utilisation sont présentés pour votre modèle une fois l'exportation terminée.

Voir tous les export détails dans la section Exporter page.

FAQ

Qu'est-ce que l'estimation de pose avec Ultralytics YOLO26 et comment cela fonctionne-t-il ?

L'estimation de pose avec Ultralytics YOLO26 implique l'identification de points spécifiques, appelés keypoints, dans une image. Ces keypoints représentent généralement des articulations ou d'autres caractéristiques importantes de l'objet. La sortie inclut les [x, y] coordonnées et scores de confiance pour chaque point. Les modèles YOLO26-pose sont spécifiquement conçus pour cette tâche et utilisent le -pose suffixe, tel que yolo26n-pose.pt. Ces modèles sont pré-entraînés sur des jeux de données comme Points clés COCO et peut être utilisé pour diverses tâches d'estimation de pose. Pour plus d'informations, consultez la Page d'estimation de pose.

Comment puis-je entraîner un modèle YOLO26-pose sur un jeu de données personnalisé ?

L'entraînement d'un modèle YOLO26-pose sur un jeu de données personnalisé implique le chargement d'un modèle, soit un nouveau modèle défini par un fichier yaml, soit un modèle pré-entraîné. Vous pouvez ensuite démarrer le processus d'entraînement en utilisant votre jeu de données et vos paramètres spécifiés.

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)

Pour des détails complets sur l'entraînement, consultez la section Entraînement. Vous pouvez également utiliser la Plateforme Ultralytics pour une approche sans code de l'entraînement de modèles d'estimation de pose personnalisés.

Comment valider un modèle YOLO26-pose entraîné ?

La validation d'un modèle YOLO26-pose implique l'évaluation de sa précision en utilisant les mêmes paramètres de jeu de données que ceux conservés pendant l'entraînement. Voici un exemple :

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

Pour plus d'informations, consultez la Section Val.

Puis-je exporter un modèle YOLO26-pose vers d'autres formats, et comment ?

Oui, vous pouvez exporter un modèle YOLO26-pose vers divers formats comme ONNX, CoreML, TensorRT, et plus encore. Cela peut être fait en utilisant python ou l'interface de ligne de commande (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")

Consultez la section Exportation pour plus de détails. Les modèles exportés peuvent être déployés sur des appareils périphériques pour des applications en temps réel telles que le suivi de la condition physique, l'analyse sportive ou la robotique.

Quels sont les modèles Ultralytics YOLO26-pose disponibles et leurs métriques de performance ?

Ultralytics YOLO26 propose divers modèles de pose pré-entraînés tels que YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, entre autres. Ces modèles diffèrent par leur taille, leur précision (mAP) et leur vitesse. Par exemple, le modèle YOLO26n-pose atteint un mAP^pose50-95 de 50,0 et un mAP^pose50 de 81,0. Pour une liste complète et des détails sur les performances, visitez la section Modèles.

📅 Créé il y a 2 ans ✏️ Mis à jour il y a 2 jours

Commentaires