Stima della posa/rilevamento del punto chiave con YOLOv7 in Python

Introduzione

Il rilevamento di oggetti è un ampio campo nella visione artificiale e una delle applicazioni più importanti della visione artificiale "in natura".

Il rilevamento degli oggetti non è standardizzato come la classificazione delle immagini, principalmente perché la maggior parte dei nuovi sviluppi viene in genere eseguita da singoli ricercatori, manutentori e sviluppatori, piuttosto che da grandi librerie e framework. È difficile impacchettare gli script di utilità necessari in un framework come TensorFlow o PyTorch e mantenere le linee guida API che hanno guidato lo sviluppo finora.

Ciò rende il rilevamento degli oggetti un po' più complesso, in genere più dettagliato (ma non sempre) e meno accessibile rispetto alla classificazione delle immagini.

Fortunatamente per le masse, Ultralytics ha sviluppato un'API di rilevamento oggetti semplice, molto potente e bella attorno a YOLOv5 che è stata estesa da altri team di ricerca e sviluppo a versioni più recenti, come YOLOv7.

In questa breve guida, eseguiremo la stima della posa (rilevamento dei punti chiave) in Python, con YOLOv7 all'avanguardia.

I punti chiave possono essere vari punti: parti di una faccia, arti di un corpo, ecc. La stima della posa è un caso speciale di rilevamento dei punti chiave, in cui i punti sono parti di un corpo umano e possono essere utilizzati per sostituire costosi hardware di rilevamento della posizione, abilita il controllo della robotica via etere e alimenta una nuova era di espressione del sé umano attraverso AR e VR.

YOLO e Stima della posa

YOLO (Guardi solo una volta) è una metodologia, nonché una famiglia di modelli costruiti per il rilevamento di oggetti. Fin dall'inizio nel 2015, YOLOv1, YOLOv2 (YOLO9000) e YOLOv3 sono stati proposti dagli stessi autori e la comunità di deep learning ha continuato negli anni a venire con progressi open source.

YOLOv5 di Ultralytics è la prima implementazione su larga scala di YOLO in PyTorch, che lo ha reso più accessibile che mai, ma il motivo principale per cui YOLOv5 ha guadagnato un tale punto d'appoggio è anche l'API meravigliosamente semplice e potente costruita attorno ad esso. Il progetto astrae i dettagli non necessari, consentendo al contempo la personalizzazione, praticamente tutti i formati di esportazione utilizzabili e impiega pratiche straordinarie che rendono l'intero progetto efficiente e ottimale.

YOLOv5 è ancora il progetto base con cui costruire modelli di Object Detection e molti repository che mirano a far avanzare il metodo YOLO iniziano con YOLOv5 come linea di base e offrono un'API simile (o semplicemente biforca il progetto e costruisci su di esso). Tale è il caso di YOLOR (Impari solo una rappresentazione) e YOLOv7 che si basa su YOLOR (stesso autore), che è l'ultimo progresso nella metodologia YOLO.

YOLOv7 non è solo un'architettura di rilevamento di oggetti: fornisce nuove teste di modello, che possono generare punti chiave (scheletri) ed eseguire la segmentazione delle istanze oltre alla sola regressione del riquadro di delimitazione, che non era standard con i precedenti modelli YOLO. Ciò non sorprende, poiché molte architetture di rilevamento degli oggetti sono state riproposte in precedenza anche per la segmentazione dell'istanza e le attività di rilevamento dei punti chiave, a causa dell'architettura generale condivisa, con output diversi a seconda dell'attività. Anche se non è sorprendente, il supporto della segmentazione delle istanze e del rilevamento dei punti chiave diventerà probabilmente il nuovo standard per i modelli basati su YOLO, che un paio di anni fa hanno iniziato a superare praticamente tutti gli altri rilevatori a due stadi.

Ciò rende la segmentazione delle istanze e il rilevamento dei punti chiave più veloci che mai, con un'architettura più semplice rispetto ai rilevatori a due stadi.

Il modello stesso è stato creato attraverso modifiche all'architettura, nonché ottimizzando aspetti dell'allenamento, soprannominati "bag-of-freebies", che hanno aumentato la precisione senza aumentare i costi di inferenza.

Installazione di YOLOv7

Andiamo avanti e installiamo il progetto da GitHub:

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

Questo crea a yolov7 directory nella tua directory di lavoro corrente, in cui potrai trovare i file di progetto di base:

%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

Nota: I blocchi appunti di Google Colab vengono reimpostati sulla directory di lavoro principale nella cella successiva, anche dopo aver chiamato %cd dirname, quindi dovrai continuare a chiamarlo in ogni cella in cui desideri eseguire un'operazione. I notebook Jupyter locali ricordano la modifica, quindi non è necessario continuare a chiamare il comando.

Ogni volta che esegui codice con un determinato set di pesi, verranno scaricati e archiviati in questa directory. Per eseguire la stima della posa, vorremo scaricare i pesi per il modello YOLOv7 pre-addestrato per quell'attività, che può essere trovato sotto il /releases/download/ scheda su 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

Ottimo, abbiamo scaricato il yolov7-w6-pose.pt weights, che può essere utilizzato per caricare e ricostruire un modello addestrato per la stima della posa.

Caricamento del modello di stima della posa YOLOv7

Importiamo le librerie di cui avremo bisogno per eseguire la stima della posa:

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 ed torchvision sono abbastanza semplici: YOLOv7 è implementato con PyTorch. Il utils.datasets, utils.general ed utils.plots i moduli provengono dal progetto YOLOv7 e ci forniscono metodi che aiutano con la preelaborazione e la preparazione dell'input per il modello su cui eseguire l'inferenza. Tra quelli ci sono letterbox() per riempire l'immagine, non_max_supression_keypoint() per eseguire l'algoritmo Non-Max Supression sull'output iniziale del modello e per produrre un output pulito per la nostra interpretazione, così come il output_to_keypoint() ed plot_skeleton_kpts() metodi per aggiungere effettivamente punti chiave a una determinata immagine, una volta previsti.

Possiamo caricare il modello dal file di peso con torch.load(). Creiamo una funzione per verificare se è disponibile una GPU, caricare il modello, metterlo in modalità di inferenza e spostarlo sulla GPU se disponibile:

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

Con il modello caricato, creiamo un run_inference() metodo che accetta una stringa che punta a un file sul nostro sistema. Il metodo leggerà l'immagine usando OpenCV (cv2), riempilo con letterbox(), applica le trasformazioni e trasformalo in un batch (il modello è addestrato e prevede batch, come al solito):

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

Qui, abbiamo restituito l'immagine trasformata (perché vorremo estrarre l'originale e tracciare su di esso) e gli output del modello. Questi output contengono 45900 previsioni di punti chiave, la maggior parte delle quali si sovrappongono. Vorremo applicare la soppressione non massima a queste previsioni grezze, proprio come con le previsioni di rilevamento di oggetti (in cui vengono previsti molti riquadri di delimitazione e quindi vengono "compressi" data una certa sicurezza e soglia IoU). Dopo la soppressione, possiamo tracciare ogni punto chiave sull'immagine originale e visualizzarlo:

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

Ora, per alcune immagini di input, come karate.jpg nella directory di lavoro principale, possiamo eseguire l'inferenza, eseguire la soppressione non massima e tracciare i risultati con:

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

Questo risulta in:

Questa è un'immagine abbastanza difficile da dedurre! La maggior parte del braccio destro del praticante sulla destra è nascosto, e possiamo vedere che il modello ha dedotto che è nascosto e alla destra del corpo, mancando che il gomito sia piegato e che una parte del braccio sia davanti . Il praticante a sinistra, che si vede molto più chiaramente, viene dedotto correttamente, anche con una gamba nascosta.

In effetti – una persona seduta dietro, quasi completamente invisibile alla fotocamera ha avuto la loro posa apparentemente stimata correttamente, solo in base alla posizione dei fianchi mentre si è seduti. Ottimo lavoro per conto della rete!

Conclusione

In questa guida, abbiamo dato una breve occhiata a YOLOv7, l'ultimo avanzamento della famiglia YOLO, che si basa su YOLOR e fornisce ulteriori capacità di segmentazione delle istanze e rilevamento dei punti chiave oltre alle capacità standard di rilevamento degli oggetti della maggior parte dei modelli basati su YOLO .

Abbiamo quindi dato un'occhiata a come scaricare i file di peso rilasciati, caricarli per costruire un modello ed eseguire l'inferenza della stima della posa per gli esseri umani, ottenendo risultati impressionanti.

Andare oltre - Apprendimento profondo pratico per la visione artificiale

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Portata: "Apprendimento profondo pratico per la visione artificiale con Python".

Un altro corso di visione artificiale?

Non faremo la classificazione delle cifre MNIST o della moda MNIST. Hanno servito la loro parte molto tempo fa. Troppe risorse di apprendimento si stanno concentrando su set di dati di base e architetture di base prima di lasciare che le architetture black-box avanzate si assumano il peso delle prestazioni.

Vogliamo concentrarci demistificazione, praticità, e una comprensione reciproca, intuizione ed progetti reali. Vuoi imparare come Puoi fare la differenza? Ti porteremo in un viaggio dal modo in cui il nostro cervello elabora le immagini alla scrittura di un classificatore di apprendimento profondo per la ricerca per il cancro al seno alle reti di apprendimento profondo che "allucinano", insegnandoti i principi e la teoria attraverso il lavoro pratico, fornendoti il know-how e strumenti per diventare un esperto nell'applicazione del deep learning per risolvere la visione artificiale.

Cosa c'è dentro?

• I primi principi della visione e come si può insegnare ai computer a "vedere"
• Diversi compiti e applicazioni della visione artificiale
• Gli strumenti del mestiere che ti semplificheranno il lavoro
• Trovare, creare e utilizzare set di dati per la visione artificiale
• La teoria e l'applicazione delle reti neurali convoluzionali
• Gestione del cambio di dominio, della co-occorrenza e di altri pregiudizi nei set di dati
• Trasferisci l'apprendimento e utilizza il tempo di formazione e le risorse di calcolo degli altri a tuo vantaggio
• Costruire e formare un classificatore di cancro al seno all'avanguardia
• Come applicare una sana dose di scetticismo alle idee tradizionali e comprendere le implicazioni delle tecniche ampiamente adottate
• Visualizzazione dello "spazio concettuale" di una ConvNet utilizzando t-SNE e PCA
• Casi di studio su come le aziende utilizzano le tecniche di visione artificiale per ottenere risultati migliori
• Valutazione corretta del modello, visualizzazione dello spazio latente e identificazione dell'attenzione del modello
• Esecuzione di ricerche di dominio, elaborazione dei propri set di dati e creazione di test di modello
• Architetture all'avanguardia, la progressione delle idee, cosa le rende uniche e come realizzarle
• KerasCV – una libreria WIP per la creazione di pipeline e modelli all'avanguardia
• Come analizzare e leggere documenti e implementarli da soli
• Selezione dei modelli in base all'applicazione
• Creazione di una pipeline di machine learning end-to-end
• Paesaggio e intuizione sul rilevamento di oggetti con R-CNN, RetinaNet, SSD e YOLO più veloci
• Istanza e segmentazione semantica
• Riconoscimento di oggetti in tempo reale con YOLOv5
• Formazione dei rilevatori di oggetti YOLOv5
• Utilizzo di Transformers tramite KerasNLP (libreria WIP di livello industriale)
• Integrazione di Transformers con ConvNets per generare didascalie di immagini
• Deepdream
• Ottimizzazione del modello di deep learning per la visione artificiale