Realtime schatting van de pose van video in Python met YOLOv7

Introductie

Objectdetectie is een groot gebied in computervisie en een van de belangrijkste toepassingen van computervisie "in het wild". Hieruit werd keypoint-detectie (vaak gebruikt voor pose-inschatting) geëxtraheerd.

Sleutelpunten kunnen verschillende punten zijn - delen van een gezicht, ledematen van een lichaam, enz. Poseschatting is een speciaal geval van sleutelpuntdetectie - waarbij de punten delen van een menselijk lichaam zijn.

Pose-schatting is een geweldig, extreem leuk en praktisch gebruik van computervisie. Hiermee kunnen we de hardware afschaffen die wordt gebruikt om houdingen in te schatten (motion capture-pakken), die duur en onpraktisch zijn. Bovendien kunnen we de beweging van mensen in kaart brengen met de beweging van robots in de Euclidische ruimte, waardoor fijne precisie motorbewegingen mogelijk zijn zonder gebruik te maken van controllers, die meestal geen hogere niveaus van precisie mogelijk maken. Keypoint-schatting kan worden gebruikt om onze bewegingen te vertalen naar 3D-modellen in AR en VR, en wordt steeds vaker gebruikt om dit te doen met alleen een webcam. Ten slotte kan pose-inschatting ons helpen in sport en veiligheid.

In deze handleiding zullen we een realtime pose-inschatting uitvoeren op basis van een video in Python, met behulp van het ultramoderne YOLOv7-model.

In het bijzonder zullen we werken met een video van de Olympische Winterspelen van 2018, gehouden in PyeongChang, Zuid-Korea:

Aljona Savchenko en Bruno Massot deden een geweldige prestatie, inclusief overlappende lichamen tegen de camera, snelle vloeiende bewegingen en ronddraaien in de lucht. Het zal een geweldige kans zijn om te zien hoe het model omgaat met moeilijk af te leiden situaties!

YOLO en pose schatting

YOLO (je kijkt maar één keer) is een methodologie, evenals een familie van modellen die zijn gebouwd voor objectdetectie. Sinds de oprichting in 2015 zijn YOLOv1, YOLOv2 (YOLO9000) en YOLOv3 voorgesteld door dezelfde auteur(s) - en de deep learning-gemeenschap ging door met open source-ontwikkelingen in de daaropvolgende jaren.

YOLov5 . van ultralytica is een objectdetectierepository van industriële kwaliteit, gebouwd bovenop de YOLO-methode. Het is geïmplementeerd in PyTorch, in tegenstelling tot C++ voor eerdere YOLO-modellen, is volledig open source en heeft een prachtig eenvoudige en krachtige API waarmee je het project flexibel kunt afleiden, trainen en aanpassen. Het is zo'n belangrijk onderdeel dat de meeste nieuwe pogingen om de YOLO-methode te verbeteren daarop voortbouwen.

Dit is hoe YOLOR (je leert maar één representatie) en YOLOv7 die bovenop YOLOR (dezelfde auteur) zijn gebouwd, zijn ook gemaakt!

YOLOv7 is niet alleen een objectdetectie-architectuur - het biedt nieuwe modelkoppen, die keypoints (skeletten) kunnen uitvoeren en instantiesegmentatie kunnen uitvoeren, naast alleen begrenzingsvakregressie, wat niet standaard was bij eerdere YOLO-modellen. Dit is niet verrassend, aangezien veel objectdetectie-architecturen eerder een nieuwe bestemming kregen voor bijvoorbeeld segmentatie- en keypoint-detectietaken, vanwege de gedeelde algemene architectuur, met verschillende outputs, afhankelijk van de taak.

Hoewel het niet verrassend is, zal het ondersteunen van instantiesegmentatie en keypoint-detectie waarschijnlijk de nieuwe standaard worden voor op YOLO gebaseerde modellen, die een paar jaar geleden praktisch alle andere tweetrapsdetectoren zijn gaan overtreffen in termen van zowel nauwkeurigheid als snelheid.

Hierdoor kunnen instantiesegmentatie en keypoint-detectie sneller dan ooit tevoren worden uitgevoerd, met een eenvoudigere architectuur dan tweetrapsdetectoren.

Het model zelf is gemaakt door middel van architecturale veranderingen, evenals het optimaliseren van aspecten van training, genaamd "bag-of-freebies", die de nauwkeurigheid verhoogden zonder de kosten voor gevolgtrekkingen te verhogen.

YOLOv7 . installeren

Laten we beginnen met het klonen van de repository om de broncode te bemachtigen:

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

Laten we nu naar de gaan yolov7 directory, die het project bevat, en bekijk de inhoud:

%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

Nu is YOLO bedoeld als objectdetector en wordt standaard niet geleverd met pose-schattingsgewichten. We willen de gewichten downloaden en er een concreet modelexemplaar van laden. De gewichten zijn beschikbaar in dezelfde GitHub-repository en kunnen ook eenvoudig worden gedownload via de 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

Eenmaal gedownload, kunnen we de bibliotheken en hulpmethoden importeren die we zullen gebruiken:

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 goed! Laten we doorgaan met het laden van het model en het maken van een script waarmee je poses kunt afleiden uit video's met YOLOv7 en OpenCV.

Realtime schatting van de pose met YOLOv7

Laten we eerst een methode maken om het model te laden vanuit de gedownloade gewichten. We kijken welk apparaat we beschikbaar hebben (CPU of 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()

Afhankelijk van of we een GPU hebben of niet, zullen we halve precisie inschakelen (met behulp van float16 in plaats van float32 in operaties), wat de inferentie aanzienlijk sneller maakt. Merk op dat het ten zeerste wordt aangemoedigd om dit op een GPU uit te voeren voor realtime snelheden, aangezien CPU's waarschijnlijk niet de kracht zullen hebben om dit te doen, tenzij ze op kleine video's draaien.

Laten we een gemaksmethode schrijven voor het uitvoeren van gevolgtrekkingen. We accepteren afbeeldingen als NumPy-arrays (want dat is wat we later zullen doorgeven tijdens het lezen van de video). Ten eerste, met behulp van de letterbox() functie - we zullen de video verkleinen en opvullen in een vorm waarmee het model kan werken. Dit hoeft niet de vorm (resolutie) van de resulterende video te zijn en zal dit ook niet zijn!

Vervolgens passen we de transformaties toe, converteren we de afbeelding naar halve precisie (als er een GPU beschikbaar is), batchen we deze en voeren we deze door het model:

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

We geven de voorspellingen van het model terug, evenals de afbeelding als tensor. Dit zijn "ruwe" voorspellingen - ze bevatten veel activeringen die elkaar overlappen, en we willen ze "opschonen" met behulp van Non-Max Supression, en de voorspelde skeletten over de afbeelding zelf plotten:

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

Als deze op hun plaats zijn, ziet onze algemene stroom er als volgt uit:

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

Om dat te vertalen naar een realtime video-instelling, gebruiken we OpenCV om een ​​video te lezen en voeren we dit proces voor elk frame uit. Op elk frame schrijven we het frame ook in een nieuw bestand, gecodeerd als een video. Dit zal het proces noodzakelijkerwijs vertragen omdat we de inferentie uitvoeren, weergeven en schrijven - zodat u de inferentie en weergave kunt versnellen door het maken van een nieuw bestand te vermijden en er in de lus naar te schrijven:

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

De VideoWriter accepteert verschillende parameters - de naam van het uitvoerbestand, de FourCC (vier codec-codes, die de codec aangeven die wordt gebruikt om de video te coderen), de framerate en de resolutie als een tuple. Om de video niet te raden of het formaat ervan aan te passen, hebben we de breedte en hoogte van de originele video gebruikt, verkregen via de VideoCapture instantie die gegevens over de video zelf bevat, zoals de breedte, hoogte, totaal aantal frames, enz.

Nu kunnen we de methode op elke invoervideo aanroepen:

pose_estimation_video('../ice_skating.mp4')

Dit opent een OpenCV-venster waarin de gevolgtrekking in realtime wordt weergegeven. En het zal ook een videobestand schrijven in de yolov7 directory (aangezien we cdheb er zin in):

Conclusie

In deze handleiding hebben we gekeken naar de YOLO-methode, YOLOv7 en de relatie tussen YOLO en objectdetectie, poseschatting en instantiesegmentatie. Vervolgens hebben we bekeken hoe u YOLOv7 eenvoudig kunt installeren en ermee kunt werken met behulp van de programmatische API, en hebben we verschillende gemaksmethoden ontwikkeld om conclusies te trekken en resultaten weer te geven.

Ten slotte hebben we een video geopend met OpenCV, inferentie uitgevoerd met YOLOv7 en een functie gemaakt voor het uitvoeren van pose-inschatting in realtime, waarbij de resulterende video in volledige resolutie en 30FPS op uw lokale schijf wordt opgeslagen.

Verder gaan - Praktisch diep leren voor computervisie

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Type cursus: "Praktisch diep leren voor computervisie met Python".

Nog een cursus computervisie?

We zullen geen classificatie van MNIST-cijfers of MNIST-mode doen. Ze hebben lang geleden hun deel gediend. Te veel leermiddelen zijn gericht op basisgegevenssets en basisarchitecturen voordat geavanceerde black-box-architecturen de last van de prestaties op zich nemen.

We willen ons concentreren op demystificatie, uitvoerbaarheid, begrip, intuïtie en echte projecten. Willen leren hoe je kan een verschil maken? We nemen je mee op een reis van de manier waarop onze hersenen afbeeldingen verwerken tot het schrijven van een onderzoeksclassificatie voor diep leren voor borstkanker tot diepgaande leernetwerken die 'hallucineren', je de principes en theorie leren door middel van praktisch werk, en je uitrusten met de knowhow en tools om een ​​expert te worden in het toepassen van deep learning om computervisie op te lossen.

Wat zit erin?

• De eerste principes van visie en hoe computers kunnen worden geleerd om te "zien"
• Verschillende taken en toepassingen van computervisie
• De tools van het vak die uw werk gemakkelijker maken
• Datasets zoeken, maken en gebruiken voor computervisie
• De theorie en toepassing van convolutionele neurale netwerken
• Omgaan met domeinverschuiving, gelijktijdig voorkomen en andere vooroordelen in datasets
• Overdragen Leren en de trainingstijd en computerbronnen van anderen gebruiken in uw voordeel
• Het bouwen en trainen van een state-of-the-art classifier voor borstkanker
• Hoe je een gezonde dosis scepsis toepast op mainstream ideeën en de implicaties begrijpt van algemeen aanvaarde technieken?
• De "conceptruimte" van een ConvNet visualiseren met t-SNE en PCA
• Casestudy's van hoe bedrijven computervisietechnieken gebruiken om betere resultaten te behalen
• Correcte modelevaluatie, visualisatie van de latente ruimte en het identificeren van de aandacht van het model
• Domeinonderzoek doen, eigen datasets verwerken en modeltesten opzetten
• Geavanceerde architecturen, de voortgang van ideeën, wat ze uniek maakt en hoe ze te implementeren
• KerasCV – een WIP-bibliotheek voor het maken van ultramoderne pijplijnen en modellen
• Hoe papers te ontleden en te lezen en ze zelf te implementeren?
• Modellen selecteren afhankelijk van uw toepassing
• Een end-to-end machine learning-pijplijn maken
• Landschap en intuïtie bij objectdetectie met snellere R-CNN's, RetinaNets, SSD's en YOLO
• Instantie en semantische segmentatie
• Realtime objectherkenning met YOLOv5
• YOLOv5-objectdetectoren trainen
• Werken met Transformers met KerasNLP (industriële WIP-bibliotheek)
• Transformers integreren met ConvNets om bijschriften van afbeeldingen te genereren
• DeepDream
• Optimalisatie van Deep Learning-modellen voor computervisie