Estimation de pose/détection de points clés avec YOLOv7 en Python

Introduction

La détection d'objets est un vaste domaine de la vision par ordinateur et l'une des applications les plus importantes de la vision par ordinateur "dans la nature".

La détection d'objets n'est pas aussi standardisée que la classification d'images, principalement parce que la plupart des nouveaux développements sont généralement réalisés par des chercheurs, des mainteneurs et des développeurs individuels, plutôt que par de grandes bibliothèques et frameworks. Il est difficile de regrouper les scripts utilitaires nécessaires dans un cadre tel que TensorFlow ou PyTorch et de maintenir les directives de l'API qui ont guidé le développement jusqu'à présent.

Cela rend la détection d'objets un peu plus complexe, généralement plus détaillée (mais pas toujours) et moins accessible que la classification d'images.

Heureusement pour les masses - Ultralytics a développé une API de détection d'objets simple, très puissante et belle autour de leur YOLOv5 qui a été étendue par d'autres équipes de recherche et développement dans des versions plus récentes, telles que YOLOv7.

Dans ce petit guide, nous effectuerons l'estimation de pose (détection de points clés) en Python, avec YOLOv7 à la pointe de la technologie.

Les points clés peuvent être divers points - parties d'un visage, membres d'un corps, etc. L'estimation de la pose est un cas particulier de détection de points clés - dans lequel les points font partie d'un corps humain et peuvent être utilisés pour remplacer le matériel de suivi de position coûteux, permettent le contrôle robotique en direct et propulsent une nouvelle ère d'expression de soi humaine grâce à la réalité augmentée et à la réalité virtuelle.

YOLO et estimation de la pose

YOLO (vous ne regardez qu'une seule fois) est une méthodologie, ainsi qu'une famille de modèles construits pour la détection d'objets. Depuis la création en 2015, YOLOv1, YOLOv2 (YOLO9000) et YOLOv3 ont été proposés par le(s) même(s) auteur(s) - et la communauté d'apprentissage en profondeur a continué avec des avancées open source au fil des années.

YOLOv5 d'Ultralytics est la première implémentation à grande échelle de YOLO dans PyTorch, ce qui l'a rendu plus accessible que jamais, mais la principale raison pour laquelle YOLOv5 a pris une telle place est également l'API magnifiquement simple et puissante construite autour de lui. Le projet élimine les détails inutiles, tout en permettant la personnalisation, pratiquement tous les formats d'exportation utilisables, et utilise des pratiques étonnantes qui rendent l'ensemble du projet à la fois efficace et aussi optimal que possible.

YOLOv5 est toujours le projet de base pour créer des modèles de détection d'objets, et de nombreux référentiels qui visent à faire progresser la méthode YOLO commencent avec YOLOv5 comme base et offrent une API similaire (ou simplement bifurquent le projet et construisent dessus). Tel est le cas de YOLOR (Vous n'apprenez qu'une seule représentation) et YOLOv7 qui s'appuie sur YOLOR (même auteur) qui est la dernière avancée de la méthodologie YOLO.

YOLOv7 n'est pas seulement une architecture de détection d'objets - fournit de nouvelles têtes de modèle, qui peuvent produire des points clés (squelettes) et effectuer une segmentation d'instance en plus de la régression de la boîte englobante, qui n'était pas standard avec les modèles YOLO précédents. Ce n'est pas surprenant, car de nombreuses architectures de détection d'objets ont également été réorientées plus tôt pour les tâches de segmentation d'instance et de détection de points clés, en raison de l'architecture générale partagée, avec des sorties différentes en fonction de la tâche. Même si ce n'est pas surprenant, la prise en charge de la segmentation des instances et de la détection des points clés deviendra probablement la nouvelle norme pour les modèles basés sur YOLO, qui ont commencé à surpasser pratiquement tous les autres détecteurs à deux étages il y a quelques années.

Cela rend la segmentation des instances et la détection des points clés plus rapides que jamais, avec une architecture plus simple que les détecteurs à deux étages.

Le modèle lui-même a été créé grâce à des changements architecturaux, ainsi qu'à l'optimisation d'aspects de la formation, surnommé "sac de cadeaux", qui a augmenté la précision sans augmenter le coût d'inférence.

Installation de YOLOv7

Continuons et installons le projet depuis GitHub :

! git clone https://github.com/WongKinYiu/yolov7.git

Cela crée un yolov7 sous votre répertoire de travail actuel, dans lequel vous pourrez trouver les fichiers de base du projet :

%cd yolov7
!ls

/Users/macbookpro/jup/yolov7
LICENSE.md       detect.py        models           tools
README.md        export.py        paper            train.py
cfg              figure           requirements.txt train_aux.py
data             hubconf.py       scripts          utils
deploy           inference        test.py

Remarque: Google Colab Notebooks est réinitialisé dans le répertoire de travail principal de la cellule suivante, même après avoir appelé %cd dirname, vous devrez donc continuer à l'appeler dans chaque cellule dans laquelle vous souhaitez effectuer une opération. Les blocs-notes Jupyter locaux se souviennent de la modification, il n'est donc pas nécessaire de continuer à appeler la commande.

Chaque fois que vous exécutez du code avec un ensemble donné de poids, ils seront téléchargés et stockés dans ce répertoire. Pour effectuer une estimation de pose, nous voudrons télécharger les poids du modèle YOLOv7 pré-formé pour cette tâche, qui se trouve sous le /releases/download/ onglet sur GitHub :

! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt
%cd ..

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  153M  100  153M    0     0  3742k      0  0:00:42  0:00:42 --:--:-- 4573k

/Users/macbookpro/jup

Super, nous avons téléchargé le yolov7-w6-pose.pt fichier de poids, qui peut être utilisé pour charger et reconstruire un modèle formé pour l'estimation de la pose.

Chargement du modèle d'estimation de pose YOLOv7

Importons les bibliothèques dont nous aurons besoin pour effectuer l'estimation de la pose :

import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np

torch ainsi que torchvision sont assez simples - YOLOv7 est implémenté avec PyTorch. La utils.datasets, utils.general ainsi que utils.plots Les modules proviennent du projet YOLOv7 et nous fournissent des méthodes qui aident au prétraitement et à la préparation des entrées pour le modèle sur lequel exécuter l'inférence. Parmi ceux-ci figurent letterbox() pour étoffer l'image, non_max_supression_keypoint() exécuter l'algorithme de suppression non maximale sur la sortie initiale du modèle et produire une sortie propre pour notre interprétation, ainsi que le output_to_keypoint() ainsi que plot_skeleton_kpts() méthodes pour ajouter réellement des points clés à une image donnée, une fois qu'ils sont prédits.

Nous pouvons charger le modèle à partir du fichier de poids avec torch.load(). Créons une fonction pour vérifier si un GPU est disponible, charger le modèle, le mettre en mode inférence et le déplacer vers le GPU si disponible :

def load_model():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = torch.load('yolov7/yolov7-w6-pose.pt', map_location=device)['model']
    
    model.float().eval()

    if torch.cuda.is_available():
        
        
        model.half().to(device)
    return model

model = load_model()

Avec le modèle chargé, créons un run_inference() méthode qui accepte une chaîne pointant vers un fichier sur notre système. La méthode lira l'image en utilisant OpenCV (cv2), tamponnez-le avec letterbox(), appliquez-lui des transformations et transformez-le en lot (le modèle est entraîné et attend des lots, comme d'habitude) :

def run_inference(url):
    image = cv2.imread(url) 
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    
    image = image.unsqueeze(0) 
    output, _ = model(image) 
    return output, image

Ici, nous avons renvoyé l'image transformée (parce que nous voudrons extraire l'original et tracer dessus) et les sorties du modèle. Ces sorties contiennent 45900 prédictions de points clés, dont la plupart se chevauchent. Nous voudrons appliquer la suppression non maximale à ces prédictions brutes, tout comme avec les prédictions de détection d'objets (où de nombreuses boîtes englobantes sont prédites, puis elles sont « effondrées » compte tenu de la confiance et du seuil d'IoU). Après suppression, nous pouvons tracer chaque point clé sur l'image d'origine et l'afficher :

def visualize_output(output, image):
    output = non_max_suppression_kpt(output, 
                                     0.25, 
                                     0.65, 
                                     nc=model.yaml['nc'], 
                                     nkpt=model.yaml['nkpt'], 
                                     kpt_label=True)
    with torch.no_grad():
        output = output_to_keypoint(output)
    nimg = image[0].permute(1, 2, 0) * 255
    nimg = nimg.cpu().numpy().astype(np.uint8)
    nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
    for idx in range(output.shape[0]):
        plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)
    plt.figure(figsize=(12, 12))
    plt.axis('off')
    plt.imshow(nimg)
    plt.show()

Maintenant, pour une image d'entrée, telle que karate.jpg dans le répertoire de travail principal, nous pouvons exécuter l'inférence, effectuer une suppression non maximale et tracer les résultats avec :

output, image = run_inference('./karate.jpg')
visualize_output(output, image)

Cela se traduit par:

C'est une image assez difficile à déduire ! La majeure partie du bras droit du praticien à droite est caché, et on peut voir que le modèle en a déduit qu'il est caché et à droite du corps, manquant que le coude soit fléchi et qu'une partie du bras soit devant . Le pratiquant de gauche, beaucoup plus visible, est déduit correctement, même avec une jambe cachée.

En fait, une personne assise à l'arrière, presque entièrement invisible à la caméra a eu leur pose apparemment correctement estimée, juste basée sur la position des hanches en position assise. Beau travail au nom du réseau !

Conclusion

Dans ce guide, nous avons brièvement examiné YOLOv7, la dernière avancée de la famille YOLO, qui s'appuie sur YOLOR et fournit en outre des capacités de segmentation d'instance et de détection de points clés au-delà des capacités de détection d'objet standard de la plupart des modèles basés sur YOLO. .

Nous avons ensuite examiné comment télécharger les fichiers de poids publiés, les charger pour construire un modèle et effectuer une inférence d'estimation de pose pour les humains, ce qui donne des résultats impressionnants.

Aller plus loin - Apprentissage profond pratique pour la vision par ordinateur

Votre nature curieuse vous donne envie d'aller plus loin ? Nous vous recommandons de consulter notre Cours: "Apprentissage profond pratique pour la vision par ordinateur avec Python".

Un autre cours de vision par ordinateur ?

Nous ne ferons pas de classification des chiffres MNIST ou de la mode MNIST. Ils ont fait leur part il y a longtemps. Trop de ressources d'apprentissage se concentrent sur les ensembles de données de base et les architectures de base avant de laisser les architectures de boîte noire avancées assumer le fardeau des performances.

Nous voulons nous concentrer sur démystification, pratique, compréhension, intuition ainsi que de vrais projets. Vouloir apprendre how tu peux faire la différence? Nous vous emmènerons dans un voyage de la façon dont notre cerveau traite les images à l'écriture d'un classificateur d'apprentissage en profondeur de qualité recherche pour le cancer du sein aux réseaux d'apprentissage en profondeur qui "hallucinent", vous enseignant les principes et la théorie par le biais de travaux pratiques, vous équipant du savoir-faire et outils pour devenir un expert dans l'application de l'apprentissage profond pour résoudre la vision par ordinateur.

Qu'est-ce qu'il y a à l'intérieur?

• Les premiers principes de la vision et comment apprendre aux ordinateurs à « voir »
• Différentes tâches et applications de la vision par ordinateur
• Les outils du métier qui faciliteront votre travail
• Trouver, créer et utiliser des ensembles de données pour la vision par ordinateur
• La théorie et l'application des réseaux de neurones convolutifs
• Gestion du changement de domaine, de la cooccurrence et d'autres biais dans les ensembles de données
• Transférer Apprendre et utiliser le temps de formation et les ressources informatiques des autres à votre avantage
• Construire et former un classificateur de pointe du cancer du sein
• Comment appliquer une bonne dose de scepticisme aux idées dominantes et comprendre les implications des techniques largement adoptées
• Visualiser « l'espace conceptuel » d'un ConvNet à l'aide de t-SNE et PCA
• Études de cas sur la façon dont les entreprises utilisent les techniques de vision par ordinateur pour obtenir de meilleurs résultats
• Évaluation appropriée du modèle, visualisation de l'espace latent et identification de l'attention du modèle
• Effectuer des recherches de domaine, traiter vos propres ensembles de données et établir des tests de modèles
• Les architectures de pointe, la progression des idées, ce qui les rend uniques et comment les mettre en œuvre
• KerasCV - une bibliothèque WIP pour créer des pipelines et des modèles de pointe
• Comment analyser et lire des articles et les mettre en œuvre vous-même
• Sélection de modèles en fonction de votre application
• Création d'un pipeline d'apprentissage automatique de bout en bout
• Paysage et intuition sur la détection d'objets avec Faster R-CNN, RetinaNets, SSD et YOLO
• Instance et segmentation sémantique
• Reconnaissance d'objets en temps réel avec YOLOv5
• Formation aux détecteurs d'objets YOLOv5
• Travailler avec des transformateurs à l'aide de KerasNLP (bibliothèque WIP de pointe)
• Intégration de Transformers avec ConvNets pour générer des légendes d'images
• Rêve profond
• Optimisation du modèle de Deep Learning pour la vision par ordinateur