Estimation de pose en temps réel à partir d'une vidéo en Python avec YOLOv7

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". De là, la détection de points clés (souvent utilisée pour l'estimation de pose) a été extraite.

Les points clés peuvent être divers points - parties d'un visage, membres d'un corps, etc. L'estimation de pose est un cas particulier de détection de points clés - dans lequel les points font partie d'un corps humain.

L'estimation de pose est une utilisation étonnante, extrêmement amusante et pratique de la vision par ordinateur. Avec lui, on peut s'affranchir du matériel utilisé pour estimer les poses (combinaisons de capture de mouvement), coûteux et peu maniable. De plus, nous pouvons mapper le mouvement des humains sur le mouvement des robots dans l'espace euclidien, permettant un mouvement de moteur de précision sans utiliser de contrôleurs, qui ne permettent généralement pas des niveaux de précision plus élevés. L'estimation des points clés peut être utilisée pour traduire nos mouvements en modèles 3D en réalité augmentée et en réalité virtuelle, et est de plus en plus utilisée pour le faire avec une simple webcam. Enfin, l'estimation de la pose peut nous aider dans le domaine du sport et de la sécurité.

Dans ce guide, nous effectuerons une estimation de pose en temps réel à partir d'une vidéo en Python, en utilisant le modèle de pointe YOLOv7.

Plus précisément, nous allons travailler avec une vidéo des Jeux olympiques d'hiver de 2018, qui se sont déroulés à PyeongChang en Corée du Sud :

Aljona Savchenko et Bruno Massot ont fait une performance incroyable, y compris des corps qui se chevauchent contre la caméra, des mouvements rapides et fluides et des rotations dans les airs. Ce sera une opportunité incroyable de voir comment le modèle gère des situations difficiles à déduire !

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 un référentiel de détection d'objets de qualité industrielle, construit sur la méthode YOLO. Il est implémenté dans PyTorch, contrairement à C++ pour les modèles YOLO précédents, est entièrement open source et dispose d'une API magnifiquement simple et puissante qui vous permet de déduire, de former et de personnaliser le projet de manière flexible. C'est tellement essentiel que la plupart des nouvelles tentatives d'amélioration de la méthode YOLO s'appuient sur celle-ci.

C'est ainsi que YOLOR (Vous n'apprenez qu'une seule représentation) et YOLOv7 qui s'appuie sur YOLOR (même auteur) ont également été créés !

YOLOv7 n'est pas seulement une architecture de détection d'objets - il 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 seule 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 en termes de précision et de vitesse.

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

Commençons par cloner le référentiel pour obtenir le code source :

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

Passons maintenant à la yolov7 répertoire, qui contient le projet, et regardez le contenu :

%cd yolov7
!ls

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

Maintenant, YOLO est censé être un détecteur d'objets et n'est pas livré avec des poids d'estimation de pose par défaut. Nous voudrons télécharger les poids et charger une instance de modèle concret à partir d'eux. Les pondérations sont disponibles sur le même référentiel GitHub et peuvent également être facilement téléchargées via la CLI :

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

 % 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  23.4M      0  0:00:06  0:00:06 --:--:-- 32.3M

Une fois téléchargés, nous pouvons importer les bibliothèques et les méthodes d'assistance que nous utiliserons :

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

Super! Passons au chargement du modèle et à la création d'un script qui vous permet de déduire des poses à partir de vidéos avec YOLOv7 et OpenCV.

Estimation de pose en temps réel avec YOLOv7

Commençons par créer une méthode pour charger le modèle à partir des poids téléchargés. Nous allons vérifier quel appareil nous avons disponible (CPU ou GPU):

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

def load_model():
    model = torch.load('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()

Selon que nous avons un GPU ou non, nous activerons la demi-précision (en utilisant float16 au lieu de float32 dans les opérations), ce qui rend l'inférence beaucoup plus rapide. Notez qu'il est fortement recommandé d'effectuer cette opération sur un GPU pour des vitesses en temps réel, car les processeurs n'auront probablement pas la puissance nécessaire pour le faire, à moins de s'exécuter sur de petites vidéos.

Écrivons une méthode pratique pour exécuter l'inférence. Nous accepterons les images en tant que tableaux NumPy (car c'est ce que nous leur transmettrons plus tard lors de la lecture de la vidéo). Tout d'abord, en utilisant le letterbox() fonction - nous redimensionnerons et remplirons la vidéo à une forme avec laquelle le modèle peut fonctionner. Cela n'a pas besoin d'être et ne sera pas la forme (résolution) de la vidéo résultante !

Ensuite, nous appliquerons les transformations, convertirons l'image en demi-précision (si un GPU est disponible), la regrouperons et l'exécuterons dans le modèle :

def run_inference(image):
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    if torch.cuda.is_available():
      image = image.half().to(device)
    
    image = image.unsqueeze(0) 
    with torch.no_grad():
      output, _ = model(image)
    return output, image

Nous allons retourner les prédictions du modèle, ainsi que l'image sous forme de tenseur. Ce sont des prédictions "grossières" - elles contiennent de nombreuses activations qui se chevauchent, et nous voudrons les "nettoyer" en utilisant la suppression non maximale, et tracer les squelettes prédits sur l'image elle-même :

def draw_keypoints(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)

  return nimg

Avec ceux-ci en place, notre flux général ressemblera à :

img = read_img()
outputs, img = run_inference(img)
keypoint_img = draw_keypoints(output, img)

Pour traduire cela en un paramètre vidéo en temps réel, nous utiliserons OpenCV pour lire une vidéo et exécuterons ce processus pour chaque image. Sur chaque image, nous écrirons également l'image dans un nouveau fichier, encodé sous forme de vidéo. Cela ralentira nécessairement le processus pendant que nous exécutons l'inférence, l'affichons et l'écrivons - vous pouvez donc accélérer l'inférence et l'affichage en évitant la création d'un nouveau fichier et en y écrivant dans la boucle :

def pose_estimation_video(filename):
    cap = cv2.VideoCapture(filename)
    
    fourcc = cv2.VideoWriter_fourcc(*'MP4V')
    out = cv2.VideoWriter('ice_skating_output.mp4', fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))))
    while cap.isOpened():
        (ret, frame) = cap.read()
        if ret == True:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            output, frame = run_inference(frame)
            frame = draw_keypoints(output, frame)
            frame = cv2.resize(frame, (int(cap.get(3)), int(cap.get(4))))
            out.write(frame)
            cv2.imshow('Pose estimation', frame)
        else:
            break

        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    out.release()
    cv2.destroyAllWindows()

La VideoWriter accepte plusieurs paramètres - le nom du fichier de sortie, le FourCC (quatre codes codec, désignant le codec utilisé pour encoder la vidéo), le framerate et la résolution sous forme de tuple. Pour ne pas deviner ou redimensionner la vidéo - nous avons utilisé la largeur et la hauteur de la vidéo d'origine, obtenues via le VideoCapture instance qui contient des données sur la vidéo elle-même, telles que la largeur, la hauteur, le nombre total d'images, etc.

Maintenant, nous pouvons appeler la méthode sur n'importe quelle vidéo d'entrée :

pose_estimation_video('../ice_skating.mp4')

Cela ouvrira une fenêtre OpenCV, affichant l'inférence en temps réel. Et aussi, il écrira un fichier vidéo dans le yolov7 répertoire (puisque nous avons cd'd dedans):

Conclusion

Dans ce guide, nous avons examiné la méthode YOLO, YOLOv7 et la relation entre YOLO et la détection d'objets, l'estimation de pose et la segmentation d'instance. Nous avons ensuite examiné comment vous pouvez facilement installer et utiliser YOLOv7 à l'aide de l'API de programmation, et créé plusieurs méthodes pratiques pour faciliter l'inférence et l'affichage des résultats.

Enfin, nous avons ouvert une vidéo à l'aide d'OpenCV, exécuté une inférence avec YOLOv7 et créé une fonction permettant d'effectuer une estimation de pose en temps réel, en enregistrant la vidéo résultante en pleine résolution et à 30 images par seconde sur votre disque local.

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