Poseringsestimering/nøglepunktsdetektion med YOLOv7 i Python

Introduktion

Objektdetektion er et stort felt inden for computersyn og en af ​​de vigtigere anvendelser af computersyn "i naturen".

Objektdetektion er ikke så standardiseret som billedklassificering, hovedsagelig fordi de fleste af de nye udviklinger typisk udføres af individuelle forskere, vedligeholdere og udviklere i stedet for store biblioteker og rammer. Det er svært at pakke de nødvendige hjælpescripts i en ramme som TensorFlow eller PyTorch og vedligeholde API-retningslinjerne, der har været styret af udviklingen indtil videre.

Dette gør genkendelse af objekter noget mere kompleks, typisk mere omfattende (men ikke altid) og mindre tilgængelig end billedklassificering.

Heldigvis for masserne – Ultralytics har udviklet en enkel, meget kraftfuld og smuk objektdetektions-API omkring deres YOLOv5, som er blevet udvidet af andre forsknings- og udviklingshold til nyere versioner, såsom YOLOv7.

I denne korte vejledning udfører vi Pose Estimation (Keypoint Detection) i Python, med state-of-the-art YOLOv7.

Nøglepunkter kan være forskellige punkter – dele af et ansigt, lemmer af en krop osv. Pose-estimering er et særligt tilfælde af nøglepunktsdetektion – hvor punkterne er dele af en menneskelig krop og kan bruges til at erstatte dyrt positionssporingsudstyr, muliggør over-the-air robotstyring, og driver en ny tidsalder af menneskelig selvudtryk gennem AR og VR.

YOLO og Pose Estimation

YOLO (Du ser kun én gang) er en metode såvel som en familie af modeller bygget til objektdetektion. Siden starten i 2015 er YOLOv1, YOLOv2 (YOLO9000) og YOLOv3 blevet foreslået af samme forfatter(e) – og deep learning-fællesskabet fortsatte med open source-fremskridt i de fortsatte år.

Ultralytics' YOLOv5 er den første storstilede implementering af YOLO i PyTorch, som gjorde det mere tilgængeligt end nogensinde før, men hovedårsagen til at YOLOv5 har fået sådan fodfæste er også den smukt enkle og kraftfulde API bygget op omkring det. Projektet abstraherer de unødvendige detaljer væk, samtidig med at det tillader tilpasningsmuligheder, praktisk talt alle brugbare eksportformater og anvender en fantastisk praksis, der gør hele projektet både effektivt og så optimalt, som det kan være.

YOLOv5 er stadig hovedprojektet at bygge objektdetektionsmodeller med, og mange depoter, der har til formål at fremme YOLO-metoden, starter med YOLOv5 som en baseline og tilbyder en lignende API (eller blot forgrene projektet og bygge ovenpå det). Sådan er det YOLOR (Du lærer kun én repræsentation) og YOLOv7, som byggede oven på YOLOR (samme forfatter), som er det seneste fremskridt inden for YOLO-metoden.

YOLOv7 er ikke kun en objektdetektionsarkitektur – giver nye modelhoveder, der kan udskrive nøglepunkter (skeletter) og udføre instanssegmentering udover kun bounding box-regression, hvilket ikke var standard med tidligere YOLO-modeller. Dette er ikke overraskende, da mange objektdetekteringsarkitekturer også tidligere blev genbrugt, f.eks. segmenterings- og nøglepunktsdetektionsopgaver, på grund af den fælles generelle arkitektur, med forskellige output afhængigt af opgaven. Selvom det ikke er overraskende – at understøtte instanssegmentering og nøglepunktsdetektion vil sandsynligvis blive den nye standard for YOLO-baserede modeller, som er begyndt at overgå praktisk talt alle andre to-trins detektorer for et par år siden.

Dette gør instanssegmentering og nøglepunktsdetektion hurtigere at udføre end nogensinde før, med en enklere arkitektur end to-trins detektorer.

Selve modellen blev skabt gennem arkitektoniske ændringer, såvel som optimering af aspekter af træning, kaldet "bag-of-freebies", hvilket øgede nøjagtigheden uden at øge omkostningerne ved slutningen.

Installation af YOLOv7

Lad os gå videre og installere projektet fra GitHub:

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

Dette skaber en yolov7 mappe under din nuværende arbejdsmappe, hvor du vil kunne finde de grundlæggende projektfiler:

%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

Bemærk: Google Colab Notebooks nulstilles til hovedbiblioteket i den næste celle, selv efter opkald %cd dirname, så du bliver nødt til at blive ved med at kalde det i hver celle, du vil have en operation udført i. Lokale Jupyter Notebooks husker ændringen, så der er ingen grund til at blive ved med at kalde kommandoen.

Hver gang du kører kode med et givet sæt vægte – vil de blive downloadet og gemt i denne mappe. For at udføre estimering af stilling vil vi gerne downloade vægtene til den fortrænede YOLOv7-model til den opgave, som kan findes under /releases/download/ fanen på 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

Fantastisk, vi har downloadet yolov7-w6-pose.pt vægt-fil, som kan bruges til at indlæse og rekonstruere en trænet model til positur-estimering.

Indlæser YOLOv7 Pose Estimation Model

Lad os importere de biblioteker, vi skal bruge for at udføre stillingsestimat:

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 , torchvision er ligetil nok – YOLOv7 er implementeret med PyTorch. Det utils.datasets, utils.general , utils.plots moduler kommer fra YOLOv7-projektet, og giver os metoder, der hjælper med at forbehandle og forberede input til, at modellen kan køre slutninger på. Blandt dem er letterbox() at polstre billedet, non_max_supression_keypoint() at køre Non-Max Supression-algoritmen på det oprindelige output af modellen og at producere et rent output til vores fortolkning, såvel som output_to_keypoint() , plot_skeleton_kpts() metoder til rent faktisk at tilføje nøglepunkter til et givet billede, når de først er forudsagt.

Vi kan indlæse modellen fra vægtfilen med torch.load(). Lad os oprette en funktion for at kontrollere, om en GPU er tilgængelig, indlæse modellen, sætte den i inferenstilstand og flytte den til GPU'en, hvis den er tilgængelig:

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

Med modellen indlæst, lad os skabe en run_inference() metode, der accepterer en streng, der peger på en fil på vores system. Metoden vil læse billedet ved hjælp af OpenCV (cv2), pud det med letterbox(), påfør transformationer på det, og gør det til en batch (modellen er trænet på og forventer batches, som normalt):

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

Her har vi returneret det transformerede billede (fordi vi gerne vil udtrække originalen og plotte på det) og modellens output. Disse output indeholder 45900 nøglepunktsforudsigelser, hvoraf de fleste overlapper. Vi ønsker at anvende Non-Max-undertrykkelse på disse rå forudsigelser, ligesom med forudsigelser af objektgenkendelse (hvor mange afgrænsningsfelter forudsiges, og så bliver de "kollapset" givet en vis tillid og IoU-tærskel). Efter undertrykkelse kan vi plotte hvert nøglepunkt på det originale billede og vise det:

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 til noget inputbillede, som f.eks karate.jpg i hovedarbejdsbiblioteket kan vi køre inferens, udføre Non-Max-undertrykkelse og plotte resultaterne med:

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

Dette resulterer i:

Dette er et ret svært billede at udlede! Det meste af udøverens højre arm til højre er skjult, og vi kan se, at modellen udledte, at den er skjult og til højre for kroppen, idet den mangler, at albuen er bøjet, og at en del af armen er foran . Udøveren til venstre, som ses meget tydeligere, udledes korrekt, selv med et skjult ben.

Faktisk - en person, der sidder bagerst, næsten fuldstændig usynlig for kameraet har fået deres positur tilsyneladende korrekt estimeret, blot baseret på hofternes stilling, mens de sidder ned. Flot arbejde på vegne af netværket!

Konklusion

I denne vejledning – vi har taget et kort kig på YOLOv7, det seneste fremskridt i YOLO-familien, som bygger oven på YOLOR, og som ydermere giver mulighed for instanssegmentering og nøglepunktsdetektering ud over standardobjektdetektionsfunktionerne i de fleste YOLO-baserede modeller .

Vi har derefter taget et kig på, hvordan vi kan downloade frigivne vægtfiler, indlæse dem for at konstruere en model og udføre positur-estimering inferens for mennesker, hvilket giver imponerende resultater.

Gå videre – Praktisk dyb læring til computersyn

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Kursus: "Praktisk dyb læring til computersyn med Python".

Endnu et kursus i computersyn?

Vi laver ikke klassificering af MNIST-cifre eller MNIST-mode. De tjente deres del for længe siden. For mange læringsressourcer fokuserer på grundlæggende datasæt og grundlæggende arkitekturer, før de lader avancerede black-box-arkitekturer bære byrden af ​​ydeevne.

Vi ønsker at fokusere på afmystificering, praktisk, forståelse, intuition , rigtige projekter. Vil gerne lære hvordan kan du gøre en forskel? Vi tager dig med på en tur fra den måde, vores hjerner behandler billeder på, til at skrive en deep learning-klassificerer for brystkræft i forskningsklasse til deep learning-netværk, der "hallucinerer", lærer dig principperne og teorien gennem praktisk arbejde, og udstyrer dig med knowhow og værktøjer til at blive ekspert i at anvende dyb læring til at løse computervision.

Hvad er der indenfor?

• De første principper for vision og hvordan computere kan læres at "se"
• Forskellige opgaver og anvendelser af computersyn
• Branchens værktøjer, der vil gøre dit arbejde lettere
• Finde, skabe og bruge datasæt til computervision
• Teorien og anvendelsen af ​​​​konvolutionelle neurale netværk
• Håndtering af domæneskift, samtidige forekomster og andre skævheder i datasæt
• Overfør Læring og udnyttelse af andres træningstid og beregningsressourcer til din fordel
• Opbygning og træning af en avanceret brystkræftklassificering
• Hvordan man anvender en sund dosis skepsis til mainstream ideer og forstår implikationerne af vidt anvendte teknikker
• Visualisering af et ConvNets "konceptrum" ved hjælp af t-SNE og PCA
• Casestudier af, hvordan virksomheder bruger computervisionsteknikker til at opnå bedre resultater
• Korrekt modelevaluering, latent rumvisualisering og identifikation af modellens opmærksomhed
• Udførelse af domæneforskning, bearbejdning af dine egne datasæt og etablering af modeltest
• Banebrydende arkitekturer, udviklingen af ​​ideer, hvad der gør dem unikke, og hvordan man implementerer dem
• KerasCV – et WIP-bibliotek til at skabe state of the art pipelines og modeller
• Hvordan man analyserer og læser papirer og implementerer dem selv
• Valg af modeller afhængigt af din applikation
• Oprettelse af en end-to-end machine learning pipeline
• Landskab og intuition på objektdetektion med hurtigere R-CNN'er, RetinaNets, SSD'er og YOLO
• Forekomst og semantisk segmentering
• Objektgenkendelse i realtid med YOLOv5
• Træning af YOLOv5 objektdetektorer
• Arbejde med transformere ved hjælp af KerasNLP (industristærkt WIP-bibliotek)
• Integrering af transformere med ConvNets for at generere billedtekster
• Deepdream
• Deep Learning model optimering til computer vision