Riconoscimento e Identificazione Facciale nella Visione Artificiale

Lo sviluppo rapido nelle tecnologie dell’apprendimento automatico e dell’intelligenza artificiale ha fatto significativi progressi in visione artificiale per il rilevamento e il riconoscimento degli oggetti. Tuttavia, creare un sistema che possa riconoscere l’umorismo e il divertimento negli esseri umani rimane un problema difficile per i programmatori, poiché la comicità e il divertimento sono soggettivi e basati su gusti personali e contesto culturale. Pertanto, è complicato creare un sistema in grado di determinare con precisione cosa gli individui trovano divertente o piacevole.

Tuttavia, la visione artificiale nel riconoscimento facciale e nell’identificazione ha fatto significativi progressi, ampiamente utilizzata in varie applicazioni come sicurezza, sorveglianza e biometria. La tecnologia di riconoscimento facciale identifica principalmente le persone analizzando e confrontando le loro caratteristiche facciali con un database di volti noti. Identificazione facciale implica il confronto di un volto con l’identità della persona. Utilizza algoritmi per estrarre caratteristiche del viso come la distanza tra gli occhi, le curve del naso e l’angolo della mandibola per generare una firma facciale distintiva.

Tecniche per il Riconoscimento e l’Identificazione Facciale

Ci sono vari metodi per riconoscere e identificare i volti, ma questo tutorial si concentrerà su tre tecniche e ne esporrà i vantaggi e gli svantaggi.

1. Approccio basato su Template

Innanzitutto, l’approccio basato su template confronta i tratti del viso di una persona target con quelli presenti in un’immagine di riferimento o template. L’immagine del template comprende diversi tratti del viso, come la posizione degli occhi, del naso, della bocca e le distanze tra di essi. Quindi, la tecnica confronta il viso target con l’immagine del template per determinare se c’è un match. Le eigenfaces sono uno dei metodi più comuni basati su template che utilizzano l’analisi delle componenti principali (PCA) per ridurre la dimensionalità delle immagini del viso e estrarre i tratti più rilevanti.

Vantaggi

• Sono molto precisi con template di alta qualità
• Tratta variazioni di illuminazione e espressioni facciali

Svantaggi

• Richiede template di alta qualità per risultati precisi
• Potrebbe essere computazionalmente oneroso

2. Approccio Basato su Caratteristiche

In secondo luogo, la tecnica basata su caratteristiche estrae caratteristiche dal viso, come la forma degli occhi, la distanza tra le sopracciglia e la curvatura delle labbra. L’approccio quindi confronta queste caratteristiche con quelle in un database di volti noti per identificare il viso target. Esempi di tecniche tipiche basate su caratteristiche includono il Local Binary Pattern (LBP) e il Scale-Invariant Feature Transform (SIFT).

Vantaggi

• Relativamente veloce ed efficiente
• Funziona con immagini a bassa risoluzione

Svantaggi

• Potrebbe non funzionare bene con condizioni di illuminazione variabili
• Potrebbe non essere robusto alle variazioni di espressioni facciali o pose

3. Approccio basato su Deep Learning

Infine, un approccio basato su deep learning utilizza reti neurali profonde per apprendere direttamente caratteristiche da immagini del volto. Le reti vengono addestrate su grandi dataset di immagini del volto per identificare pattern e caratteristiche rilevanti per il riconoscimento facciale. Esempi di metodi tipici basati su deep learning includono Reti Neurali Convoluzionali (CNN) e Reti Siamese.

Vantaggi

• Raggiunge alta precisione con grandi dataset
• Gestisce variazioni nelle espressioni facciali e nelle pose

Svantaggi

• Richiede una grande quantità di dati di addestramento
• Computazionalmente costoso

OSSERVAZIONE: Esistono diverse tecniche per il riconoscimento e l’identificazione del volto.

Riconoscimento e Identificazione del Volto con Python e OpenCV

Con la disponibilità di potenti librerie come OpenCV e i progressi delle algoritmi di machine learning, è diventato più facile che mai sviluppare sistemi di riconoscimento e identificazione del volto utilizzando Python. OpenCV offre una ricca gamma di funzioni e strumenti per il trattamento delle immagini, particolarmente utili nei compiti di riconoscimento del volto come la rilevazione del viso, l’estrazione di caratteristiche e il matching. Inoltre, dispone di modelli pre-costituiti come il classificatore Haar Cascades per la rilevazione del viso e VGG o ResNet per etichettare i volti rilevati.

OpenCV offre vari modelli per il riconoscimento dei volti, come Eigenfaces, Fisherfaces e Local Binary Patterns Histograms (LBPH). Addestriamo questi modelli per identificare individui specifici presentando loro immagini delle persone che vogliamo riconoscere. Eigenfaces utilizza l’Analisi delle Componenti Principali (PCA) per costruire un’immagine del volto da parti più piccole, mentre Fisherfaces utilizza l’Analisi Discriminante Lineare (LDA) per distinguere tra volti. LBPH confronta la texture dei volti con volti noti.

Identificazione del Volto

Importa Dipendenze

Importa le librerie necessarie.

import numpy as np
import cv2
import matplotlib.pyplot as plt
from IPython.display import Image

from google.colab import drive
drive.mount('/content/drive')

Carica Modelli Pre-Addestrati e Immagine

OpenCV fornisce un set di classificatori `Haar Cascade` pre-addestrati per rilevare vari oggetti, compresi i volti. `cv2.CascadeClassifier` è una classe che rappresenta il classificatore Haar Cascade. Il cv2.data.haarcascades è un percorso verso la directory contenente i modelli pre-addestrati. `haarcascade_frontalface_default.xml` è il file contenente il modello pre-addestrato per il riconoscimento dei volti. Il modello è disponibile per download gratuito su GitHub.

# Carica il modello pre-addestrato per il riconoscimento dei volti
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

Carica l’immagine di input `image1.jpg` che può essere un’immagine a tua scelta utilizzando la funzione `imread()` di OpenCV. Quindi converte l’immagine in scala di grigi utilizzando la funzione `cvtColor()` di OpenCV. L’immagine in scala di grigi è richiesta per l’algoritmo di rilevamento del volto.

# Carica l'immagine e convertirla in scala di grigi
img = cv2.imread('/content/drive/MyDrive/Face Detection/image1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Mostra l'immagine 
plt.imshow(gray)

La riga sottostante rileva i volti nell’immagine in scala di grigi utilizzando il metodo detectMultiScale() della classe CascadeClassifier. Il metodo detectMultiScale() accetta i seguenti argomenti:

`gray`: l’immagine in scala di grigi

`scaleFactor`: è un parametro che specifica di quanto l’immagine viene ridotta a ogni scala dell’immagine. Un valore di 1.3 significa che l’immagine viene ridotta del 30% a ogni scala.

`minNeighbors`: è un parametro che specifica quanti vicini ciascun rettangolo candidato dovrebbe avere per mantenerlo, un valore più alto risulta in meno dettagli ma con maggiore confidenza.

`Il metodo detectMultiScale()` restituisce un elenco di rettangoli in cui sono rilevati i volti. Ogni rettangolo rappresenta una tupla di quattro interi `(x,y,w,h)` che rappresentano le coordinate del vertice in alto a sinistra `(x,y)` del rettangolo e la sua larghezza `w` e altezza `h`.

# Rileva i volti nell'immagine in scala di grigi
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

Disegnare un rettangolo nella regione del volto

Creiamo un ciclo che disegna rettangoli attorno ai volti rilevati nell’immagine originale. La funzione cv2.rectangle() accetta i seguenti argomenti:

`img`: l’immagine originale.    

`(x,y)`: le coordinate del vertice in alto a sinistra del rettangolo.    

`(x+w,y+h)`: le coordinate del vertice in basso a destra del rettangolo.    

`(255,0,0)`: rappresenta il colore binario del rettangolo disegnato in formato RGB. (255,0,0) rappresenta il blu.

`5`: lo spessore del bordo del rettangolo in pixel.

# Disegna rettangoli attorno alle facce rilevate
for (x,y,w,h) in faces:

    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),5)

# Mostra l'immagine dopo aver costruito il rettangolo.


# Visualizza l'immagine con le facce rilevate

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

plt.show()

# Salva l'immagine rilevata con un nome
cv2.imwrite('detected_image.jpg', img)

# Conferma se l'immagine salvata esiste.
detected_image=cv2.imread("detected_image.jpg", 1)
gray_channels_reversed = detected_image[:, :, ::-1]
plt.imshow(gray_channels_reversed)

Riconoscimento facciale

Non entreremo in una spiegazione come quella sopra, ma utilizzeremo l’immagine rilevata salvata per confermare se il modello funziona per l’identificazione fornendo immagini diverse per il rilevamento.

Importa Dipendenze

import numpy as np
import cv2
import matplotlib.pyplot as plt
import dlib
from imutils import face_utils
from scipy.spatial.distance import cosine
from sklearn.metrics.pairwise import cosine_similarity

Carica il Modello di Rilevamento delle Facce e il Detector dei Landmark Faciali

La funzione `dlib.get_frontal_face_detector()` restituisce un modello di rilevamento delle facce pre-addestrato in grado di rilevare facce umane nelle immagini. Per maggiori informazioni, consulta le funzioni di dlib.net. Inoltre, scarica il detector di landmark.

# Carica il modello di rilevamento delle facce e il detector dei landmark faciali
face_detector = dlib.get_frontal_face_detector()
landmark_detector = dlib.shape_predictor('/content/drive/MyDrive/Face Detection/shape_predictor_68_face_landmarks_GTX.dat')

# Carica l'immagine rilevata di 

img1 = cv2.imread('/content/drive/MyDrive/Face Detection/detected_image.jpg')
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)


# Rileva la faccia e i landmark faciali dell'immagine
rects1 = face_detector(gray1, 1)
landmarks1 = landmark_detector(gray1, rects1[0])
landmarks1 = face_utils.shape_to_np(landmarks1)

# Carica un'altra immagine per confrontarla con l'immagine caricata precedentemente
img2 = cv2.imread('/content/drive/MyDrive/Face Detection/001_d3323f3c.jpg')
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

### Imposta il parametro del modello

# Rileva il volto e i punti salienti del secondo immagine

rects2 = face_detector(gray2, 1)

landmarks2 = landmark_detector(gray2, rects2[0])

landmarks2 = face_utils.shape_to_np(landmarks2)

# Estrai le caratteristiche delle due immagini calcolando le distanze euclidee tra i punti salienti del viso

features1 = np.zeros(68)

features2 = np.zeros(68)

for i in range(68):

    features1[i] = np.linalg.norm(landmarks1[i] - landmarks1[0])

    features2[i] = np.linalg.norm(landmarks2[i] - landmarks2[0])

#### Addestra sulla base delle somiglianze

# Calcola la similarità coseno tra i due vettori delle caratteristiche

score = cosine(features1, features2)

# Verifica se il punteggio è al di sotto di una certa soglia (ad esempio 0.5) per determinare se i due volti corrispondono

if score < 0.5:

    print("The model did not recognize Joseph in one or both of the images..")

else:

    print("The model recognized Joseph in both images.")

Conclusione

In questo tutorial, hai imparato la riconoscimento facciale e l’identificazione utilizzando Python OpenCV, come funziona, le sue applicazioni e come può essere implementato. Il codice per questo progetto è accessibile dal repo GitHub.