Poseestimering/nøkkelpunktdeteksjon med YOLOv7 i Python

Introduksjon

Objektdeteksjon er et stort felt innen datasyn, og en av de viktigste bruksområdene for datasyn "i naturen".

Objektdeteksjon er ikke like standardisert som bildeklassifisering, hovedsakelig fordi de fleste av de nye utviklingene vanligvis gjøres av individuelle forskere, vedlikeholdere og utviklere, i stedet for store biblioteker og rammeverk. Det er vanskelig å pakke de nødvendige verktøyskriptene i et rammeverk som TensorFlow eller PyTorch og opprettholde API-retningslinjene som har ledet utviklingen så langt.

Dette gjør gjenstandsgjenkjenning noe mer kompleks, vanligvis mer detaljert (men ikke alltid), og mindre tilgjengelig enn bildeklassifisering.

Heldigvis for massene – Ultralytics har utviklet et enkelt, veldig kraftig og vakkert objektdeteksjons-API rundt deres YOLOv5 som har blitt utvidet av andre forsknings- og utviklingsteam til nyere versjoner, som YOLOv7.

I denne korte veiledningen skal vi utføre Pose Estimation (Keypoint Detection) i Python, med toppmoderne YOLOv7.

Nøkkelpunkter kan være ulike punkter – deler av et ansikt, lemmer på en kropp osv. Pose-estimering er et spesielt tilfelle av nøkkelpunktdeteksjon – der punktene er deler av en menneskekropp, og kan brukes til å erstatte kostbar maskinvare for posisjonssporing, aktiver over-the-air robotikkkontroll, og driver en ny tidsalder av menneskelig selvuttrykk gjennom AR og VR.

YOLO og Pose estimering

YOLO (Du ser bare en gang) er en metodikk, samt familie av modeller bygget for gjenstandsdeteksjon. Siden oppstarten i 2015 har YOLOv1, YOLOv2 (YOLO9000) og YOLOv3 blitt foreslått av samme forfatter(e) – og dyplæringsfellesskapet fortsatte med fremskritt med åpen kildekode i de påfølgende årene.

Ultralytics' YOLOv5 er den første storskalaimplementeringen av YOLO i PyTorch, som gjorde den mer tilgjengelig enn noen gang før, men hovedårsaken til at YOLOv5 har fått et slikt fotfeste er også den vakkert enkle og kraftige APIen bygget rundt den. Prosjektet abstraherer bort de unødvendige detaljene, samtidig som det tillater tilpasning, praktisk talt alle brukbare eksportformater, og benytter utrolige fremgangsmåter som gjør hele prosjektet både effektivt og så optimalt som det kan bli.

YOLOv5 er fortsatt hovedprosjektet å bygge objektdeteksjonsmodeller med, og mange depoter som tar sikte på å fremme YOLO-metoden starter med YOLOv5 som en baseline og tilbyr en lignende API (eller ganske enkelt fordeler prosjektet og bygger på toppen av det). Slik er tilfellet med YOLOR (Du lærer bare én representasjon) og YOLOv7 som bygget på toppen av YOLOR (samme forfatter) som er det siste fremskrittet innen YOLO-metodikken.

YOLOv7 er ikke bare en objektdeteksjonsarkitektur – gir nye modellhoder, som kan sende ut nøkkelpunkter (skjeletter) og utføre forekomstsegmentering i tillegg til bare grenseboksregresjon, som ikke var standard med tidligere YOLO-modeller. Dette er ikke overraskende, siden mange objektdeteksjonsarkitekturer ble gjenbrukt, for eksempel segmenterings- og nøkkelpunktdeteksjonsoppgaver tidligere også, på grunn av den delte generelle arkitekturen, med forskjellige utganger avhengig av oppgaven. Selv om det ikke er overraskende – støtte for eksempelsegmentering og nøkkelpunktdeteksjon vil sannsynligvis bli den nye standarden for YOLO-baserte modeller, som har begynt å overgå praktisk talt alle andre totrinnsdetektorer for et par år siden.

Dette gjør forekomstsegmentering og nøkkelpunktdeteksjon raskere å utføre enn noen gang før, med en enklere arkitektur enn to-trinns detektorer.

Selve modellen ble skapt gjennom arkitektoniske endringer, samt optimalisering av aspekter ved trening, kalt "bag-of-freebies", som økte nøyaktigheten uten å øke slutningskostnadene.

Installerer YOLOv7

La oss gå videre og installere prosjektet fra GitHub:

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

Dette skaper en yolov7 katalog under din nåværende arbeidskatalog, der du vil kunne finne de grunnleggende prosjektfilene:

%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

OBS: Google Colab Notebooks tilbakestilles til hovedarbeidskatalogen i neste celle, selv etter oppringing %cd dirname, så du må fortsette å ringe den i hver celle du vil at en operasjon skal utføres i. Lokale Jupyter Notebooks husker endringen, så det er ikke nødvendig å fortsette å ringe kommandoen.

Hver gang du kjører kode med et gitt sett med vekter – vil de bli lastet ned og lagret i denne katalogen. For å utføre positur-estimering, vil vi laste ned vektene for den ferdigtrente YOLOv7-modellen for den oppgaven, som du finner 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

Flott, vi har lastet ned yolov7-w6-pose.pt vekter-fil, som kan brukes til å laste og rekonstruere en trent modell for positur-estimering.

Laster YOLOv7 Pose Estimation Model

La oss importere bibliotekene vi trenger for å utføre poseringsestimering:

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 og torchvision er enkle nok – YOLOv7 er implementert med PyTorch. De utils.datasets, utils.general og utils.plots moduler kommer fra YOLOv7-prosjektet, og gir oss metoder som hjelper med forbehandling og forberedelse av input for modellen å kjøre slutninger på. Blant disse er letterbox() for å polstre bildet, non_max_supression_keypoint() å kjøre Non-Max Supression-algoritmen på den første utgangen av modellen og å produsere en ren utgang for tolkningen vår, samt output_to_keypoint() og plot_skeleton_kpts() metoder for å faktisk legge til nøkkelpunkter til et gitt bilde, når de er forutsagt.

Vi kan laste modellen fra vektfilen med torch.load(). La oss lage en funksjon for å sjekke om en GPU er tilgjengelig, last inn modellen, sett den i slutningsmodus og flytte den til GPU hvis tilgjengelig:

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 lastet, la oss lage en run_inference() metode som godtar en streng som peker til en fil på systemet vårt. Metoden vil lese bildet ved hjelp av OpenCV (cv2), fyll den med letterbox(), bruk transformasjoner på den, og gjør den om til en batch (modellen er trent på og forventer batcher, som vanlig):

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 returnert det transformerte bildet (fordi vi vil trekke ut originalen og plotte på det) og utdataene til modellen. Disse utgangene inneholder 45900 nøkkelpunktprediksjoner, hvorav de fleste overlapper. Vi vil bruke Non-Max-undertrykkelse på disse rå spådommene, akkurat som med objektdeteksjonsprediksjoner (hvor mange avgrensende bokser er forutsagt og så blir de "kollapset" gitt en viss tillit og IoU-terskel). Etter undertrykking kan vi plotte hvert nøkkelpunkt på det originale bildet 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()

Nå, for noen input-bilde, som f.eks karate.jpg i hovedarbeidskatalogen kan vi kjøre inferens, utføre Non-Max Supression og plotte resultatene med:

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

Dette resulterer i:

Dette er et ganske vanskelig bilde å si! Det meste av høyrearmen til utøveren til høyre er skjult, og vi kan se at modellen antydet at den er skjult og til høyre for kroppen, mangler at albuen er bøyd og at en del av armen er foran . Utøveren til venstre, som er mye tydeligere sett, utledes riktig, selv med et skjult ben.

Faktisk – en person som sitter bak, nesten helt usynlig for kameraet har fått tilsynelatende riktig estimert positur, bare basert på posisjonen til hoftene mens de sitter ned. Flott arbeid på vegne av nettverket!

konklusjonen

I denne veiledningen – vi har tatt en kort titt på YOLOv7, det siste fremskrittet i YOLO-familien, som bygger på toppen av YOLOR, og som gir funksjoner for eksempelsegmentering og nøkkelpunktdeteksjon utover standard objektdeteksjonsfunksjonene til de fleste YOLO-baserte modeller .

Vi har deretter tatt en titt på hvordan vi kan laste ned utgitte vektfiler, laste dem inn for å konstruere en modell og utføre posisjonsestimat for mennesker, noe som gir imponerende resultater.

Gå videre – praktisk dyp læring for datasyn

Din nysgjerrige natur gjør at du ønsker å gå lenger? Vi anbefaler å sjekke ut vår Kurs: "Praktisk dyplæring for datasyn med Python".

Et annet datasynskurs?

Vi kommer ikke til å klassifisere MNIST-sifre eller MNIST-mote. De tjente sin del for lenge siden. For mange læringsressurser fokuserer på grunnleggende datasett og grunnleggende arkitekturer før de lar avanserte svartboksarkitekturer bære byrden av ytelse.

Vi ønsker å fokusere på avmystifisering, praktisk, forståelse, intuisjon og ekte prosjekter. Vil lære hvordan du kan gjøre en forskjell? Vi tar deg med på en tur fra måten hjernen vår behandler bilder på til å skrive en dyplæringsklassifiser for brystkreft til dyplæringsnettverk som "hallusinerer", lærer deg prinsippene og teorien gjennom praktisk arbeid, og utstyrer deg med kunnskap og verktøy for å bli en ekspert på å bruke dyp læring for å løse datasyn.

Hva er inni?

• De første prinsippene for visjon og hvordan datamaskiner kan læres å "se"
• Ulike oppgaver og anvendelser av datasyn
• Verktøyene i bransjen som vil gjøre arbeidet ditt enklere
• Finne, lage og bruke datasett for datasyn
• Teorien og anvendelsen av konvolusjonelle nevrale nettverk
• Håndtering av domeneskift, samtidig forekomst og andre skjevheter i datasett
• Overfør Læring og bruk av andres treningstid og beregningsressurser til din fordel
• Bygge og trene en toppmoderne brystkreftklassifiser
• Hvordan bruke en sunn dose skepsis til mainstream ideer og forstå implikasjonene av vidt vedtatte teknikker
• Visualisere et ConvNets "konseptrom" ved hjelp av t-SNE og PCA
• Kasusstudier av hvordan bedrifter bruker datasynsteknikker for å oppnå bedre resultater
• Riktig modellevaluering, latent romvisualisering og identifisering av modellens oppmerksomhet
• Utføre domeneforskning, behandle egne datasett og etablere modelltester
• Nyskapende arkitekturer, utviklingen av ideer, hva som gjør dem unike og hvordan de implementeres
• KerasCV – et WIP-bibliotek for å lage toppmoderne rørledninger og modeller
• Hvordan analysere og lese artikler og implementere dem selv
• Velge modeller avhengig av din applikasjon
• Opprette en ende-til-ende maskinlæringspipeline
• Landskap og intuisjon på objektdeteksjon med raskere R-CNN, RetinaNets, SSD og YOLO
• Forekomst og semantisk segmentering
• Objektgjenkjenning i sanntid med YOLOv5
• Trening av YOLOv5-objektdetektorer
• Arbeide med transformatorer ved å bruke KerasNLP (bransjesterkt WIP-bibliotek)
• Integrering av transformatorer med ConvNets for å generere bildetekster
• Deepdream
• Deep Learning-modelloptimalisering for datasyn