Pose Estimation/Keypoint Detection met YOLOv7 in Python

Introductie

Objectdetectie is een groot gebied in computervisie en een van de belangrijkste toepassingen van computervisie "in het wild".

Objectdetectie is niet zo gestandaardiseerd als beeldclassificatie, vooral omdat de meeste nieuwe ontwikkelingen doorgaans worden gedaan door individuele onderzoekers, beheerders en ontwikkelaars, in plaats van door grote bibliotheken en frameworks. Het is moeilijk om de benodigde hulpprogrammascripts in een framework als TensorFlow of PyTorch te verpakken en de API-richtlijnen te handhaven die de ontwikkeling tot dusver hebben geleid.

Dit maakt objectdetectie iets complexer, doorgaans uitgebreider (maar niet altijd) en minder benaderbaar dan beeldclassificatie.

Gelukkig voor de massa heeft Ultralytics een eenvoudige, zeer krachtige en mooie objectdetectie-API ontwikkeld rond hun YOLOv5, die door andere onderzoeks- en ontwikkelingsteams is uitgebreid naar nieuwere versies, zoals YOLOv7.

In deze korte handleiding voeren we Pose Estimation (Keypoint Detection) uit in Python, met ultramoderne YOLOv7.

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 en kunnen worden gebruikt om dure hardware voor het volgen van posities te vervangen, maak over-the-air robotbesturing mogelijk en stimuleer een nieuw tijdperk van menselijke zelfexpressie via AR en VR.

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 de eerste grootschalige implementatie van YOLO in PyTorch, waardoor het toegankelijker is dan ooit tevoren, maar de belangrijkste reden waarom YOLOv5 zo'n voet aan de grond heeft gekregen, is ook de prachtig eenvoudige en krachtige API die eromheen is gebouwd. Het project abstraheert de onnodige details, terwijl het aanpasbaarheid mogelijk maakt, praktisch alle bruikbare exportformaten, en maakt gebruik van verbazingwekkende praktijken die het hele project zowel efficiënt als optimaal maken.

YOLOv5 is nog steeds het belangrijkste project om objectdetectiemodellen mee te bouwen, en veel repositories die de YOLO-methode willen bevorderen, beginnen met YOLOv5 als basislijn en bieden een vergelijkbare API (of gewoon het project splitsen en er bovenop bouwen). Zo is het geval van YOLOR (je leert maar één representatie) en YOLOv7 die voortbouwde op YOLOR (dezelfde auteur), de nieuwste vooruitgang in de YOLO-methodologie.

YOLOv7 is niet alleen een objectdetectie-architectuur - 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.

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 doorgaan en het project van GitHub installeren:

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

Dit creëert een yolov7 directory onder uw huidige werkdirectory, waarin u de basisprojectbestanden kunt vinden:

%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

Opmerking: Google Colab Notebooks worden teruggezet naar de hoofdwerkmap in de volgende cel, zelfs na aanroepen %cd dirname, dus je moet het blijven aanroepen in elke cel waarin je een bewerking wilt laten uitvoeren. Lokale Jupyter-notebooks onthouden de wijziging, dus het is niet nodig om het commando te blijven aanroepen.

Telkens wanneer u code uitvoert met een bepaalde set gewichten, worden deze gedownload en opgeslagen in deze map. Om de pose-inschatting uit te voeren, willen we de gewichten downloaden voor het vooraf getrainde YOLOv7-model voor die taak, die te vinden is onder de /releases/download/ tabblad op 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

Geweldig, we hebben de . gedownload yolov7-w6-pose.pt weights-bestand, dat kan worden gebruikt om een ​​getraind model voor pose-schatting te laden en te reconstrueren.

Het YOLOv7 Pose-schattingsmodel laden

Laten we de bibliotheken importeren die we nodig hebben om de pose-schatting uit te voeren:

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 en torchvision zijn eenvoudig genoeg - YOLOv7 is geïmplementeerd met PyTorch. De utils.datasets, utils.general en utils.plots modules komen uit het YOLOv7-project en bieden ons methoden die helpen bij het voorbewerken en voorbereiden van invoer voor het model om gevolgtrekkingen op uit te voeren. Daaronder zijn: letterbox() om het beeld op te vullen, non_max_supression_keypoint() om het Non-Max Supression-algoritme uit te voeren op de initiële uitvoer van het model en om een ​​schone uitvoer voor onze interpretatie te produceren, evenals de output_to_keypoint() en plot_skeleton_kpts() methoden om keypoints daadwerkelijk aan een bepaalde afbeelding toe te voegen, zodra ze zijn voorspeld.

We kunnen het model uit het gewichtsbestand laden met torch.load(). Laten we een functie maken om te controleren of een GPU beschikbaar is, het model laden, in de inferentiemodus zetten en indien beschikbaar naar de GPU verplaatsen:

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

Laten we met het geladen model een . maken run_inference() methode die een tekenreeks accepteert die naar een bestand op ons systeem verwijst. De methode leest de afbeelding met OpenCV (cv2), vul het met letterbox(), pas er transformaties op toe en verander het in een batch (het model is getraind op en verwacht batches, zoals gewoonlijk):

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

Hier hebben we de getransformeerde afbeelding geretourneerd (omdat we het origineel willen extraheren en erop plotten) en de uitvoer van het model. Deze outputs bevatten 45900 keypoint-voorspellingen, waarvan de meeste elkaar overlappen. We willen Non-Max Supression toepassen op deze onbewerkte voorspellingen, net als bij Object Detection-voorspellingen (waar veel begrenzingsvakken worden voorspeld en dan worden ze "samengevouwen" gegeven enig vertrouwen en IoU-drempel). Na onderdrukking kunnen we elk sleutelpunt op de originele afbeelding plotten en weergeven:

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

Nu, voor een invoerafbeelding, zoals: karate.jpg in de hoofdwerkdirectory kunnen we gevolgtrekkingen uitvoeren, Non-Max Supression uitvoeren en de resultaten plotten met:

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

Dit resulteert in:

Dit is een vrij moeilijk beeld om af te leiden! Het grootste deel van de rechterarm van de beoefenaar aan de rechterkant is verborgen, en we kunnen zien dat het model concludeerde dat het verborgen is en aan de rechterkant van het lichaam, missend dat de elleboog gebogen is en dat een deel van de arm vooraan zit . De beoefenaar aan de linkerkant, die veel duidelijker te zien is, wordt correct afgeleid, zelfs met een verborgen been.

In feite - een persoon die achterin zit, bijna volledig onzichtbaar voor de camera hun pose schijnbaar correct is ingeschat, alleen gebaseerd op de positie van de heupen tijdens het zitten. Knap werk namens het netwerk!

Conclusie

In deze gids hebben we een korte blik geworpen op YOLOv7, de nieuwste vooruitgang in de YOLO-familie, die voortbouwt op YOLOR, en verder voorziet in segmentatie van instanties en keypoint-detectiemogelijkheden die verder gaan dan de standaard objectdetectiemogelijkheden van de meeste op YOLO gebaseerde modellen .

Vervolgens hebben we bekeken hoe we vrijgegeven gewichtsbestanden kunnen downloaden, ze kunnen laden om een ​​model te construeren en pose-inferentie voor mensen uit te voeren, wat indrukwekkende resultaten oplevert.

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