Face Recognition and Tracking con OpenCV e face_recognition (seconda parte)

Eccoci qua, di nuovo, pronti a capire come sia possibile  creare un semplice software per riconoscere dei volti.

Nel precedente articolo abbiamo visto come gestire la webcam e trattare video ed immagini in real time, adesso cerchiamo di capire come estrarre delle features dalla immagini per usarle quali “firme” ai fini della comparazione. Per fare ciò, in questo primo esempio, utilizzeremo una libreria python che ci semplificherà la vita: face_recognition.

Per poterla utilizzare basterà, banalmente, installare la lib:

pip3 install face_recognition

ed importarla nello nostro codice

import face_recognition

Cosa serve, dunque, per implementare il nostro classificatore?

per poter effettuare il riconoscimento di un volto basterà fare, ancora, alcuni semplici passaggi.

1) Carichiamo l’immagine del volto che vogliamo sottopporre al confronto

volto_noto=face_recognition.load_image_file("volto_noto.jpg")

2) estraiamo da questa ultima le informazioni (features) che utilizzeremo per il confronto:

volto_noto_features=face_recognition.face_encodings(volto_noto)[0]

3) carichiamo il file del volto sconosciuto da verificare

volto_sconosciuto=face_recognition.load_image_file("volto_sconosciuto.jpg")

4) estraiamo da questo ultimo le informazioni che utilizzeremo per il confronto:

volto_sconosciuto_features=face_recognition.face_encodings(volto_sconosciuto)[0]

5) compariamo i due volti

confronta=face_recognition.compare_faces([volto_sconosciuto_features], volto_noto_features)

Se il confronto è positivo  il risultato sarà True altrimenti il metodo restituirà valore False.

Tutto qua.

Ma come funziona la lib  face_recognition? In generale la face recognition viene fatta attraverso due possibili approcci, che è possibile scegliere a piacimento a seconda delle esigenze e delle risorse a disposizione.

In linea di massima è possibile, in fase di analisi dell’immagine, scegliere l’algoritmo da usare attraverso il seguente metodo:

volti_nella_img = face_recognition.face_locations(image,number_of_times_to_upsample=1,model='hog')

il metodo face_location ci consente di  individuare i volti all’interno di una foto ed attraverso il parametro model si può definire l’algoritmo da usare; esso  può assumere due valori  hog (Histogram of Oriented Gradients) e cnn (Convolutional Neural Network)

HOG (Histogram of Oriented Gradients)

E’ un algoritmo basato sul calcolo di gradienti dell’immagine orientati e del primo ordine.
Gli algoritmi che implementano questo filtro sono ingegnerizzati a mano e fissi, pertanto non prevedono meccanismi  di apprendimento o di adattamento. Il vantaggio di questo approccio è che si  utilizzano poche risorse in fase di classificazione/comparazione.

CNN(Convolutional Neural Network)

Si tratta di una rete neurale convoluzionale basata su un’architettura deep learning gerarchica. Una CCN è, dunque, una rete neurale che opera su più livelli che filtrano ripetutamente l’immagine target fino alla fase di classificazione. I filtri sono “allenabili” e sono in grado pertanto di adattarsi durante l’apprendimento.

Le CNN, di conseguenza,  possono raggiungere livelli di alta precisione, perchè i vari livelli possono essere “addestrati” ad hoc e possono apprendere caratteristiche di basso livello simili a quelle previste nel metodo HOG  ma esse riescono a farlo operando autonomamente.

Il parametro number_of_times_to_upsample=1 invece ci consente di decidere quante volte sia necessario analizzare l’imagine per ricercare volti. Maggiore è il numero di sample maggiore sarà la possibilità di individuare nell’immagine target volti più piccoli.

Per concludere questo articolo  di seguito lascio un piccolo esempio su come sia possibile analizzare i frames di un video in realtime catturato dalla webcam per effettuare face recognition su un video.

import cv2
import face_recognition
video = cv2.VideoCapture(0)
volto_noto=face_recognition.load_image_file("volto_noto.jpg")
volto_noto_features=face_recognition.face_encodings(volto_noto)[0]


while True:
	#estraggo il singolo frame dal video
	ret, frame = video.read()
	posizione_del_volto_sconosciuto_nel_frame = face_recognition.face_locations(frame,model='hog')
	#estraggo le features dal frames in cui c'è il volto
	if len(posizione_del_volto_sconosciuto_nel_frame) > 0 :
	   volto_sconosciuto_in_video_features = face_recognition.face_encodings(frame)[0]
	   #confronto il volto trovato nel frame con il volto di confronto
	   confronta=face_recognition.compare_faces([volto_sconosciuto_in_video_features], volto_noto_features)
	   if confronta:
              print ('Riconosciuto') 
           else:
              print ('Sconosciuto') 
	else :
	   print ('Sconosciuto') 

<< prima parte 

terza parte  >>