Poseestimation i realtid fra video i Python med YOLOv7

Introduktion

Objektdetektion er et stort felt inden for computersyn og en af ​​de vigtigere anvendelser af computersyn "i naturen". Fra den blev nøglepunktsdetektion (ofte brugt til positur-estimering) udtrukket.

Nøglepunkter kan være forskellige punkter – dele af et ansigt, lemmer på en krop osv. Pose-estimering er et særligt tilfælde af nøglepunktsdetektion – hvor punkterne er dele af en menneskekrop.

Pose-estimering er en fantastisk, ekstremt sjov og praktisk brug af computersyn. Med det kan vi gøre op med hardware, der bruges til at estimere positurer (motion capture-dragter), som er dyre og uhåndterlige. Derudover kan vi kortlægge menneskers bevægelser til bevægelser af robotter i det euklidiske rum, hvilket muliggør finpræcisionsmotoriske bevægelser uden at bruge controllere, som normalt ikke tillader højere præcisionsniveauer. Keypoint-estimering kan bruges til at oversætte vores bevægelser til 3D-modeller i AR og VR, og bliver i stigende grad brugt til at gøre det med kun et webcam. Endelig – estimering af stilling kan hjælpe os med sport og sikkerhed.

I denne vejledning udfører vi positionsvurdering i realtid fra en video i Python ved hjælp af den avancerede YOLOv7-model.

Specifikt vil vi arbejde med en video fra de olympiske vinterlege 2018, der afholdes i Sydkoreas PyeongChang:

Aljona Savchenko og Bruno Massot gjorde en fantastisk præstation, inklusive overlappende kroppe mod kameraet, hurtige flydende bevægelser og spinning i luften. Det vil være en fantastisk mulighed for at se, hvordan modellen håndterer vanskelige situationer!

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 et objektdetekteringsopbevaring i industrikvalitet, bygget oven på YOLO-metoden. Det er implementeret i PyTorch, i modsætning til C++ for tidligere YOLO-modeller, er fuldt open source og har en smuk enkel og kraftfuld API, der lader dig udlede, træne og tilpasse projektet fleksibelt. Det er så vigtigt, at de fleste nye forsøg på at forbedre YOLO-metoden bygger ovenpå.

Dette er, hvordan YOLOR (Du lærer kun én repræsentation) og YOLOv7, som er bygget oven på YOLOR (samme forfatter) blev også oprettet!

YOLOv7 er ikke kun en objektdetektionsarkitektur – den 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 udkonkurrere praktisk talt alle andre to-trins detektorer for et par år siden med hensyn til både nøjagtighed og hastighed.

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

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

Lad os nu gå ind i yolov7 mappe, som indeholder projektet, og tag et kig på indholdet:

%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 er YOLO beregnet til at være en objektdetektor og sendes ikke som standard med vægtestimeringer. Vi vil gerne downloade vægtene og indlæse en konkret modelforekomst fra dem. Vægtene er tilgængelige på det samme GitHub-lager og kan også nemt downloades gennem 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 downloadet, kan vi importere de biblioteker og hjælpemetoder, vi skal bruge:

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

Store! Lad os komme i gang med at indlæse modellen og oprette et script, der lader dig udlede poseringer fra videoer med YOLOv7 og OpenCV.

Positionsvurdering i realtid med YOLOv7

Lad os først oprette en metode til at indlæse modellen fra de downloadede vægte. Vi tjekker, hvilken enhed vi har tilgængelig (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()

Afhængigt af om vi har en GPU eller ej, slår vi halvpræcision til (vha float16 i stedet for float32 i operationer), hvilket gør inferens væsentligt hurtigere. Bemærk, at det stærkt opfordres til at udføre dette på en GPU til realtidshastigheder, da CPU'er sandsynligvis vil mangle kraften til at gøre det, medmindre de kører på små videoer.

Lad os skrive en bekvemmelighedsmetode til at køre inferens. Vi accepterer billeder som NumPy-arrays (da det er det, vi sender dem senere, mens vi læser videoen). Først ved hjælp af letterbox() funktion – vi ændrer størrelsen og polstret videoen til en form, som modellen kan arbejde med. Dette behøver ikke at være og vil ikke være formen (opløsningen) af den resulterende video!

Derefter anvender vi transformationerne, konverterer billedet til halv præcision (hvis en GPU er tilgængelig), batcherer det og kører det gennem 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 returnerer modellens forudsigelser såvel som billedet som en tensor. Disse er "grove" forudsigelser - de indeholder mange aktiveringer, der overlapper, og vi vil gerne "rydde op" ved hjælp af Non-Max Supression og plotte de forudsagte skeletter over selve billedet:

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å plads vil vores generelle flow se ud:

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

For at oversætte det til en videoindstilling i realtid – vi bruger OpenCV til at læse en video og kører denne proces for hvert billede. På hver frame skriver vi også rammen ind i en ny fil, kodet som en video. Dette vil nødvendigvis sinke processen, mens vi kører slutningen, viser den og skriver – så du kan fremskynde slutningen og visningen ved at undgå at oprette 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()

VideoWriter accepterer flere parametre - outputfilnavnet, FourCC (fire codec-koder, der angiver det codec, der bruges til at kode videoen), framerate og opløsningen som en tuple. For ikke at gætte eller ændre størrelsen på videoen – vi har brugt bredden og højden af ​​den originale video, opnået gennem VideoCapture instans, der indeholder data om selve videoen, såsom bredde, højde, det samlede antal billeder osv.

Nu kan vi kalde metoden på enhver inputvideo:

pose_estimation_video('../ice_skating.mp4')

Dette åbner et OpenCV-vindue, der viser inferensen i realtid. Og det vil også skrive en videofil i yolov7 mappe (da vi har cdgik ind i det):

Konklusion

I denne guide har vi taget et kig på YOLO-metoden, YOLOv7 og forholdet mellem YOLO og objektdetektering, positur-estimering og instanssegmentering. Vi har derefter taget et kig på, hvordan du nemt kan installere og arbejde med YOLOv7 ved hjælp af den programmatiske API, og skabt flere bekvemmelighedsmetoder for at gøre det nemmere at konkludere og vise resultater.

Endelig har vi åbnet en video ved hjælp af OpenCV, kørt inferens med YOLOv7 og lavet en funktion til at udføre positur-estimering i realtid, gemme den resulterende video i fuld opløsning og 30FPS på din lokale disk.

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