Stima della posa in tempo reale da video in Python con YOLOv7

Introduzione

Il rilevamento di oggetti è un ampio campo nella visione artificiale e una delle applicazioni più importanti della visione artificiale "in natura". Da esso è stato estratto il rilevamento dei punti chiave (spesso utilizzato per la stima della posa).

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 di punti chiave, in cui i punti sono parti di un corpo umano.

La stima della posa è un uso sorprendente, estremamente divertente e pratico della visione artificiale. Con esso, possiamo eliminare l'hardware utilizzato per stimare le pose (tute per il motion capture), che sono costose e ingombranti. Inoltre, possiamo mappare il movimento degli esseri umani con il movimento dei robot nello spazio euclideo, consentendo movimenti motori di precisione senza l'uso di controller, che di solito non consentono livelli di precisione più elevati. La stima dei punti chiave può essere utilizzata per tradurre i nostri movimenti in modelli 3D in AR e VR, e sempre più spesso viene utilizzata per farlo solo con una webcam. Infine, la stima della posa può aiutarci nello sport e nella sicurezza.

In questa guida, eseguiremo la stima della posa in tempo reale da un video in Python, utilizzando il modello YOLOv7 all'avanguardia.

In particolare, lavoreremo con un video delle Olimpiadi invernali del 2018, tenutesi a PyeongChang, in Corea del Sud:

Aljona Savchenko e Bruno Massot hanno fatto una performance straordinaria, tra cui corpi sovrapposti alla telecamera, movimenti veloci e fluidi e rotazioni nell'aria. Sarà un'opportunità straordinaria per vedere come il modello gestisce situazioni difficili da dedurre!

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 è un repository di rilevamento di oggetti di livello industriale, basato sul metodo YOLO. È implementato in PyTorch, al contrario di C++ per i precedenti modelli YOLO, è completamente open source e ha un'API meravigliosamente semplice e potente che ti consente di dedurre, addestrare e personalizzare il progetto in modo flessibile. È un punto fermo che la maggior parte dei nuovi tentativi di migliorare il metodo YOLO si basa su di esso.

Questo è il modo YOLOR (Impari solo una rappresentazione) e anche YOLOv7 che si basa su YOLOR (stesso autore) sono stati creati!

YOLOv7 non è solo un'architettura di rilevamento di oggetti: fornisce nuove teste di modello, in grado di 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 in termini di precisione e velocità.

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

Iniziamo clonando il repository per ottenere il codice sorgente:

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

Ora, spostiamoci nel yolov7 directory, che contiene il progetto, e dai un'occhiata al contenuto:

%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

Ora, YOLO è pensato per essere un rilevatore di oggetti e non viene fornito con pesi di stima della posa per impostazione predefinita. Vorremo scaricare i pesi e caricare un'istanza del modello concreto da essi. I pesi sono disponibili sullo stesso repository GitHub e possono essere facilmente scaricati anche tramite la 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

Una volta scaricato, possiamo importare le librerie e i metodi di supporto che utilizzeremo:

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

Grande! Procediamo con il caricamento del modello e la creazione di uno script che ti permetta di dedurre le pose dai video con YOLOv7 e OpenCV.

Stima della posa in tempo reale con YOLOv7

Creiamo prima un metodo per caricare il modello dai pesi scaricati. Verificheremo quale dispositivo abbiamo a disposizione (CPU o 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()

A seconda che disponiamo di una GPU o meno, attiveremo la mezza precisione (usando float16 invece di float32 nelle operazioni), il che rende l'inferenza significativamente più veloce. Nota che è altamente incoraggiato eseguirlo su una GPU per velocità in tempo reale, poiché le CPU probabilmente non avranno la potenza per farlo a meno che non vengano eseguite su piccoli video.

Scriviamo un metodo di convenienza per eseguire l'inferenza. Accetteremo le immagini come array NumPy (poiché è ciò che le passeremo in seguito durante la lettura del video). Innanzitutto, utilizzando il letterbox() funzione: ridimensioneremo e imbottiremo il video in una forma con cui il modello può lavorare. Questa non deve essere e non sarà la forma (risoluzione) del video risultante!

Quindi, applicheremo le trasformazioni, convertiremo l'immagine in una precisione dimezzata (se è disponibile una GPU), la batch e la eseguiremo attraverso il modello:

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

Restituiremo le previsioni del modello, nonché l'immagine come tensore. Queste sono previsioni "approssimative": contengono molte attivazioni che si sovrappongono e vorremo "ripulirle" usando Non-Max Supression e tracciare gli scheletri previsti sull'immagine stessa:

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

Con questi in atto, il nostro flusso generale sarà simile a:

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

Per tradurlo in un'impostazione video in tempo reale, useremo OpenCV per leggere un video ed eseguiremo questo processo per ogni fotogramma. Su ogni fotogramma, scriveremo anche il fotogramma in un nuovo file, codificato come video. Ciò rallenterà necessariamente il processo mentre eseguiamo l'inferenza, la visualizzazione e la scrittura, quindi puoi accelerare l'inferenza e la visualizzazione evitando la creazione di un nuovo file e la scrittura su di esso nel ciclo:

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

Il VideoWriter accetta diversi parametri: il nome del file di output, il FourCC (quattro codici codec, che denotano il codec utilizzato per codificare il video), il framerate e la risoluzione come una tupla. Per non indovinare o ridimensionare il video, abbiamo utilizzato la larghezza e l'altezza del video originale, ottenute tramite il VideoCapture istanza che contiene dati sul video stesso, come la larghezza, l'altezza, il numero totale di fotogrammi, ecc.

Ora possiamo chiamare il metodo su qualsiasi video di input:

pose_estimation_video('../ice_skating.mp4')

Si aprirà una finestra OpenCV, che mostra l'inferenza in tempo reale. Inoltre, scriverà un file video nel file yolov7 directory (dal momento che abbiamo cd'd in esso):

Conclusione

In questa guida, abbiamo esaminato il metodo YOLO, YOLOv7 e la relazione tra YOLO e il rilevamento di oggetti, la stima della posa e la segmentazione dell'istanza. Abbiamo quindi dato un'occhiata a come è possibile installare e utilizzare facilmente YOLOv7 utilizzando l'API programmatica e creato diversi metodi pratici per semplificare l'inferenza e la visualizzazione dei risultati.

Infine, abbiamo aperto un video utilizzando OpenCV, eseguito l'inferenza con YOLOv7 e creato una funzione per eseguire la stima della posa in tempo reale, salvando il video risultante a piena risoluzione e 30 FPS sul disco locale.

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