Estimarea poziției/Detecția punctelor cheie cu YOLOv7 în Python

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”.

Detectarea obiectelor nu este la fel de standardizată precum clasificarea imaginilor, în principal pentru că majoritatea noilor dezvoltări sunt realizate de obicei de către cercetători, întreținerii și dezvoltatori individuali, mai degrabă decât de biblioteci și cadre mari. Este dificil să împachetați scripturile utilitare necesare într-un cadru precum TensorFlow sau PyTorch și să mențineți ghidurile API care au ghidat dezvoltarea până acum.

Acest lucru face ca detectarea obiectelor să fie oarecum mai complexă, de obicei mai pronunțată (dar nu întotdeauna) și mai puțin accesibilă decât clasificarea imaginilor.

Din fericire pentru mase – Ultralytics a dezvoltat un API simplu, foarte puternic și frumos de detectare a obiectelor în jurul lui YOLOv5, care a fost extins de alte echipe de cercetare și dezvoltare în versiuni mai noi, cum ar fi YOLOv7.

În acest scurt ghid, vom efectua Estimarea Pozei (Detecția punctului cheie) în Python, cu YOLOv7 de ultimă generație.

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 unui corp uman și pot fi folosite pentru a înlocui hardware-ul scump de urmărire a poziției, permiteți controlul roboticii prin aer și alimentați o nouă eră a autoexprimării umane prin AR și VR.

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 prima implementare la scară largă a YOLO în PyTorch, ceea ce l-a făcut mai accesibil decât oricând înainte, dar principalul motiv pentru care YOLOv5 a câștigat un astfel de punct de sprijin este, de asemenea, API-ul minunat de simplu și puternic construit în jurul lui. Proiectul abstrage detaliile inutile, permițând în același timp personalizarea, practic toate formatele de export utilizabile și folosește practici uimitoare care fac întregul proiect atât eficient, cât și cât se poate de optim.

YOLOv5 este încă proiectul de bază cu care se construiește modele de detectare a obiectelor, iar multe depozite care urmăresc să avanseze metoda YOLO încep cu YOLOv5 ca linie de bază și oferă un API similar (sau pur și simplu bifurcă proiectul și construiește deasupra acestuia). Acesta este cazul YOLOR (Înveți doar o reprezentare) și YOLOv7, care s-a construit pe YOLOR (același autor), care este cea mai recentă avansare în metodologia YOLO.

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 – sprijinirea 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 toate celelalte detectoare în două trepte în urmă cu câțiva ani.

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ă mergem mai departe și să instalăm proiectul din GitHub:

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

Aceasta creează un yolov7 directorul din directorul de lucru actual, în care veți putea găsi fișierele de bază ale proiectului:

%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

Notă: Blocnotesurile Google Colab se resetează la directorul de lucru principal din celula următoare, chiar și după apel %cd dirname, așa că va trebui să o apelați în continuare în fiecare celulă în care doriți să fie efectuată o operație. Notebook-urile Jupyter locale își amintesc modificarea, deci nu este nevoie să continuați să apelați comanda.

Ori de câte ori executați cod cu un anumit set de greutăți – acestea vor fi descărcate și stocate în acest director. Pentru a efectua estimarea poziției, vom dori să descarcăm greutățile pentru modelul YOLOv7 pre-antrenat pentru acea sarcină, care pot fi găsite în secțiunea /releases/download/ fila pe 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

Grozav, am descărcat yolov7-w6-pose.pt fișierul ponderi, care poate fi folosit pentru a încărca și a reconstrui un model antrenat pentru estimarea poziției.

Se încarcă modelul de estimare a poziției YOLOv7

Să importăm bibliotecile de care avem nevoie pentru a efectua estimarea poziției:

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 și torchvision sunt destul de simple – YOLOv7 este implementat cu PyTorch. The utils.datasets, utils.general și utils.plots modulele provin din proiectul YOLOv7 și ne oferă metode care ajută la preprocesarea și pregătirea intrării pentru modelul pe care să ruleze inferența. Printre acestea sunt letterbox() pentru a completa imaginea, non_max_supression_keypoint() pentru a rula algoritmul de suprimare Non-Max pe ieșirea inițială a modelului și pentru a produce o ieșire curată pentru interpretarea noastră, precum și output_to_keypoint() și plot_skeleton_kpts() metode pentru a adăuga efectiv puncte cheie la o anumită imagine, odată ce acestea sunt prezise.

Putem încărca modelul din fișierul de greutate cu torch.load(). Să creăm o funcție pentru a verifica dacă un GPU este disponibil, să încărcăm modelul, să îl punem în modul de inferență și să îl mutam în GPU dacă este disponibil:

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()

Cu modelul încărcat, să creăm un run_inference() metodă care acceptă un șir care indică un fișier din sistemul nostru. Metoda va citi imaginea folosind OpenCV (cv2), tamponați-l cu letterbox(), aplicați-i transformări și transformați-l într-un lot (modelul este antrenat și așteaptă loturi, ca de obicei):

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

Aici, am returnat imaginea transformată (pentru că vom dori să extragem originalul și să tragem pe ea) și rezultatele modelului. Aceste ieșiri conțin 45900 de predicții de puncte cheie, dintre care majoritatea se suprapun. Vom dori să aplicăm Non-Max Supression acestor predicții brute, la fel ca și în cazul predicțiilor de detectare a obiectelor (unde sunt prezise multe casete de delimitare și apoi sunt „restrânse” având în vedere o anumită încredere și un prag IoU). După suprimare, putem reprezenta fiecare punct cheie pe imaginea originală și îl putem afișa:

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()

Acum, pentru o imagine de intrare, cum ar fi karate.jpg în directorul de lucru principal, putem rula inferențe, putem efectua Suprimarea Non-Max și reprezentam rezultatele cu:

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

Rezultă:

Aceasta este o imagine destul de dificil de dedus! Cea mai mare parte a brațului drept al practicianului din dreapta este ascuns, și putem observa că modelul a dedus că acesta este ascuns și în dreapta corpului, lipsind că cotul este îndoit și că o porțiune a brațului este în față. . Practicantul din stânga, care se vede mult mai clar, este dedus corect, chiar și cu un picior ascuns.

De fapt, o persoană care stă în spate, aproape complet invizibil pentru cameră a avut poziția aparent corect estimată, doar pe baza poziției șoldurilor în timp ce stau jos. O lucrare excelentă în numele rețelei!

Concluzie

În acest ghid – am aruncat o scurtă privire asupra YOLOv7, cel mai recent progres din familia YOLO, care se bazează pe YOLOR și oferă în continuare capabilități de segmentare a instanțelor și de detectare a punctelor cheie dincolo de capacitățile standard de detectare a obiectelor ale majorității modelelor bazate pe YOLO. .

Apoi am aruncat o privire asupra modului în care putem descărca fișierele de greutate lansate, le putem încărca pentru a construi un model și a realiza inferențe de estimare a poziției pentru oameni, dând rezultate impresionante.

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ă