Poseestimering i sanntid fra video i Python med YOLOv7

Introduksjon

Objektdeteksjon er et stort felt innen datasyn, og en av de viktigste bruksområdene for datasyn "i naturen". Fra den ble nøkkelpunktdeteksjon (ofte brukt for positur-estimering) hentet ut.

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.

Pose-estimering er en utrolig, ekstremt morsom og praktisk bruk av datasyn. Med den kan vi gjøre unna maskinvare som brukes til å estimere positurer (motion capture-drakter), som er kostbare og uhåndterlige. I tillegg kan vi kartlegge bevegelsen til mennesker til bevegelsen til roboter i det euklidiske rom, noe som muliggjør finpresisjonsmotoriske bevegelser uten å bruke kontrollere, som vanligvis ikke tillater høyere presisjonsnivåer. Keypoint-estimering kan brukes til å oversette bevegelsene våre til 3D-modeller i AR og VR, og blir i økende grad brukt til å gjøre det med bare et webkamera. Til slutt – posisjonsestimat kan hjelpe oss innen sport og sikkerhet.

I denne veiledningen skal vi utføre estimering av positur i sanntid fra en video i Python, ved å bruke den toppmoderne YOLOv7-modellen.

Nærmere bestemt skal vi jobbe med en video fra vinter-OL 2018, holdt i Sør-Koreas PyeongChang:

Aljona Savchenko og Bruno Massot gjorde en fantastisk forestilling, inkludert overlappende kropper mot kameraet, rask flytende bevegelse og spinning i luften. Det vil være en fantastisk mulighet til å se hvordan modellen takler vanskelige situasjoner!

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 et industri-grade objektdeteksjonsdepot, bygget på toppen av YOLO-metoden. Den er implementert i PyTorch, i motsetning til C++ for tidligere YOLO-modeller, er fullstendig åpen kildekode, og har en vakker enkel og kraftig API som lar deg utlede, trene og tilpasse prosjektet fleksibelt. Det er en slik stift at de fleste nye forsøk på å forbedre YOLO-metoden bygger på toppen av den.

Dette er hvordan YOLOR (Du lærer bare én representasjon) og YOLOv7 som bygget på toppen av YOLOR (samme forfatter) ble også laget!

YOLOv7 er ikke bare en objektdeteksjonsarkitektur – den gir nye modellhoder som kan sende ut nøkkelpunkter (skjeletter) og utføre instanssegmentering i tillegg til bare regresjon av grensebokser, 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 når det gjelder både nøyaktighet og hastighet.

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 starte med å klone depotet for å få tak i kildekoden:

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

La oss nå gå inn i yolov7 katalogen, som inneholder prosjektet, og ta en titt på innholdet:

%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

Nå er YOLO ment å være en gjenstandsdetektor, og leveres ikke med posisjonsestimatvekter som standard. Vi vil laste ned vektene og laste inn en konkret modelleksempel fra dem. Vektene er tilgjengelige på samme GitHub-lager, og kan også enkelt lastes ned gjennom 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

Når den er lastet ned, kan vi importere bibliotekene og hjelpemetodene vi skal bruke:

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

Flott! La oss fortsette med å laste inn modellen og lage et skript som lar deg utlede poseringer fra videoer med YOLOv7 og OpenCV.

Poseestimering i sanntid med YOLOv7

La oss først lage en metode for å laste modellen fra de nedlastede vektene. Vi sjekker hvilken enhet vi har tilgjengelig (CPU eller 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()

Avhengig av om vi har en GPU eller ikke, slår vi halvpresisjon på (ved hjelp av float16 istedenfor float32 i operasjoner), noe som gjør slutninger betydelig raskere. Merk at det er sterkt oppfordret til å utføre dette på en GPU for sanntidshastigheter, da CPUer sannsynligvis vil mangle kraften til å gjøre det med mindre de kjører på små videoer.

La oss skrive en bekvemmelighetsmetode for å kjøre slutninger. Vi godtar bilder som NumPy-matriser (da det er det vi sender dem senere mens vi leser videoen). Først bruker du letterbox() funksjon – vi endrer størrelsen på og putter videoen til en form som modellen kan jobbe med. Dette trenger ikke å være og vil ikke være formen (oppløsningen) til den resulterende videoen!

Deretter bruker vi transformasjonene, konverterer bildet til halv presisjon (hvis en GPU er tilgjengelig), batcherer det og kjører det gjennom modellen:

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

Vi vil returnere spådommene til modellen, så vel som bildet som en tensor. Dette er "grove" spådommer - de inneholder mange aktiveringer som overlapper hverandre, og vi vil "rydde opp" ved å bruke Non-Max Supression, og plotte de forutsagte skjelettene over selve bildet:

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

Med disse på plass vil vår generelle flyt se slik ut:

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

For å oversette det til en videoinnstilling i sanntid – vi bruker OpenCV til å lese en video, og kjører denne prosessen for hvert bilde. På hver ramme vil vi også skrive rammen inn i en ny fil, kodet som en video. Dette vil nødvendigvis bremse prosessen mens vi kjører slutningen, viser den og skriver – slik at du kan øke hastigheten på slutningen og visningen ved å unngå å lage en ny fil og skrive til den i løkken:

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 aksepterer flere parametere - utdatafilnavnet, FourCC (fire kodekkoder, angir kodeken som brukes til å kode videoen), bildehastigheten og oppløsningen som en tuppel. For ikke å gjette eller endre størrelsen på videoen – vi har brukt bredden og høyden til den originale videoen, hentet gjennom VideoCapture forekomst som inneholder data om selve videoen, for eksempel bredde, høyde, totalt antall bilder osv.

Nå kan vi kalle metoden på hvilken som helst inngangsvideo:

pose_estimation_video('../ice_skating.mp4')

Dette vil åpne et OpenCV-vindu, som viser slutningen i sanntid. Og det vil også skrive en videofil i yolov7 katalog (siden vi har cdgikk inn i det):

konklusjonen

I denne veiledningen har vi tatt en titt på YOLO-metoden, YOLOv7 og forholdet mellom YOLO og gjenstandsdeteksjon, positur-estimering og instanssegmentering. Vi har deretter tatt en titt på hvordan du enkelt kan installere og jobbe med YOLOv7 ved å bruke det programmatiske API, og laget flere bekvemmelighetsmetoder for å gjøre slutninger og visning av resultater enklere.

Til slutt har vi åpnet en video ved hjelp av OpenCV, kjørt inferens med YOLOv7, og laget en funksjon for å utføre positur-estimering i sanntid, og lagre den resulterende videoen i full oppløsning og 30FPS på din lokale disk.

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