INDICE
In questo articolo, vedremo un modo sorprendentemente semplice per iniziare a lavorare con il riconoscimento facciale utilizzando Python e la libreria open source OpenCV .
Cosa è OpenCV ?
OpenCV è la libreria più popolare per la visione artificiale. Scritto originariamente in C/C++, ora fornisce collegamenti per Python. La libreria OpenCV permette grazie a algoritmi di apprendimento automatico di cercare i volti all'interno di un'immagine. Poiché i volti sono così complicati, non esiste una semplice condizione che ti dirà se ha trovato un volto o meno. Invece, ci sono migliaia di piccoli modelli e caratteristiche che devono essere abbinati. Gli algoritmi suddividono il compito di identificare il volto in migliaia di compiti più piccoli e di dimensioni ridotte, ognuno dei quali è facile da risolvere.
Per qualcosa come un volto, potresti avere 6.000 o più feature, che devono corrispondere tutti affinché un volto venga rilevato (entro i limiti di errore, ovviamente).
Ma qui sta il problema: per il rilevamento dei volti, l'algoritmo inizia in alto a sinistra di un'immagine e si sposta verso il basso attraverso piccoli blocchi di dati, guardando ogni blocco, chiedendo costantemente: "È un volto? … Questa è una faccia? … È una faccia?” Poiché ci sono 6.000 o più test per blocco, potresti avere milioni di calcoli da fare, che bloccheranno il tuo computer.
Per aggirare questo problema, OpenCV utilizza le cascate ( modelli preaddestrati ) . Cos'è una cascata? La risposta migliore si trova nel dizionario.
Come una serie di cascate, la cascata OpenCV rompe il problema del rilevamento dei volti in più fasi. Per ogni blocco, fa un test molto approssimativo e veloce. Se passa, esegue un test leggermente più dettagliato e così via. L'algoritmo può avere da 30 a 50 di queste fasi o cascate e rileverà un volto solo se tutte le fasi passano.
Il vantaggio è che la maggior parte dell'immagine restituirà un negativo durante le prime fasi, il che significa che l'algoritmo non perderà tempo a testare tutte le 6.000 funzionalità su di essa. Invece di impiegare ore, ora è possibile eseguire il rilevamento del volto in tempo reale.
Modelli Pre Addestrati per il Riconoscimento Facciale
Sebbene la teoria possa sembrare complicata, in pratica è abbastanza facile. Le stesse cascate sono solo un mucchio di file XML che contengono dati OpenCV usati per rilevare oggetti. Inizializzi il tuo codice con il modello pre addestrato che desideri e poi fa il lavoro per te.
Poiché il rilevamento dei volti è un progetto così comune, OpenCV è dotato di una serie di modelli preaddestrati integrati per rilevare di tutto, dai volti agli occhi, dalle mani alle gambe. Ci sono anche cascate per cose non umane. Ad esempio, se gestisci un negozio di banane e vuoi rintracciare le persone che rubano banane, questo ragazzo ne ha costruito uno per quello!
Installazione di OpenCV
Innanzitutto, devi trovare il file di installazione corretto per il tuo sistema operativo . Ho scoperto che l'installazione di OpenCV è stata la parte più difficile del compito. Se ricevi strani errori inspiegabili, potrebbe essere dovuto a conflitti di libreria, differenze a 32/64 bit e così via. Ho trovato più semplice usare una macchina virtuale Linux e installare OpenCV da zero.
Oppure ancora più facile, apri l'editor di Google "Colab" e digita
!pip3 install opencv-pythonUna volta completata l'installazione, puoi verificare se funziona o meno avviando una sessione Python e digitando:
import cv2se utilizzate colab importate anche questo modulo
from google.colab.patches import cv2_imshowSe non ricevi errori, puoi passare alla parte successiva.
Scriviamo e capiamo il codice per il Riconoscimento Facciale in python
Analizziamo il codice vero e proprio, che puoi scaricare dalla nostra pagina progetti.
Per prima cosa avrai bisogna del tuo file Python ( face_detect.py ) o netebook ( .ipynb ) , l'immagine immagine.png e haarcascade_frontalface_default.xml . ( Tutto ciò di cui hai bisogno come detto lo troverai nella pagina progetti )
# carichiamo immagine e haarcascade_frontalface_default
imagePath = sys.argv[1]
cascPath = sys.argv[2]Utilizzeremo l'immagine e il modello preaddestrato per rilevare i volti con OpenCV.
# Creiamo il nostro modello pre addestrato
faceCascade = cv2.CascadeClassifier(cascPath)Ora creiamo la cascata e la inizializziamo con la nostra cascata di volti. Questo carica la cascata del viso in memoria in modo che sia pronta per l'uso. Ricorda, la cascata è solo un file XML che contiene i dati per rilevare i volti.
# leggiamo l'immagine
image = cv2.imread(imagePath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)Qui leggiamo l'immagine e la convertiamo in scala di grigi. Molte operazioni in OpenCV vengono eseguite in scala di grigi.
# Rilevamento volti nell'immagine
faces = faceCascade.detectMultiScale(gray,scaleFactor=1.1,minNeighbors=5,minSize=(30, 30))
Questa funzione rileva il volto effettivo ed è la parte fondamentale del nostro codice, quindi esaminiamo le opzioni:
La detectMultiScalefunzion è una funzione generale che rileva gli oggetti. Dal momento che lo chiamiamo sulla cascata del viso, è quello che rileva.
La prima opzione è l'immagine in scala di grigi.
Il secondo è il scaleFactor. Poiché alcuni volti potrebbero essere più vicini alla fotocamera, apparirebbero più grandi dei volti nella parte posteriore. Il fattore di scala compensa questo.
L'algoritmo di rilevamento utilizza una finestra mobile per rilevare gli oggetti. minNeighborsdefinisce quanti oggetti vengono rilevati vicino a quello corrente prima di dichiarare il volto trovato. minSize, nel frattempo, fornisce le dimensioni di ciascuna finestra.
Nota: ho preso i valori comunemente usati per questi campi. Nella vita reale, sperimenteresti valori diversi per la dimensione della finestra, il fattore di scala e così via finché non trovi quello che funziona meglio per te.
La funzione restituisce un elenco di rettangoli in cui ritiene di aver trovato una faccia. Successivamente, esamineremo il punto in cui pensa di aver trovato qualcosa.
print(f"Trovate {len(faces)} Facce!")
# disegnamo un rettangolo intorno ai volti
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)Questa funzione restituisce 4 valori: la xe la yposizione del rettangolo e la larghezza e l'altezza del rettangolo ( w, h). Usiamo questi valori per disegnare un rettangolo usando la rectangle()funzione incorporata.
cv2.imshow("Facce Trovate", image)
cv2.waitKey(0)se invece utilizzate colab dovrete scrivere
cv2_imshow(image)Alla fine, visualizziamo l'immagine e aspettiamo che l'utente prema un tasto. Mettiamo alla prova la nostra foto:
$ python face_detect.py image.png haarcascade_frontalface_default.xml Ha funzionato.
Che ne dici di fare un'altra prova con foto nuova:
Quella... non è una faccia. Proviamo di nuovo. Ho cambiato i parametri e ho scoperto che l'impostazione scaleFactor di 1.2 ha eliminato la faccia sbagliata.
# Configurazione che da facce che non esistono
faces = faceCascade.detectMultiScale(gray,scaleFactor=1.1,minNeighbors=5,minSize=(30, 30))
# Configurazione che non rileva le facce inesistenti
faces = faceCascade.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=5,minSize=(30, 30))
Cosa è successo ? Aggiustiamo il nostro Programma per il Riconoscimento Facciale
Bene, la prima foto è stata scattata abbastanza da vicino con una fotocamera di alta qualità. Il secondo sembra essere stato ripreso da lontano e forse con un cellulare. Questo è il motivo per cui scaleFactor doveva essere modificato. Come ho detto, dovrai impostare l'algoritmo caso per caso per evitare falsi positivi.
Tieni presente, tuttavia, che poiché si basa sull'apprendimento automatico, i risultati non saranno mai accurati al 100%. Otterrai risultati abbastanza buoni nella maggior parte dei casi, ma occasionalmente l'algoritmo identificherà oggetti errati come volti.
Il codice può essere trovato qui
Grazie mille per la lettura, Iscriviti al sito, presto usciranno altri tutorial con Python. 
.png)
