Reaalajas poseerimise hinnang Pythonis olevast videost koos YOLOv7-ga

Sissejuhatus

Objektide tuvastamine on arvutinägemise suur valdkond ja üks olulisemaid arvutinägemise rakendusi "looduses". Sellest eraldati võtmepunkti tuvastamine (mida kasutatakse sageli poosi hindamiseks).

Võtmepunktid võivad olla erinevad punktid – näoosad, kehajäsemed jne. Poosi hindamine on võtmepunktide tuvastamise erijuhtum – kus punktid on inimkeha osad.

Poosi hindamine on hämmastav, äärmiselt lõbus ja praktiline arvutinägemise kasutamine. Selle abil saame loobuda pooside hindamiseks kasutatavast riistvarast (liikumise jäädvustamise ülikonnad), mis on kulukad ja kohmakad. Lisaks saame kaardistada inimeste liikumise robotite liikumisega eukleidilises ruumis, võimaldades mootori täpset liikumist ilma kontrollereid kasutamata, mis tavaliselt ei võimalda suuremat täpsust. Võtmepunkti hindamist saab kasutada meie liikumiste tõlkimiseks 3D-mudeliteks AR-is ja VR-is ning üha enam kasutatakse seda ainult veebikaamera abil. Lõpuks – poosi hindamine võib meid aidata spordis ja turvalisuses.

Selles juhendis hindame Pythonis olevast videost reaalajas poseerimist, kasutades tipptasemel YOLOv7 mudelit.

Täpsemalt töötame videoga 2018. aasta taliolümpiamängudest, mis peeti Lõuna-Koreas PyeongChangis:

Aljona Savtšenko ja Bruno Massot tegid suurepärase esituse, sealhulgas kehade kattumine vastu kaamerat, kiire vedeliku liikumine ja õhus pöörlemine. See on suurepärane võimalus näha, kuidas modell raskesti järeldatavates olukordades toime tuleb!

YOLO ja poosi hindamine

YOLO (sa vaatad ainult korra) on metoodika, samuti objektide tuvastamiseks loodud mudelite perekond. Alates loomisest 2015. aastal on YOLOv1, YOLOv2 (YOLO9000) ja YOLOv3 pakkunud sama(d) autor(id) – ja süvaõppekogukond jätkas jätkuvatel aastatel avatud lähtekoodiga edusammudega.

Ultralytics YOLOv5 on tööstusklassi objektide tuvastamise hoidla, mis on üles ehitatud YOLO meetodile. See on rakendatud PyTorchis, erinevalt eelmiste YOLO mudelite C++-st, on täielikult avatud lähtekoodiga ning sellel on kaunilt lihtne ja võimas API, mis võimaldab teil projekti paindlikult järeldada, koolitada ja kohandada. See on nii põhiline, et enamik uusi katseid YOLO meetodi täiustamiseks tuginevad sellele.

See, kuidas YOLOR (õpid ainult ühe esituse) ja YOLOv7, mis ehitati YOLORi peale (sama autor), loodi samuti!

YOLOv7 ei ole lihtsalt objektide tuvastamise arhitektuur – see pakub uusi mudelipäid, mis suudavad väljastada võtmepunkte (skelette) ja teostada eksemplari segmenteerimist lisaks piirdekasti regressioonile, mis ei olnud eelmiste YOLO mudelite puhul standardne. See pole üllatav, kuna paljusid objektituvastusarhitektuure kasutati jagatud üldarhitektuuri tõttu ka varem segmenteerimise ja võtmepunkti tuvastamise ülesannete jaoks ümber, sõltuvalt ülesandest erinevate väljunditega.

Kuigi see pole üllatav – eksemplaride segmenteerimise ja võtmepunkti tuvastamise toetamisest saab tõenäoliselt uus standard YOLO-põhistele mudelitele, mis on paar aastat tagasi hakanud nii täpsuse kui ka kiiruse poolest ületama praktiliselt kõiki teisi kaheastmelisi detektoreid.

See muudab eksemplari segmentimise ja võtmepunktide tuvastamise kiiremaks kui kunagi varem ning lihtsama arhitektuuriga kui kaheastmelised detektorid.

Mudel ise loodi nii arhitektuursete muudatuste kui ka koolituse optimeerimise kaudu, mida nimetati "tasuta tasuta kottideks", mis suurendas täpsust ilma järelduskulusid suurendamata.

YOLOv7 installimine

Alustame lähtekoodi leidmiseks hoidla kloonimisega:

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

Liigume nüüd edasi yolov7 kataloogi, mis sisaldab projekti, ja vaadake selle sisu:

%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üüd on YOLO mõeldud objektide detektoriks ja vaikimisi ei tarnita poosihinnangu kaaludega. Soovime kaalud alla laadida ja laadida neist konkreetse mudeli eksemplari. Kaalud on saadaval samas GitHubi hoidlas ja neid saab hõlpsasti alla laadida ka CLI kaudu:

! 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

Pärast allalaadimist saame importida kasutatavad teegid ja abimeetodid:

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

Suurepärane! Jätkame mudeli laadimisega ja skripti loomisega, mis võimaldab YOLOv7 ja OpenCV-ga videote põhjal poose järeldada.

Reaalajas poosi hindamine YOLOv7 abil

Loome esmalt meetodi allalaaditud kaaludest mudeli laadimiseks. Kontrollime, milline seade meil on saadaval (CPU või 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()

Sõltuvalt sellest, kas meil on GPU või mitte, lülitame pooltäpsuse sisse (kasutades float16 asemel float32 operatsioonides), mis muudab järelduste tegemise oluliselt kiiremaks. Pange tähele, et reaalajas kiiruse saavutamiseks on väga soovitatav seda teha GPU-ga, kuna protsessoritel puudub tõenäoliselt selleks võimsus, välja arvatud juhul, kui see töötab väikestes videotes.

Kirjutame mugavusmeetodi järelduste tegemiseks. Aktsepteerime pilte NumPy massiividena (kuna see on see, mida me need hiljem video lugemise ajal edastame). Esiteks, kasutades letterbox() funktsioon – muudame video suurust ja polsterdame selle kuju, millega mudel saab töötada. See ei pea olema saadud video kuju (eraldusvõime) ja see ei saa olema!

Seejärel rakendame teisendused, teisendame pildi poole täpsusega (kui GPU on saadaval), komplekteerime selle ja käivitame mudeli:

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

Tagastame mudeli ennustused, aga ka pildi tensorina. Need on "umbkaudsed" ennustused – need sisaldavad palju kattuvad aktiveerimised ja me tahame need "puhastada" mittemaksimaalse supressiooni abil ja joonistada ennustatud skeletid pildile endale:

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

Kui need on paigas, näeb meie üldine voog välja järgmine:

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

Selle reaalajas video seadistusse tõlkimiseks kasutame video lugemiseks OpenCV-d ja käitame seda protsessi iga kaadri jaoks. Igal kaadril kirjutame kaadri ka uude faili, mis on kodeeritud videona. See aeglustab ilmtingimata protsessi, kui käitame järeldusi, kuvame ja kirjutame – nii et saate järeldamist ja kuvamist kiirendada, vältides uue faili loomist ja sellele tsüklis kirjutamist:

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 aktsepteerib mitmeid parameetreid – väljundfaili nimi, FourCC (neli koodeki koodi, mis tähistavad video kodeerimiseks kasutatud kodekit), kaadrisagedus ja eraldusvõime koretisena. Video ära arvamiseks või selle suuruse muutmiseks kasutasime algse video laiust ja kõrgust, mis saadi läbi VideoCapture eksemplar, mis sisaldab andmeid video enda kohta, nagu laius, kõrgus, kaadrite koguarv jne.

Nüüd saame seda meetodit kutsuda mis tahes sisendvideo puhul:

pose_estimation_video('../ice_skating.mp4')

See avab OpenCV akna, mis kuvab järelduse reaalajas. Ja see kirjutab ka videofaili yolov7 kataloog (kuna oleme cdsellesse):

Järeldus

Selles juhendis oleme vaatlenud YOLO meetodit YOLOv7 ning seost YOLO ja objekti tuvastamise, pooside hindamise ja eksemplari segmenteerimise vahel. Seejärel uurisime, kuidas saate YOLOv7 programmilise API abil hõlpsasti installida ja sellega töötada, ning loonud mitu mugavusmeetodit, mis hõlbustavad järeldusi ja tulemuste kuvamist.

Lõpuks avasime OpenCV-d kasutades video, tegime YOLOv7-ga järeldused ja loosime funktsiooni reaalajas poseerimise hindamiseks, salvestades saadud video täiseraldusvõimega ja 30 kaadrit sekundis teie kohalikule kettale.

Edasiminek – praktiline süvaõpe arvutinägemise jaoks

Sinu uudishimulik loomus tekitab sinus soovi minna kaugemale? Soovitame tutvuda meiega Kursus: "Praktiline süvaõpe arvutinägemise jaoks Pythoniga".

Veel üks arvutinägemise kursus?

Me ei klassifitseeri MNIST-i numbreid ega MNIST-moodi. Nad teenisid oma osa juba ammu. Liiga paljud õpperessursid keskenduvad põhiandmekogumitele ja põhiarhitektuuridele, enne kui lasevad täiustatud musta kasti arhitektuurid jõudluskoormuse enda kanda võtta.

Tahame keskenduda demüstifitseerimine, praktilisus, mõistmine, intuitsioon ja tõelisi projekte. Tahad õppida kuidas saate midagi muuta? Viime teid teele alates viisist, kuidas meie aju töötleb pilte, kuni rinnavähi süvaõppe klassifikaatori kirjutamiseni kuni süvaõppevõrgustikeni, mis "hallutsineerivad", õpetades teile põhimõtteid ja teooriat praktilise töö kaudu, varustades teid oskusteavet ja tööriistu, et saada eksperdiks süvaõppe rakendamisel arvutinägemise lahendamisel.

Mis seal sees on?

• Nägemise esimesed põhimõtted ja see, kuidas arvuteid saab õpetada nägema
• Arvutinägemise erinevad ülesanded ja rakendused
• Tööriistad, mis muudavad teie töö lihtsamaks
• Arvutinägemise andmestike otsimine, loomine ja kasutamine
• Konvolutsiooniliste närvivõrkude teooria ja rakendus
• Domeeni nihke, koosesinemise ja muude andmekogumite eelarvamuste käsitlemine
• Teisaldage õppimine ja teiste koolitusaja ja arvutusressursside kasutamine teie kasuks
• Kaasaegse rinnavähi klassifikaatori ehitamine ja väljaõpe
• Kuidas rakendada tervet annust skepsist peavoolu ideede suhtes ja mõista laialdaselt kasutusele võetud tehnikate mõju
• ConvNeti "kontseptsiooniruumi" visualiseerimine t-SNE ja PCA abil
• Juhtumiuuringud, kuidas ettevõtted kasutavad arvutinägemise tehnikaid paremate tulemuste saavutamiseks
• Mudeli nõuetekohane hindamine, varjatud ruumi visualiseerimine ja mudeli tähelepanu tuvastamine
• Domeeniuuringu läbiviimine, oma andmekogumite töötlemine ja mudelitestide loomine
• Tipptasemel arhitektuurid, ideede edenemine, mis teeb need ainulaadseks ja kuidas neid ellu viia
• KerasCV – WIP-teek tipptasemel torujuhtmete ja mudelite loomiseks
• Kuidas töid sõeluda ja lugeda ning neid ise rakendada
• Mudelite valimine sõltuvalt teie rakendusest
• Täieliku masinõppe torujuhtme loomine
• Maastik ja intuitsioon objektide tuvastamisel kiiremate R-CNN-ide, RetinaNetside, SSD-de ja YOLO-ga
• Eksemplar ja semantiline segmenteerimine
• Reaalajas objektituvastus YOLOv5-ga
• YOLOv5 objektidetektorite koolitamine
• Transformeritega töötamine KerasNLP-ga (tööstuse tugev WIP-teek)
• Transformerite integreerimine ConvNetsiga, et luua piltide pealdised
• Deepdream
• Süvaõppe mudeli optimeerimine arvutinägemise jaoks