estrazione e riconoscimento di volti da filmati

UNIVERSITÀ POLITECNICA DELLE MARCHE
FACOLTÀ DI INGEGNERIA
Corso di Laurea Specialistica in Ingegneria Informatica
ESTRAZIONE E RICONOSCIMENTO
DI VOLTI DA FILMATI
Candidato:
Gianluca Dolcini
Relatore:
Prof. Aldo Franco Dragoni
Correlatore:
Ing. Andrea Claudi
Anno Accademico 2010-2011
Indice generale
Indice Generale............................................................................................................................I
Indice delle Illustrazioni.............................................................................................................II
Indice delle Tabelle....................................................................................................................V
Introduzione................................................................................................................................1
Capitolo1 -Stato dell'arte.............................................................................................................3
1.1 Localizzazione e identificazione di volti..........................................................................3
1.2 Face Detection..................................................................................................................7
1.2.1 Skin-segmentation....................................................................................................7
1.2.2 Algoritmo Viola-Jones............................................................................................16
1.3 Face Recognition............................................................................................................25
1.3.1 Principal Component Analysis...............................................................................26
1.3.2 Elastic Bunch Graph Matching..............................................................................30
1.3.3 Scale Invariant Feature Trasform...........................................................................33
1.3.4 Approccio Ibrido.....................................................................................................39
1.4 Algoritmi di Classificazione...........................................................................................41
1.4.1 Algoritmo di classificazione AdaBoost..................................................................43
1.4.2 Algoritmo di classificazione SVM..........................................................................46
Capitolo2 -Sviluppo del Software.............................................................................................52
2.1 Ambiente Sviluppo.........................................................................................................52
2.2 Realizzazione Sistema....................................................................................................53
2.2.1 Procedura di face detection.....................................................................................54
2.2.2 Procedura di Face Recognition...............................................................................64
Capitolo3 -Testing.....................................................................................................................70
3.1 Sistema e risorse ............................................................................................................70
3.2 Valutazione Face Detection su Video.............................................................................71
3.3 Valutazione Face Recognition su Database....................................................................75
3.4 Valutazione Face Recognition su video..........................................................................81
3.5 Prestazioni del sistema nel complesso............................................................................84
Conclusione...............................................................................................................................88
Bibliografia...............................................................................................................................90
I
Indice delle illustrazioni
Fig. 1.1: Esempio di skin-map....................................................................................................8
Fig. 1.2: Esempio di fusione di più skin-map[2].......................................................................10
Fig. 1.3: Esempio di skin-map ottenute utilizzando 3 differenti modelli si skin color.............11
Fig. 1.4: Esempio di istogrammi di Cr e Cb ottenuti da tre volti con pigmentazione della pelle
differente...................................................................................................................................12
Fig. 1.5: Esempio di sottospazio delimitato da 4 rette (in nero) oppure da 5 rette (in rosso)...13
Fig. 1.6: Esempio di due funzioni gaussiane e della GMM ottenuta come somma pesata delle
due.............................................................................................................................................15
Fig. 1.7: Skin map ottenuta assegnando ai pixel il valore di probabilità condizionata............15
Fig. 1.8: Esempio di Summed Area Tablet e della versione ruotata.........................................17
Fig. 1.9: Immagine che esemplifica come avviene il calcolo della sotto area evidenziata.......18
Fig. 1.10: Esempio di rettangolo verticale e del corrispondente rettangolo ruotato di 45 gradi
...................................................................................................................................................19
Fig. 1.11: Esempio delle tre haar fondamentali........................................................................19
Fig. 1.12: Immagine dei coefficienti ottenuti applicando le wavelet sull'immagine in alto a
sinistra.......................................................................................................................................20
Fig. 1.13: Esempio di haar like feature verticali e ruotate. ......................................................21
Fig. 1.14: Esempio della cascata di classificatori. Ogni nodo uno stage della cascata.............24
Fig. 1.15: Haar feature usate per l'apprendimento dei primi 3 stage della cascata di
classificatori..............................................................................................................................24
Fig. 1.16: Esempio di come avviene la riduzione di dimensione dello spazio tramite l'utilizzo
della tecnica di analisi delle componenti principali..................................................................27
Fig. 1.17: Esempio di immagini di volti che compongono un database (a) e insieme delle
eigenfaces ricavate dal database (b)..........................................................................................28
Fig. 1.18: Esempio di adattamento del grafo su volti in pose differenti...................................30
Fig. 1.19: Esempio di FBG che fornisce una rappresentazione generale di un volto. Gli stack
di dischi rappresentano i jet.......................................................................................................31
Fig. 1.20: Rappresentazione grafica del calcolo della differenza gaussiana.............................34
Fig. 1.21: Punti che vengono utilizzati per determinare massimo e minimo della differenza
Gaussiana. Il pixel analizzato è quello identificato con la X, gli altri evidenziati sono quelli
presi in considerazione per il calcolo........................................................................................35
Fig. 1.22: Immagini rappresentative del processo di estrazione dei keypoint. La figura (a)
II
rappresenta l'immagine originale, la (b) rappresenta i keypoint estratti nella prima fase e la (c)
rappresenta i keypoint che sono stati selezionati perché più stabili..........................................35
Fig. 1.23: Esempio del posizionamento e orientamento di due differenti keypoint.................37
Fig. 1.24: Istogramma che rappresenta il numero di voti ricevuti dai diversi soggetti del
database.....................................................................................................................................38
Fig. 1.25: Struttura grafica del funzionamento dell'algoritmo di face recognition che prevede
fusione di feature locali e globali..............................................................................................39
Fig. 1.26: Dataset di apprendimento D.....................................................................................43
Fig. 1.27: Dataset ottenuti da D, rispettivamente D1, D2 e D3................................................44
Fig. 1.28: Classificatore finale..................................................................................................44
Fig. 1.29: Andamento dell'errore all'aumentare delle iterazioni...............................................46
Fig. 1.30: Due differenti iperpiani di separazione nel caso di dati linearmente separabili.......48
Fig. 1.31: Iperpiano di separazione nel caso di dati linearmente non separabili......................49
Fig. 1.32: Caso di dati non linearmente separabili che richiedono una funzione di mapping.. 50
Fig. 2.1: Immagine che descrive come funziona il processo di erosione..................................56
Fig. 2.2: (a) Skin-map ottenuta dalla procedura di classificazione dei pixel, (b) skin-map
ottenuta dopo il processo di erosione con kernel 3x3...............................................................57
Fig. 2.3: Immagine di un frame dove in rosso sono riquadrate le aree identificate con la
procedura di skin-segmentation. Le aree in blu sono le sotto aree di ricerca per occhio sinistro
e bocca. I riquadri verdi indicano gli elementi individuati con algoritmo Viola-Jones............58
Fig. 2.4: Metodologia di Shiqi Yu [27] per l'estrazione delle aree oculari per apprendimento.59
Fig. 2.5: Schema di ricerca delle componenti fondamentali del volto. In verde le uscite
positive, in rosso le situazioni che generano un rigetto della sotto area. .................................62
Fig. 2.6: Dieci immagini raffiguranti il mio volto inserite nel database...................................65
Fig. 2.7: Esempio di aree limitrofe ad occhi e bocca che hanno un maggiore peso per la
decisione....................................................................................................................................67
Fig. 2.8: Sotto aree contenenti occhi e bocca ricavate dalle immagini raffiguranti il mio volto
inserite nel database..................................................................................................................68
Fig. 3.1: Confronto tra fotogrammi acquisiti con webcam differenti. (a) frame acquisito con
webcam Hp, (b) frame acquisito con webcam Toshiba............................................................70
Fig. 3.2: Fotogramma estratto dal video 4 rappresentante l'area di minori dimensioni che
contiene un volto 50x52 pixel...................................................................................................72
Fig. 3.3: Parte di frame estratti dal video 4 che raffigurano diverse posizioni del volto.......73
Fig. 3.4: Fotogrammi tratti dai video 2, 3 e 4. Si noti come varia la skin-map al variare della
III
sistema di acquisizione..............................................................................................................74
Fig. 3.5: Grafico riferito alla percentuale di riconoscimenti corretti su tutti i volti del
database.....................................................................................................................................77
Fig. 3.6: Grafico riferito alla percentuale di riconoscimenti corretti su tutto il database tranne
i volti di apprendimento............................................................................................................77
Fig. 3.7: Grafico riferito alla percentuale di classificazioni unknown su tutti i volti del
database.....................................................................................................................................78
Fig. 3.8: Grafico riferito alla percentuale di classificazioni unknown su tutti i volti del
database tranne quelli usati per l'apprendimento......................................................................78
Fig. 3.9: Grafico riferito alla percentuale di classificazioni errate su tutto il database.............79
Fig. 3.10: Grafico riferito alla percentuale di classificazioni errate su tutto il database tranne i
volti di apprendimento..............................................................................................................80
Fig. 3.11: Percentuali di identificazioni ottenute al variare dei livelli di soglia e al punteggio
da attribuire ai keypoint localizzati nei pressi degli occhi e della bocca..................................82
Fig. 3.12: Percentuale di volti identificati come sconosciuti al variare della soglia e del peso
dei keypoint localizzati vicino a occhi e bocca.........................................................................83
Fig. 3.13: Percentuale di volti identificati come sconosciuti o classificati in maniera errata al
variare della soglia e del peso dei keypoint localizzati vicino a occhi e bocca........................83
Fig. 3.14: Test eseguiti per valutare le prestazioni del sistema. ...............................................85
IV
Indice delle tabelle
Tabella 1.1: Calcolo del numero delle feature estratte da un'immagine di dimensioni 24x24
pixel...........................................................................................................................................22
Tabella 1.2: Percentuali di corretta identificazione al variare del numero di immagini usate per
l'apprendimento.........................................................................................................................37
Tabella 1.3: Tabella che riporta il tasso medio di successo riferito all'applicazione di diverse
tecniche su ORL database.........................................................................................................41
Tabella 2.1: Cardinalità degli insiemi di colori che appartengono alla classe pelle in base alle
soglie riferite a due differenti spazi di colore............................................................................55
Tabella 3.1: Sono riportati il numero di volte che è stato estratto un volto dai diversi video e la
percentuale in riferimento al numero totale di frame del video................................................75
Tabella 3.2: Tabella riassuntiva che contiene le percentuali di corretta identificazione con
valore di soglia fissato a 0,14....................................................................................................80
Tabella 3.3: Test eseguiti utilizzando il meccanismo di riduzione del numero di riquadri da
analizzare. Con parametro di soglia impostato a 0,0 e peso dei keyipoint, localizzati nelle aree
vicino agli occhi e alla bocca, pari a 2. ....................................................................................86
V
Introduzione
Introduzione
Il mio lavoro si incentra sullo sviluppo di un software in grado di estrarre ed identificare volti
umani all'interno di un flusso video. I flussi video possono essere acquisiti direttamente da
una webcam oppure da file precedentemente salvati.
Per la creazione del software è necessario prendere in considerazione due differenti aspetti. Il
primo è quello che rintraccia ed estrae un'area contenente un volto all'interno di un video,
prende il nome di face detection. Il secondo è quello che identifica l'appartenenza del volto
confrontandolo con i soggetti presenti in un database, prende il nome di face recognition.
Per poter scegliere l'approccio migliore è stato prima necessario approfondire entrambi gli
aspetti, ricercando quelle metodologie che meglio si combinavano per consentire una corretta
realizzazione del software.
Le tecniche scelte per la fase di face detection sono:
•
la Skin-Segmentation: utilizzata per estrarre da un frame tutte le sotto aree che
contengono dei pixel classificabili come colore della pelle. Il suo ruolo è dunque
quello di limitare il numero di aree all'interno del frame dove ricercare la presenza del
volto;
•
la procedura Viola-Jones: fa uso di un algoritmo di classificazione di tipo AdaBoost
abbinato ad una tecnica di estrazione delle feature chiamata Haar. L'algoritmo,
pensato inizialmente come tecnica di ricerca dei volti, è stato esteso anche per la
localizzazione di componenti come occhi e bocca. Viene utilizzato per ricercare la
bocca e gli occhi nelle sotto aree ottenute dalla skin-segmentation.
La tecnica di skin-segmentation è stata presa in considerazione poiché è molto semplice da
realizzare ed al contempo estremamente efficace nel ridurre le aree dove effettuare successive
elaborazioni.
La procedura Viola-Jones, invece, è stata scelta poiché è molto affermata ed è in grado di
garantire la localizzazione dei componenti del volto con tempistiche real-time e con buona
efficacia.
Per quanto riguarda invece la fase di face recognition si è scelto di utilizzare queste tecniche:
•
Scale Invariant Feature Transform (SIFT): per l'estrazione delle feature
caratteristiche delle immagini raffiguranti il volto;
1
Introduzione
•
Support Vector Machine (SVM): algoritmo di machine learning in grado di definire i
confini tra i diversi soggetti che compongono il database a partire da un set di
campioni di apprendimento.
La scelta delle Scale Invariant Feature Transform è stata fatta poiché esse garantiscono una
rappresentazione dei punti caratteristi di un'immagine, invarianti a scala e rotazione. Dunque,
in un contesto in cui il volto può apparire in posizione e pose differenti, questa tecnica
dovrebbe garantire una maggiore tolleranza. Inoltre, poiché queste metodologie danno una
rappresentazione locale dell'immagine, sono completamente svincolate dalla morfologia del
volto consentendo di estrarre feature confrontabili anche in presenza di parziali occlusioni.
La scelta del Support Vector Machine come algoritmo di apprendimento supervisionato è
motivata dalla sua capacità di operare in multiclasse, cioè distinguere tra un numero finito N
di soggetti. Nel caso specifico ciascuna classe è rappresentata da un individuo del database.
Altri algoritmi non potendo operare in contesti multiclasse sono stati scartati anche se
avrebbero potuto garantire migliori velocità di risposta.
La tesi si compone di tre capitoli:
•
Stato dell'Arte.
Verranno presentate le più importanti tecniche di estrazione ed identificazione del
volto, separando la trattazione dell'una e dell'altra. Si presterà particolare attenzione
alle diverse tecniche per il face recognition poiché questo aspetto è ancora dibattuto.
Inoltre si farà una breve descrizione di due algoritmi di machine learning.
•
Sviluppo del Software.
Verrà presentato il funzionamento del software di estrazione e identificazione,
descrivendo separatamente la parte di face detection e quella di face recognition.
•
Test.
Questo capitolo sarà dedicato alla verifica delle prestazioni del sistema realizzato,
concentrando l'attenzione sulla capacità di estrazione ed identificazione. Si
verificheranno quali condizioni generano il maggior numero di errori di classificazione
e come porvi rimedio. Inoltre si cercherà di analizzare le prestazioni in termini di
tempi di computazione.
2
Stato dell'arte
Capitolo1 - Stato dell'arte
In questo capitolo saranno presentate separatamente tecniche di localizzazione e tecniche di
riconoscimento di volti. Inoltre alla fine del capitolo verranno presentati due algoritmi di
classificazioni menzionati nei paragrafi precedenti.
1.1 Localizzazione e identificazione di volti.
La localizzazione e l'identificazione di volti attraverso l'analisi di immagini, e più in generale
attraverso l'analisi dei frame dei flussi video, è molto interessante nell'ambito informatico allo
scopo di produrre applicazioni in grado di automatizzare processi molto onerosi.
I differenti ambiti a cui si possono rivolgere tali applicazioni sono:
•
la sicurezza: video sorveglianza, monitoraggio di accessi e identificazione per
accesso. Il monitoraggio di accesi potrebbe ad esempio essere usato per verificare se
un individuo non autorizzato è presente in una determinata area. Se ciò dovesse
accadere l'operatore si metterà in allerta e potrà agire in maniera opportuna;
•
i media: catalogazione automatica di risorse multimediali. Un software per
identificare i volti sarebbe in grado di rintracciare la presenza di individui specifici
all'interno di un video e annotare in tempo reale quando ciò accade. In tal modo si
faciliterebbe la catalogazione del contenuto per una successiva ricerca.
Le applicazioni sono svariate e hanno lo scopo di diminuire o addirittura eliminare il carico di
lavoro di un individuo.
Risolvere tale problema richiede l'attuazione di due differenti operazioni:
•
localizzazione di un volto all'interno dell'immagine (face detection);
•
identificazione del volto verificando se è presente o meno all'interno del database
(face recognition).
Queste due classi di algoritmi possono presentare similarità ma sono fondamentalmente
differenti. Sicuramente una caratteristica comune che le coinvolge entrambe sono le
problematiche riguardanti l'acquisizione dell'immagine.
Anche se tale problema dovrebbe influenzare principalmente la fase di face detection, poiché
3
Stato dell'arte
essa viene svolta a monte della fase di face recognition, in realtà anche se siamo in grado di
riconoscere la presenza di un volto non si può essere certi che questo possa essere identificato
con successo.
Possiamo distinguere tre tipologie di problematiche che si possono riscontrare:
•
le condizioni ambientali in cui viene acquisita la scena. Se l'acquisizione avviene
sempre con lo stesso background e la stessa illuminazione è possibile eliminare
parzialmente tale interferenza;
•
la morfologia e la posa del volto. Il volto può essere in posizioni non ottimali per
l'acquisizione oppure potrebbe essere parzialmente coperto;
•
le caratteristiche fisiche dell'hardware di acquisizione della scena. Ovvero le
caratteristiche del sensore e delle lenti, la posizione del sistema di acquisizione rispetto
alla scena.
Analizziamo più specificatamente questi tre gruppi di problematiche, vediamo quali sono i
principali aspetti che possono portare a malfunzionamenti di un sistema di localizzazione e
identificazione.
Partiamo dall'analisi delle condizioni ambientali.
Il problema maggiore che si manifesta è la variazione dell'illuminazione[1][2] poiché
influisce negativamente sulla possibilità di comparare immagini ottenute dalla medesima
scena e che hanno luminosità differente. Non è sufficiente che il sistema conosca solamente
come appare il volto di un individuo in condizione di luminosità ideale, ne deve apprendere i
tratti caratteristici anche in condizioni differenti.
La morfologia e la posa del volto sono legati a da due aspetti fondamentali: la posizione del
sistema di acquisizione e l'espressione dell'individuo.
Possiamo dunque distinguere i seguenti fattori:
•
la posa [1]: il volto può essere orientato in diversi modi. La migliore condizione di
analisi è con volto perfettamente frontale;
•
la presenza di componenti strutturali [1]: la presenza o l'assenza di elementi come
barba, baffi o occhiali cambia l'aspetto del volto acquisito;
•
le espressioni facciali [1]: il volto ha un differente aspetto a seconda dell'espressione
assunta dal soggetto;
•
le occlusioni [1]: il volto può essere parzialmente coperto da altri elementi presenti
nell'ambiente. Anche gli occhiali possono essere considerati come occlusione, seppur
4
Stato dell'arte
vengono trattati come componenti strutturali;
•
la rotazione dell'immagine [1]: il volto appare differente in base alla diversa
rotazione del soggetto rispetto agli assi del sistema di acquisizione. Mentre la posa
dipende dal soggetto che viene inquadrato, la rotazione dell'immagine dipende dal
montaggio del sistema che potrebbe non essere ottimale.
Il terzo aspetto che dobbiamo prendere in considerazione è relativo all'hardware che verrà
utilizzato. La scelta della periferica di acquisizione è fondamentale, ma per determinate
applicazioni è molto importante anche il sistema hardware che compirà le operazioni di
analisi. Le caratteristiche del sensore e delle lenti[1] del sistema di acquisizione influiscono
sulla qualità dell'immagine che verrà processata. Il sistema hardware che compirà le
operazioni di elaborazione dell'immagine determinerà la prontezza della risposta del software.
Tutti i fattori fin qui descritti, se non controllati, influenzano negativamente le prestazioni di
un sistema di localizzazione e identificazione. Infatti quando non è possibile controllare
l'ambiente in cui si cercherà di identificare i soggetti, tutti i fattori esaminati in precedenza
determineranno un notevole aumento della complessità degli algoritmi.
Differente è la situazione quando si vuole realizzare un sistema dove il volto è utilizzato come
meccanismo per l'autorizzazione di accesso.
Tutti i fattori che possono determinare variabilità vengono limitati ponendosi in un ambiente
ottimale. Inoltre il soggetto che intende accedere si posizionerà in maniera tale da aumentare
la possibilità di identificazione.
Concentrandoci sulla componente del face detection possiamo distinguere quattro differenti
tipologie di algoritmi [1]:
•
Knowledge-based methods: si basa sulla definizione di regole per stabilire quali aree
dell'immagine rappresentino un volto. Le regole vengono utilizzate per codificare il
concetto di volto;
•
Feature invariant approaches: estrazione di feature che caratterizzano il volto umano.
Esse sono tali da non variare al mutare di condizioni come la luminosità o la posa. Di
queste fa parte la tecnica basata sullo skin-color;
•
Template matching methods: vengono definiti dei template pattern di feature che
descrivono il prototipo di un volto, vengono utilizzati per scandagliare un'immagine
alla ricerca di un'area che presenti dei pattern di feature similari;
•
Apparence based methods: i pattern che descrivono il prototipo di un volto vengono
5
Stato dell'arte
ricavati da un set di immagini di apprendimento realizzato in base alle finalità che si
cerca di ottenere. Ad esempio si porrà come condizione la ricerca di volti di profilo se
si intende rilevarli solo con questa caratteristica. Il metodo più importante
appartenente a questa categoria è l'algoritmo proposto da Viola-Jones [3].
Prendendo in considerazione il face recognition, esistono svariati tipi di approcci. In questa
procedura un ruolo importantissimo viene svolto dal meccanismo utilizzato per l'estrazione
delle feature che caratterizzano il volto umano. Migliore è il sistema di estrazione delle
feature più facile sarà per l'algoritmo apprendere i confini che dividono un volto da un altro.
Di conseguenza sarà in grado di generalizzare tali informazioni allo scopo di predire in
maniera corretta la classe di appartenenza di un volto rilevato.
Molte sono le tecniche che hanno il compito di estrarre dalle immagini di volti le feature
caratteristiche. Nello specifico ne prendiamo in considerazione due: Eigenfaces e Fisherfaces
[11].
La metodologia Eigenfaces è basata sulla proiezione delle immagini in uno spazio delle
feature ridotto, che viene ulteriormente ridimensionato attraverso l'uso delle tecniche basate
sull'analisi delle componenti principali (principal component analisis – PCA) [16]. A partire
dall'algoritmo PCA si sono evolute diverse varianti tra cui two-dimensional PCA [15].
La metodologia Fisherfaces è invece un procedimento derivato dalla tecnica Fisher's linear
discriminate (FLD)
[16] in cui, analogamente a quanto accade per il PCA, si proietta
l'immagine in uno spazio delle feature che viene poi ridotto. Anche tale tecnica ha subito
modifiche e miglioramenti, tra le tipologie esistenti se ne ricordano due: two-dimensional
FLD e generalized two-dimensional FLD [15].
Tra i meccanismi di estrazione delle feature possiamo inserire una tecnica più recente
chiamata Scale Invariant Feature Transform. Tale tecnica estrae da un'immagine un insieme
di punti caratteristici, chiamati keypoint che sono invarianti a scala, rotazione e parzialmente
anche ai cambiamenti di luminosità [14].
Tutte le tecniche sopra citate necessitano di un meccanismo di confronto che può variare dalla
semplice distanza euclidea a più complessi algoritmi di classificazione supervisionata come
support vector machine, alberi binari o reti neurali.
Altre tecniche di estrazione delle feature si basano sulle proprietà del volto come distanze e
angoli di punti ben definiti. Confrontando le informazioni geometriche estratte con quelle
precedentemente calcolate si cerca di ottenere l'identificazione.
6
Stato dell'arte
Una tecnica che fa molto uso di un approccio di questo tipo è l'Elastic Bunch Graph
Matching (EBGM) dove il volto viene rappresentato tramite un grafo in cui i nodi sono
posizionati in punti prestabiliti del volto e i lati sono etichettati con il vettore delle distanze.
Inoltre ogni nodo contiene un insieme di coefficienti delle Gabor Wavelet [13].
1.2 Face Detection
Come precedentemente affermato, il problema di estrazione dei volti presenti in un'immagine
viene chiamato con il nome di face detection. Tale procedura sta a monte rispetto a operazioni
di riconoscimento o altre tipologie di elaborazioni che possono richiedere la conoscenza della
presenza di un volto in un'immagine.
Le classi in cui possono essere raggruppati questi algoritmi sono quattro.
Ora ci concentreremo sull'analisi di due differenti tecniche che rappresentano quelle
maggiormente usate.
La prima, molto semplice da realizzare, fa parte dei feature invariant approaches ed è basata
sulla determinazione delle aree che contengono pixel con colore del volto. Possiamo riferirci a
tali tecniche con il nome di skin-segmentation [4].
L'altra tecnica molto diffusa e con ottime prestazioni, anche per applicazioni di tipo real-time,
è quella proposta da Viola-Jones [3], si basa sulla estrazione delle wavelet haar e sul loro uso
come informazioni per l'apprendimento di un algoritmo di classificazione di tipo AdaBoost.
1.2.1 Skin-segmentation
La skin-segmentation è una tecnica che prevede la ricerca delle aree di un'immagine
contenenti colori simili a quelli della pelle del volto umano. Come è facile intuire è molto
semplice da implementare ma richiede dei meccanismi di validazione dell'area trovata che
solitamente sono basati sulla determinazione della presenza di elementi come occhi, naso,
orecchie e bocca.
7
Stato dell'arte
Fig. 1.1: Esempio di skin-map.
Il passo fondamentale di questa tecnica è quello di produrre, a partire da un'immagine a
colori, una skin-map, cioè un'immagine in scala di grigi, o addirittura solamente a due colori,
che distingua le aree identificate come colore della pelle da quelle con colorazioni differenti.
Il primo aspetto da prendere in considerazione quando si tratta dell'estrazione delle aree
contenenti colorazioni della pelle è proprio la rappresentazione del colore. Gli spazi di colori a
nostra disposizione sono differenti ma vanno comunque tenute in considerazione le
caratteristiche del sistema di acquisizione. Se questo lavora solamente in scala di grigi è
impossibile utilizzare una tecnica del tipo skin-segmentation.
Nonostante esistano molte rappresentazioni del colore, quelle più comunemente usate sono le
seguenti:
•
RGB (red, green, blue): standard per la rappresentazione di immagini in strumenti
elettronici come schermi e sensori di fotocamere [1]. Lo standard non è valido per i
sistemi di stampa. Rappresenta la decomposizione del colore nelle sue componenti
primarie rosso, verde e blu;
•
HSV (Hue Saturation Value): standard basato sulla percezione del colore da parte
dell' uomo. Il colore viene descritto attraverso la tonalità (H), la saturazione (S) e
l'intensità luminosa (V). Si ottiene da una trasformazione non lineare dell' RGB [4][5].
Uno spazio di colore simile è HSI [2] e HLS;
8
Stato dell'arte
•
YCrCb: si rappresenta il colore come composizione di intensità luminosa (Y) e di due
segnali differenti di crominanza (Cr Cb) [5]. Il passaggio da RGB avviene con una
trasformazione di tipo lineare [4].
1
∗(65.738∗R+129.057∗G+25.064∗B)
256
1
Cb=128+
∗(−37.945∗R−74.494∗G+112.439∗B)
256
1
Cr =128+
∗(112.439∗R−94.154∗G −18.285∗B)
256
Y =16+
Indipendentemente dal tipo di codifica del colore che abbiamo a disposizione è sempre
possibile passare da una rappresentazione all'altra. La scelta più logica da effettuare è
utilizzare come spazio di colori l'RGB poiché utilizzata per le più comuni apparecchiature
elettroniche.
Il problema che però ci si trova ad affrontare scegliendo questo spazio di colori è l'influenza
di cambiamenti di luminosità. Infatti gli altri due spazi di colori, anche se in modalità
differenti, hanno una rappresentazione esplicita della componente luminosa (Y e V).
In realtà si può ovviare a ciò escludendo tali canali in fase di analisi, così da ottenere una
rappresentazione non influenzata dai cambiamenti di luminosità.
Nel caso RGB è possibile attenuare l'effetto della luminosità utilizzando la normalizzazione
del colore e sfruttando solamente i canali rosso (r) e verde (v) normalizzati [6]. Le formule per
effettuare tale normalizzazione sono le seguenti:
r=
R
R+G+B
g=
9
G
R+G+ B
Stato dell'arte
In alcuni casi è possibile combinare l'uso dei differenti spazi di colore con la finalità di
ottenere delle regioni più accurate.
Una proposta in questa ottica viene presentata nell'articolo “A Robust Skin Color Based Face
Detection Algorithm” [2]. I risultati ottenuti dalla procedura di skin-segmentation applicata a
RGB normalizzato, a HSI e a YCrCb vengono fusi per ottenere una skin-map unica con
migliore precisione rispetto alle skin-map ottenute nei singoli spazi di colore.
Fig. 1.2: Esempio di fusione di più skin-map[2]
Per svolgere la procedura di skin-segmentation possono essere utilizzati differenti approcci:
•
Limite di decisione lineare a tratti: vengono definiti dei valori di soglia con tecniche
che possono essere più o meno complesse [4]. Un esempio è quello di analizzare gli
istogrammi generati da una regione classificata come colore del volto e verificare
come si concentrano i valori dei pixel;
•
Classificatore bayesiano: il ruolo degli istogrammi, anche in questo caso, è
fondamentale per determinare la probabilità condizionata che un pixel appartenga o
meno al modello del colore della pelle;
p( x∣skin)
≥soglia
p( x∣noskin)
•
Classificatore di tipo Gaussiano: vengono creati dei modelli gaussiani che
descrivono lo skin color.
◦ Unimodali: una sola funzione di densità di probabilità condizionata (p(x|skin) che
10
Stato dell'arte
caratterizza il modello;
◦ Mixture [7]: la densità di probabilità viene descritta da una combinazione pesata
di più funzioni di tipo gaussiano unimodali, chiamati Gaussian Mixture Model
(GMM).
•
Multilayer Perceptron: vengono utilizzate delle reti neurali per definire il confine tra
skin e noskin color.
Più in generale possiamo però usare un qualsiasi algoritmo di classificazione al fine di
apprendere il confine tra colore delle pelle e non. Tali classificatori dovranno avere un set di
apprendimento tale da garantire la copertura di tutte le possibili casistiche. Quindi la pelle
umana dovrà essere rappresentata in contesti di illuminazione differenti e dovrà riguardare
tutte le possibili tipologie di pigmentazione.
Solitamente si cerca di generare un modello unico per descrivere tutte le differenti razze che si
potrebbero incontrare. In alcuni casi potrebbe essere necessario utilizzare un modello per ogni
razza. Nell'approccio proposto da Li Zuo e Kamata [7] si realizzano tre differenti Gaussian
Mixture Model per rappresentare le tre colorazioni della carnagione: bianca, scura e olivastra.
Lo spazio di colore utilizzato in questo caso è YCrCb che, con l'esclusione dell'analisi del
canale Y, dovrebbe garantire una buona tolleranza alle variazioni di luminosità.
Fig. 1.3: Esempio di skin-map
ottenute utilizzando 3 differenti
modelli si skin color
Nell'immagine riportata precedentemente (Fig. 1.3), che fa riferimento alla ricerca di pixel
con modelli diversi per le tre differenti carnagioni, possiamo vedere come il confine tra esse
non sia così netto. Infatti alcuni pixel del volto con carnagione bianca vengono classificati in
maniera corretta come appartenenti alla carnagione bianca, ma anche come appartenenti alla
11
Stato dell'arte
carnagione scura ed olivastra. Questo accade principalmente nelle zone in ombra oppure in
quelle sottoposte ad una forte illuminazione. Ciò implica che la scelta di un unico modello per
tutte le carnagioni non dovrebbe portare a problemi di classificazione dei singoli pixel.
Di seguito (Fig. 1.4) possiamo vedere gli istogrammi dei canali Cr e Cb di tre diversi volti,
uno per ogni carnagione. Come si può notare, la maggioranza dei pixel ricadono all'interno di
limiti superiori e inferiori molto simili per le differenti tipologie di carnagione. Invece la
distribuzione all'interno di tali limiti risulta essere diversa.
Fig. 1.4: Esempio di istogrammi di Cr e Cb ottenuti da tre volti
con pigmentazione della pelle differente.
Analizziamo quindi più attentamente come funzionano i limiti di decisione lineari a tratti.
Il modo più semplice per classificare un pixel è quello di definire dei valori di soglia per i
differenti canali dello spazio di colori. Solitamente se ne prendono in considerazione due,
quelli che rappresentano le crominanze.
L'obiettivo è quello di creare un sottospazio dello spazio di colori che contiene tutti i pixel di
tipo pelle. Se il pixel analizzato ricade all'interno di questo sottospazio si classifica come pelle
altrimenti no. Tale sottospazio può essere più o meno preciso, dipende dal metodo di
delimitazione dei confini scelto. Il modo più semplice è definire un limite superiore ed un
limite inferiore per ogni canale del colore. Ad esempio se usassimo solamente i canali Cr e
Cb, definendo i limiti superiori ed inferiori, si otterrebbe un sottospazio di forma rettangolare.
Se invece si includesse anche il canale Y, lavorando in uno spazio tridimensionale, si
12
Stato dell'arte
creerebbe un sottospazio di forma parallelepipeda.
Ponendo il limite superiore e quello inferiore è come se considerassimo un sottospazio
definito da 4 rette. É ovvio che se volessimo ottenere un sottospazio più accurato potremmo
utilizzare un numero maggiore di rette per delimitare lo spazio. Nel caso però volessimo
prendere in considerazione tutti e tre i canali di uno spazio di colori dovremmo definire dei
piani di separazione e non delle rette.
Fig. 1.5: Esempio di sottospazio delimitato da 4 rette
(in nero) oppure da 5 rette (in rosso)
La determinazione dei limiti viene fatta analizzando gli istogrammi di immagini raffiguranti
volti. Per i differenti spazi di colore esistono dei limiti ben precisi:
•
RGB normalizzato: 0,335 ≤ r ≤ 0,465 e 0,27 ≤ g ≤ 0,363 [6];
•
YCrCb: 77 ≤ Cb ≤ 127 e 133 ≤ Cr ≤ 173 [4] in cui è escluso il canale Y;
•
HSV: 0,23 ≤ S ≤ 0,68 e 0° ≤ H ≤ 50° [4] in cui è escluso il canale V.
Il metodo che fa uso di limiti di decisione di tipo lineare a tratti risulta essere molto semplice
da realizzare e computazionalmente poco oneroso.
Tra i modelli per descrivere il colore in maniera più accurata vi è sicuramente il classificatore
di tipo gaussiano. In questo caso, a partire da esempi di pixel del colore della pelle, si genera
una funzione gaussiana che descrive la probabilità condizionata che esso appartenga alla
classe pelle. Possiamo perciò assegnargli il valore ottenuto da questa funzione di probabilità.
La skin-map che otterremo in questo caso sarà in scala di grigi dove la colorazione bianca
corrisponderà alla massima probabilità che il pixel sia di tipo pelle, mentre una colorazione
nera corrisponderà alla probabilità minima.
Occorre precisare che tale metodo di classificazione dei pixel è più complesso rispetto a
13
Stato dell'arte
quello dei classificatori lineari a tratti. La maggiore complessità sta nel dover memorizzare
una o più funzioni di tipo gaussiano per descrivere il modello del colore della pelle. Di contro
però, le informazioni aggiuntive ottenute con questo metodo potrebbero risultare importanti ai
fini della validazione dell'area che presumibilmente contiene un volto umano.
Possiamo distinguere due differenti tipi di modelli gaussiani: quelli unimodali, in cui la
funzione di densità di probabilità condizionata è rappresentata da una sola funzione gaussiana;
quelli misti, dove la funzione di densità di probabilità è descritta da una somma pesata di
funzioni gaussiane.
La funzione di densità di probabilità gaussiana nel caso di modello unimodale ha la seguente
forma:
−d / 2
p ( x∣skin)= g (x ; ms , C s)=(2 π)
−1/ 2
∣C s∣
1
− ( x−m s)T C −1
s ( x−m s )
2
exp
.
Dove d rappresenta la dimensione del vettore delle feature e, in base agli spazi di colore presi
in considerazione in precedenza, solitamente prende il valore 2. Nel caso in cui invece si
includa anche la componete relativa alla luminosità, d prenderebbe il valore 3. Il parametro ms
rappresenta il vettore delle medie e Cs la matrice di covarianza, entrambi sono relativi alla
classe pelle. La formula utilizzata per definire se un pixel appartiene ad una classe è quella del
classificatore bayesiano:
p( x∣skin)
≥soglia .
p( x∣noskin)
Se invece consideriamo una distribuzione gaussiana unimodale per p(x|skin) e una
distribuzione uniforme della classe non pelle, è possibile ridurre la formula nel seguente
modo:
( x−ms )T C−1
s ( x−m s)≤soglia .
L'elemento a sinistra della disuguaglianza è il quadrato della distanza di Mahalanobis,
descrive una misura di similarità tra un campione dato e descritto da media e covarianza ed un
campione ignoto.
Nel caso invece si decidesse di descrivere anche la funzione di densità di probabilità p(x|
noskin) con una funzione gaussiana unimodale, definiti Cns e mns rispettivamente covarianza e
media della classe non pelle, la formula precedente diventa:
T
−1
( x−ms )T C−1
s ( x−m s)−( x−m ns ) C ns (x−m ns )≤soglia .
14
Stato dell'arte
Tale semplificazione non è valida se si prendono in considerazione le funzioni di densità di
probabilità descritte dai modelli gaussiani misti (GMM). In questo caso le due funzioni
sarebbero le seguenti:
Ns
p ( x∣skin)=∑ w s , i g ( x ; ms , i , C s ,i ) ,
i =1
N ns
p ( x∣noskin)=∑ wns , i g ( x ; m ns ,i ,C ns ,i ) .
i=1
Nelle formule precedenti il parametro w rappresenta i pesi assegnati ad ogni funzione
gaussiana. Solitamente i valori dei pesi, delle medie e delle covarianze vengono determinati
con l'utilizzo dell'algoritmo Expectation–maximization.
Nell'immagine seguente (Fig. 1.6) possiamo vedere un esempio di modello gaussiano misto e
delle due funzioni gaussiane che ne determinano l'andamento.
0 .1 6
0 .1 4
0 .1 2
0 .1
0 .0 8
0 .0 6
0 .0 4
0 .0 2
0
0
1
2
3
4
5
6
7
8
9
10
Fig. 1.6: Esempio di due funzioni
gaussiane e della GMM ottenuta
come somma pesata delle due.
Le differenti tecniche di classificazione dei singoli pixel possono essere utilizzate per la
produzione della skin-map. Però essa non è sufficiente per garantire che un'area rappresenti
effettivamente un volto. Vanno quindi attuate delle tecniche di validazione che confermino se
l'area contiene o non contiene un volto. Le tecniche
utilizzate possono essere molto differenti ma nella
maggioranza dei casi si basano sulla ricerca di elementi
caratteristici di un volto: occhi, orecchie, naso e bocca.
Alcuni approcci come quello proposto da Li Zou e
Kamata [7] prevedono l'utilizzo di modelli gaussiani
misti per rintracciare le aree dell'immagine che
Fig. 1.7: Skin map ottenuta
contengono pixel con colorazione similare a quelli della assegnando ai pixel il valore di
pelle. Estratte tutte le sotto aree dell'immagine probabilità condizionata.
15
Stato dell'arte
compatibili con la presenza di un volto, queste vengono analizzate con l'algoritmo Viola-Jones
per determinare se lo contengono. Le immagini in scala di grigi rappresentano la probabilità
che il pixel appartenga al colore pelle mentre nella formulazione originale sono la
trasposizione in scala di grigi dell'immagine a colori.
Di seguito viene riportato un esempio di tre volti codificati in scala di grigi in base alla
probabilità che il pixel sia di tipo pelle.
1.2.2 Algoritmo Viola-Jones
L'algoritmo proposto da Viola e Jones [3] e modificato successivamente da Lienhart e Meydt
[10] propone un framework basato su tecniche di machine learning. Risulta essere un sistema
molto robusto ed estremamente rapido per il rilevamento di volti e più in generale di oggetti.
L'algoritmo è caratterizzato da tre componenti fondamentali:
•
Integral Image: è una elaborazione dell'immagine di input finalizzata al
miglioramento della velocità di calcolo delle Haar like feature. Questa ricodifica delle
informazioni consente un tempo costante per il calcolo delle feature.
•
Haar like feature: è un meccanismo di estrazione delle feature da un'immagine basato
sulle Haar wavelet, viene proposto per un generico sistema di object detection [9].
•
AdaBoost: si tratta di un algoritmo di machine learning che, correttamente addestrato,
è in grado di determinare il confine tra due differenti classi. Nel caso dell'algoritmo
Viola-Jones, per aumentarne le prestazioni, ne viene proposta una variante.
L'approccio proposto da Viola-Jones risulta avere delle prestazioni molto valide per uso anche
in contesti di tipo real-time.
Le immagini di input per tale algoritmo possono essere a colori o in scala di grigi. Nel caso di
immagini a colori si dovrà provvedere ad una conversione in scala di grigi. Se utilizzassimo lo
spazio di colori YCrCb sarebbe sufficiente prendere in considerazione esclusivamente il
canale Y, che rappresenta la componente relativa alla luminosità, ed escludere gli altri due
canali.
L'immagine in scala di grigi di input subisce una trasformazione che ricodifica le
informazioni dei singoli pixel per creare la Integral Image, anche chiamata Summed Area
Tablet.
Le modifiche all'algoritmo invece fatte da Lienhart e Meydt portano all'introduzione del
16
Stato dell'arte
concetto di Rotated Summed Area Tablet. Ovvero una seconda codifica dell'immagine, da
affiancare alla Integral Image, finalizzata ad incrementare le prestazioni dell'algoritmo con
l'uso di particolari haar-like feature, ruotate rispetto a quelle originariamente proposte da
Viola-Jones.
La formula per il calcolo della Integral Image è la seguente:
∑
sat ( x , y)=ii( x , y)=
i( x ' , y ' ) [3][10 ].
x ' ≤x , y '≤ y
Mentre la formula per il calcolo della Rotated Summed Area Tablet è:
rsat (x , y)=
∑
i( x ' , y ' ) [10].
x '≤x , y' ≤ y−∣x−x '∣
Con le variabili x e y si indicano le coordinate di un pixel all'interno dell'immagine da
elaborare, indicata con la lettera i. Come è facile comprendere, ogni pixel della nuova
immagine conterrà la somma di tutti i pixel con valori di x ed y inferiori a quelli del punto da
calcolare. La matrice che ne risulterà avrà dunque le stesse dimensioni dell'immagine di
partenza ma l'informazione verrà espressa in maniera differente.
Nell'immagine seguente (Fig. 1.8) è riportata una rappresentazione grafica della Integral
Image e della Rotated Summed Area Tablet. L'area evidenziata rappresenta la sotto area
dell'immagine originale che contribuisce a determinare il valore di ii(x,y) e rsat(x,y).
Fig. 1.8: Esempio di Summed Area Tablet e della versione
ruotata.
Per rendere più efficiente il calcolo della Integral Image è possibile utilizzare le seguenti
espressioni ricorsive:
s (x , y)=s ( x , y−1)+i ( x , y) ;
ii( x , y)=ii( x−1, y)+ s(x , y) ;
con condizioni iniziali:
s (x ,−1)=0 ;ii (−1, y)=0 ;
deve s(x,y) è la somma cumulativa delle righe.
17
Stato dell'arte
Sono disponibili delle formule analoghe che consentono di calcolare la Rotated Summed Area
Tablet solamente con due passaggi sopra ogni pixel.
Il primo passaggio viene eseguito da sinistra a destra e dall'alto verso il basso, la formula
corrispondente è:
rsat (x , y)=rsat ( x−1, y−1)+rsat (x−1, y )+i ( x , y)+rsat (x−2, y−1) ;
il secondo passaggio viene eseguito da destra verso sinistra e dal basso verso l'alto, la formula
è:
rsat (x , y)=rsat ( x , y)+rsat (x−1, y+1)−rsat ( x−2, y) ;
le condizioni iniziali sono:
rsat (−1, y)=rsat (−2, y )=rsat (x ,−1)=0 .
La Integral Image e la Rotated Summed Area Tablet sono necessarie per calcolare in maniera
rapida la somma dei pixel contenuti in un rettangolo all'interno dell'immagine. Nel caso di
Rotated Summed Area Tablet i rettangoli da calcolare sono ruotati di 45°. Nell'immagine
seguente è riportata una rappresentazione grafica di come avviene il calcolo del rettangolo
scuro.
Fig. 1.9: Immagine che esemplifica come avviene il calcolo
della sotto area evidenziata.
La formula per il calcolo della somma dei pixel del rettangolo per Integral Image è:
RSum( x , y , w , h)=ii (x−1, y−1)+ii( x+w−1, y+h−1)
−ii( x−1, y+h−1)−ii( x+w−1, y−1) .
Mentre la formula per Rotated Summed Area Tablet è:
RSum( x , y , w , h)=rsat ( x+w , y+w)+rsat (x−h , y+h)
−rsat (x , y)−rsat ( x+w−h , y+w+h) .
I rettangoli sono descritti da x e y che rappresentano le coordinate del vertice alto del
rettangolo e da h e w che rappresentano altezza e larghezza del rettangolo nel caso della
Integral Image. Mentre per la Rotated Summed Area Tablet h e w sono le proiezioni di altezza
e larghezza del rettangolo. Nell'immagine seguente è possibile vedere graficamente cosa
18
Stato dell'arte
rappresentano i diversi parametri.
Fig. 1.10: Esempio di rettangolo verticale e del corrispondente
rettangolo ruotato di 45 gradi
La rappresentazione dell'immagine come Integral Image e Rotated Summed Area Tablet
consente una maggior rapidità di calcolo delle haar-like feature. Infatti per poter calcolare le
feature sarebbe stato necessario determinare ad ogni passo la somma di pixel di aree
dell'immagine, processo computazionalmente molto oneroso se ripetuto a diversa scala e
posizione, come nel caso delle haar-like feature.
Nodo fondamentale per l'algoritmo è il meccanismo di estrazione delle feature. La tecnica
adottata prende il nome di haar-like feature e deriva dal filtro haar [9]. In questo filtro sono
presenti tre tipi di wavelet che hanno un significato molto preciso:
•
la wavelet verticale, che codifica la differenza di intensità media di due regioni
verticali adiacenti, è quindi è in grado di estrarre i bordi verticali presenti in
un'immagine;
•
la wavelet orizzontale, che codifica la differenza di intensità media di due regioni
orizzontali adiacenti, estrae perciò i bordi orizzontali presenti nell'immagine;
•
la wavelet diagonale, che è invece il risultato della combinazione delle altre due
wavelet in quanto estrae i bordi diagonali da un'immagine.
Fig. 1.11: Esempio delle tre haar
fondamentali.
19
Stato dell'arte
Le ragioni fondamentali che determinano la scelta delle Haar wavelet sono:
•
la codificazione delle differenze di intensità media tra regioni con diversi orientamenti,
consentendo un'analisi con più scale [9]. Tali differenze dovrebbero essere invariabili e
quindi identiche per tutte le immagini rappresentanti volti.
Nell'algoritmo Viola-Jones si usano immagini di volti di 20x20 e si generano tutti i
possibili coefficienti modificando le dimensioni delle wavelet dalla dimensione
minima alla massima contenibile nell'immagine.
•
l'uso di un insieme di coefficienti haar che permette di propagare i vincoli tra le
regioni confinanti e descrivere modelli complessi [9]. I coefficienti haar vengono
calcolati in tutte le possibili posizioni e dimensioni all'interno di un'immagine
generando una quantità elevata di feature.
Nella figura riportata a fianco (Fig. 1.12) sono rappresentate quattro immagini in scala di
grigi. La prima in alto a sinistra contenente l'immagine
originale, le altre tre rappresentano i coefficienti haar
calcolati sull'immagine originale.
Per ottenere le immagini dei coefficienti sono state applicate
le wavelet haar con dimensione 2x2 pixel in tutte le possibili
posizioni all'interno dell'immagine originale. Quelle così
ottenute sono state rappresentate in scala di grigi dove il
colore nero rappresenta un coefficiente negativo, il colore
bianco un coefficiente positivo e il grigio il valore zero.
Fig. 1.12: Immagine dei
coefficienti ottenuti
In questa figura le immagini sono relative a:
applicando le wavelet
• la wavelet verticale (in alto a destra), marca sull'immagine in alto a
sinistra.
nettamente la riga verticale e meno intensamente
quella obliqua, tralasciando completamente la riga orizzontale;
•
la wavelet orizzontale (in basso a sinistra), marca nettamente la retta orizzontale e
meno intensamente quella obliqua, tralasciando completamente la riga verticale;
•
la wavelet diagonale (in basso a destra), marca nettamente la riga obliqua tralasciando
le altre due righe. In oltre evidenzia il punto di incontro tra la riga orizzontale e quella
verticale.
Le wavelet basilari sono solamente tre, mentre le haar-like proposte da Viola e Jones sono in
numero superiore per codificare un maggior numero di situazioni.
20
Stato dell'arte
Il set ha subito poi un'estensione ulteriore de parte di Lienhart e Meydt con l'introduzione di
haar-like ruotate di 45° rispetto alle originarie. Questa estensione ulteriore ha richiesto
l'impiego della Rotated Summed Area Tablet descritta in precedenza.
Nell'immagine seguente (Fig. 1.13) sono raffigurati tutti i possibili prototipi del set esteso di
haar-like. L'algoritmo Viola-Jones faceva uso esclusivamente delle feature 1a, 1b, 2a, 2b, 2c,
2d e 4.
Fig. 1.13: Esempio di haar like feature verticali e ruotate.
Il set di haar-like è scelto per codificare al meglio tutte le possibili feature presenti all'interno
di un volto umano. Con delle semplici formule è possibile valutare quante ne possono essere
estratte da un'immagine campione di dimensioni WxH. Le formule sono le seguenti:
XY ∗(W +1−w∗(
XY ∗(W +1− z∗(
X +1
Y +1
))∗( H +1−h∗(
)) .
2
2
X +1
Y +1
))∗( H +1− z∗(
)) con z =w+h.
2
2
La prima è la generica formula per haar-like normali mentre la seconda è la formula per il
caso delle haar-like ruotate di 45°. Con i valori w e h si intendono le dimensioni minime di
altezza e larghezza della haar-like presa in considerazione. Il termine X rappresenta il
rapporto tra larghezza dell'immagine e larghezza minima della haar-like (X= W/w).
Analogamente Y rappresenta il rapporto tra altezza dell'immagine e altezza minima della
21
Stato dell'arte
haar-like (Y=H/h).
Nella tabella riportata di seguito ci sono tutte le informazioni per calcolare le cardinalità delle
feature estraibili da un'immagine di dimensione 24x24 pixel utilizzando tutte le haar-like
descritte in precedenza.
Feature
w/h
X/Y
#
1a : 1b
2/1 : 1/2
12/24 :24/12 43200
1c : 1d
2/1 : 1/2
8/8
8464
2a : 2c
3/1: 1/3
8/24 : 24/8
27600
2b : 2d
4/1 : 1/4
6/24 : 24/6
20736
2e : 2g
3/1: 1/3
6/6
4356
2f : 2h
4/1 : 1/4
4/4
3600
3a
3/3
8/8
8464
3b
3/3
3/3
1521
4
2/2
12/12
69696
Type
Somma
187637
Tabella 1.1: Calcolo del numero delle feature estratte da un'immagine di
dimensioni 24x24 pixel.
Dunque da un'immagine di dimensioni 24x24 pixel è possibile estrarre un totale di 187637
feature. Tra tutte le feature estratte, verranno selezionate dall'algoritmo di apprendimento
solamente quelle che garantiscono una maggior capacità di discriminare tra due classi.
La parte fondamentale dell'approccio Viola-Jones è proprio quella dell'algoritmo utilizzato per
distinguere tra le classi volti e non volti.
L'algoritmo scelto è AdaBoost ma ne viene elaborata una versione che consenta, in fase di
apprendimento, di selezionare l'insieme delle feature che garantiscono la massima
discriminazione tra le due classi. Infatti sarebbe proibitivo scegliere di discriminare un volto
da un non volto apprendendo per intero più di 180000 feature per ogni immagine campione
usata.
L'algoritmo proposto si basa sull'ipotesi di costruire una combinazione lineare pesata di
classificatori deboli. Ogni classificatore debole si limita ad utilizzare una singola feature.
Dunque verrà selezionato ad ogni passo il classificatore debole che garantisce la maggiore
discriminazione tra le due classi.
22
Stato dell'arte
La formula che esprime il classificatore debole è:

h j ( x)= 1
0
p j f j (x)< p j θ j .
altrimenti
Dove fj rappresenta la feature, θj rappresenta la soglia e pj la direzione della disuguaglianza.
La formulazione dell'algoritmo di apprendimento è la seguente:
•
Dato un training set (x1,y1),...,(xn,yn) con yi = 0,1 rispettivamente per esempi negativi e
positivi.
•
Inizializzare i pesi w 1, j =1/2 m
per gli esempi negativi, dove m rappresenta la
cardinalità degli esempi negativi e w 1, j =1/2 l per gli esempi positivi, dove l
rappresenta la cardinalità degli esempi positivi.
•
Per t = 1,...,T dove T è il numero di classificatori deboli
1. Normalizzare i pesi,
w t , j=
wt , i
n
∑ wt, j
j=1
2. Selezionare il miglior classificatore debole in base all'errore pesato
ϵt =min f , p , θ ∑ w i∣h(x i , f , p ,θ)− y i∣
i
3. ht(x) = h(x,ft,pt,θt) sarà quello con il minor errore ϵt
4. Aggiornare i pesi
ϵt 1−e
w t+1, j =w t , i +(
)
1−ϵt
i
Dove ei = 0 se l'esempio xi è stato classificato correttamente altrimenti ei = 1.
•
Il classificatore finale è:

C ( x)= 1
0
dove α t=log (
T
T
∑ α t ht (x)≥12 ∑ αt
t=1
t=1
altrimenti
1−ϵt
)
ϵt
23
Stato dell'arte
La procedura di apprendimento appena descritta è solamente una parte dell'algoritmo
completo. Infatti l'algoritmo di apprendimento prevede una cascata di classificatori pesati con
lo scopo di rendere il procedimento decisionale incrementale.
Ad ogni stage della cascata di classificatori aumenta il numero delle feature che vengono
valutate. Per passare da uno stage al successivo è necessario che nello stage a monte si sia
ottenuto un responso positivo dal classificatore pesato, cioè che le feature valutate in quello
stage sono classificabili come appartenenti ad un volto.
Se il responso del classificatore pesato è negativo si interrompe la cascata e si respinge la
sotto area dell'immagine perché non contiene un volto.
Se invece si termina la cascata di classificatori ottenendo un responso positivo in tutti gli
stage, la sotto area dell'immagine viene classificata come volto.
Fig. 1.14: Esempio della cascata di classificatori. Ogni nodo uno stage
della cascata.
Nella figura seguente (Fig. 1.15) possiamo vedere le feature che sono state prescelte per i
primi tre stage della cascata di classificatori, tendono ad aumentare ad ogni passaggio.
Fig. 1.15: Haar feature usate per l'apprendimento
dei primi 3 stage della cascata di classificatori.
24
Stato dell'arte
Il numero degli stage che devono essere attraversati prima di ottenere il responso definitivo
dipende dal livello di accuratezza che si richiede all'algoritmo. Infatti ad ogni stage si
mantiene invariata la percentuale di riconoscimenti corretti mentre si diminuisce la possibilità
che si verifichi un falso positivo.
La cascata di classificatori viene eseguita in tutte le possibili finestre contenute nell'immagine.
Si sposta la finestra all'interno dell'immagine partendo dall'angolo in alto a destra e
spostandosi dall'alto verso il basso e da destra verso sinistra. Inoltre si parte dalla minima
dimensione possibile e si scala la finestra di ricerca fino alla massima contenibile
nell'immagine. La minima grandezza della finestra di ricerca è data dalla dimensione delle
immagini di volti e di background che vengono utilizzati per l'apprendimento. Solitamente le
dimensioni sono di 20x20 o di 24x24 pixel.
1.3 Face Recognition
Riconoscere un individuo significa confrontare il volto estratto da un'immagine con un
insieme di volti campione che fanno parte di un database. Se si verifica tale corrispondenza si
deve indicare l'individuo altrimenti si dichiara che è sconosciuto.
É evidente che il costo per identificare un volto cresce all'aumentare del numero dei soggetti
presenti nel database. Alcuni metodi possono funzionare semplicemente con un'immagine
campione per ogni individuo mentre altri richiedono che un soggetto sia rappresentato da un
maggior numero di volti.
Possiamo dividere gli approcci atti a riconoscere un volto in due classi [17]:
•
Holistic Method: considera il volto umano come un segnale unico. Quindi lo
interpreta e lo elabora nella sua interezza. Fanno parte di questa metodologia le
tecniche derivate principal component analysis (PCA) e Fisher's linear disciminate
(FLD).
•
Local Method: il volto umano viene elaborato e vengono estratte delle feature locali
che vengono utilizzate per riconoscerlo. In questa categoria possiamo inserire le
tecniche basate sulle Scale Invariant Feature Trasform (SIFT) e Elastic Bunch Graph
Matching (EBGM).
In realtà esiste un terza classe di metodologie derivata dalla fusione delle feature di tipo locale
e di quelle di tipo globale. Tale metodologia dovrebbe garantire migliori prestazioni. Un
25
Stato dell'arte
esempio di utilizzo di feature globali e locali è proposto da Chowdhury, Sing, Basu e Nasipuri
[18].
Di seguito verranno presentate le tecniche PCA, SIFT, EBGM e quella ibrida proposta da
Chowdhury, Sing, Basu e Nasipuri.
1.3.1 Principal Component Analysis
L'analisi delle componenti principali (PCA) è uno strumento della statistica multivariata
proposto da Karl Pearson nel 1901 e sviluppato da Harold Hotelling nel 1933. E' una tecnica
utilizzata in ambiti economici, sociali, matematici e ingegneristici, prende anche il nome di
“trasformata di Karhunen-Loève” (KLT).
Lo scopo di tale tecnica è quello di ridurre le dimensioni di un fenomeno tramite l'estrazione
di
una
ristretta
quantità
di
informazioni
che,
se
ricostruite,
devono
garantire
un'approssimazione valida del fenomeno di partenza.
L'obiettivo è dunque quello di passare da uno spazio N-dimensionale ad uno spazio Mdimensionale con M < N. Questa riduzione di dimensioni determina una riduzione della
complessità del problema.
In termini di statistica multivariata significa che, partendo da dati con matrice di covarianza
non diagonale e in uno spazio N-dimensionale, si cerca uno spazio di dimensione inferiore ad
N in cui la matrice di covarianza è diagonale. In tal caso significa che non ci sono correlazioni
tra le variabili che descrivono il fenomeno. Per ottenere la diagonalizzazione è necessario
ruotare le coordinate in base agli autovettori. Se le variabili originarie sono correlate, alcuni
autovalori avranno un valore trascurabile e quindi gli autovettori associati a questi potranno
essere scartati [22].
26
Stato dell'arte
Fig. 1.16: Esempio di come avviene la riduzione di dimensione dello spazio
tramite l'utilizzo della tecnica di analisi delle componenti principali.
Come possiamo intuire, si tratta di una tecnica del tutto generale che può essere applicata in
qualsiasi contesto per ridurre la complessità delle informazioni legate ad un fenomeno.
E' largamente usata per l'identificazione di volti è può essere combinata a altre tecniche di
estrazione di feature[18] o come tecnica principale [20] [21].
L'applicazione diretta della tecnica PCA prende il nome di eigenface [20] [21]. Cerca di
estrarre e valutare le differenze tra i volti appartenenti a un gruppo per poterli codificare e
comparare con altri esterni attraverso meccanismi olistici.
La metodologia si propone di trovare un insieme di immagini, chiamate eigenfaces, che
consenta di rappresentare tutto il database di volti. Ognuno sarà rappresentato, in maniera
approssimata, da una combinazione lineare pesata di più eigenfaces. In termini di analisi dei
componenti principali si vogliono trovare gli autovettori dominanti, cioè quelli legati agli
autovalori maggiori, della popolazione di volti contenuti nel database.
Un nuovo volto rilevato sarà dunque codificato come combinazione lineare di eigenfaces e i
pesi potranno esser utilizzati per identificare il soggetto. Questo può avvenire semplicemente
con l'uso di una funzione che calcola la distanza geometrica.
Nella figura seguente (Fig. 1.17) l'immagine di destra rappresenta l'insieme delle eigenfaces
che sono state selezionate a partire dal database rappresentato nell'immagine di sinistra.
27
Stato dell'arte
Fig. 1.17: Esempio di immagini di volti che compongono un database (a) e
insieme delle eigenfaces ricavate dal database (b).
La procedura per effettuare un riconoscimento può dunque essere schematizzata nel seguente
modo:
•
a partire da un database di immagini di apprendimento vengono calcolate le
eigenfaces che costituiranno lo spazio dei volti;
•
il volto da identificare viene proiettato nello spazio dei volti e viene calcolato il vettore
dei pesi;
•
usando il vettore dei pesi si definisce se il soggetto appartiene al database e a che
identità corrisponde.
La parte fondamentale di questa metodologia è quella del calcolo delle eigenfaces, vediamo
come ciò avviene.
Per prima cosa dobbiamo considerare un'immagine di NxM pixel come un vettore di
dimensioni (N*M). Tale vettore si ottiene come concatenazione di tutte le righe di
un'immagine. Dunque una di dimensione 256x256 pixel darà luogo ad un vettore di 65536
elementi, ovvero ad un punto in uno spazio (MxN)-dimensionale.
Poiché tutti i volti presentano caratteristiche simili, si andranno a concentrare in un
sottospazio limitato. Il PCA si occuperà appunto di ridurre la dimensione di tale spazio.
Il primo passo per l'individuazione delle eigenfaces è il calcolo del volto medio. Questo
passaggio è fondamentale perché, come abbiamo già detto, l'obiettivo è quello di codificare le
differenze tra i volti. La formula è:
28
Stato dell'arte
Ψ=
1
M
M
∑ Γn
n= 1
dove Γ 1 , Γ2,... , Γ M sono gli M volti che compongono il training set. Ogni volto differirà
dunque dal volto medio del valore Φ n=Ψ−Γn .
A partire dalle informazioni così codificate sarà necessario calcolare la matrice di covarianza
al fine di estrarre gli autovettori e gli autovalori. La formula è la seguente:
1
C=
M
dove
M
∑ Φn ΦTn = AAT
n=1
A=[ Φ1 ,Φ 2 , ... ,Φ n ] .
Dalla matrice di covarianza è possibile calcolare gli autovettori
(μ k )
utilizzando il metodo
Jacobiano [20]. Dunque la formula è la seguente:
1
λ k=
M
M
∑ (μTk Φn)2
n=1
che è massimizzata quando:
T
l
μ μk=
{
1
0
se l=k
alrimenti
Si sceglierà quindi un sottoinsieme di autovettori che massimizza gli autovalori. In questo
modo si approssima la rappresentazione di ogni singolo volto ma al contempo si riduce la
complessità del problema. Dunque se il set completo di immagini di apprendimento è
composto da M=115 volti, si è stimato che M' = 40 determina un errore del 2%. M' è il
numero di autovettori selezionati.
Una volta definite le eigenfaces è possibile utilizzare il sistema per classificare un nuovo
volto. Esso deve essere proiettato nello spazio generale calcolando il vettore di pesi associato.
Il calcolo di ogni peso si effettua con la seguente formula:
ωn =μ n (Γ−Ψ )
n=1,..., M'
dove Γ rappresenta il volto da identificare. Il vettore dei pesi sarà dunque:
Ω=[ ω1 , ω2 ,... , ω M ' ]
Un volta ottenuto il vettore dei pesi è possibile classificare il volto di input. Per fare questo è
necessario confrontare tutti i vettori dei pesi, associati ai volti nel database, con il vettore
appena estratto. Si calcola la distanza euclidea tra i due vettori e si determina l'appartenenza
29
Stato dell'arte
ad un soggetto solo quando questa distanza è al di sotto di una soglia prefissata.
La formula per il calcolo è la seguente:
ε2k =∥Ω−Ωk∥2
k =1, ..., M
dunque se εk ⩽θϵ è classificato come la faccia k-esima.
Può inoltre essere definita una distanza dal sottospazio dei volti. Questa indicherà se
l'immagine di input contiene effettivamente un volto. Dobbiamo quindi calcolare un vettore
dei pesi del volto medio, e la formula è:
M'
Φ f = ∑ ω n μn .
n=1
Il calcolo della distanza è:
ε=∥Ω−Ω f ∥2 .
Come nel caso precedente si fissa una soglia θ che definisce se un'immagine di input
appartiene o meno allo spazio dei volti.
Il vettore dei pesi di un volto può essere visto come un punto in uno spazio M'-dimensionale.
Dunque un insieme di vettori peso possono essere utilizzati come set di apprendimento per
algoritmi di classificazioni, ad esempio SVM [18].
1.3.2 Elastic Bunch Graph Matching
Si tratta di una tecnica basata sulla ricerca di corrispondenza tra grafi rappresentativi di un
volto. Tale tecnica proposta da Wiskott, Fellous, Kuiger, e von der Malsburg [19] fa uso di un
grafo composto da archi e nodi. Ogni nodo è etichettato da un jet: l'insieme di coefficienti di
filtri di Gabor, con diversa scala e orientamento, applicati alla parte di immagine individuata
dal nodo. Gli archi a loro volta sono etichettati con la distanza tra due nodi.
Fig. 1.18: Esempio di adattamento del grafo su volti in pose
differenti.
30
Stato dell'arte
La proprietà principale dei grafi è rappresentata dalla facilità di manipolazione, difatti essi
possono essere traslati, ruotati, ridimensionati e deformati elasticamente. Nella figura
precedente si può notare che possono essere acquisiti in condizioni di posa differenti, così da
risultare diversi per geometria e per le feature locali.
Per mappare un grafico è necessario prendere in considerazione alcuni punti caratteristici che
prendono il nome di fiducial point. Generalmente questi punti sono le pupille, gli angoli della
bocca, le estremità del naso e tutte le possibili aree di particolare interesse.
Inoltre l'uso dei grafi consente la definizione di relazioni tra nodi appartenenti a grafi in pose
del volto differenti. In questo modo si aumenta la possibilità di identificazione corretta.
Poiché può risultare computazionalmente molto costoso rappresentare ogni combinazione di
feature attraverso grafi separati, si introduce il face bunch graph (FBG). E' una struttura
similare ad uno stack dove tutti i modelli di un grafo hanno la stessa struttura e i nodi si
riferiscono agli stessi fiducial point. Un insieme di jet riferiti ad un fiducial point prende il
nome di bunch. Ad esempio quello riferito al fiducial point di un occhio conterrà jet riferiti
agli occhi chiusi, aperti, maschili e femminili, al fine di coprire tutte le possibili casistiche.
Nella figura seguente è possibile osservare il grafo FBG. Ad ogni nodo è assegnato un bunch
composto da 6 differenti jet. In grigio sono evidenzianti quelli che sono stati selezionati
durante l'analisi di un'immagine sconosciuta.
Fig. 1.19: Esempio di FBG che fornisce
una rappresentazione generale di un
volto. Gli stack di dischi rappresentano i
jet.
31
Stato dell'arte
L'etichettatura iniziale dei fiducial point deve essere eseguita manualmente finché non si ha
un campione di grafi abbastanza grande. Quando FBG conterrà all'incirca 70 grafi non sarà
più necessario aggiungerne di nuovi. Infatti con un'etichettatura manuale di 6 grafi si ha che,
se il grafo contiene 9 nodi come nella figura precedente, FBG sarebbe potenzialmente in
grado di rappresentare 69 volti differenti. Viene così creato un FBG per ogni possibile posa.
Gli archi che compongono il modello FBG vengono etichettati con i valori medi ottenuti dai
grafi delle immagini campione utilizzate.
La procedura per il riconoscimento di una nuova immagine è la seguente:
•
Sul volto incognito vengono posizionati i fiducial point in modo che:
1. corrispondano a particolari feature;
2. sia massimizzata la similarità del grafo con un FBG. Per valutare la similarità tra
due grafi si utilizza la seguente formula:
1
S (G , B)=
N
G
B 2
( Δ ⃗x e −Δ ⃗x e )
(S ϕ ( J , J ))− λ ∑
∑ max
E e
m
( ⃗x eB )2
n
G
n
Bm
n
m=1,... , M
con n=1,... , N
e=1,... , E
Dove con B si indica un FBG che contiene M esempi con N nodi ed E archi. Con
G si indica il grafo rilevato dall'immagine da identificare. La prima parte della
formula descrive la similarità tra jet mentre la seconda parte è il termine che fa
riferimento alla topografia del grafo. Il termine λ indica l'importanza da attribuire
al temine che compara le topografie dei grafi.
La formula che descrive la similarità tra due jet è la seguente:
∑ a j a j ' cos(ϕ j −ϕ j ' − ⃗d k⃗j )
S ϕ ( J , J ' )=
j
√∑ a ∑ a '
2
j
j
j
j
2
()
a 1 ei ϕ
...
J = a j ei ϕ
...
iϕ
a 40 e
1
j
40
Dove con i termini a si indicano l'ampiezza e con φ si indica la fase. Il jet è
composto da 40 wavelet Gabor ottenute a 5 frequenze e 8 orientazioni differenti.
•
A questo punto, conoscendo la posa del volto è possibile confrontare il grafo ottenuto
dalla nuova immagine con tutti i grafi pre-calcolati dei volti presenti nel database. Il
confronto avviene mediante procedura di graph matching. I risultati sono ordinati in
base alla similarità.
•
Ricavati i valori di similarità si decide se attribuire al volto l'identità del soggetto con
32
Stato dell'arte
maggiore similarità oppure scartare i risultati.
1.3.3 Scale Invariant Feature Trasform
La Scale invariant feature trasform (SIFT) è una tecnica di estrazione delle feature da
un'immagine introdotta da Lowe [14]. Il suo scopo è quello di prelevare un insieme di punti,
che prendono il nome di keypoint.
I keypoint sono caratterizzati da un descrittore che ha un'elevata stabilità in caso di rotazione e
ridimensionamento dell'immagine, mentre la precisione in termini di cambiamenti di
luminosità risulta essere limitata.
Tale tecnica, per poter essere utilizzata al fine del riconoscimento di volti, richiede l'utilizzo di
un meccanismo di confronto dei keypoint. Prendendo in considerazione un'immagine
campione di un volto all'interno di un database, questa può essere messa in corrispondenza
con un'altra tramite un sistema di comparazione dei descrittori dei keypoint.
Il meccanismo più semplice che può essere utilizzato è quello del calcolo della distanza
euclidea tra i descrittori di due keypoint. Funziona assegnando l'appartenenza al keypoint che
minimizza tale distanza.
Altri meccanismi più complessi utilizzabili per il confronto sono quelli del machine learning.
In particolare a tale tecnica sono stati associati gli algoritmi AdaBoost [12], Support Vector
Machine [13] e Multilayer Perceptron [11].
Il meccanismo di estrazione delle feature è basato sull'applicazione in cascata di una serie di
filtri. Gli stage principali che possiamo identificare sono:
•
Scale-space Extrema Detection;
•
Accurate Keypoint Localization;
•
Orientation Assignment;
•
Costruction Keypoint Descriptor.
La fase di Scale-space extrema detection ha l'obiettivo di identificare tutte le possibili
posizioni che sono invarianti al cambiamento di scala. Per fare ciò è necessario l'utilizzo di
uno scale-space kernel che in questo caso è una funzione gaussiana. Lo scale space è definito
dalla funzione:
L( x , y ,σ)=G( x , y ,σ)∗I ( x , y) ,
33
Stato dell'arte
con G(x,y,σ):
G (x , y , σ)=
1
e−( x +y ) /2 σ ,
2
2πσ
2
2
2
dove I(x,y) è l'immagine di input e * è l'operazione di convoluzione.
Per selezionare i keypoint stabili nello scale space si utilizza la funzione di differenza
gaussiana. La quale è ottenuta come la differenza tra due scale vicine separate da un fattore
moltiplicativo k:
D (x , y , σ)=L( x , y , k σ)− L(x , y , σ) .
Il primo passo è quello di produrre un insieme composto dall'immagine iniziale convoluta con
la funzione gaussiana al variare di k. In questo modo si può calcolare la differenza gaussiana
tra valori di k consecutivi. Una volta calcolata la prima ottava le immagini gaussiane ottenute
vengono scalate di un fattore 2 e vengono calcolate le differenze con la nuova scala. La figura
seguente (Fig. 1.20) descrive in maniera dettagliata il procedimento per il calcolo delle
differenze gaussiane.
Fig. 1.20: Rappresentazione grafica del calcolo della differenza
gaussiana.
Ogni ottava è composta da uno stack formato da un numero di immagini gaussiane pari a s+3
dove s è un valore intero che influenza la scelta del valore k. Infatti il termine k può essere
calcolato come k=21/s.
34
Stato dell'arte
Per localizzare i keypoint si ricercano i minimi e i
massimi della funzione di differenza gaussiana (DoG).
Per fare ciò vengono analizzati tutti i possibili punti di
D(x,y,σ), questi vengono messi a confronto con gli otto
punti vicini e con i nove punti corrispondenti della DoG
precedente e seguente a quella presa in considerazione.
A questo punto, una volta identificati tutti i possibili
keypoint di un'immagine, è necessario eseguire la
rimozione di quelli che vengono ritenuti deboli. Tale
procedura prende il nome di Accurate Keypoint
Localization. Si eliminano tutti i punti con un
coefficiente basso o posizionati sui bordi. I punti
rimanenti dopo tale fase sono quelli più stabili alle
distorsioni e poco soggetti alla presenza di rumore.
Fig. 1.21: Punti che vengono
utilizzati per determinare
massimo e minimo della
differenza Gaussiana. Il pixel
analizzato è quello identificato
con la X, gli altri evidenziati sono
quelli presi in considerazione per
il calcolo.
L'immagine della figura seguente (Fig. 1.22) è di 233x189 pixel. Dopo la fase di ricerca di
calcolo di minimi e massimi delle differenze gaussiane si sono ottenuti ben 832 keypoint.
Rimuovendo tutti i keypoint non ritenuti sufficientemente stabili si ottengono 536 keypoint.
Fig. 1.22: Immagini rappresentative del processo di estrazione
dei keypoint. La figura (a) rappresenta l'immagine originale,
la (b) rappresenta i keypoint estratti nella prima fase e la (c)
rappresenta i keypoint che sono stati selezionati perché più
stabili.
35
Stato dell'arte
Ora che sono stati estratti tutti i possibili keypoint di un'immagine si passa alla fase chiamata
Orientation Assignment. Ad ogni keypoint viene assegnato un valore di grandezza m(x,y) e
uno che ne definisce l'orientamento θ(x,y).
Le funzioni utilizzate per il calcolo di questi valori sono:
m( x , y)=√ (L( x+1, y)− L(x−1, y))2+( L( x , y+1)−L( x , y−1))2 ,
θ(x , y)=tan−1
L( x , y+1)−L( x , y−1)
.
L( x+1, y)−L( x−1, y)
Viene creato un istogramma formato dall'orientamento dei gradienti della regione attorno al
keypoint. L'istogramma è formato da 36 valori che coprono tutti i 360° attorno al keypoint.
Il picco sull'istogramma degli orientamenti definisce la direzione dominante. Ogni altro picco
locale, che assume un valore maggiore all'80% del picco massimo, viene selezionato per la
creazione di un altro keypoint. Solamente il 15% dei keypoint dà luogo ad una assegnazione di
orientamenti multipli.
La fase finale dell'estrazione dei keypoint è quella della creazione del descrittore associato,
Costruction Keypoint Descriptor. Per calcolare le informazioni che caratterizzeranno il
descrittore si divide lo spazio intorno al keypoint in una matrice 4x4 di sotto regioni. Per ogni
sotto regione viene calcolato un istogramma del gradiente formato da 8 valori. Tutti gli
istogrammi così ottenuti vengono concatenati e danno luogo ad un vettore di dimensione 128,
cioè 4x4x8.
L'informazione di orientamento del keypoint, estratta nel passaggio precedente, viene
utilizzata per ruotare le informazioni degli istogrammi appena ottenuti. In tale modo tutti i
vettori avranno una rappresentazione coerente confrontabile tra loro.
Nella figura seguente (Fig. 1.23) è rappresentato graficamente come viene posizionata e
orientata la griglia che serve per creare il descrittore di due keypoint con scala e orientamento
differenti.
36
Stato dell'arte
Fig. 1.23: Esempio del posizionamento e
orientamento di due differenti keypoint.
Quindi ogni keypoint sarà descritto da locazione, orientamento e un vettore da 128 elementi
che definisce il gradiente locale.
Per un utilizzo come face recognition è necessario collezionare ed etichettare tutti i keypoint,
estratti dai volti campioni, in un database. É possibile associare a tale tecnica di estrazione di
feature un meccanismo di classificazione basato o su una semplice funzione di distanza
euclidea tra descrittori dei keypoint o da una algoritmo di machine learning [11][12][13].
I tre algoritmi di classificazione presi in considerazione sono AdaBoost, SVM e MLP. Mentre
AdaBoost è un algoritmo di riconoscimento binario gli altri due sono di tipo N-ario. Dunque
AdaBoost necessita di un tecnica che combini il funzionamento di più algoritmi, ognuno
specializzato sull'identificazione di uno degli N soggetti.
Di seguito sono riportati i risultati ottenuti dai differenti algoritmi di machine learning ricavati
applicando le differenti tecniche sull'ORL database.
Metodo
Fisher Face
AdaBoost SIFT
SVM SIFT
MPL SIFT
K=5
-96,3
---
Numero di immagini di apprendimento
k=6
k=7
k=8
-93,18
95,42
96,8
97,1
--95,8
97,4
92,2
96,7
98
k=9
97,8
-99,5
--
Tabella 1.2: Percentuali di corretta identificazione al variare del
numero di immagini usate per l'apprendimento.
Per quanto riguarda l'algoritmo AdaBoost, per poter eseguire un calcolo del tasso di
riconoscimento corretto si segue il seguente procedimento.
Si seleziona ad ogni passo un individuo da utilizzare come target, quindi si fa apprendere
37
Stato dell'arte
l'algoritmo al fine di riconoscere l'individuo target rispetto al resto degli individui del
database.
A questo punto ogni immagine presente nel database viene passata all'algoritmo ed ogni
singolo keypoint, estratto dall'immagine, viene classificato come appartenente o non
appartenente al soggetto. Se la maggioranza dei keypoint
viene classificata come
appartenente al soggetto si assegna al volto ignoto il corrispondente identificativo.
Una volta che si sono analizzate tutte le immagini del database si calcola il tasso di corretto
riconoscimento per quel soggetto. La procedura viene ripetuta per ogni soggetto del database.
Tutti i tassi per i singoli soggetti vengono mediati per ottenere un tasso unico.
Fig. 1.24: Istogramma che rappresenta il numero
di voti ricevuti dai diversi soggetti del database.
Nel caso di SVM e MLP invece l'analisi è semplificata poiché questi algoritmi sono in grado
di restituire la classe di appartenenza di un keypoint. Quindi dopo aver fatto apprendere
l'algoritmo di classificazione si esegue l'identificazione di tutti i volti del database. Per ogni
immagine vengono estratti i keypoint e vengono classificati. Si origina così un istogramma
che contiene un numero di valori pari al numero di soggetti presenti nel database. Il volto
incognito viene assegnato al soggetto che ha avuto la votazione maggiore nell'istogramma.
La formula per il calcolo del tasso di riconoscimento corretto è la seguente:
cr =
numero dei volti correttamente identificati
.
numero totale dei volti analizzati
Tutti i procedimenti proposti si attestano ad un buon livello di riconoscimento quando il
numero di volti campione è maggiore di 6. Tale comportamento è prevedibile poiché il
numero di keypoint appresi aumenta all'aumentare delle immagini campioni utilizzate. Se
38
Stato dell'arte
queste sono acquisite in contesti di illuminazione e posa differenti determinano una maggiore
espressività del database.
1.3.4 Approccio Ibrido
Chowdhury, Sing, Basu e Nasipuri [18] propongono un approccio ibrido per il riconoscimento
di volti basato sull'uso degli algoritmi:
•
generalized two-dimension fisher's linear discriminate (G-2FLD): per l'estrazione di
feature locali e globali da un'immagine che contiene un volto. Si tratta di
un'evoluzione dell'algoritmo fisher's linear discriminate;
•
principal component analysis (PCA): per la riduzione della dimensione dello spazio
delle feature;
•
support vector machine (SVM): per definire confini tra i differenti soggetti
appartenenti al database.
Lo schema di funzionamento generale dell'algoritmo è rappresentato nella figura seguente
(Fig. 1.25).
Fig. 1.25: Struttura grafica del funzionamento
dell'algoritmo di face recognition che prevede
fusione di feature locali e globali
39
Stato dell'arte
La proposta di questa tecnica è quella di fondere feature globali, estratte dall'immagine intera
del volto, a delle feature di tipo locale. Queste si ottengono suddividendo l'immagine
raffigurante un volto in N sotto immagini non sovrapponibili. Nello specifico si utilizza una
suddivisione dell'immagine in 4 aree.
Le 5 immagini così ottenute vengono elaborate per l'estrazione delle feature con l'uso del
metodo G-2FLD che massimizza, in maniera simultanea, la separabilità delle classi per ogni
riga e colonna. Per farlo utilizza la trasformazione lineare seguente:
Z=U T XV
dove X è la matrice dell'immagine di dimensione mxn. Mentre U e V sono due matrici di
proiezione di dimensioni, rispettivamente mxp (p ≤ m) e mxq (q ≤ n). Questo metodo ricerca
la direzione di proiezione ottima U e V così che il vettore di dimensione pxq garantisca la
massima separabilità delle classi.
A questo punto le feature così estratte, dall'immagine completa e dalle sue 4 parti, vengono
fuse in un unico vettore descritto dalla formula:
F =(Z 1, Z 2, Z 3, Z 4, Z )
dove Zn sono le feature delle 4 parti mentre Z sono le feature dell'immagine completa. La
dimensione del vettore così ottenuto è 5xpxq.
A questo punto il vettore delle feature viene rielaborato tramite l'uso del metodo PCA per
ridurre le dimensioni delle spazio delle feature. La prima operazione da fare è quella del
calcolo della matrice di covarianza con la formula:
1
E=
N
N
∑ ( F i − F )(F i−F )T ,
i=1
con:
1
F=
N
N
∑ F i.
i=1
Con N si indica il numero delle immagini di apprendimento.
Successivamente vengono calcolati gli autovalori e gli autovettori. Poiché la maggiore
informazione è contenuta dagli autovettori associati agli autovalori più grandi è possibile
eliminare una parte degli autovettori. In questo modo si determina una riduzione delle
dimensioni dello spazio delle feature ma si mantengono tutte le informazioni necessarie per
eseguire una corretta identificazione.
La matrice degli autovettori W=(W1,W2,...,Wr) con r<N è utilizzata per il calcolo del vettore
40
Stato dell'arte
delle feature ridotte, applicando la seguente formula:
R=W T F .
Ogni vettore viene impiegato per far apprendere l'algoritmo SVM che si occuperà di
determinare la corrispondenza di un volto incognito con volti appresi.
I risultati ottenuti da questo metodo sono riportati nella tabella seguente.
Tabella 1.3: Tabella che riporta il tasso medio di successo riferito
all'applicazione di diverse tecniche su ORL database
La metodologia usata per calcolare il tasso medio di corretta identificazione è la seguente.
Per ogni soggetto sono state prese in considerazione un numero d di immagini di
apprendimento scelte in maniera random tra le 10 per soggetto presenti nell'ORL database. Le
immagini scartate sono state utilizzate come immagini del test set. Per ridurre l'influenza
determinata dalla scelta del training e del test set è stata ripetuta la procedura per 20 volte.
Nella tabella è possibile confrontare il risultati ottenuti da questa tecnica con quelli delle
tecniche basate su metodologie similari.
Nel complesso questo approccio sembra ottenere delle prestazioni superiori alle altre
metodologie.
1.4 Algoritmi di Classificazione
Per comprendere quale è lo scopo degli algoritmi di classificazione partiamo dalla definizione
della parola “classificazione”:
41
Stato dell'arte
“Attività consistente nel disporre le entità di un dato dominio di conoscenze (persone di un
dato gruppo sociale, specie animali o vegetali, oggetti di un certo genere, concetti di un certo
settore disciplinare, nozioni utilizzate per certi fini, ...) in opportuni contenitori di conoscenze
tra i quali si stabiliscono dei collegamenti riguardanti una o anche più relazioni. Per i
contenitori vengono usati vari termini: classi, sezioni, categorie, specie …”.
Dalla definizione è immediato comprendere che lo scopo di un algoritmo di classificazione
non è altro che generare in maniera automatica l’assegnazione di un oggetto ad una
determinata classe.
In pratica stiamo parlando di tecniche per il riconoscimento automatico di un oggetto.
Per fare questo però gli algoritmi di classificazione necessitano di una fase di apprendimento
nella quale vengono forniti dei campioni appartenenti alle differenti classi. Per tale motivo
questo approccio è definito supervised cioè supervisionato.
Esiste un altro approccio che è definito unsupervised che, come dice il termine stesso, non è
supervisionato, quindi la suddivisione in classi viene fatta attraverso l’aggregazione di oggetti.
Una volta a disposizione tutte le informazioni relative ad uno specifico oggetto, queste
vengono rielaborate estraendo solamente quelle utili per la distinzione tra differenti classi. Le
caratteristiche che descrivono un oggetto vengono chiamate feature e devono essere scelte in
maniera accurata.
Nella classificazione supervisionata, esistono differenti approcci:
•
statistici;
•
con funzioni di discriminazione lineare;
•
non metrici.
Questi sono solamente alcuni tipi di approcci.
Nell’ambito degli approcci di tipo statistico molto importante è la teoria bayesiana. Ha
l’obiettivo di confrontare quantitativamente diverse decisioni di classificazione utilizzando le
probabilità ed i costi che le accompagnano. È fondamentale che:
•
la questione della decisione sia posta in termini probabilistici;
•
siano noti i valori di tutte le probabilità rilevanti per il problema.
Gli approcci con funzioni di discriminazione lineare, come è evidente, utilizzano funzioni di
tipo lineare per distinguere due differenti gruppi. Vengono utilizzati i dati del training set, cioè
dati di apprendimento, per calcolare i parametri e minimizzare il training error, l'errore di
apprendimento.
42
Stato dell'arte
Le tecniche non metriche per la classificazione sono introdotte per consentire l’utilizzo di
training set che non contengono esclusivamente dati di tipo numerico. In questi training set
sono contenute anche delle feature di tipo nominale.
1.4.1 Algoritmo di classificazione AdaBoost
L’algoritmo “AdaBoost” è una procedura di raffinazione dei dati di apprendimento finalizzata
all’aumento dell’accuratezza di classificazione di un dato algoritmo, anche se non è
propriamente di classificazione[1].
Questa tecnica di raffinazione è una diretta evoluzione del processo di “boosting”. Per capire
il funzionamento dell’algoritmo “AdaBoost”, adaptative boosting, è conveniente partire dalla
spiegazione dell'attività del normale processo di “boosting”.
Le condizioni che vengono considerate per spiegare il
funzionamento sono quelle ideali:
•
Classificazione di tipo binaria, solamente due
classi da distinguere;
•
Architettura di classificazione tri-componente.
Partiamo da un dataset D (Fig. 1.26) la cui cardinalità
è data dal valore “n”. Estraendo da questo dataset un
numero n1<n di elementi si produce il dataset D1 (Fig. Fig. 1.26: Dataset di
apprendimento D.
1.27). Il dataset D1 viene utilizzato per
l’apprendimento del classificatore C1.
A questo punto si passa alla creazione di un ulteriore dataset D2 (Fig. 1.27) sempre
sottomultiplo del dataset D. Viene creato estraendo da D una metà di elementi correttamente
classificati dal classificatore C1 e un’altra metà erroneamente classificati dal medesimo
classificatore. A questo punto il dataset ottenuto viene utilizzato per condurre l’addestramento
del classificatore C2.
43
Stato dell'arte
Fig. 1.27: Dataset ottenuti da D, rispettivamente D1, D2 e D3.
Infine viene creato un terzo dataset (D3) in cui sono contenuti tutti gli elementi per cui il
classificatore C1 e il C2 sono discordanti. Questo dataset viene utilizzato per l’addestramento
del classificatore C3.
Una volta conclusa la fase di addestramento dei tre classificatori, la regola che si segue per
determinare l’appartenenza di un elemento ad una classe è quella in cui sia il classificatore C1
che il C2 danno la stessa risposta. Nel caso contrario si considera l’assegnazione del
classificatore C3.
Si ottiene in questo modo un classificatore unico (Fig.
1.28) che consente di distinguere in maniera più
precisa i differenti elementi di una classe.
Le variazioni che apporta l’adaptative boosting al
normale processo di boosting sono:
•
Uso di una procedura iterativa che aggiunge
classificatori fino a ottenere una determina
Fig. 1.28: Classificatore finale.
accuratezza di classificazione;
•
Assegnazione di un peso ad ogni pattern di training che indica la probabilità di essere
usato per l’addestramento di un classificatore. Tale peso cambia ad ogni iterazione
dell’algoritmo, diminuendo se il pattern è classificato correttamente, aumentando nel
caso contrario.
In pratica il processo dell’adptative boosting fa sì che venga compiuto il maggior sforzo per la
l’addestramento su quei pattern più difficili da classificare.
44
Stato dell'arte
Algoritmo AdaBoost
1
begin initialize D = {x1,y1, x2,y2,..., xn,yn},kmax,W1(i)=1/n, i =1,...,n
2
k←0
3
do k ← k +1
4
Train weak learner Ck using D sampled according to distribution Wk(i)
5
Ek ← Training error of Ck measured on D using Wk(i)
6
αk ← ln[(1 − Ek)/Ek]
7
Wk+1(i) ←
8
until k = kmax
9
return Ck and αk for k =1 to kmax (ensemble of classifiers with weights)
10
end
Dove hk(xi) rappresenta la classe assegnata al pattern xi.
L’algoritmo descritto in precedenza è una generalizzazione del funzionamento di “AdaBoost”.
Un parametro molto importate da calcolare è l’errore di training di ogni singolo classificatore.
Questo può essere reso arbitrariamente piccolo aumentando il valore di kmax .Risulta quindi
che la formula che lo descrive è:
valida solo per alcuni valori Gk .Il suo valore denota un peso che influisce sull’errore di
apprendimento del singolo classificatore.
Da questa si può ricavare la formula che descrive l’errore complessivo del classificatore:
45
Stato dell'arte
Fig. 1.29: Andamento dell'errore all'aumentare delle iterazioni.
Nel grafico (Fig. 1.29) viene riportato l’andamento dell’errore di training del classificatore
(ensemble training error) al variare del parametro kmax. Inoltre si evidenzia come
all’aumentare del valore kmax l’errore di addestramento di ogni componente successivo è
generalmente più grande del componente precedente (nella Fig. 1.29 è l’andamento riportato
in grigio).
Si registra anche la tendenza dell’errore di test complessivo dell’algoritmo all’aumentare di
kmax che nel grafico (Fig. 1.1) è in colore rosso [23].
1.4.2 Algoritmo di classificazione SVM
Le support vector machines sono state sviluppate negli AT&T Bell Laboratories da Vapnik e
colleghi (Boser et al., 1992, Guyon et al., 1993, Cortes and Vapnik, 1995, Schölkopf et al.,
1995, Vapnik et al., 1997) [24][25].
Alcuni ambiti in cui si utilizzano le SVM sono:
•
l'OCR (optical character recognition, dove in breve tempo le SVM divennero
competitive con i migliori metodi per problemi di OCR);
•
il riconoscimento di oggetti (Blanz et al., 1996);
•
l'identificazione di oratori (Schmidt, 1996);
•
l'identificazione di volti in immagini (Osuna, et al. 1997);
46
Stato dell'arte
•
la classificazione di testi (Joachims, 1997).
Si tratta di un algoritmo di classificazione di tipo binario che apprende i confini tra due
differenti classi. Per fare ciò gli elementi che fanno parte del training set vengono proiettati in
uno spazio multidimensionale e a questo punto si cerca un “iperpiano di separazione”.
Alcune proprietà generali delle SVM:
•
l'improbabile l'overfitting;
•
la capacità di gestire dati con molte caratteristiche descrittive;
•
il compattamento dell'informazione contenuta nel data set in input.
Nella fase di apprendimento l’algoritmo “SVM” genera un insieme di funzioni di soglia:
dove ∆ è un insieme di parametri reali preclassificati nella forma:
L’obiettivo e quello di trovare la funzione fλ* che minimizzi “l’errore teorico” rappresentato
dalla formula:
dove con P(x,y) si indica la distribuzione di probabilità da cui sono stati presi i parametri.
L’errore teorico rappresenta una misura di quanto sia buona un’ipotesi nel predire la classe yi
di un punto x.
Poiché la distribuzione di probabilità P(x,y) non è nota, non è possibile minimizzare tale
errore. Si conosce però un campione di tale probabilità, quella composta dal training set. Si
introduce dunque “l’errore empirico” che rappresenta un’approssimazione dell’errore teorico.
La formula che lo descrive è:
Però non è sufficiente prendere in considerazione l’errore empirico, è necessario introdurre
anche il concetto di “dimensione VC” dello spazio di ipotesi H. Questa misura è un numero
naturale che corrisponde al più grande numero di punti che possono essere separati in tutti i
modi possibili dall’insieme di funzioni fλ. È un indice della complessità dell’insieme H.
La teoria della convergenza uniforme in probabilità, sviluppata da Vapnik e Chervonenkis,
fornisce anche un limite alla deviazione dell’errore empirico dall’errore teorico espresso dalla
disuguaglianza:
47
Stato dell'arte
dove h è la dimensione VC di fλ.
Dunque per poter minimizzare l’errore teorico è necessario minimizzare contemporaneamente
l’errore empirico e il rapporto tra la dimensione VC e il numero di punti (h/l).
L’algoritmo “SVM” risolve efficacemente questo problema.
I dati di training set che possono essere usati sono di due tipi:
•
linearmente separabili;
•
non linearmente separabili.
Partiamo dal caso più semplice, cioè che i dati siano linearmente separabili. In questo caso
non ci sono problemi nell’individuazione di un iperpiano di separazione, l’obiettivo diventa
quello di trovare il migliore.
Per fare questo è necessario minimizzare la norma, ciò comporta la massimizzazione del
margine tra iperpiano di separazione e training set.
Nella figura seguente (Fig. 1.30) si vede come entrambi gli iperpiani di separazione siano
accettabili. Solamente quello nella figura di destra risulta essere l’iperpiano ottimo poiché è
quello che massimizza il margine, cioè la distanza tra se stesso e i punti più vicini
dell’insieme di dati.
La massimizzazione del margine determina una maggiore generalizzazione e quindi minore
overfitting.
Fig. 1.30: Due differenti iperpiani di separazione nel caso di dati linearmente
separabili.
48
Stato dell'arte
Si può descrivere il classificatore nel caso di dati linearmente separabili con la formula:
Si ha che tutti i punti xi a cui corrisponde un moltiplicatore λi strettamente maggiore di zero
vengono detti support vector e si trovano su uno dei due iperpiani H1, H2 riportati nella figura
seguente (Fig. 1.31).
I support vector sono dei punti critici del training set, rappresentano tutti quei valori che sono
i più vicini all’iperpiano di separazione. L’eliminazione di tutti gli altri punti di training set,
ad eccezione di quelli critici, non determina cambiamenti nell’algoritmo di classificazione,
facendo ottenere lo stesso risultato.
Fig. 1.31: Iperpiano di separazione nel caso di
dati linearmente non separabili.
L’eventualità che i dati del training set non siano linearmente separabili (Fig. 1.31) è
determinata dalla presenza di punti in posizione anomala rispetto agli altri della stessa classe.
Si inserisce quindi una costante di scarto ξ , tanto maggiore quanto più lontani sono i punti
anomali,introducendo così una certa tolleranza agli errori. Questo fa sì che si possa utilizzare
un classificatore di tipo lineare come nell'esempio precedente.
Anche in questo caso possiamo scrivere la formula che riassume il classificatore:
49
Stato dell'arte
E' la medesima del caso di dati linearmente separabili. L’introduzione della costante di scarto
non ha conseguenze sulla formula, il suo effetto è quello di determinare un limite superiore C
per i moltiplicatori.
Vi sono alcuni casi in cui non è possibile separare i due differenti gruppi in maniera lineare
(Fig. 1.32), si introducono quindi dei classificatori non lineari.
Fig. 1.32: Caso di dati non linearmente separabili che richiedono una funzione di
mapping.
Un classificatore non lineare si ottiene con l’introduzione di una funzione di mapping Φ.
Questa ci permette di passare da una condizione di non separabilità ad una condizione di
separabilità lineare attraverso la mappatura dei dati originari in un altro spazio.
Purtroppo tali funzioni di mapping possono originare problemi di calcolo poiché per creare la
separazione dei dati si aumenta la dimensione dello spazio fino a comportare un aumento
anche dei vettori su cui lavora l’algoritmo per l’apprendimento.
Per agevolare le condizioni di calcolo vengono introdotte le “funzioni di kernel” che hanno lo
scopo di restituire il valore del prodotto intero fra le immagini di due argomenti.
Ciò era stato introdotto appositamente per creare il mapping in un differente spazio in modo
da ottenere la condizione di separazione lineare dei dati.
La formula che descrive una generica funzione dei kernel è:
A questo punto è possibile riscrivere la formula che rappresenta il classificatore nel seguente
modo:
50
Stato dell'arte
Si è riuscito a ottenere nuovamente un classificatore lineare a partire da dati che non
permettevano il suo utilizzo.
Per assolvere a differenti compiti esistono diverse formule per la funzione di kernel. È
necessario, in base al problema che si deve affrontare, scegliere quella più appropriata. Una
scelta errata porterebbe comunque alla creazione di un classificatore perfetto ma diminuirebbe
la capacità di generalizzazione e di conseguenza lo renderebbe incapace di lavorare in
maniera efficiente su nuovi dati.
Le più diffuse funzioni di kernel sono:
•
funzione di tipo lineare:
•
funzione di tipo polinomiale:
•
funzione di Radial Basis:
•
funzione di Gaussian Radial Basis:
•
funzione Multi-Layer Perceptron:
Dunque gli elementi base per il corretto funzionamento di un algoritmo “SVM” sono un
modulo di apprendimento e una funzione specifica per il problema che si deve andare ad
affrontare.
51
Sviluppo del Software
Capitolo2 - Sviluppo del Software
Dopo aver descritto nei precedenti capitoli il funzionamento teorico degli algoritmi, in questa
sezione ne verrà presentata l'applicazione concreta per realizzare un sistema di ricerca e
identificazione di volti. Si porrà particolare attenzione alle tecniche adottate e si motiveranno
le scelte fatte.
2.1 Ambiente Sviluppo
Il software realizzato ha lo scopo di analizzare un flusso video, indipendentemente che esso
sia acquisito da un file precedentemente salvato su un archivio di massa o direttamente da una
webcam. Il sistema hardware utilizzato è quindi un normalissimo personal computer dotato di
una webcam.
I flussi video solitamente hanno un frame rate di circa 25 fotogrammi per secondo, ovvero in
un secondo vengono visualizzate 25 immagini in successione. Scendendo al di sotto di tale
limite l'occhio umano incomincia a percepire un flusso video in maniera non fluida.
Se volessimo analizzare tutti i frame in tempo reale il sistema di elaborazione dovrebbe essere
in grado di analizzare un frame ogni 40 millisecondi.
La complessità di analizzare un frame è influenzata principalmente dalla sua risoluzione. In
questo caso si prende in considerazione una risoluzione di 640x480 pixel. É evidente che se
avessimo considerato una risoluzione di 320x240 pixel la complessità sarebbe scesa di un
quarto.
Per implementare il software di identificazione e riconoscimento dei volti si è deciso di
utilizzare come linguaggio di programmazione il C++ in ambiente Windows, e come editor
Microsoft Visual C++ Express in quanto completamente gratuito.
La decisione di utilizzare C++ è stata dettata principalmente da due motivazioni:
•
il software sviluppato in tale linguaggio garantisce una capacità computazionale
maggiore rispetto ad altri linguaggi come Java e Python,
•
esistono delle librerie, OpenCV [26], molto complete e affidabili che contengono
implementate un insieme di funzioni destinate all'elaborazione e all'acquisizione di
52
Sviluppo del Software
immagini, oltre ad una vasta gamma di algoritmi di machine learning.
Inoltre OpenCV può essere integrato con QT per migliorare le funzionalità dell'interfaccia
grafica.
La scelta del C++ come linguaggio di programmazione penalizza sicuramente la portabilità
del software. Comunque nella sua stesura si è cercato di utilizzare il più possibile istruzioni
ANSI che quindi dovrebbero garantirne la portabilità su altri sistemi operativi. Non è stato
possibile rispettare l'utilizzo di istruzioni ANSI solamente nel caso dell'uso dei thread poiché
essi dipendono da librerie specifiche del sistema operativo.
2.2 Realizzazione Sistema
Il software realizzato si basa sull'applicazione in successione di differenti tecniche atte a
diminuire ad ogni passo la complessità della ricerca ed dell'identificazione di un volto.
Le operazioni che devono essere eseguite in successione sono le seguenti:
1. acquisizione di un flusso video;
2. estrazione del frame dal flusso video;
3. ricerca di volti presenti nel video;
4. estrazione della sotto area contenente un volto;
5. identificazione del volto contenuto nella sotto area.
Le operazioni al punto 1 e al punto 2 riguardano l'acquisizione del flusso video e la
scomposizione in frame. La libreria OpenCV contiene al suo interno vari codec per la
decodifica di video e immagini già memorizzate in sistemi di archiviazione di massa. Inoltre
integra le api DiretShow che gestiscono l'acquisizione di video direttamente da webcam in
ambienti Windows.
L'operazione al punto 3 si riferisce alla procedura di face detection. Come abbiamo visto nel
capitolo precedente, gli approcci sono diversi, sicuramente uno dei più comuni è l'algoritmo
Viola-Jones.
Nel nostro caso si è decido di procedere con una combinazione di due differenti tecniche che
vengono applicate in cascata. Prima si utilizza la tecnica di skin-segmentation, per ridurre le
aree di ricerca del volto solamente a quelle contenenti pixel che possono essere classificati
come pelle. Poi si applica l'algoritmo Viola-Jones addestrato per cercare singolarmente le aree
contenenti gli occhi e la bocca.
53
Sviluppo del Software
L'operazione al punto 4 consente, a partire dalle informazioni delle posizioni di occhi e bocca,
di determinare il riquadro che meglio contiene il volto. Questa procedura è fondamentale per
ridurre al massimo la presenza di elementi dello sfondo all'interno dell'immagine su cui
compiere la procedura di face recognition.
Infine l'ultima operazione è quella del face recognition che si occupa di confrontare il volto
estratto con quelli campione precedentemente selezionati per costituire il database.
A conclusione di tutto il processo, il software riproduce a video il frame, riquadrando i volti
dei soggetti. Se il volto appartiene al database viene poi etichettato con il nome
corrispondente, altrimenti viene etichettato come sconosciuto.
L'interfaccia grafica è minimale ed è gestita direttamente dalla libreria OpenCV. Per poterla
utilizzare con le piene funzionalità è necessario ricompilare le librerie OpenCV includendo le
dipendenze delle librerie QT.
2.2.1 Procedura di face detection
Come già presentato in precedenza, la procedura di estrazione del volto da un frame video si
compone dell'uso in cascata di due tecniche ben distinte.
La prima è la skin-segmentation che consiste nel classificare ogni singolo pixel per produrre
tutte le sotto aree contenenti aggregazioni consistenti di pixel della classe pelle. Tale
procedura, una volta estratto il frame da analizzare, può essere scomposta nelle seguenti fasi:
•
riduzione in scala del frame;
•
analisi del frame scalato per produrre la skin-map;
•
erosione della skin-map per eliminare pixel isolati;
•
individuazione di tutte le sotto aree che contengono una aggregazione di pixel;
•
eliminazione di tutte le sotto aree che, per la loro dimensione ridotta, non potrebbero
contenere un volto.
La riduzione in scala di un frame non comporta significative perdite di informazioni e viene
utilizzata solamente nella fase di skin-segmentation. Lo scopo è quello di diminuire il più
possibile il peso computazionale della scansione dei pixel contenuti nel frame. Infatti scalando
di un fattore 4 l'altezza e la larghezza del frame originario si ottiene un'immagine di 160x120
pixel che contiene una buona approssimazione dell'immagine originaria. La diminuzione di
54
Sviluppo del Software
pixel in tal caso è sensibile, infatti si tratta di analizzare un sedicesimo dei pixel originari.
La riduzione in scala è conveniente poiché sia l'operazione di erosione che quella di
identificazione delle sotto aree richiedono una scansione completa della skin-map prodotta.
L'analisi del frame scalato consiste nel verificare pixel per pixel il frame e produrre
un'immagine di output a due livelli, bianco e nero, dove con il bianco si indica il pixel
classificato come colore della pelle e con il colore nero un pixel non appartenente a tale
classe. Per eseguire la classificazione ci si limita a verificare se i pixel cadono all'interno di
soglie ben precise.
In questo caso il software è implementato per utilizzare lo spazio di colori nativo della
sorgente video, cioè RGB, e la conversione lineare in YCrCb. In realtà RGB viene
normalizzato al fine di ridurre l'influenza della luminosità. Nel precedente capitolo sono stati
definiti i valori soglia e le formule di conversione per gli spazi di colore.
Inoltre è possibile utilizzare una combinazione dell'estrazione nei due spazi di colore per
definire con più accuratezza i limiti tra pelle e non pelle. In tal caso si definisce che un pixel
appartiene alla classe pelle se viene classificato come tale con uno dei due metodi.
Nella tabella seguente sono riportate le percentuali di colori che ricadono all'interno della
classe pelle per le due tecniche e la loro combinazione. I valori sono calcolati considerando
un'immagine a colori RGB con profondità di 8 bit per canale.
Numero Colori
CrCb
RGB normalizato
CrCb or RGB
1854671
855012
2029019
Percentuale rispetto a
colori rappresentabili con
3 canali a 8 bit
11,05%
5,10%
12,09%
Tabella 2.1: Cardinalità degli insiemi di colori che
appartengono alla classe pelle in base alle soglie riferite a
due differenti spazi di colore.
Come si può vedere dalla tabella, la tecnica che fa uso dello spazio di colore RGB
normalizzato individua come appartenente alla classe pelle meno della metà delle tonalità che
sono selezionate con lo spazio di colore YCrCb.
Dunque la scelta di uno spazio di colore piuttosto che un altro è determinante per il
funzionamento del sistema. Se le soglie definite nei due spazi di colore sono state ottenute
analizzando un campione abbastanza espressivo è molto strano che tra le due tecniche ci sia
una differenza così elevata.
55
Sviluppo del Software
Utilizzando dunque lo spazio di colori YCrCb ci troveremmo nella situazione di avere una
fase di classificazione molto più permissiva rispetto all'utilizzo di RGB normalizzato.
Potenzialmente un numero maggiore di oggetti con colorazioni ritenute simili alla pelle
potrebbero essere erroneamente classificati.
Una volta determinata la skin-map, si deve raffinarla in maniera tale da escludere tutti quei
pixel isolati che rappresentano rumore del background. Per fare questo si è scelto di utilizzare
una delle due operazioni fondamentali della Morphological Image Processing: la tecnica
dell'erosione.
Prevede la definizione di una matrice kernel che verrà applicata a quella che rappresenta
l'immagine binaria, così che ogni aggregazione di pixel di valore 1 con dimensioni inferiori
alla matrice di kernel viene eliminata. Al contempo, le aggregazioni di pixel di dimensioni
maggiori subiranno solamente un'eliminazione delle aree lungo il bordo dell'aggregazione.
Nell'immagine seguente (Fig. 2.1) è possibile vedere graficamente come funziona l'operazione
di erosione quando si applica ad un'immagine di input un kernel di dimensioni 3x3 contenente
tutti 1.
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
←
kernel
1 1 1
1 1 1
1 1 1
=
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
0
0
0
0
0
0
1
1
1
0
0
0
0
0
0
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Fig. 2.1: Immagine che descrive come funziona il processo di erosione.
Nel caso specifico, poiché si lavora con un frame di dimensioni 160x120, che è scalato di un
fattore 4 rispetto al frame originale, si utilizza un kernel di dimensioni 3x3. Questa è la
dimensione massima poiché altrimenti si perderebbe troppo contenuto informativo. Sarebbe
come applicare un kernel di dimensioni 12x12 alla skin-map prodotta con la risoluzione
originaria.
E' riportato di seguito (Fig. 2.2) un esempio di skin-map prima e dopo il processo di erosione.
É possibile vedere come le aree con aggregazione di pixel di una certa entità siano state
conservate.
56
Sviluppo del Software
Fig. 2.2: (a) Skin-map ottenuta dalla procedura di
classificazione dei pixel, (b) skin-map ottenuta dopo il
processo di erosione con kernel 3x3
Il passo successivo alla produzione della skin-map è quello della creazione di riquadri che
contengano le aree bianche. Per fare questo è stata sviluppata una procedura che scansiona
tutti i pixel e genera dei rettangoli che inglobano il volto.
Una volta determinati tutti i riquadri che potrebbero contenere un volto, vengono eliminati
quelli di dimensioni ridotte. Per la grandezza originale del frame, la dimensione minima che si
ammette è quella di 40x40 pixel. Dunque nel caso del frame scalato di un fattore 4 la
dimensione minima del rettangolo è quella di 10 x 10.
Ogni rettangolo sarà rappresentato dalla coordinata dell'angolo in alto a destra, dall'altezza e
dalla larghezza, r(x,y,w,h). A questo punto tutti i rettangoli saranno riportati ad una dimensione
compatibile a quella del frame originale semplicemente moltiplicando per il fattore di scala,
ad esempio r'(4x,4y,4w,4h).
Nella figura seguente (Fig. 2.3) i riquadri di colore rosso sono quelli selezionati come
potenziali volti. Nel frame sono presenti due aree che contengono dei pixel classificati come
pelle. Una contiene effettivamente un volto mentre l'altra è un quadro con una colorazione
soltanto molto simile.
57
Sviluppo del Software
Fig. 2.3: Immagine di un frame dove in rosso sono
riquadrate le aree identificate con la procedura di skinsegmentation. Le aree in blu sono le sotto aree di ricerca
per occhio sinistro e bocca. I riquadri verdi indicano gli
elementi individuati con algoritmo Viola-Jones.
La scelta di usare la skin-segmentation per ridurre le dimensioni delle aree in cui cercare i
volti è motivata dall'estrema semplicità di realizzazione di tale tecnica. Inoltre la possibilità di
lavorare in scala consente, anche in condizioni di frame di notevoli dimensioni, di ridurre
l'impatto di questa operazione sul costo complessivo dell'intero sistema.
Una volta ottenuti i riquadri che potenzialmente contengono dei volti è necessario verificare la
presenza degli elementi caratteristici. In questo caso si è scelto di ricercare la presenza di
occhio destro, occhio sinistro e bocca.
Si potrebbe estendere la ricerca aggiungendo altri elementi come naso e orecchie, ma la
presenza di questi 3 dettagli è sufficiente per calcolare l'area da estrarre.
Per cercare gli elementi del volto ci si affida all'utilizzo dell'algoritmo Viola-Jones. Nella sua
formulazione originale è pensato per rintracciare in maniera efficiente i volti presenti in
un'immagine e nel nostro caso, addestrandolo in maniera appropriata, è possibile utilizzarlo
per ricercare gli elementi caratteristici.
Tali addestramenti dell'algoritmo sono presenti a corredo delle librerie, ovviamente in caso di
esigenze differenti da quelle già affrontate è sempre possibile generare il proprio
addestramento.
A corredo delle librerie sono presenti più addestramenti che riguardano la localizzazione degli
58
Sviluppo del Software
occhi. Tra questi è stato scelto quello proposto da Shiqi Yu [27] poiché in fase di utilizzo si è
dimostrato computazionalmente meno costoso. Inoltre questo apprendimento è stato
sviluppato in maniera molto accurata consentendo di estrarre una maggior quantità di
informazioni rispetto alla sola posizione dell'occhio.
Shiqi Yu ha verificato che i precedenti apprendimenti già
presenti a corredo delle librerie avevano dei problemi di
errata classificazione poiché riconoscevano come occhi le
sopracciglia, inoltre il loro funzionamento in caso di scarsa
illuminazione decadeva.
La conoscenza del riquadro che contiene l'occhio di un
individuo ci consente di ricavare altre informazioni come la
posizione della pupilla e la teorica distanza tra i due occhi.
É evidente che il suo funzionamento è ottimale quando il
volto è perfettamente frontale, mentre quando è ruotato è
possibile che le informazioni che si possono ricavare siano
affette da errori.
Nella figura a fianco (Fig. 2.4) è rappresentato un volto
Fig. 2.4: Metodologia di
umano e sono riportate le specifiche con cui sono estratti gli Shiqi Yu [27] per
occhi. Possiamo vedere che l'altezza o la larghezza dell'area l'estrazione delle aree
oculari per apprendimento
dell'occhio sono strettamente legate alla distanza tra i due
occhi. Possiamo dunque ricavare le formule per il calcolo della posizione della pupilla e per la
distanza tra gli occhi:
width height
=
0,6
0,6
1
1
EyeCenterX = DistEye∗0,6= ∗width
2
2
2
2
EyeCenterY = ∗DistEye∗0,6= ∗width
3
3
DistEye=
dove con width e height si intendono larghezza e altezza del rettangolo che contiene l'occhio.
Queste formule sono alla base del calcolo della sotto area di ricerca per l'occhio sinistro
partendo dalla conoscenza dell'occhio destro e viceversa. Infatti data la posizione di un occhio
possiamo calcolare in maniera teorica quella dell'altro e definire un'area di ricerca intorno a
questo punto. Le formule per calcolare la posizione teorica della pupilla dell'altro occhio sono
59
Sviluppo del Software
le seguenti:
x=
+ DistEye
{ EyeCenterX
EyeCenterX − DistEye
se conosco occhio destro
se conosco occhio sinistro
y=EyeCenterY
Inoltre le formule per il calcolo della sotto area di ricerca per l'occhio non ancora trovato sono
le seguenti:
xArea=
{ x−DistEye∗0,65
x−DistEye∗(1,5−0,65)
se conosco occhio destro
se conosco occhio sinistro
yArea= y−DistEye∗0,7
wArea=1,5∗DistEye
hArea=1,2∗DistEye
La zona di ricerca per il secondo occhio da trovare è rappresentata da un rettangolo con
coordinata dell'angolo in alto a destra xArea e yArea e le misure di altezza e larghezza
rispettivamente hArea e wArea (r(xArea, yArea, wArea, hArea)).
Conoscendo le posizione di uno o di entrambi gli occhi è possibile poi calcolare l'area di
ricerca della bocca e la posizione teorica del suo centro.
Le formule per il calcolo teorico sono:
x =CenterRightEyeX − DistEye∗0,5
CenterRightEyeY +CenterLeftEyeY
y=
+1,2∗DistEye
2
Se si conosce la posizione di entrambe le pupille si ricalcola DistEye utilizzando la formula
della distanza euclidea. A questo punto è possibile calcolare la sotto area di ricerca della
bocca. Le formule sono:
wArea= DistEye∗1,6
hArea= DistEye∗1,2
1
xArea= x− wArea
2
1
yArea= y− hArea
2
Tutte le formule precedenti sono ricavate a partire da una teorica struttura del volto descritta
nel lavoro di Vukadinovic e Pantic [28], dove la posizione della bocca è messa in relazione
60
Sviluppo del Software
con la distanza tra gli occhi.
Le sotto aree di ricerca, visibili in blu nella figura del frame estratto dal flusso video
precedente (Fig. 2.3), consentono di ricercare la bocca e l'occhio mancante anche in presenza
di piccoli errori di posizionamento delle componenti conosciute.
Lo schema di esecuzione per la ricerca delle componenti del volto è riportato nell'immagine
seguente (Fig. 2.5). Si ritiene sufficiente la presenza di un occhio per poter passare allo step
successivo dell'identificazione del volto. Le aree che non contengono nessun elemento
vengono rigettate.
Una volta conosciute le posizioni reali o teoriche degli elementi di un volto si passa al calcolo
dell'area da estrarre. Per fare questo è necessario calcolare il rettangolo che seleziona in
maniera migliore il volto.
Le formule utilizzate sono le seguenti:
x =CenterRightEyeX −(0.3+0.333)∗DistEye
(CenterRightEyeY −CenterLeftEyeY )
y=
−(0.4+0.333)∗DistEye
2
w= DistEye+2∗(0.3+0.333)∗DistEye
1
h=CenterMouthY − y+ ∗DisEye
2
Dove il rettangolo che rappresenta l'area del volto è definito da r(x,y,w,h).
Come si può notare dalle formule per il calcolo dell'area che racchiude il volto, in posizione
frontale ci si basa sulla conoscenza della distanza tra gli occhi. Se per qualche motivo tale
distanza non fosse corretta si rischierebbe di racchiudere il volto in un rettangolo di
dimensioni o troppo piccole o troppo grandi.
L'apprendimento su cui è basata l'individuazione degli occhi prevede una finestra di ricerca di
dimensione 20x20 pixel. Dunque possiamo in via teorica calcolare la dimensione minima
dell'area che contiene il volto. Dai calcoli si ottiene che la minima altezza è di 81 pixel mentre
la minima larghezza è di 75 pixel. Questo formato si ottiene se l'occhio destro è di dimensioni
20x20 pixel mentre gli altri elementi del volto vengono ricalcolati in maniera teorica.
Ma in realtà, poiché le posizioni dei differenti elementi possono variare, la dimensione del
volto potrebbe essere ancora inferiore.
61
Sviluppo del Software
Fig. 2.5: Schema di ricerca delle componenti fondamentali del volto. In verde le uscite
positive, in rosso le situazioni che generano un rigetto della sotto area.
62
Sviluppo del Software
La decisione di applicare in successione la tecnica di skin-segmentation e quella di ricerca
degli elementi con l'algoritmo Viola-Jones è motivata dalla volontà di utilizzare la maggior
parte delle informazioni di input possibili. Infatti le due tecniche sono complementari.
Da una parte l'algoritmo di skin-segmentation basa la sua ricerca sulla componente cromatica
dell'immagine, dall'altra l'algoritmo Viola-Jones basa la sua ricerca solamente sulla
componente di luminosità che si ottiene come combinazione pesata dei tre canali di colore
RGB.
La skin-segmentation costituisce un filtro che riduce sensibilmente le aree da investigare con
l'algoritmo Viola-Jones, il quale si trova così in una condizione di lavoro migliore.
Inoltre dopo aver rintracciato un occhio all'interno della sotto area del frame è possibile
calcolare delle sotto aree più precise e di minori dimensioni per la ricerca dell'altro occhio e
della bocca.
La riduzione, ad ogni step della sequenza di ricerca, dell'area da investigare con l'algoritmo
Viola-Jones riduce l'impatto di tale tecnica sul peso computazionale totale.
Altro impatto positivo è quello di inglobare nelle sotto-aree di ricerca, successivamente al
rintracciamento di uno dei due occhi, anche zone del frame che con la skin-segmentation
erano state precedentemente escluse. Potrebbe accadere infatti che un'area del volto, poco o
troppo illuminata, inizialmente non venga classificata come classe pelle e venga dunque
esclusa dalla ricerca. In un secondo momento però, se uno dei due occhi cade all'interno di
tale area gli elementi del volto verranno ricercati in sotto aree opportune, anche esterne alla
sotto area ottenuta con la skin-segmentation.
In alcuni casi però l'algoritmo Viola-Jones, usando gli apprendimenti prescelti per la ricerca
degli occhi, può commettere un errore di classificazione. Poiché è molto difficile discriminare
tra occhio destro e occhio sinistro si potrebbe verificare che erroneamente durante la ricerca
dell'occhio destro si individui e selezioni quello sinistro.
In tal caso l'unico modo per avere certezza di tale errore e correggerlo è quello di cercare la
bocca in due sotto aree del frame.
Per fare questo si considera l'occhio selezionato come destro. Se la ricerca della bocca nella
sotto area calcolata con tale presupposto non dà buon esito si ricalcola l'area di ricerca della
bocca assumendo che l'occhio selezionato sia invece sinistro.
63
Sviluppo del Software
Si possono così verificare due situazioni:
•
non viene identificata la bocca, quindi si attribuisce all'occhio l'etichetta di destro e si
calcola l'area che contiene il volto in base alla sua posizione;
•
viene identificata una bocca all'interno della sotto area, la classificazione dell'occhio
era errata. All'occhio viene così attribuita l'etichetta sinistro e usando le informazioni
della posizione della bocca si calcola l'area contenente il volto.
La strutturazione di una ricerca del volto così articolata consente l'introduzione di varianti per
la ricerca di altri elementi. L'utilizzo di un numero maggiore di dettagli potrebbe essere
motivato dalla necessità di più precisione nel definire il riquadro che lo contiene, oppure dalla
necessità di verificare la posa del volto o la presenza di elementi estranei come ad esempio gli
occhiali.
La struttura scelta è quella che garantisce la migliore efficienza per la ricerca di un volto
quando questo è in posizione frontale. Riesce ad riconoscerlo anche quando è ruotato di
profilo in maniera non eccessiva.
2.2.2 Procedura di Face Recognition
L'output della face detection è una sotto area del frame originario che contiene un volto in
posa prevalentemente frontale e un insieme di informazioni correlate come:
•
distanza tra gli occhi;
•
posizione della pupilla dei due occhi;
•
posizione della bocca.
Tutti questi dati ora possono essere presi in considerazione dall'algoritmo di identificazione
dei volti.
Si è scelta come metodologia la tecnica basata sulle Scale Invariant Features Trasform
(SIFT) appartenente all'algoritmo di apprendimento supervisionato Support Vector Machine
(SVM) [13]. L'analisi comparativa di diverse tecniche mostra la validità di questo approccio.
Il SIFT, come già presentato in precedenza, è una tecnica di estrazione di punti chiave
caratteristici di un'immagine.
Per poter utilizzare tale tecnica è necessario prima di tutto creare un database di volti da cui
estrarre le informazioni. Ne esistono molti, quello qui utilizzato è ORL database, composto da
64
Sviluppo del Software
40 soggetti ognuno dei quali è rappresentato da 10 immagini di volti catturate in condizioni di
posa e luminosità differenti.
A questo database è stato aggiunto il 41esimo soggetto inserendo 10 immagini del mio volto,
rappresentate nella figura seguente.
Fig. 2.6: Dieci immagini raffiguranti il mio volto inserite nel database.
É stato realizzato un software a se stante che serve per generare l'apprendimento
dell'algoritmo SVM. Si limita semplicemente ad acquisire ogni immagine del database
destinata all'apprendimento, estrarne i keypoint e addestrare l'algoritmo in maniera tale da
garantire la massima percentuale di riconoscimento.
L'algoritmo SVM è di tipo multi-classe cioè è in grado di apprendere e distinguere un numero
N di classi. I keypoint estratti da un'immagine vengono processati singolarmente e assegnati
ad un soggetto del database. Il soggetto a cui viene assegnato il maggior numero di keypoint è
quello raffigurato nel volto ignoto.
L'unico problema che mostra questo metodo è quello di non poter classificare un soggetto
come sconosciuto. Infatti, se ci si attiene strettamente ai passaggi descritti in precedenza, un
volto sconosciuto viene comunque classificato con quello a cui assomiglia maggiormente.
Per eliminare tale problema si è introdotta una soglia minima di punti che devono essere
assegnati al soggetto. Se il volto ignoto non supera tale soglia il soggetto viene ritenuto
sconosciuto.
Poiché il numero di keypoint estratti varia in base a posa e dimensione del volto, la soglia va
determinata in percentuale sul numero dei keypoint selezionati. Ponendo k un valore compreso
tra 0 e 1 e n il numero dei keypoint estratti dall'immagine analizzata, si ha che:
soglia=n∗k .
65
Sviluppo del Software
Ad esempio ponendo k=0.2 e n= 20 il valore di soglia sarà 4. Quindi se ad un volto ignoto
saranno assegnati un numero maggiore o uguale al valore di soglia dei keypoint, esso sarà
etichettato con il soggetto corrispondente nel database.
Il valore k va deciso in base alla sensibilità che si vuole avere. Un valore alto garantirà una
maggiore certezza nell'identificazione del volto con uno di quelli del database, poiché per
realizzare ciò è richiesto un maggior numero di corrispondenze. Al contempo però, siccome la
probabilità di soddisfare tutte le corrispondenze necessarie è minore, si può verificare più
frequentemente che il volto venga etichettato come sconosciuto.
Inoltre, si attribuisce al volto ignoto l'etichetta sconosciuto anche nel caso in cui a due soggetti
viene assegnato lo stesso numero di keypoint.
Possiamo schematizzare i passaggi nel seguente modo:
•
conversione dell'area contenente il volto in scala di grigi;
•
cambiamento di scala dell'area contenente il volto;
•
estrazione dei keypoint;
•
analisi di tutti i keipoint per la creazione di un istogramma;
•
identificazione del soggetto più votato;
•
verifica se un altro soggetto ha ottenuto la stessa votazione;
•
verifica se si è superata la soglia minima di keypoint;
•
assegnazione dell'etichetta sconosciuto o del nome del soggetto.
Il passaggio del cambiamento di scala viene attuato quando la dimensione dell'area contenente
il volto ignoto è maggiore della dimensione delle immagini di apprendimento. Questo
passaggio ha lo scopo di ottenere dal volto un numero di keypoint il più simile possibile al
numero che si ottiene dai volti del database.
Per ottimizzare la procedura di analisi dei keypoint, questa è stata strutturata in maniera tale
da funzionare in parallelo. Si può pertanto definire il numero dei thread che si occupano
dell'analisi già in fase di avvio. Questo parametro consente di ottimizzare la fase di face
recognition nel sistema hardware su cui viene eseguito.
Ogni keypoint è rappresentato da un vettore di 128 elementi che ne descrive le caratteristiche.
Nella fase di identificazione è sufficiente utilizzare tale vettore, che prende il nome di
descrittore, per verificare la corrispondenza tra keypoint. Altra informazione invece che
abbiamo a disposizione, cioè la locazione del keypoint all'interno dell'area del volto, viene
completamente trascurata.
66
Sviluppo del Software
Opzionalmente il sistema può funzionare assegnando un punteggio maggiore ai keypoint
localizzati in sotto aree limitrofe agli occhi e alla bocca. Dunque è sufficiente attribuire il
punteggio 1.5 a questi keypoint per renderli predominanti.
Gli altri keypoint manterranno l'assegnazione del punteggio
base, ovvero 1.
Un esempio delle sotto aree che hanno un maggiore peso in
fase di decisione è rappresentato nella figura a lato (Fig. 2.7).
Le aree che riquadrano gli occhi e la bocca hanno
rispettivamente le dimensioni di 74x32 e 50x42 pixel se ci si
riferisce alle immagini di apprendimento che hanno una
dimensione di 92x112 pixel.
Fig. 2.7: Esempio di aree
Poiché il volto potrebbe avere delle dimensioni minori o limitrofe ad occhi e bocca
maggiori rispetto a quelle delle immagini di apprendimento, che hanno un maggiore
peso per la decisione.
le dimensioni delle sotto aree devono essere ogni volta
riportate in scala.
Le formule per il calcolo delle aree sono le seguenti:
DistEye wRetEye
−
2
2
(CenterRightEyeY −CenterLeftEyeY ) hRetEye
yEye =
−
2
2
wEye=wRetEye
hEye=hRetEye
xEye =CenterRightEyeX +
wRetMouth
2
hRetMouth
yMouth=CenterMouthY −
2
wMouth=wRetMouth
hMouth=hRetMouth
xMouth=CenterMouthX −
Dove wRetEye e hRetEye sono la larghezza e l'altezza correttamente scalate riferite alla sotto
area degli occhi. Il rettangolo che racchiude gli occhi sarà quindi definito come r(xEye, yEye,
wEye, hEye).
WRetMouth e hRetMouth sono la larghezza e l'altezza correttamente scalate riferite alla sotto
area della bocca. Il rettangolo che la racchiude sarà quindi definito come r(xMouth, yMouth,
wMouth, hMouth).
67
Sviluppo del Software
L'accuratezza del meccanismo di definizione dei riquadri in cui si trovano occhi e bocca è
minore quando l'area contenente il volto è ottenuta solamente dalla conoscenza di uno dei due
occhi. Di seguito (Fig. 2.8) sono riportate le immagini di occhi e bocca estratti dai volti
campione inseriti nel database.
Fig. 2.8: Sotto aree contenenti occhi e bocca ricavate dalle immagini
raffiguranti il mio volto inserite nel database.
Si è scelto di utilizzare la tecnica di estrazione delle feature SIFT poiché restituisce una
rappresentazione locale del volto sotto forma di keypoint. Ogni keypoint rappresenta un punto
caratteristico dell'immagine presa in considerazione, estrapolando il contenuto informativo e
svincolandolo dalla posizione nel volto. Questo garantisce che, anche se il volto viene
acquisito in condizioni di posa differenti da quelle dell'apprendimento, il descrittore del
keypoint risulta confrontabile con i descrittori ottenuti dalle immagini del database.
Invece, tecniche come PCA o l'approccio ibrido visto nel capitolo precedente considerano
l'immagine in un contesto generale o segmentandola in più parti per fornire una descrizione
globale e locale. Il descrittore del keypoint dà una rappresentazione locale del punto, che
viene completamente svincolato dalla posizione che assume all'interno del volto. Si riduce il
problema ad un confronto tra punti in uno spazio N-dimensionale dove N è la dimensione del
vettore del descrittore, cioè 128. Dunque in presenza di rotazione, cambi di posa e di
espressioni del volto la tecnica SIFT dovrebbe garantire un miglior funzionamento rispetto
alle tecniche precedentemente menzionate.
Invece rispetto ad una tecnica come EBGM, che si basa sull'estrazione di fiducial point e sulla
costruzione di grafi, la tecnica di estrazione SIFT tralascia la componente relativa al
posizionamento dei keypoint. I fiducial point sono posizionati in punti specifici come angoli
della bocca e degli occhi, mentre i keypoint sono dei punti caratteristici estratti dalla
68
Sviluppo del Software
rappresentazione del volto, cioè dei punti stabili a rotazioni e scala che sono significativi per
l'immagine che rappresenta il volto.
Si sposta l'attenzione da punti caratteristici del volto a punti caratteristici dell'immagine che
rappresenta il volto. La conseguenza di questo cambio di focus sta nella necessità di
aumentare il più possibile le condizioni e le pose delle immagini che sono associate a un
soggetto nel database.
Inoltre il fatto che SIFT tralascia la componente morfologica del volto, cioè il grafo che
descrive la distanza tra i fiducial point, comporta una minor dipendenza dall'identificazione
della posa.
Inoltre SIFT dovrebbe garantire una maggiore tolleranza alla presenza di mascheramenti
parziali del volto. L'identificazione dell'individuo può avvenire anche in condizioni di volti
parziali.
A questa tecnica di estrazione delle feature è stato affiancato l'algoritmo di machine learning
SVM per poter apprendere dai volti contenuti nel database i descrittori dei keypoint
rappresentativi dei soggetti. Tali informazioni, correttamente codificate dall'algoritmo,
consentono di classificare un nuovo volto.
La scelta è caduta su tale tecnica poiché è un algoritmo di tipo multiclasse ovvero in grado di
distinguere tra un numero finito N di classi. Altri algoritmi ugualmente validi sono stati
scartati poiché di tipo binario. Inoltre tale metodologia è molto utilizzata con buon successo
affiancata a PCA dove i vettori che rappresentano un soggetto possono avere grandi
dimensioni.
In aggiunta, l'utilizzo di una funzione di kernel adeguata, nel nostro caso si è scelto RBF,
consente di rendere linearmente separabili classi che nella realtà non lo sarebbero.
69
Testing
Capitolo3 - Testing
In questo capitolo verranno svolti alcuni test per verificare l'efficienza e il funzionamento del
sistema nel suo complesso. Verrà valutato come configurare i parametri al fine di ottenere le
migliori prestazioni. Si porrà molta attenzione alla velocità del sistema e si valuterà quanto è
incisivo ogni passo sul tempo complessivo di elaborazione. Tali test serviranno ad evidenziare
dove lavorare per migliorare i tempi di risposta.
Inoltre si verificheranno nello specifico le prestazioni dell'algoritmo di classificazione SVM.
Tale test verrà svolto sull'ORL database.
3.1 Sistema e risorse
Il sistema che verrà utilizzato per eseguire i test è
basato su processore Intel Core 2 Duo T7250 con
frequenza di 2 Ghz, 2 GB di ram e sistema
operativo Windows Vista 32 bit. Come ambiente di
sviluppo si è scelto Visual C++ 2010 Express.
Per acquisizione video sono state utilizzate due
differenti webcam:
•
Toshiba PX134xE-1CAM in grado di
acquisire 30 frame per secondo;
•
HP
Pavilion
WebCam
integrata
sul
notebook della serie dv6000.
Le due webcam differiscono per qualità di
rappresentazione del colore e per lunghezza focale.
La webcam integrata nel pc offre un angolo di
ripresa più ampio. Le differenze tra le due webcam
Fig. 3.1: Confronto tra fotogrammi
acquisiti con webcam differenti. (a)
Nonostante il punto di ripresa sia lo stesso, la frame acquisito con webcam Hp, (b)
frame acquisito con webcam Toshiba
differenza di angolo è molto evidente, basta
sono visibili nella figura qui a fianco (Fig. 3.1).
70
Testing
prendere come riferimento il quadro che compare sullo sfondo di entrambe le immagini. La
webcam Toshiba ci consentirà dunque di allontanarci maggiormente dal punto di ripresa
mantenendo una dimensione del volto tale da consentire il riconoscimento della sua presenza.
Possiamo anche notare una diversa acquisizione del colore, in quanto i colori della webcam
Toshiba appaiono più sbiaditi. Questa differenza potrebbe influenzare la fase di skinsegmentation.
Per poter garantire la ripetibilità dei test al variare dei parametri si è deciso di acquisire e
salvare più filmati con entrambe le webcam. I file sono memorizzati in formato mpg alla
risoluzione di 640x480 pixel ed a 25 frame per secondo.
Il software in realtà è pensato anche per acquisire e analizzare il video, non solo su file
precedentemente registrati, ma su flussi prelevati in tempo reale dalla webcam.
Per i test vengono presi in considerazione 3 semplici video con le seguenti caratteristiche:
•
video 1: acquisito con webcam Hp. Il volto è sempre in primo piano con poche
rotazioni del capo. E' presente una fonte di luce alle spalle. Numero totale di frame
407;
•
video 2: acquisito con webcam Toshiba in ambiente con sfondo regolare.
L'illuminazione proviene da lato rispetto al volto, che viene ripreso con espressioni
facciali differenti, con rotazioni del capo e a diverse distanze dal punto di ripresa.
Numero totale di frame 1364;
•
video 3: acquisito con webcam Hp. Le condizioni di ripresa sono le medesime del
video 2. Numero totale di frame 1311;
•
video 4: acquisito con fotocamera Canon SX100 IS. Le condizioni di ripresa sono
analoghe a quelle del video 2 e 3. Numero totale di frame 2300.
Il video 4 è stato inserito per valutare il comportamento del software quando si utilizzano dei
video provenienti da altre fonti diverse da webcam. É evidente che l'uso di tale strumento di
acquisizione comporta un'analisi offline del video.
3.2 Valutazione Face Detection su Video
Il comportamento del face detection verrà valutato sui 4 video descritti in precedenza. Tre di
questi sono stati girati in condizioni simili e con identico punto di ripresa, ma con tre
71
Testing
hardware di acquisizione differenti.
Il confronto tra questi 3 video ci consentirà di valutare l'influenza del sistema di acquisizione,
in particolare sulla procedura di skin-segmentation. Questo perché tale metodologia fa uso
della componente relativa al colore per identificare le aree di ricerca.
In tutti i frame del video compare il mio volto dunque si può definire la percentuale di volti
correttamente individuati semplicemente facendo il rapporto tra le volte che viene identificato
il volto e il numero totale di frame. Va però tenuto in considerazione che il sistema non è in
grado di riconoscere gli elementi del volto quando questo è parzialmente o completamente di
profilo.
Oltre alla percentuale di volti individuati su tutti i frame del video si verificheranno quanti di
questi sono individuati con uno, due o tutti e tre gli elementi del viso. Un volto identificato
con tutti e tre gli elementi dà una maggiore certezza dell'area selezionata.
Nel capitolo precedente inoltre è stata calcolata la dimensione minima teorica di un volto.
Poiché questa è solo teorica è necessario verificarla. Questo perché occorre valutare le
dimensioni minime delle aree identificate con la skin-segmentation da scartare.
Fig. 3.2: Fotogramma estratto dal video 4 rappresentante l'area
di minori dimensioni che contiene un volto 50x52 pixel.
Utilizzando il video 4 come input dell'algoritmo, poiché in questo video il soggetto si
allontana maggiormente dal punto di ripresa, si è registrata l'immagine la cui area contenente
il volto è minima. Questa è riportata nella figura precedente (Fig. 3.2), è di circa 50x52 pixel,
di molto inferiore rispetto a quella minima teorica calcolata in precedenza. Questo significa
72
Testing
che le sotto aree da scartare con la skin-segmentation devono essere inferiori alla dimensione
di 40x40 pixel circa.
Sempre prendendo in considerazione i video,
in particolare il video 4, è possibile valutare
come
influisce
la
rotazione
del
volto.
Nell'immagine qui a lato (Fig. 3.3) è possibile
vedere il volto catturato sia in posizione
centrale che completamente di profilo, sia
destro che sinistro, nonostante nei frame vi è
quasi sempre un'identificazione corretta del
soggetto. Notiamo che l'area bianca che
delimita la parte del frame che deve essere
usata in fase di identificazione è estremamente
precisa quando il volto è frontale rispetto alla
telecamera o con una lieve rotazione. Mentre
peggiora notevolmente quando è di profilo.
Un altro aspetto che influisce sull'area che
racchiude il volto è l'identificazione di
entrambi gli occhi. Infatti, in tutti i frame in
cui viene identificato solamente un occhio, il
riquadro è calcolato in maniera errata.
Fig. 3.3: Parte di frame estratti dal video 4
Tale problema era prevedibile poiché le che raffigurano diverse posizioni del
volto.
formule di calcolo sono basate sulla
conoscenza della distanza tra gli occhi. Per
poter risolvere questo problema sarebbe necessario introdurre la ricerca di altri elementi
caratteristici come orecchie e naso.
Si potrebbe anche operare una modifica all'albero di ricerca, consentirebbe di identificare in
maniera più accurata la posa del soggetto ma al contempo determinerebbe un deterioramento
delle prestazioni complessive del sistema.
Finché il volto rimane posizionato frontalmente o comunque entrambi gli occhi sono
correttamente identificabili l'area viene estratta in maniera precisa.
73
Testing
Un altro parametro importante da prendere in
considerazione è l'influenza del colore sulla
procedura di skin-segmentation. Nella figura di
lato (Fig. 3.4) sono presenti dei fotogrammi
tratti da tre video girati nello stesso ambiente
con analoga illuminazione ma con sistemi di
acquisizione differenti. Le skin-map prodotte,
immagini in bianco e nero, sono molto diverse.
La prima coppia di immagini in alto è tratta dal
video 2, e la skin-map ottenuta da tale
fotogramma è sicuramente la migliore.
Invece nelle altre due immagini tratte dal video
3 e dal video 4 la skin-map prodotta appare
molto più confusa assegnando la classificazione
come colore della pelle a delle parti di sfondo
che in realtà sono solamente parete.
Fig. 3.4: Fotogrammi tratti dai video 2, 3
e 4. Si noti come varia la skin-map al
variare della sistema di acquisizione.
Quando la skin-map è confusa le sotto aree da
investigare alla ricerca di volti potrebbero aumentare determinando di conseguenza un
decadimento delle prestazioni del sistema.
Purtroppo ogni sistema di acquisizione ha una diversa sensibilità al colore e una differente
interpretazione delle condizioni luminose dell'ambiente. Per ottimizzare quindi il processo di
skin-segmentation potrebbe essere utile tarare le soglie di classificazione della classe pelle in
base al sistema di acquisizione che si utilizzerà.
L'ultimo aspetto che andiamo ad indagare è la frequenza di identificazione del volto sui video.
La tabella seguente riporta i dati estratti dall'analisi di ogni video. I dati riportati sono il
numero totale di volti rintracciati, il rapporto tra totale volti trovati e frame e il numero di
volti identificati con la presenza di 1, 2 o 3 componenti caratteristici del volto.
74
Testing
Totale volti identificati
Percentuale volti identificati
rispetto al numero di frame
Un elemento identificato
Due elementi identificati
Tre elementi identificati
Video 1
407
Video 2
1297
Video 3
1101
Video 4
2177
100,00%
95,09%
83,98%
94,65%
0
12
395
188
941
168
611
344
146
368
290
1519
Tabella 3.1: Sono riportati il numero di volte che è stato estratto un volto dai
diversi video e la percentuale in riferimento al numero totale di frame del
video.
Possiamo vedere che nel video 1, quello in cui il volto rimane frontale per la maggior parte
del tempo, il volto viene identificato in ogni frame. Nella maggioranza dei casi vengono
individuati entrambi gli occhi e la bocca. Negli altri video la percentuale di volti estratti
rispetto al numero di frame rimane comunque molto alta. Nel video 3 si riscontra la
percentuale più bassa perché la parte sinistra del volto risulta ombreggiata per quasi tutto il
filamto. Tale situazione di illuminazione giustifica anche il basso valore legato
all'identificazione del volto con tutti e tre gli elementi.
La perdita di identificazione del volto è principalmente dovuta alla posizione di profilo o
all'eccessivo allontanamento dal punto di ripresa.
Nel complesso il sistema di face detection si comporta conformemente alle aspettative in
quanto riconosce in maniera efficiente i volti frontali. In alcuni casi riesce a riconoscere anche
volti parzialmente di profilo.
3.3 Valutazione Face Recognition su Database
La valutazione della procedura di face recognition viene eseguita su ORL database con
l'aggiunta del mio volto. Analogamente ai risultati riportati nel capitolo 1, in riferimento
all'uso della tecnica SIFT abbinata a SVM [13], si utilizzerà un numero k di voti inferiore a 10
per ogni individuo presente nel database. Il valore k verrà fatto variare da un minimo di 2 ad
un massimo di 9.
A differenza dell'algoritmo adottato in fase di face recognition presentato nel capitolo 2,
l'implementazione utilizzata per svolgere questo tipo di test attribuisce a tutti i punti estratti lo
stesso peso.
Verranno valutati diversi parametri:
75
Testing
•
percentuale di riconoscimenti corretti su tutti i volti del database;
numero volti correttamente riconosciuti
41∗10
•
percentuale di riconoscimenti corretti su tutto il database tranne i volti di
apprendimento;
numero volti correttamente riconosciuti
41∗(10−k )
•
percentuale di classificazioni errate su tutti i volti del database;
numero volti erroneamente classificati
41∗10
•
percentuale di classificazioni errate su tutto il database tranne i volti di apprendimento;
numero volti erroneamente classificati
41∗(10−k )
•
percentuale di classificazioni unknown su tutti i volti del database;
numero volti classificati come sconosciuti
41∗10
•
percentuale di classificazioni unknown su tutto il database tranne i volti di
apprendimento;
numero volti classificati come sconosciuti
41∗10
Le immagini non usate per l'apprendimento decrescono all'aumentare di k. Quando k sarà
uguale a 9 si avranno solamente 42 immagini sconosciute.
Oltre alla variazione del numero di volti per l'apprendimento, si analizza il comportamento del
face recognition al variare della soglia minima di keypoint assegnati ad un soggetto per la
corretta identificazione. Ciò ci consente di valutare i limiti minimi e massimi di tale valore e
di scegliere quale è quello più adeguato in base alla sensibilità che vogliamo ottenere.
Il grafico seguente (Fig. 3.5) riporta la percentuale di corrette identificazioni al variare dei due
parametri presi in considerazione, sono state utilizzate tutte le immagini del database che
includono anche quelle di apprendimento. Possiamo vedere che, al crescere del numero di
volti per soggetto utilizzati per l'apprendimento, si ottengono risultati migliori. Inoltre
l'aumentare del valore di soglia fa diminuire il tasso di riconoscimento poiché un maggior
numero di individui viene classificato come sconosciuto.
76
Testing
100,00%
90,00%
80,00%
70,00%
60,00%
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,14
0,2
0,3
1
2
3
4
5
6
7
8
9
Fig. 3.5: Grafico riferito alla percentuale di riconoscimenti corretti
su tutti i volti del database.
Nel grafico seguente (Fig. 3.6) invece è rappresentata la percentuale di successi solamente
sulle immagini che sono state escluse per l'apprendimento. Sostanzialmente l'andamento è
analogo a quello visto in precedenza. Ovviamente va tenuto in considerazione che
all'aumentare delle immagini usate per l'apprendimento si riduce il numero di quelle
disponibili per la verifica. Nel caso di 9 immagini usate si ha che solamente 41 sono quelle
che risultano ignote. Questo motiva l'elevata percentuale di successo in tale caso.
100,00%
90,00%
80,00%
70,00%
60,00%
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,14
0,2
0,3
1
2
3
4
5
6
7
8
9
Fig. 3.6: Grafico riferito alla percentuale di riconoscimenti corretti
su tutto il database tranne i volti di apprendimento.
Nel grafico seguente (Fig. 3.7) sono rappresentate le percentuali di individui classificati come
77
Testing
sconosciuti al variare dei due parametri presi in considerazione. Si può vedere che al crescere
del valore di soglia c'è un corrispettivo aumento degli individui che vengono scartati e dunque
classificati come sconosciuti. Questo avviene in particolar modo quando il numero di
immagini per soggetto è basso. Infatti in questo caso i keypoint che rappresentano un
individuo sono in numero minore con la conseguenza di non garantire un corretto
riconoscimento di nuovi volti.
100,00%
80,00%
0
0,14
0,2
0,3
60,00%
40,00%
20,00%
0,00%
1
2
3
4
5
6
7
8
9
Fig. 3.7: Grafico riferito alla percentuale di classificazioni
unknown su tutti i volti del database.
Nel grafico seguente (Fig. 3.8) è raffigurata la percentuale di individui etichettati come
sconosciuti analizzando tutte le immagini tranne quelle usate per l'apprendimento.
100,00%
80,00%
0
0,14
0,2
0,3
60,00%
40,00%
20,00%
0,00%
1
2
3
4
5
6
7
8
9
Fig. 3.8: Grafico riferito alla percentuale di classificazioni
unknown su tutti i volti del database tranne quelli usati per
l'apprendimento.
Vediamo che sostanzialmente tale percentuale si tiene leggermente al di sopra di quelle
78
Testing
ottenute su tutte le immagini del database. Questo è un comportamento atteso poiché si tratta
dell'analisi di volti sconosciuti per l'algoritmo di apprendimento. Al variare del valore di
soglia si osserva un progressivo aumento della percentuale.
In questo grafico (Fig. 3.9) è rappresentata la percentuale di classificazioni errate su tutte le
immagini del database. Come possiamo vedere il crescere del numero di immagini usate
determina un abbassamento della percentuale.
100,00%
90,00%
80,00%
70,00%
60,00%
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,14
0,2
0,3
1
2
3
4
5
6
7
8
9
Fig. 3.9: Grafico riferito alla percentuale di classificazioni errate su
tutto il database.
Questo grafico (Fig. 3.10) rappresenta la percentuale di errori di classificazione sulle
immagini non usate per l'apprendimento. Come possiamo vedere tale errore decresce
all'aumentare di volti utilizzati per soggetto. Inoltre l'aumento del valore di soglia determina
un passaggio da volti erroneamente classificati a volti sconosciuti.
79
Testing
100,00%
90,00%
80,00%
70,00%
60,00%
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,14
0,2
0,3
1
2
3
4
5
6
7
8
9
Fig. 3.10: Grafico riferito alla percentuale di classificazioni errate su
tutto il database tranne i volti di apprendimento.
Nei grafici finora analizzati abbiamo preso in considerazione solamente 4 livelli di soglia. Per
soglie più elevate di 0,3 si verifica un aumento dei soggetti classificati come sconosciuti
anche se nella realtà sarebbero stati correttamente classificati. Il valore di soglia ottimale che
si può dedurre è tra 0,15 e 0,20. Questo perché si verifica il migliore equilibrio tra individui
correttamente e erroneamente classificati che vengono etichettati come sconosciuti.
Il numero di immagini per soggetto che garantisce dei risultati accettabili deve essere
superiore o uguale a 6. Di seguito sono riportate in tabella le percentuali di corretta
identificazione nel caso del database completo o nel caso di esclusione delle immagini usate
per l'apprendimento. La soglia è fissata al valore 0,14.
Database completo
Database privo delle
immagini di apprendimento
5
94,39%
Numero di volti per soggetto
6
7
8
95,85%
97,56%
98,54%
90,24%
93,29%
93,50%
98,78%
9
99,76%
100,00%
Tabella 3.2: Tabella riassuntiva che contiene le percentuali di corretta identificazione con
valore di soglia fissato a 0,14.
80
Testing
3.4 Valutazione Face Recognition su video
I video vengono utilizzati per verificare il corretto riconoscimento del soggetto estratto dalla
procedura di face detection. Tutti i volti vengono analizzati e etichettati con l'identificativo
dell'individuo a cui assomigliano maggiormente.
Poiché nei video compare solamente il mio volto è molto semplice ottenere le informazioni
relative alla corretta identificazione. Inoltre è stato già ricavato in precedenza il numero di
volti estratti. Questo dato ci servirà per calcolare i valori percentuali.
Le informazioni che possiamo ottenere sono il tasso di corretti riconoscimenti come il
rapporto tra numero di volti correttamente identificati e numero totale di volti estratti.
CR=
numero volti classificati correttamente
.
numero di volti estratti dal video
La percentuale di errata classificazione è ottenuta come rapporto tra volti classificati come
altro soggetto più classificati come sconosciuti e numero totale di volti estratti.
ER=
numero volti classificati errati+numero di volti classificati sconosciuti
.
numero di volti estratti dal video
La percentuale di classificazione come sconosciuti è calcolata come rapporto tra volti
etichettati sconosciuti e volti estratti dal video.
UR=
numero di volti classificati sconosciuti
.
numero di volti estratti dal video
Tutti questi indicatori potranno essere calcolati al variare di due parametri:
•
il valore di soglia;
•
il valore del punteggio per i keypoint localizzati in aree limitrofe a bocca e occhi;
Nel grafico seguente (Fig. 3.11) sono riportate le percentuali di corretta identificazione del
soggetto estratto dai 4 video presi in considerazione. I parametri che vengono variati sono
due: il valore di soglia, che viene valutato per tre differenti valori ( 0; 0,15; 0,20 ) e il
punteggio da assegnare ai keypoint che sono localizzati in posizioni limitrofe agli occhi e alla
bocca.
Come possiamo vedere, i risultati sono molto differenti tra loro. Il primo video, quello più
semplice da analizzare poiché il volto rimane quasi sempre in posizione frontale, dà ottimi
risultati al variare dei due parametri. In particolare utilizzando il valore di soglia 0,15 si
ottiene il migliore risultato indipendentemente dall'altro parametro.
81
Testing
Il parametro che attribuisce ai keypoint un maggior peso ha una particolare influenza sugli atri
3 video determinando in molti casi un miglioramento dell'identificazione soprattutto quando
si sceglie il valore di soglia di 0,15.
100,00%
90,00%
80,00%
70,00%
60,00%
1
2
3
4
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,15 0,2
Video 1
0
0,15 0,2
Video 2
0
0,15 0,2
Video 3
0
0,15 0,2
Video 4
Fig. 3.11: Percentuali di identificazioni ottenute al variare dei livelli di
soglia e al punteggio da attribuire ai keypoint localizzati nei pressi degli
occhi e della bocca.
Il video 4 è quello su cui si riscontra la peggiore prestazione. La sorgente video in questo caso
è differente e la qualità delle immagini risulta essere molto diversa da quella ottenuta dalle
due webcam. Abbiamo visto già in fase di skin-segmentation che le sotto aree di ricerca e la
skin-map ottenuta con tale video sono nettamente inferiori. Inoltre in molti fotogrammi il
volto compare in posizione di profilo e questo pregiudica spesso la corretta identificazione.
Nel grafico che segue (Fig. 3.12) viene riportato il numero di volti etichettati come
sconosciuti al variare dei due parametri. Come possiamo vedere, quando la soglia è uguale a 0
non si hanno classificazioni come sconosciuti mentre all'aumentare di tale valore cresce la
quantità di volti scartati. Nel caso del video 4 vediamo come l'aumentare del valore di soglia
determina un gran numero di individui sconosciuti che influiscono negativamente sul tasso di
corretta identificazione.
82
Testing
100,00%
90,00%
80,00%
70,00%
60,00%
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
1
2
3
4
0
0,15 0,2
Video 1
0
0,15 0,2
Video 2
0
0,15 0,2
Video 3
0
0,15 0,2
Video 4
Fig. 3.12: Percentuale di volti identificati come sconosciuti al variare della
soglia e del peso dei keypoint localizzati vicino a occhi e bocca.
L'aumento del peso dei punti localizzati in posizione significativa del volto determina una
minor quantità di individui sconosciuti. Questo sta ad indicare che molti keypoint analizzati
ricadono nelle sotto aree limitrofe ad occhi e bocca.
Il seguente grafico (Fig. 3.13) riporta l'errore di classificazione inteso come totale dei volti
riconosciuti in maniera errata e quelli etichettati come sconosciuti. Si tratta del grafico
perfettamente speculare a quello rappresentato in figura 3.11.
100,00%
90,00%
80,00%
70,00%
60,00%
1
2
3
4
50,00%
40,00%
30,00%
20,00%
10,00%
0,00%
0
0,15 0,2
Video 1
0
0,15 0,2
Video 2
0 0,15 0,2
Video 3
0 0,15 0,2
Video 4
Fig. 3.13: Percentuale di volti identificati come sconosciuti o classificati in
maniera errata al variare della soglia e del peso dei keypoint localizzati
vicino a occhi e bocca.
83
Testing
I grafici riportati in precedenza evidenziano un buon comportamento generale del sistema di
identificazione, soprattutto quando il volto è frontale rispetto al punto di ripresa. L'altro dato
che emerge è l'importanza della localizzazione dei keypoint estratti, infatti aumentando il peso
di quelli individuati in posizioni sensibili vicino a occhi e bocca, si ottengono generalmente
migliori risultati.
Inoltre, come già sostenuto, il miglior compromesso per quanto concerne il valore di soglia è
0,15.
In questi test è sempre stato utilizzato l'apprendimento ottenuto descrivendo ogni soggetto del
database con 9 immagini di volti. Si è riscontrato che diminuendo il numero di volti per
soggetto si riduce la percentuale di corretti riconoscimenti.
3.5 Prestazioni del sistema nel complesso
I video vengono utilizzati per verificare le prestazioni in termini di numero di frame analizzati
per secondo dal software. Maggiore è tale numero, minori sono le prestazioni. Si valuterà tale
parametro al variare della risoluzione di input dei video. Per fare questo i video verranno
scalati ad una risoluzione di 340x240 pixel.
Inoltre verrà valutato quanto tempo in media si impiega per ogni fase della ricerca e
dell'identificazione. Si suddivide l'algoritmo in 3 parti fondamentali:
•
la skin-segmentation, che racchiude tutte le operazioni eseguite in scala;
•
l'algoritmo
Viola-Jones,
che
comprende
l'identificazione
delle
componenti
fondamentali del volto;
•
la face recognition, che raggruppa tutte le operazioni orientate all'identificazione del
soggetto.
Di seguito è riportata una tabella con i tempi di elaborazione media delle tre fasi
precedentemente descritte per i 4 video presi in considerazione, sia alla risoluzione originaria
di 640x480 pixel che a quella ridotta di 320x240 pixel. Si precisa che i dati riportati riferiti ai
tempi di esecuzione delle tre fasi sono espressi in millisecondi.
84
Testing
Video elaborati alla risoluzione di 640x480 pixel
Skin-Segmentation Viola-Jones
(ms)
(ms)
Video 1
5,1
104,9
Video 2
5,0
115,0
Video 3
4,6
106,4
Video 4
4,6
456,4
Face Detection
(ms)
150,0
249,0
287,0
317,0
Frame per
Secondo
3,6
2,9
2,8
2,3
Keypoint medi
per volto
15,5
33,0
37,1
42,0
Video elaborati alla risoluzione di 320x240 pixel
Skin-Segmentation Viola-Jones
(ms)
(ms)
Video 1
1,4
22,0
Video 2
1,3
23,7
Video 3
1,3
23,5
Video 4
1,4
41,8
Face Detection
(ms)
149,6
315,0
367,2
544,8
Frame per
Secondo
5,2
5,6
7,8
12,6
Keypoint medi
per volto
17,8
39,8
43,1
31,0
Fig. 3.14: Test eseguiti per valutare le prestazioni del sistema.
Dai dati emerge che la fase di skin-segmentation influisce in maniera limitata sul tempo
complessivo di elaborazione, invece molto più pesanti risultano essere le altre due fasi.
Mentre l'uso dell'algoritmo Viola-Jones, come è ovvio, è influenzato positivamente
dall'abbassamento della risoluzione del video, la fase di face recognition impiega sempre la
stessa quantità di tempo.
Abbassare la risoluzione dunque crea un incremento delle prestazioni in termini di frame
analizzati per secondo ma si ripercuote negativamente sulla capacità di estrarre volti. Infatti la
minor risoluzione comporta una riduzione della dimensione del volto, che in alcuni casi non
rientra nella minima dimensione rintracciabile.
La quantità di tempo impiegata dal face recognition non subisce sostanziali variazioni quando
si modifica la risoluzione poiché il numero di keypoint estratti è stabile al mutare della scala
dell'immagine. Questa proprietà dei keypoint determina una piccola riduzione della loro
quantità identificata in un volto ma non sufficiente da influenzare le prestazioni del sistema. I
dati riportati contrastano con quanto affermato poiché il numero di volti estratti, con la
diminuzione della dimensione del frame, è minore e dunque la quantità media dei keypoint
risente del fatto che vengono selezionati solo quelli di maggiore dimensione.
Il video 4 impiega un maggior tempo rispetto agli altri in fase di esecuzione dell'algoritmo di
Viola-Jones, ciò accade perché parte dello sfondo viene erroneamente classificato come
appartenente alla classe pelle. Ne risulta che le sotto aree da analizzare alla ricerca di un
potenziale volto sono maggiori.
85
Testing
Per incrementare le prestazioni del software in termini di aumento del numero di frame
analizzati per secondo, è stata introdotta una procedura che utilizza informazioni del frame
precedente, che è valida solamente per i video pre registrati e non catturati in real-time dalla
webcam.
Tale procedura consiste nell'analizzare una sotto area individuata in fase di skin-segmentation
solamente quando questa si discosta sensibilmente da quella ottenuta nel frame precedente
oppure dopo aver tralasciato un numero N di frame. Alla sotto area che viene scartata
dall'analisi si assegna il riquadro del volto precedentemente identificato con la corrispettiva
identità del soggetto. Tale tecnica risulta utile quando il volto dell'individuo permane per
lungo tempo nella stessa posizione e con la stessa posa, ma è inutile in un contesto dinamico.
Per valutare se due riquadri sono compatibili tra loro si calcola la distanza euclidea tra i loro
baricentri e se questa è inferiore ad un determinato valore significa che la corrispondenza è
verificata.
Per testare il funzionamento e l'influenza sulle prestazioni si eseguirà il software impostando
il parametro N al valore 5 e definendo la massima distanza tra i baricentri assegnando il valore
di 20 pixel. I risultati così ottenuti sono i seguenti:
Video 1
Video 2
Video 3
Video 4
Percentuale
corretta
identificazione
97,05%
94,99%
81,35%
50,16%
Numero totale di Numero effettivo
riquadri da
dei riquadri
analizzare
analizzati
764
427
2202
1243
2462
1489
8583
7050
Frame per
Secondo
10,06
7,02
7,17
3,85
Tabella 3.3: Test eseguiti utilizzando il meccanismo di riduzione del numero
di riquadri da analizzare. Con parametro di soglia impostato a 0,0 e peso dei
keyipoint, localizzati nelle aree vicino agli occhi e alla bocca, pari a 2.
La riduzione dei riquadri da analizzare è sensibile quando il volto è in posa stabile. Infatti
come possiamo vedere nei primi tre video se ne esamina solamente il 50% circa, mentre nel
video 4 la riduzione è di poco inferiore al 20%. Questo risultato è influenzato da come il
sistema di acquisizione codifica il colore del frame. Infatti in questo ultimo video sono
presenti molti riquadri classificati come colore della pelle che in realtà sono delle porzioni di
sfondo.
Il frame rate risultante è nettamente superiore a quello che si otterrebbe se non si usasse il
86
Testing
meccanismo di riduzione. E le percentuali di corretta identificazione rimangono
sostanzialmente uguali.
87
Conclusione
Conclusione
L'estrazione e l'identificazione di volti sono materie molto complesse da trattare poiché la loro
applicazione è influenzata in maniera marcata dalle condizioni ambientali in cui vengono
utilizzate. L'ambiente che circonda un individuo rappresenta nella maggior parte dei casi la
principale fonte di malfunzionamento di software pensati per svolgere tali operazioni. Se ci
trovassimo in condizioni ideali saremmo in grado di ridurre tale tipologia di disturbo.
L'approccio da me proposto è pensato per suddividere le operazioni di identificazione e
ricerca dei volti in piccoli step. Ogni fase è ragionata per rendere più efficiente la
computazione delle successive filtrando e aggregando al meglio le informazioni che vengono
usate.
La suddivisione in piccoli step garantisce una maggiore versatilità consentendo di eliminare
potenziali errori di classificazione, in particolare nelle fasi di ricerca delle componenti
fondamentali del volto. Questo garantisce una maggiore efficacia del prodotto finale.
In fase di testing si è verificato che le prestazioni del software, per quanto riguarda la
precisione di identificazione ed estrazione, sono valide e consentono di ottenere dei buoni
risultati sia per quanto riguarda la verifica su database sia per ciò che concerne la verifica su
video. La percentuale di corretta identificazione del volto si è sempre tenuta a livelli
accettabili.
L'uso di video acquisiti da diverse sorgenti ci ha consentito di valutare la validità del software
per quanto concerne la variazione del sistema di ripresa. Nonostante vi siano nette differenze
in fase di produzione della skin-map, tra i tre video girati nelle stesse condizioni, ma variando
il sistema di acquisizione, il risultato della classificazione è stato sempre accettabile. Se
dovessimo scegliere una delle tre sorgenti sicuramente la webcam Toshiba garantisce, in quel
contesto, la produzione di una skin-map più accurata.
Il problema che più ha afflitto il software è stata la velocità di analisi del video. Purtroppo il
frame rate si è sempre mantenuto tra 2 e 4, nonostante in fase implementativa si sia
ottimizzato il processo di identificazione del volto parallelizzandolo. La scarsa velocità di
identificazione ne pregiudica un utilizzo real-time per il monitoraggio di ambienti.
Confrontando i tempi necessari per estrarre il volto e identificarlo, ci accorgiamo che, esclusa
la parte di skin-segmentation molto rapida, la fase di ricerca dei componenti del volto e quella
di identificazione impiegano tempi molto elevati. Il vero collo di bottiglia è rappresentato
88
Conclusione
dalla fase di identificazione. Il numero di keypoint che viene estratto da ogni volto deve essere
il più possibile ridotto poiché il suo incremento comporta un peggioramento delle prestazioni.
Per poter interpretare più situazioni possibili è necessario utilizzare un numero elevato di
immagini per ogni soggetto. Nei test si è verificato che già con 6 immagini per volto si
ottengono buoni risultati. All'applicazione pratica sui video si è così deciso di adottare 9
immagini per soggetto.
Inoltre, all'interno dei video, utilizzare le informazioni dei frame già analizzati, consente in
generale di aumentare la velocità complessiva del software. Tale applicazione è però efficiente
in un ristretto contesto poiché l'eccessivo dinamismo della scena vanificherebbe questo
meccanismo.
La metodologia utilizzata per l'identificazione e l'estrazione dei volti nel suo complesso
rimane valida e fornisce delle prestazioni apprezzabili.
A partire da tale base si potrebbe migliorare la prontezza di risposta provando ad utilizzare un
algoritmo di machine learning differente da SVM poiché anche se questo dà ottimi risultati di
identificazione risulta essere troppo pesante.
Inoltre potrebbe essere interessante attuare un meccanismo di riduzione dello spazio delle
feature ottenuto con SIFT, realizzabile con l'applicazione di tecniche come PCA e similari.
89
Bibliografia
Bibliografia
[1]
Ming-Hsuan Yang, David J. Kriegman, Narendra Ahuja, “Detecting Faces in Images: A
Survey” , Ieee Transactions on Pattern Analysis and Machine Intelligence, vol. 24, no. 1,
pp. 34-58, 2002.
[2]
Sanjay Kr. Singh, D. S. Chauhan, Mayank Vatsa, Richa Singh, “A Robust Skin Color
Based Face Detection Algorithm”, Tamkang Journal of Science and Engineering, vol. 6,
no. 4, pp. 227-234, 2003.
[3]
Paul Viola, Michael J. Jones, “Robust Real-Time Face Detection”, International Jurnal
of Computer Vision 57(2), pp. 137-154, 2004.
[4]
Son Lam Phung, Abdesselam Bouzerdoum, Douglas Chai, “Skin Segmentation Using
Color Pixel Classification: Analysis and Comparison”, Ieee Transactions on Pattern
Analysis and Machine Intelligence, vol. 27, no. 1, pp. 148-154, 2005.
[5]
Chai D., Ngan K.N., “Face segmentation using skin-color map in videophone
applications ”, Circuits and Systems for Video Technology, IEEE Transactions on ,
vol.9, no.4, pp.551-564, Jun 1999.
[6]
Kap-Ho Seo, Won Kim, Changmok Oh, Ju-Jang Lee , “Face detection and facial feature
extraction using color snake”, Industrial Electronics, 2002. ISIE 2002. Proceedings of
the 2002 IEEE International Symposium on , vol.2, pp. 457- 462, 2002.
[7]
Li Zou, Kamata, S., “Face detection in color images based on skin color models”,
TENCON 2010 - 2010 IEEE Region 10 Conference, pp.681-686, Nov. 2010.
[8]
Yao-Jiunn Chen, Yen-Chun Lin, “Simple Face-detection Algorithm Based on Minimum
Facial Features”, Industrial Electronics Society, 2007. IECON 2007. 33rd Annual
Conference of the IEEE, pp.455-460, Nov. 2007.
[9]
Constantine Papageorgiou, Tomaso Poggio, “A Trainable System for Object Detection”,
International Journal of Computer Vision 38(1), pp.15–33, 2000
[10] Lienhart R., Maydt J., “An extended set of Haar-like features for rapid object
detection”, Image Processing. 2002. Proceedings. 2002 International Conference on ,
90
Bibliografia
vol.1, pp. I-900- I-903, 2002
[11] Tong Liu, Sung-Hoon Kim, Hyon-Soo Lee, Hyung-Ho Kim, “Face Recognition base on a
New Design of Classifier with SIFT keypoint”, Intelligent Computing and Intelligent
Systems, 2009. ICIS 2009. IEEE International Conference on , pp 366 - 370 ,Nov. 2009
[12] Han Yanbin; Yin Jianqin; Li Jinping; , “Human Face Feature Extraction and Recognition
Base on SIFT” Computer Science and Computational Technology, 2008. ISCSCT '08.
International Symposium on , vol.1, no., pp.719-722, 20-22 Dec. 2008
[13] Lichun Zhang; Junwei Chen; Yue Lu; Wang, P.; , “Face Recognition Using Scale
Invariant Feature Transform and Support Vector Machine” Young Computer Scientists,
2008. ICYCS 2008. The 9th International Conference for , vol., no., pp.1766-1770, 1821 Nov. 2008
[14] D. Lowe, “Distinctive Image Features from Scale-Ivariant Keypoint” International
Journal of Computer Vision, vol. 60(2), pp 91 – 110, 2004
[15] Chowdhury, S.; Sing, J.K.; Basu, D.K.; Nasipuri, M.; , “A Hybrid Approach to Face
Recognition Using Generalized Two-Dimensional Fisher's Linear Discriminant
Method” Emerging Trends in Engineering and Technology (ICETET), 2010 3rd
International Conference on , pp.506-511, 19-21 Nov. 2010
[16] Belhumeur, P.N.; Hespanha, J.P.; Kriegman, D.J.; , “Eigenfaces vs. Fisherfaces:
recognition using class specific linear projection” Pattern Analysis and Machine
Intelligence, IEEE Transactions on , vol.19, no.7, pp.711-720, Jul 1997
[17] Xiaoyang Tan, Songcan Chen, Zhi-Hua Zhou, Fuyan Zhang, “Face recognition from a
single image per person: A survey” Pattern Recognition, vol. 39, no. 9, pp 1725-1745,
Sep. 2006
[18] Chowdhury, S.; Sing, J.K.; Basu, D.K.; Nasipuri, M.; , “Feature extraction by fusing
local and global discriminant features: An application to face recognition”
Computational
Intelligence
and
Computing
Research
(ICCIC),
2010
IEEE
International Conference on , vol., no., pp.1-4, 28-29 Dec. 2010
[19] Wiskott, L.; Fellous, J.-M.; Kuiger, N.; von der Malsburg, C.; , “Face recognition by
elastic bunch graph matching” Pattern Analysis and Machine Intelligence, IEEE
Transactions on , vol.19, no.7, pp.775-779, Jul 1997
91
Bibliografia
[20] Kshirsagar, V.P.; Baviskar, M.R.; Gaikwad, M.E.; , “Face recognition using Eigenfaces”
Computer Research and Development (ICCRD), 2011 3rd International Conference on ,
vol.2, no., pp.302-306, 11-13 March 2011
[21] Turk, M.A.; Pentland, A.P.; , “Face recognition using eigenfaces” Computer Vision and
Pattern Recognition, 1991. Proceedings CVPR '91., IEEE Computer Society
Conference on , vol., no., pp.586-591, 3-6 Jun 1991
[22] E. Martinelli,C. Di Natale, “Introduzione al trattamento Statistico dei Dati”
www.uniroma2.it/didattica/Sensori_ed_applic_2/deposito/lez5.pdf
[23] Richard O. Duda, Peter E. Hart, David G. Stork, “Pattern Classification”, Wiley, 2001
[24] Shigeo Abe, “Support Vector Machines for Pattern Classification”, Springer, 2005
[25] Steve R. Gunn, “Support Vector Machine for Classification and Regression”, 1998,
http://users.ecs.soton.ac.uk/srg/publications/pdf/SVM.pdf
[26] “Libreria OpenCV 2.3.1” Intel Corporation http://opencv.willowgarage.com/wiki/
[27] Shiqi Yu, “haarcascade lefteye and righteye” http://yushiqi.cn/research/eyedetection
[28] Vukadinovic, D.; Pantic, M.; , “Fully automatic facial feature point detection using
Gabor feature based boosted classifiers” Systems, Man and Cybernetics, 2005 IEEE
International Conference on , vol.2, pp. 1692- 1698, 10-12 Oct. 2005
92