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. Ces points clés peuvent représenter diverses parties de l'objet telles que des articulations, des points de repère ou d'autres caractéristiques distinctives. Les emplacements des points clés sont généralement représentés sous la forme d'un ensemble de coordonnées 2D [x, y] ou 3D [x, y, visible].

Le résultat d'un modèle d'estimation de pose est un ensemble de points qui représentent les points clés sur un objet dans l'image, généralement accompagnés de scores de confiance pour chaque point. L'estimation de pose est un excellent choix lorsque tu as besoin d'identifier des parties spécifiques d'un objet dans une scène, ainsi que leur emplacement les unes par rapport aux autres.

Modèles

Les modèles de pose pré-entraînés Ultralytics YOLO26 sont présentés ici. Les modèles de détection (Detect), de segmentation (Segment) et de pose (Pose) sont pré-entraînés sur le jeu de données COCO, tandis que les modèles de classification (Classify) sont pré-entraînés sur le jeu de données ImageNet.

Les modèles se téléchargent automatiquement depuis la dernière version d'Ultralytics lors de leur première utilisation.

• mAP^val sont les valeurs pour un modèle unique à échelle unique sur le jeu de données COCO Keypoints val2017.
  Reproduis-le avec yolo val pose data=coco-pose.yaml device=0
• Vitesse moyennée sur les images de validation COCO en utilisant une instance Amazon EC2 P4d.
  Reproduis-le avec yolo val pose data=coco-pose.yaml batch=1 device=0|cpu
• Les valeurs Params et FLOPs sont pour le modèle fusionné après model.fuse(), ce qui fusionne les couches Conv et BatchNorm et, pour les modèles end2end, supprime la tête de détection auxiliaire one-to-many. Les points de contrôle pré-entraînés conservent l'architecture d'entraînement complète et peuvent afficher des nombres plus élevés.

Entraînement

Entraîne 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'échantillonnage idéal pour tester et déboguer tes 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)

Consulte les détails complets du mode train sur la page Entraîner (Train). Les modèles de pose peuvent également être entraînés sur des GPU dans le cloud via la Plateforme Ultralytics.

Format de jeu de données

Le format du jeu de données YOLO pose se trouve en détail dans le Guide des jeux de données. Pour convertir ton jeu de données existant depuis d'autres formats (comme COCO, etc.) vers le format YOLO, utilise l'outil JSON2YOLO d'Ultralytics. La Plateforme Ultralytics prend également en charge l'annotation de pose avec des modèles de squelette intégrés pour les personnes, les mains, les visages et les mises en page de points clés personnalisées.

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

Validation

Valide l'accuracy du modèle YOLO26n-pose entraîné sur le jeu de données COCO8-pose. Aucun argument n'est nécessaire car le model conserve ses data d'entraînement et ses arguments en tant qu'attributs de 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.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 FN

Prédire

Utilise un modèle YOLO26n-pose entraîné pour effectuer des prédictions sur des images. Le mode de prédiction (predict mode) te permet d'effectuer l'inférence 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)

Vois tous les détails du mode predict sur la page Predict.

Exportation

Exporte un modèle YOLO26n Pose vers un format différent comme ONNX, CoreML, etc. Cela te permet de déployer ton 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")

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

Voir les détails complets sur l'export dans la page Export.

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 consiste à identifier des points spécifiques, appelés points clés, dans une image. Ces points clés représentent généralement des articulations ou d'autres caractéristiques importantes de l'objet. Le résultat inclut les coordonnées [x, y] et les scores de confiance pour chaque point. Les modèles YOLO26-pose sont spécifiquement conçus pour cette tâche et utilisent le suffixe -pose, tel que yolo26n-pose.pt. Ces modèles sont pré-entraînés sur des jeux de données comme COCO keypoints et peuvent être utilisés pour diverses tâches d'estimation de pose. Pour plus d'informations, visite 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é. Tu peux ensuite lancer le processus d'entraînement en utilisant ton jeu de données et tes 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, reporte-toi à la Section Entraîner (Train). Tu peux également utiliser la Plateforme Ultralytics pour une approche sans code pour entraîner des modèles d'estimation de pose personnalisés.

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

La validation d'un modèle YOLO26-pose implique d'évaluer sa précision en utilisant les mêmes paramètres de jeu de données 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, visite la Section Valider (Val).

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

Oui, tu peux exporter un modèle YOLO26-pose vers divers formats comme ONNX, CoreML, TensorRT, et plus encore. Cela peut être fait en utilisant soit Python, soit 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")

Reporte-toi à la Section Exporter (Export) pour plus de détails. Les modèles exportés peuvent être déployés sur des appareils de périphérie (edge devices) pour des applications en temps réel comme le suivi de fitness, l'analyse sportive, ou la robotique.

Quels sont les modèles de pose Ultralytics YOLO26 disponibles et leurs mesures de performance ?

Ultralytics YOLO26 propose divers modèles de pose pré-entraînés tels que YOLO26n-pose, YOLO26s-pose, YOLO26m-pose, parmi d'autres. Ces modèles diffèrent en taille, en précision (mAP) et en 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 les détails de performance, visite la Section Modèles.