Estimare poziția în timp real din videoclip în Python cu YOLOv7

Introducere

Detectarea obiectelor este un domeniu larg în viziunea computerizată și una dintre cele mai importante aplicații ale vederii computerizate „în sălbăticie”. Din acesta, a fost extrasă detectarea punctelor cheie (deseori folosită pentru estimarea poziției).

Punctele cheie pot fi diferite puncte – părți ale unei fețe, membre ale unui corp etc. Estimarea poziției este un caz special de detectare a punctelor cheie – în care punctele sunt părți ale corpului uman.

Estimarea poziției este o utilizare uimitoare, extrem de distractivă și practică a vederii computerizate. Cu el, putem elimina hardware-ul folosit pentru a estima ipostaze (costume de captare a mișcării), care sunt costisitoare și greu de manevrat. În plus, putem mapa mișcarea oamenilor la mișcarea roboților în spațiul euclidian, permițând mișcarea motorului de precizie fină fără a folosi controlere, care de obicei nu permit niveluri mai mari de precizie. Estimarea punctelor cheie poate fi folosită pentru a traduce mișcările noastre în modele 3D în AR și VR și este folosită din ce în ce mai mult pentru a face acest lucru doar cu o cameră web. În cele din urmă – estimarea pozelor ne poate ajuta în sport și securitate.

În acest ghid, vom efectua estimarea poziției în timp real dintr-un videoclip în Python, folosind modelul YOLOv7 de ultimă generație.

Mai exact, vom lucra cu un videoclip de la olimpiadele de iarnă din 2018, desfășurate în PyeongChang din Coreea de Sud:

Aljona Savchenko și Bruno Massot au făcut o performanță uimitoare, incluzând corpuri suprapuse împotriva camerei, mișcare rapidă fluidă și rotire în aer. Va fi o oportunitate uimitoare de a vedea cum modelul face față situațiilor dificil de dedus!

YOLO și Estimarea Pozei

YOLO (Te uiți doar o dată) este o metodologie, precum și o familie de modele construite pentru detectarea obiectelor. De la înființarea în 2015, YOLOv1, YOLOv2 (YOLO9000) și YOLOv3 au fost propuse de același(i) autori – iar comunitatea de învățare profundă a continuat cu progrese open-source în anii următori.

YOLOv5 de la Ultralytics este un depozit de detectare a obiectelor de calitate industrială, construit pe baza metodei YOLO. Este implementat în PyTorch, spre deosebire de C++ pentru modelele anterioare YOLO, este complet open source și are un API frumos și puternic care vă permite să deduceți, să antrenați și să personalizați proiectul în mod flexibil. Este atât de important încât majoritatea încercărilor noi de îmbunătățire a metodei YOLO se bazează pe ea.

Acesta este modul în care YOLOR (Înveți doar o reprezentare) și YOLOv7 care s-a construit deasupra lui YOLOR (același autor) au fost create de asemenea!

YOLOv7 nu este doar o arhitectură de detectare a obiectelor - oferă noi capete de model, care pot scoate puncte cheie (schelete) și pot realiza segmentarea instanțelor pe lângă doar regresia cu casete de delimitare, care nu era standard cu modelele YOLO anterioare. Acest lucru nu este surprinzător, deoarece multe arhitecturi de detectare a obiectelor au fost reutilizate, de exemplu, sarcinile de segmentare și detectarea punctelor cheie mai devreme, datorită arhitecturii generale partajate, cu rezultate diferite în funcție de sarcină.

Chiar dacă nu este surprinzător – susținerea segmentării instanțelor și a detectării punctelor cheie va deveni probabil noul standard pentru modelele bazate pe YOLO, care au început să depășească practic toți ceilalți detectoare în două etape în urmă cu câțiva ani, atât în ​​ceea ce privește precizia, cât și viteza.

Acest lucru face ca segmentarea instanțelor și detectarea punctelor cheie să fie efectuate mai rapid decât oricând, cu o arhitectură mai simplă decât detectoarele în două etape.

Modelul în sine a fost creat prin modificări arhitecturale, precum și prin optimizarea aspectelor de antrenament, numite „bag-of-freebies”, care au crescut precizia fără a crește costul de inferență.

Instalarea YOLOv7

Să începem prin a clona depozitul pentru a obține codul sursă:

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

Acum, să trecem la yolov7 director, care conține proiectul și aruncați o privire asupra conținutului:

%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

Acum, YOLO este menit să fie un detector de obiecte și nu este livrat cu greutăți de estimare a poziției din greșeală. Vom dori să descarcăm greutățile și să încărcăm o instanță de model concret din ele. Greutățile sunt disponibile în același depozit GitHub și pot fi descărcate cu ușurință și prin 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

Odată descărcate, putem importa bibliotecile și metodele de ajutor pe care le vom folosi:

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

Grozav! Să continuăm cu încărcarea modelului și crearea unui script care vă permite să deduceți ipostaze din videoclipurile cu YOLOv7 și OpenCV.

Estimare poziția în timp real cu YOLOv7

Să creăm mai întâi o metodă de încărcare a modelului din greutățile descărcate. Vom verifica ce dispozitiv avem disponibil (CPU sau 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()

În funcție de faptul că avem sau nu un GPU, vom activa jumătate de precizie (folosind float16 în loc de float32 în operațiuni), ceea ce face inferența semnificativ mai rapidă. Rețineți că este foarte încurajat să efectuați acest lucru pe un GPU pentru viteze în timp real, deoarece procesoarele nu vor avea probabil puterea de a face acest lucru decât dacă rulează pe videoclipuri mici.

Să scriem o metodă de convingere pentru rularea inferenței. Vom accepta imagini ca matrice NumPy (deoarece asta le vom transmite mai târziu în timp ce citim videoclipul). În primul rând, folosind letterbox() funcție – vom redimensiona și vom completa videoclipul la o formă cu care modelul poate funcționa. Aceasta nu trebuie să fie și nu va fi forma (rezoluția) videoclipului rezultat!

Apoi, vom aplica transformările, vom converti imaginea la jumătate de precizie (dacă este disponibil un GPU), o vom grupa și o vom rula prin model:

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

Vom returna predicțiile modelului, precum și imaginea ca tensor. Acestea sunt predicții „aspre” – conțin multe activări care se suprapun și vom dori să le „curățăm” folosind Non-Max Supression și să trasăm scheletele prezise peste imaginea însăși:

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

Cu acestea în loc, fluxul nostru general va arăta astfel:

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

Pentru a traduce asta într-o setare video în timp real – vom folosi OpenCV pentru a citi un videoclip și vom rula acest proces pentru fiecare cadru. Pe fiecare cadru, vom scrie și cadrul într-un fișier nou, codificat ca videoclip. Acest lucru va încetini neapărat procesul pe măsură ce rulăm inferența, o afișăm și scriem - astfel încât să puteți accelera inferența și afișarea evitând crearea unui fișier nou și scriind în el în buclă:

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 acceptă mai mulți parametri – numele fișierului de ieșire, FourCC (patru coduri de codec, care indică codecul folosit pentru a codifica videoclipul), framerate și rezoluția ca tuplu. Pentru a nu ghici sau redimensiona videoclipul – am folosit lățimea și înălțimea videoclipului original, obținute prin VideoCapture instanță care conține date despre videoclipul în sine, cum ar fi lățimea, înălțimea, numărul total de cadre etc.

Acum, putem apela metoda pe orice videoclip de intrare:

pose_estimation_video('../ice_skating.mp4')

Aceasta va deschide o fereastră OpenCV, afișând inferența în timp real. Și, de asemenea, va scrie un fișier video în fișierul yolov7 director (din moment ce avem cdam intrat în el):

Concluzie

În acest ghid, am aruncat o privire asupra metodei YOLO, YOLOv7 și a relației dintre YOLO și detectarea obiectelor, estimarea poziției și segmentarea instanțelor. Am analizat apoi cum puteți instala și lucra cu ușurință cu YOLOv7 utilizând API-ul programatic și am creat mai multe metode convenabile pentru a face inferența și afișarea rezultatelor mai ușoară.

În cele din urmă, am deschis un videoclip folosind OpenCV, am efectuat inferențe cu YOLOv7 și am creat o funcție pentru efectuarea estimării poziția în timp real, salvând videoclipul rezultat la rezoluție completă și 30FPS pe discul local.

Mergând mai departe – Învățare profundă practică pentru viziunea computerizată

Natura ta curios te face să vrei să mergi mai departe? Vă recomandăm să verificați Curs: „Învățare profundă practică pentru viziunea computerizată cu Python”.

Un alt curs de Computer Vision?

Nu vom face clasificarea cifrelor MNIST sau a modei MNIST. Și-au servit rolul cu mult timp în urmă. Prea multe resurse de învățare se concentrează pe seturile de date de bază și pe arhitecturile de bază înainte de a lăsa arhitecturile avansate de tip cutie neagră să asume povara performanței.

Vrem să ne concentrăm asupra demistificare, practic, înţelegere, intuiţie și proiecte reale. Vreau sa invat cum poți face o diferență? Vă vom duce într-o plimbare de la modul în care creierul nostru procesează imaginile până la scrierea unui clasificator de învățare profundă de nivel de cercetare pentru cancerul de sân la rețele de învățare profundă care „halucinează”, învățându-vă principiile și teoria prin muncă practică, echipându-vă cu know-how și instrumente pentru a deveni un expert în aplicarea învățării profunde pentru a rezolva viziunea computerizată.

Ce e inauntru?

• Primele principii ale vederii și modul în care computerele pot fi învățate să „vadă”
• Diferite sarcini și aplicații ale vederii computerizate
• Instrumentele meseriei care vă vor ușura munca
• Găsirea, crearea și utilizarea seturilor de date pentru viziune computerizată
• Teoria și aplicarea rețelelor neuronale convoluționale
• Gestionarea deplasării de domeniu, apariției concomitente și a altor părtiniri în seturile de date
• Transfer Învățați și utilizați timpul de instruire și resursele de calcul ale altora în beneficiul dumneavoastră
• Construirea și formarea unui clasificator de ultimă generație pentru cancerul de sân
• Cum să aplicați o doză sănătoasă de scepticism ideilor principale și să înțelegeți implicațiile tehnicilor adoptate pe scară largă
• Vizualizarea unui „spațiu conceptual” al unui ConvNet folosind t-SNE și PCA
• Studii de caz despre modul în care companiile folosesc tehnicile de viziune computerizată pentru a obține rezultate mai bune
• Evaluarea corectă a modelului, vizualizarea spațiului latent și identificarea atenției modelului
• Efectuarea cercetărilor de domeniu, procesarea propriilor seturi de date și stabilirea de teste de model
• Arhitecturi de ultimă oră, progresul ideilor, ce le face unice și cum să le implementăm
• KerasCV – o bibliotecă WIP pentru crearea de conducte și modele de ultimă generație
• Cum să analizați și să citiți lucrările și să le implementați singur
• Selectarea modelelor în funcție de aplicația dvs
• Crearea unui canal de învățare automată de la capăt la capăt
• Peisaj și intuiție în detectarea obiectelor cu R-CNN-uri mai rapide, RetinaNets, SSD-uri și YOLO
• Instanță și segmentare semantică
• Recunoașterea obiectelor în timp real cu YOLOv5
• Instruirea detectoarelor de obiecte YOLOv5
• Lucrul cu Transformers folosind KerasNLP (bibliotecă WIP puternică în industrie)
• Integrarea Transformers cu ConvNets pentru a genera subtitrări ale imaginilor
• Deepdream
• Optimizarea modelului de Deep Learning pentru viziunea computerizată