1. UNIVERSITÀ DEGLI STUDI DI TRIESTE
FACOLTÀ DI INGEGNERIA
CORSO DI LAUREA SPECIALISTICO IN INGEGNERIA INFORMATICA
TESI DI LAUREA
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER
L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON
TECNICHE DI WEB MINING
Laureando: Relatore:
ANDREA DE LORENZO CHIAR.MO PROF ALBERTO BARTOLI
Correlatore:
ERIC MEDVET
ANNO ACCADEMICO 2008-2009

3. Ai miei nonni, ai miei genitori,
a mia sorella ed a Monica.
Grazie.

5. 1. INTRODUZIONE .................................................................................................................................. 2
2. DESCRIZIONE DEL SISTEMA.......................................................................................................... 4
3. ESTRAZIONE DEI NOMI. .................................................................................................................. 7
3.1. TERM EXTRACTOR .......................................................................................................................... 7
3.1.1. Yahoo! Term Extractor .............................................................................................................. 8
3.1.2. Zemanta ..................................................................................................................................... 8
3.2. RICERCA MAIUSCOLE ...................................................................................................................... 8
3.3. RICERCA PER LINGUAGGIO NATURALE. ........................................................................................... 9
3.4. AGGREGAZIONE .............................................................................................................................. 9
3.5. RISULTATI ..................................................................................................................................... 10
4. RICERCA IMMAGINI SU INTERNET ........................................................................................... 12
4.1. MOTORI DI RICERCA PER IMMAGINI ............................................................................................... 12
4.1.1. Google Immagini ..................................................................................................................... 12
4.1.2. Bing Immagini.......................................................................................................................... 13
4.1.3. Yahoo! Immagini...................................................................................................................... 13
5. INDIVIDUAZIONE DELLE FACCE................................................................................................ 15
5.1. OPENCV, ADABOOST E CLASSIFICATORI HAAR-LIKE ................................................................... 15
5.2. INDIVIDUAZIONE DELLE FACCE ..................................................................................................... 16
5.3. PRESTAZIONI ................................................................................................................................. 17
6. RETTIFICAZIONE FACCE .............................................................................................................. 18
6.1. POSIZIONAMENTO OCCHI ............................................................................................................... 18
6.2. TRASFORMAZIONI AFFINI .............................................................................................................. 19
6.3. RITAGLIO E RIDIMENSIONAMENTO ................................................................................................ 20
6.4. COMPENSAZIONE DELLA LUMINOSITÀ ........................................................................................... 20
7. ASSOCIAZIONE DEL NOME CON L’IMMAGINE...................................................................... 22
7.1. EIGENFACES .................................................................................................................................. 22
7.2. ANALISI DELLE COMPONENTI PRINCIPALI ...................................................................................... 23
7.3. LOCAL DENSITY SCORE ................................................................................................................ 24
7.3.1. Shared neighbors ..................................................................................................................... 25
7.3.2. Euclidea ................................................................................................................................... 27
7.3.3. Posizionamento motore di ricerca. .......................................................................................... 29
8. IMPLEMENTAZIONE DEL SISTEMA........................................................................................... 32
9. CONCLUSIONI ................................................................................................................................... 36

6. 1

7. 1. Introduzione
Uno dei campi di maggiore interesse per la ricerca informatica è da sempre quello della
computer vision, ovvero il tentativo di far emulare ad un calcolatore il funzionamento della
vista umana. In questo lavoro di tesi verrà presentata la progettazione e la realizzazione di
un sistema in grado di riconoscere le persone presenti in un’immagine quando questa è
associata ad un testo. Particolarità di questo sistema è la capacità di risolvere il problema
sfruttando l’enorme quantità di informazioni disperse in Internet ed accessibili attraverso i
motori di ricerca.
Il risultato finale è un software che, a partire da un testo ed un’immagine, restituisce una
lista di nomi che rappresentano le persone presenti nell’immagine e che sono citate nel
testo.
I risvolti applicativi di questo sistema sono molteplici e vanno dalla possibilità di realizzare
anomaly detection tra un testo ed un’immagine (ad esempio, un articolo di politica di
politica in cui l’immagine associata è stata sostituita in modo fraudolento con un’immagine
dai contenuti inappropriati), estensione delle capacità di indicizzazione automatica dei siti
web da parte dei motori di ricerca, fino alla automazione delle annotazioni (tagging) nelle
foto, caratteristica molto importante nelle applicazioni più recenti quali social network ed
affini.
La caratteristica distintiva di questo lavoro rispetto alla letteratura esistente consiste nella
natura dell’informazione utilizzata per risolvere il problema. Gli approcci esistenti si
basano su un dataset di conoscenze preventivamente acquisito, mentre in questo lavoro si
esplora la possibilità di attingere direttamente ad Internet attraverso i motori di ricerca,
estraendo dinamicamente la conoscenza necessaria in base alla specifica istanza del
problema da risolvere.
Per la realizzazione del progetto sono state seguiti i seguenti passaggi:
1. studio preliminare della fattibilità del progetto
2. analisi delle tecnologie esistenti
3. formulazione degli algoritmi di estrazione dei nomi e di riconoscimento facciale
4. test e valutazione delle prestazione degli algoritmi
5. implementazione del sistema finale
2

8. Le tecnologie impiegate in questo progetto sono la libreria di computer vision OpenCV1,
che permette l’elaborazione di immagini e il riconoscimento di caratteristiche proprie
dell’immagine o di una sua porzione, e la libreria di analisi del linguaggio naturale
OpenNLP2. Il progetto è stato realizzato in Java con l’aggiunta delle librerie
HttpConnection3 di Apache.
La validazione del sistema è stata svolta in due fasi. Nella prima ci si è soffermati sulla
verifica dell’associazione tra un nome ed una foto e, per la verifica delle prestazioni, si è
ricorso ad un dataset di coppie di nomi e immagini di personaggi famosi e di politici
scaricati da Wikipedia4. Ognuno di questi nomi è stato provato sia con l’immagine corretta
che con altre 2 immagine scelte a caso. La seconda parte invece ha coinvolto l’intero
sistema, quindi si è usato un dataset costruito con notizie scaricate dal sito di Repubblica5,
del New York Times6 e da Yahoo! Notizie7.
1
http://opencv.willowgarage.com/
2
http://opennlp.sourceforge.net/
3
http://hc.apache.org/
4
http://en.wikipedia.org/
5
http://www.repubblica.it/
6
http://www.nytimes.com/
7
http://it.notizie.yahoo.com/
3

9. 2. Descrizione del sistema
Il sistema qui descritto cerca di associare ad un’immagine, in maniera automatica, uno o
più nomi propri di persona trovati all’interno di un testo, dato assieme all’immagine, senza
quindi il bisogno dell’intervento umano. Questo automatismo sfrutta le potenzialità dei
motori di ricerca di immagini per costruirsi una base di conoscenza sufficiente per
distinguere, tra i vari nomi riconosciuti nel testo, quelli che effettivamente figura
nell’immagine proposta. Tutto ciò si articola in tre fasi principali: l’estrazione dei nomi di
persona dal testo dato, la ricerca di immagini che rappresentino queste persone su Internet
e la verifica che uno o più fra i nomi candidati sia appropriato per l’immagine data. Nella
figura 2.1 è possibile vedere quello che è l’obiettivo del progetto, ovvero, partendo da
un’immagine ed un testo, trovare i nomi delle persone citate nel testo e presenti
nell’immagine.
Figura 2.1 - Input e output del sistema
In particolare l’estrazione dei nomi viene effettuata tramite alcune proprietà del linguaggio
o della grammatica, quali la posizione dei possibili nomi, la loro vicinanza ad un verbo o la
proprietà di dover sempre iniziare con una lettera maiuscola. Trovati i nomi viene eseguita
una ricerca per ognuno di essi sui tre più importanti motori di ricerca di immagini, Google,
Bing e Yahoo!, vengono salvate le immagini e viene costruito un insieme di immagini per
ogni nome. Infine l’immagine di partenza viene confrontata con i vari insiemi e se il
confronto fornisce esito positivo, viene considerato come valido il nome usato per creare
l’insieme d’immagini. Il confronto si basa sull’identificazione, all’interno di un’immagine,
della porzione contenente il volto di una persona, che viene estratta ed elaborata per poter
essere confrontata con le altre immagini contenenti volti presenti nell’insieme ottenuto dai
motori di ricerca, opportunamente trattate per essere meglio confrontabili.
In altre parole, l'immagine di partenza I0 viene confrontata con insiemi di immagini IW0,
IW1, ...IWK estratti da web, ognuno dei quali è associato a una persona n0, n1, ..nK. Se il
confronto stabilisce che I0 "e' simile" all'insieme IWj, allora I0 è associata alla persona nj. La
4

10. definizione del criterio di confronto tra l'immagine di partenza e gli insiemi di immagini è
uno dei contributi innovativi di questa tesi. Sono stati definiti e sperimentati vari criteri di
confronto e vari criteri per la costruzione degli insiemi di immagini.
Dopo essere state trattate, queste porzioni d’immagine, vengono descritte come un vettore
e, con l’uso di algoritmi di clustering e anomaly detection, si controlla se i vettori ottenuti
dalle facce trovate nell’immagine da annotare siano sufficientemente vicini ai vettori delle
facce trovate nelle immagini scaricate da Internet.
Nella figura 2.2 è rappresentato lo schema generico del funzionamento del sistema. Dati
come input un testo ed un’immagine I0 si procede con l’individuazione dei nomi nel testo
e, per ognuno di questi nomi N, vengono cercate delle immagini su Internet tramite i
motori di ricerca. A questo punto le immagini scaricate vengono confrontate I0 con per
verificare la presenza del nome N in questa.
Figura 2.2 - Descrizione generica del sistema
La definizione dei criteri per l'estrazione dei nomi dal testo è uno dei contributi innovativi
di questa tesi. Sono stati definiti vari criteri, alcuni dei quali hanno fornito prestazioni
decisamente migliori di quelli proposti in letteratura.
Al momento della realizzazione di questo progetto esistono altre soluzioni in grado di
annotare un’immagine con i nomi delle persone presenti in essa. Nel 2006 M. Everingham,
J. Sivic e A. Zisserman hanno realizzato un software in grado di riconoscere le persone
presenti in un video, nel 2008 Akio Kitahara, Taichi Joutou e Keiji Yanai hanno realizzato
un sistema che, partendo da un ampio dataset di notizie ed immagini, fosse in grado di
annotare per ogni immagine le persone presenti in questa ma per i soli articoli in
giapponese e M. Guillaumin, T. Mensink, J. Verbeek e C. Schmid hanno proposto un più
efficiente dello stesso algoritmo. Tuttavia questi metodi si basano sull’uso di un dataset
preesistente e non sulla possibilità di reperire le conoscenze sulle persone tramite Internet.
5

11. Come già rilevato, l'esplorazione della possibilità di costruire dinamicamente un dataset,
distillando opportunamente l'enorme quantità di informazione già disponibile su Internet, è
uno degli aspetti essenziali di questa tesi.
6

12. 3. Estrazione dei nomi.
La prima componente del sistema è il blocco di estrazione dei nomi. Questo riceve in
entrata un testo e offre come output una lista di nomi e di cognomi di persona. Questi
verranno usati come input per eseguire le ricerche di immagini sui motori di ricerca, quindi
è importante che il sistema sia in grado di trovare tutti i nomi presenti nel testo e, piuttosto
di non riportarne qualcuno, è preferibile avere falsi positivi piuttosto che falsi negativi. Per
falsi positivi ci si riferisce a parole date come output che non sono nomi, per falsi negativi
a nomi presenti nel testo non dati come output. Queste due nozioni, di falsi e positivi e falsi
negativi, in information retrieval, permettono di definire i valori di precision e recall che
meglio caratterizzano le prestazioni di un sistema. In particolare sono definite come:
TP
precision =
TP + FP
TP
recall =
TP + FN
dove TP indica un risultato vero positivo, ovvero un nome correttamente trovato dal
sistema , FP un falso positivo e FN un falso negativo.
Per il sistema è più rilevante avere una recall alta piuttosto che una buona precision, infatti
la prima indica quanti nomi sono stati trovati tra quelli presenti nel testo, la seconda quanti,
tra i nomi trovati, lo siano effettivamente. Se il sistema dovesse considerare come nome
qualcosa che in realtà non lo è, i risultati del motore di ricerca sarebbero poche immagini
contenenti la stessa faccia, insufficienti per caratterizzare una persona, e quindi verrebbero
scartate nei passaggi successivi.
Il processo di riconoscimento dei nomi si basa su varie tecniche che hanno mostrato ottimi
risultati se usate assieme.
3.1. Term Extractor
La prima tecnica implementata sfrutta dei servizi online di estrazione di parole chiave da
un testo. Questi servizi sono molto usati su Internet per valutare le parole chiave con cui
verrà indicizzato un sito sui motori di ricerca ed offrono come output una lista di gruppi di
una o più parole che ben caratterizzano il testo esaminato. Le parole ottenute in output non
sono esclusivamente nomi di persona, ma questi rappresentano una buona percentuale delle
parole proposte. Per migliorare i risultati di questo processo di estrazione è stato scelto di
7

13. filtrare le parole chiave tenendo solo quei gruppi che contenessero almeno una parola
facente parte di una lista predefinita di nomi propri di persona. Come servizi di estrazione
delle parole chiave è stato utilizzato il Yahoo! Term Extractor8 e le api semantiche di
Zemanta9.
3.1.1. Yahoo! Term Extractor
Questa API offerta da Yahoo!, dato un testo, mette in evidenza 20 gruppi di parole
significativi senza dare indicazioni ne sulla rilevanza delle parole ne sui criteri usati. I dati
ricevuti dal server di Yahoo! vengono filtrati per eliminare tutti qui gruppi che non
contengono nemmeno un nome proprio di persona.
3.1.2. Zemanta
Il servizio online di Zemanta offre la possibilità di ottenere un insieme di 8 gruppi di parole
chiave che il servizio ritiene adatti per descrivere il contenuto di un testo. Le parole
ottenute come output non sono necessariamente parole presenti nel testo. A differenza del
servizio di Yahoo!, questo da un valore tra 0 e 1 di rilevanza dei termini estratti.
Anche a questo output è stato applicato il filtro dei nomi in modo da escludere tutte le
parole chiave che non contenessero almeno un nome.
3.2. Ricerca maiuscole
La seconda tecnica implementata si basa sulla ricerca, all’interno delle frasi che
compongono il testo, dei gruppi dalle 2 alle 5 parole che inizino per lettere maiuscola.
Questo si basa sulla proprietà delle grammatiche di lingue come Italiano ed Inglese di
scrivere i nomi propri ed i cognomi con lettere maiuscole.
Il processo di identificazione si basa sull’uso di una apposita espressione regolare che
ricerca le ripetizioni di parole con lettere maiuscole, intervallate da spazi, apostrofi o punti:
([A-Z][A-Za-z]*[.']?[s]*){2,5}[.,:;s]*
8
http://search.yahooapis.com/ContentAnalysisService/V1/termExtraction
9
http://api.zemanta.com/services/rest/0.0/
8

14. Questa espressione regolare cerca dalle 2 alle 5 ripetizioni di una lettera maiuscola seguita
da una serie di lettere maiuscole, minuscole, da un punto o da un apostrofo e separate da
spazi, virgole, due punti e punti e virgola.
Una volta trovati questi gruppi di parole, vengono filtrati con una lista di nomi propri in
modo da eliminare tutto quello che non contiene almeno un nome.
Un difetto di questo metodo è di inglobare, tra i nomi di persona ottenuti, non solo i
cognomi, ma anche eventuali parole ad inizio frase, quindi con lettera maiuscola, che
precedono il nome trovato. Essendo queste parole perlopiù articoli o preposizioni, questo
non rovina il risultato della ricerca di immagini, infatti gli stessi motori di ricerca filtrano le
parole comuni, tuttavia è possibile rendere migliore il risultato filtrando le parole comuni
trovate ad inizio frase, come gli articoli o certe preposizioni. Al momento questa
correzione non è stata implementata nel sistema.
3.3. Ricerca per linguaggio naturale.
L’ultima tecnica utilizzata per la ricerca dei nomi all’interno di un testo è la ricerca per
massima entropia10 nel linguaggio naturale. Questa è implementata nel pacchetto
OpenNLP, una suite di funzioni che permettono di trattare il linguaggio naturale nelle
lingue Inglese, Spagnolo e Tedesco. Se a OpenNLP viene data una frase estratta da un
testo, questo è in grado di fornire in output le posizioni delle parole che rappresentano i
nomi. Sfruttando questo ed il fatto che i nomi tendono a precedere i cognomi, partendo
dalla posizione indicata da OpenNLP si prendono le prime 5 parole che inizino con una
maiuscola per ottenere in output una lista di nomi e cognomi presenti nel testo.
3.4. Aggregazione
Per migliorare i risultati, in maniera da minimizzare il numero di falsi negativi, è stata fatta
la scelta di aggregare i risultati ottenuti con le varie tecniche illustrate.
In particolare, se la tecnica basata su Yahoo! Term Extractor offre un insieme di nomi N1 =
{ n11, n12,…}, quella su Zemanta un insieme N2 = { n21, n22,…}, quella con l’estrazione di
parole maiuscole un insieme N3 = { n31, n32,…} e quella basata su OpenNLP un insieme N4
= { n41, n42,…}, l’insieme di nomi che verrà usato per le ricerche su Internet sarà
10
Hai Leong Chieu , Hwee Tou Ng, 2002, Named Entity Recognition: A Maximum Entropy Approach
Using Global Information
9

15. N = N1 ∪ N 3 ∪ N 3 ∪ N 4
3.5. Risultati
Per ognuna di queste tecniche sono stati analizzati i valori di precision e recall. Questi
valori indicano quanti nomi effettivi ci sono nell’insieme Ni restituito dai vari metodi e
quanti nomi sono stati trovati tra quelli presenti nel testo.
In particolare, per il sistema generale, è molto rilevante il valore della recall, in quanto una
recall elevata indica che pochi nomi non sono stati trovati dal meccanismo di estrazione.
La precision, diversamente, da un’indicazione dell’efficienza del processo di estrazione,
infatti per precision alte si ha un basso numero di falsi positivi, quindi i successivi passaggi
del sistema perderanno meno tempo in richieste inutili ai motori di ricerca. In figura si
possono notare i valori di precision e recall per le varie tecniche provate in funzione della
lingua (Italiano o Inglese). Yahoo e Zemanta rappresentano le tecniche di term extraction
basate sui rispettivi servizi online, capital si riferisce ala ricerca di gruppi di parole con
lettera maiuscola, min 1 è l’aggregatore di tutti i risultati delle tecniche precedenti, min 2
rappresenta l’insieme dei nomi ottenuti da almeno due delle tecniche di prima. Tra questi
spicca come la ricerca di termini con lettere maiuscole permetta di trovare la maggior parte
dei i nomi presenti nel testo.
Figura 3.1 - Valori di precisione e recall dei metodi per l'estazione dei nomi da un testo
10

16. Dal grafico in figura 3.1, ottenuta estraendo i nomi da 20 articoli scaricati dal sito di
Repubblica e altrettanti presi dal sito del New York Times, si può notare come le
prestazioni del meccanismo di ricerca delle parole che iniziano per una maiuscola sia
molto efficace avendo una recall che tende al 100%, mentre i metodi basati sull’estrazione
delle parole chiave non siano molto performanti. Tuttavia si è scelto di tenere tutti i
risultati ottenuti perché, dall’unione dei 4 insiemi di risultati, si può ottenere un insieme
finale con recall del 100%, risultato che garantisce di non perdere nessun nome presente
nel testo.
11

17. 4. Ricerca immagini su Internet
La seconda componente del sistema è la ricerca di immagini su Internet tramite un nome di
persona. L’obbiettivo di questa ricerca è quello di creare un profilo di immagini da
associare ad un nome per poterlo confrontare con l’immagine data in input al sistema
completo nella quale si vogliono riconoscere le persone.
Negli ultimi anni si sono sviluppati su Internet diversi motori di ricerca di immagini.
Questi classificano le immagini che trovano durante l’indicizzazione dei siti Internet in
base a delle parole chiave trovate nei tag html della pagina. Questo permette di associare
alle parole cercate dagli utenti un insieme di risultati interessanti, che però si riferisce alle
parole cercate in maniera generica: cerca, ad esempio “Barack Obama”, è possibile trovare
tra i primi risultati delle immagini di Michelle Obama. Quello che ci offre un motore di
ricerca, quindi, è un insieme rumoroso di immagini che potrebbero rappresentare la
persona cercata.
4.1. Motori di ricerca per immagini
Ad oggi vi sono, su Internet, tre motori di ricerca per immagini di riferimento, legati a
Google, Bing e Yahoo!. Tutti e tre offrono un’interfaccia API online che si basa su REST11
e quindi rendono agevole la ricerca di immagini da parte di un software esterno.
Oltre ai semplici metodi di ricerca per parole chiave, spesso questi motori offrono la
possibilità di ricerche avanzate che permettono di filtrare meglio i risultati. In particolare è
spesso presente l’opzione per la visualizzazione, tra i risultati, di sole immagini contenenti
volti. Questa opzione permette di ridurre la rumorosità dell’insieme di immagini ricevuto
in output dal motore di ricerca.
4.1.1. Google Immagini
Google offre la possibilità di interfacciarsi con il suo motore di ricerca per immagini
tramite un apposito URL12. Come input chiede, oltre alla query di ricerca, di specificare
una chiave fornita da Google stesso o, in alternativa, un referrer valido. Inoltre permette di
specificare se si vuole ottenere 4 o 8 risultati per query, la posizione, tra i risultati, da cui
11
http://it.wikipedia.org/wiki/Representational_State_Transfer
12
http://ajax.googleapis.com/ajax/services/search/images
12

18. iniziare la ricerca e alcune opzioni sulla dimensione e sul formato dell’immagine. Tra i
parametri più interessanti c’è la possibilità di ottenere solo immagini contenenti volti.
L’output di Google Immagini è un documento in formato JSON13 che descrive i risultati
della query fornendo informazioni riguardo l’immagine trovata quali le dimensioni o il
titolo ad essa associato. Il dato più importante è l’URL al quale si trova l’immagine che
verrà usato dal sistema per recuperare l’immagine.
Google Immagini offre fino ad un massimo di 64 risultati per query e non da informazioni
esplicite sulla rilevanza del risultato in funzione delle parole chiave usate per la ricerca.
4.1.2. Bing Immagini
Bing Immagini14 è il motore di ricerca di immagini di Microsoft. Offre anche esso
un’interfaccia REST che permette di ottenere i risultati di una interrogazione in un
documento XML. Per utilizzare il sistema è necessaria la registrazione presso il Bing
Developer Center15 di Microsoft il quale fornirà una chiave alfanumerica da usare ad ogni
richiesta al motore di ricerca. Oltre alla chiave, Bing chiede che venga specificata una
query di ricerca, un numero tra 1 e 50 di risultati che si vogliono ricevere con una query e
la posizione del primo risultato. Nonostante si possa richiedere a Bing un numero infinito
di risultati, il motore non da informazioni su quanti risultati potrà offrire.
Anche Bing offre la possibilità di specificare delle opzioni avanzate di ricerca tra le quali,
la più interessante per il sistema, è quella di ricercare soltanto immagini contenenti volti.
L’output di Bing Immagini è un file XML dal quale è possibile ricavare l’url delle
immagini da scaricare.
4.1.3. Yahoo! Immagini
Il motore di ricerca di immagini di Yahoo! può essere interrogato tramite chiamate REST
una uno specifico URL16. Come per gli altri motori di ricerca è necessario specificare, tra i
dati forniti in input, una query di ricerca e una chiave ottenibile previa registrazione al
Yahoo! Developer Network17. Fra le opzioni messa a disposizione dal motore di ricerca ci
sono quelle per decidere quanti risultati, da 1 a 50, restituire per ogni query e da che
risultato iniziare. Nemmeno Yahoo! da garanzie sul numero di risultati ottenibili con ogni
13
http://www.json.org/
14
http://api.bing.net/xml.aspx
15
http://www.bing.com/developers
16
http://search.yahooapis.com/ImageSearchService/V1/imageSearch
17
http://developer.yahoo.com/
13

19. singola query. I risultati vengono forniti in XML e da questo si potranno estrarre gli
indirizzi delle immagini da scaricare.
Yahoo! Immagini non permette di filtrare i risultati per mostrare solo le immagini
contenenti una faccia.
14

20. 5. Individuazione delle facce
Buona parte del sistema di tagging delle immagini si basa sulla possibilità di riconoscere la
porzione d’immagine in cui si trova una faccia. Questo permette di escludere dalle
successive analisi tutte le zone non interessanti per il riconoscimento delle persone in una
foto. L’identificazione della posizione di un volto è affidato ad una libreria esterna,
OpenCV di Intel, che offre molto funzioni di image processing e, soprattutto, di computer
vision.
5.1. OpenCV, AdaBoost e classificatori Haar-like
Per mostrare le potenzialità dei suoi processori, Intel ha sviluppato la libreria OpenCV,
rilasciata sotto licenza BSD, la quale, da semplice strumento dimostrativo, è cresciuta fino
ad affermarsi come punto di riferimento per la computer vision. Tra le funzioni più
interessanti di OpenCV c’è la possibilità di riconoscere oggetti in un’immagine. Questa
sfrutta l’algoritmo AdBoost18 per individuare le posizioni degli oggetti.
AdaBoost si basa sull’utilizzo di un insieme ristretto di caratteristiche derivate da
trasformate di Haar, dette Haar-like, in grado di riconoscere una particolare immagine
anche se questa è ruotata rispetto alla posizione in cui ci si aspetterebbe di trovarla. Un
classificatore di features è un albero decisionale con almeno due foglie che utilizza le
caratteristiche Haar-like se una regione di un’immagine corrisponde ad un’immagine ad
esso nota.
La caratteristica usata in un classificatore è definita dalla sua forma (visibile in figura 5.1),
dalla posizione all’interno della regione di interesse e dalla scala.
Figura 5.1 - Caratteristiche usate da AdaBoost
18
http://en.wikipedia.org/wiki/AdaBoost
15

21. Per esempio, nel caso della caratteristica 2c rappresentata nella figura 5.1, la risposta è
calcolata come la differenza fra la somma dei pixel di immagine coperti da tutta la
caratteristica e la somma dei pixel coperti dalla banda nera, moltiplicati per 3 per
compensare le differenze nel formato delle zone.
L’algoritmo AdaBoost si occupa di scegliere la caratteristica più importante tra quelle
presenti nel classificatore, normalmente quella che appare più volte. Ad ogni passaggio
dell’algoritmo viene creato un classificatore “debole” e, per non dover aspettare la raccolta
di tutti i classificatori possibili per tutte le regioni in cui è divisibile un’immagine, si usa
una struttura a cascata. In pratica si parte con l’analizzare il primo di una serie di
classificatori, se questo da esito positivo si passa al secondo e così via coi successivi, se un
classificatore non fornisce esito positivo la regione viene scartata e si passa ad analizzarne
un’altra. In questo modo il costo computazionale dell’algoritmo cala notevolmente.
5.2. Individuazione delle facce
La libreria OpenCV richiede come input l’immagine da analizzare e il classificatore che si
vuole utilizzare per l’individuazione degli oggetto, in questo caso delle facce.
L’output di OpenCV, come si può vedere nell’immagine 5.1 è un rettangolo che
rappresenta la porzione d’immagine contenente un volto.
Figura 5.1 - Risultato dell'individuazione di un volto in un'immagine
OpenCv offre diversi classificatori per i volti. Spesso le facce individuate da un
classificatore non sono individuate dagli altri. Per evitare di non riconoscere qualche volto,
è stato scelto di considerare due classificatori e, per escludere il rischio di doppi risultati, si
è deciso di non considerare i risultati del secondo classificatore che si sovrapponessero a
quelli del primo.
16

22. 5.3. Prestazioni
Il meccanismo di riconoscimento facciale di OpenCv ha mostrato di essere maturo e di
garantire ottimi risultati. In particolare, tra i tool resi disponibili assieme alla libreria c’è
performances, un software che permette di misurare le prestazioni di OpenCv su una
collezione di dati.
In particolare, sfruttando i classificatori di default per le facce dati assieme alla libreria e
usando le impostazioni di default della funzione di detect, l’estrazione delle face ha
mostrato una precision del 96% ed una recall del 92% su un dataset di 160 immagini
contenenti volti.
17

23. 6. Rettificazione facce
Le facce estratte dalle immagini scaricate da Internet sono raramente in una sola posa,
spesso sono inclinate o ruotate, e frequentemente non presentano un’illuminazione
costante, ma sono coperte da zone d’ombra o sovraesposte. Un esempio di faccia inclinata
e non uniformemente illuminata è presente in figura 6.1.
Figura 6.1 - Esempio di un volto male illuminato e inclinato
Per poter confrontare meglio le immagini con facce tra di loro, è preferibile portarle tutte
nelle stesse condizioni di luce e cercare di posizionare occhi e bocca nelle stesse regioni
dell’immagine. Una volta applicate queste correzioni alle immagini contenenti facce,
queste verranno ritagliate dall’immagine di partenza, portate tutte ad una dimensione di
100x100 pixel e convertite in scala di grigi. Così facendo avremo delle immagini che
contengono dei volti tutte nelle stesse condizioni di dimensione, posizione degli occhi e
contrasto, in modo da essere più facilmente confrontabili per il sistema.
6.1. Posizionamento occhi
Per capire se una faccia è da ruotare oppure no, si è scelto di considerare il posizionamento
degli occhi nell’immagine. L’individuazione degli occhi fa ancora una volta uso di
OpenCV, questa volta però non con un classificatore dato in dotazione come quello
utilizzato per l’individuazione dei volti, ma con uno adeguatamente addestrato per trovare
le porzioni d’immagine che contengono un occhio. Il classificatore è stato costruito usando
il tool haartraining di OpenCV che, dati un insieme di esempi positivi, ovvero immagini
18

24. che contengono un occhio, e un insieme di immagini negative, ovvero immagini di
qualsiasi tipo che non contengano occhi, costruisce un classificatore Haar valido per
OpenCV. Il classificatore usato in questo progetto è stato scaricato da Internet19.
L’output di questo processo sarà un insieme di punti E = { (x1, y1), (x2, y2),…}, dove ogni
punto rappresenta un occhio. Se
E =2
il processo di rettificazione della posizione continua con le trasformazioni affini,
altrimenti, se la cardinalità di E dovesse essere diversa da 2, si passerebbe al
ridimensionamento e alla compensazione della luminosità. Nella figura 6.2 è visibile un
esempio in cui sono stati correttamente individuati gli occhi nella faccia.
Figura 6.2 - Risultato dell'individuazione degli occhi
6.2. Trasformazioni affini
Se l’identificazione degli occhi ha restituito un insieme E tale che
E = 2,
allora il sistema può provare a calcolare un angolo ed un centro di rotazione. Come prima
cosa si verifica che
Δy < d
con Δy = y 2 − y1 e d una distanza massima tra le componenti verticali degli occhi, in
modo da escludere errori di posizionamento di un occhio da parte del classificatore. La
distanza d è stata scelta come 5% dell’altezza dell’immagine. Cioè è dovuto al fatto che
l’inclinazione dei volti è normalmente contenuta e, nel caso di Δy alto, è più probabile un
errore nell’individuazione degli occhi piuttosto che un volto molto ruotato. Se questa
condizione è verificata si passa alla determinazione di un punto c che sarà il centro della
porzione d’immagine contenente il volto e che sarà usato come centro di rotazione. Quindi
si calcola l’angolo
19
Zeeshan Ejaz Bhatti, Face and Eyes Detection Using OpenCV
19

25. 90° ⋅ Δy
α= dove Δx = x 2 − x1 con x2 > x1 .
Δx 2 + Δ y 2
A questo punto l’immagine verrà ruotata dell’angolo α rispetto al centro c in modo da
allineare tra di loro gli occhi.
6.3. Ritaglio e ridimensionamento
A questo punto la porzione d’immagine individuata come faccia viene ritagliata e scalata,
tramite interpolazione lineare, in una miniatura di 100 pixel di altezza e 100 pixel di
larghezza. In questo modo si otterrà che tutte le immagini di facce trovate avranno la stessa
dimensione. Queste verranno infine convertite in scala di grigi perché l’informazione del
colore è superflua per i passaggi successivi del sistema ed in scala di grigi le immagini
sono più facilmente confrontabili.
6.4. Compensazione della luminosità
L’ultimo passaggio del processo di rettificazione delle immagini è la compensazione della
luminosità. Questa è stata implementata tramite la tecnica dell’equalizzazione
dell’istogramma della scala di grigi.
Il vantaggio di questa tecnica è quello di migliorare il contrasto di un’immagine e di
rendere uniforme l’illuminazione come si può vedere nella figura 6.3.
Figura 6.3 - Esempio di faccia prima e dopo l'equalizzazione dell'istogramma dei grigi
Il primo passo per l’equalizzazione è quello di prendere un’immagine in scala di grigi {x},
nel nostro caso le facce trovate da OpenCV, con ni che identifica il numero di occorrenze
del livello di grigio i all’interno dell’immagine. Si calcola quindi la probabilità di
occorrenza di un pixel per il livelli i di grigio
ni
p x (i ) = p ( x = i ) = ,0 < i < L
n
20

26. con L il numero totale di livelli di grigio dell’immagine e n il numero totale di pixel
dell’immagine. p x (i ) rappresenta l’istogramma dei grigi dell’immagine, e verrà
normalizzato tra [0,1]. Definita
cdf x (i ) = ∑ j =0 p x ( j )
i
la funzione di ripartizione di p x (i) , creiamo una trasformazione
y = T (x )
che produca una nuova immagine {y} la cui cdf sia linearizzata al valore
cdf y (i ) = iK
per una costante K. Per le proprietà dell’inversa della funzione di ripartizione,
y = T ( x) = cdf x ( x)
sarà la nuova immagine equalizzata.
Come si può vedere della figura, il risultato della trasformazione T è lo “stiracchiamento”
dell’istogramma dei grigi, che produce un miglioramento sui contrasti dell’immagine 6.4.
Figura 6.4 - Equalizzazione dell'istogramma dei grigi
21

27. 7. Associazione del nome con l’immagine
A questo punto del sistema si ha un insieme N di nomi estratti da un testo, per ogni
elemento di N un insieme Fn di immagini contenenti un volto, scaricate da Internet, e
un’immagine, che chiameremo Io, per la quale vogliamo verificare se sia possibile
l’associazione con i nomi trovati. È importante notare come l’immagine Io possa contenere
al suo interno più di una persona, o come per una persona siano possibili più associazioni
con un nome (ad esempio il Papa o un personaggio famoso noto sia col suo nome che con
uno pseudonimo).
La verifica dell’associazione tra Io e un nome n elemento di N verrà fatta mettendo in
relazione le facce estratta da Io con le immagini associate a n presenti in Fn. Si procederà,
quindi, come segue:
1. all’estrazione delle facce f’0, f’1,… dall’immagine I0
2. trasformazione, tramite la tecnica di Eigenfaces, delle immagini contenenti facce fn
appartenenti a Fn e delle facce f’0, f’1,… estratte da I0 in vettori multidimensionali.
3. calcolo di un punteggio per ogni faccia f’0, f’1,… in relazione ai vari elementi fn di
Fn
4. se il punteggio supererà una certa soglia S il nome n associato a Fn verrà
considerato come appropriato per I0.
Il punteggio verrà calcolato in base all’algoritmo di Local Density Score, che premia
maggiormente la coppie f,Fn per le quali f cade in una zona molto densa di elementi di Fn.
7.1. Eigenfaces
La tecnica per il riconoscimento facciale Eigenfaces è un metodo molto usato nel campo
della computer vision per riconoscere le persone e si basa sull’analisi delle componenti
principali di un insieme di immagini date contenenti facce (trainingset) e sulla misura
della distanza tra queste e una faccia sconosciuta. I passi dell’algoritmo Eigenfaces sono:
1. Calcolo del PCA delle facce presenti nel trainingset.
2. Proiezione della faccia da valutare nel nuovo spazio vettoriale
3. Misura della distanza tra la faccia indagata e delle facce note.
Un modo intuitivo di vedere Eigenfaces è quello di pensare all’immagine come ad punto in
uno spazio di dimensioni h ⋅ w , con h l’altezza dell’immagine in pixel, e w la larghezza
22

28. dell’immagine in pixel. Le facce occuperanno uno spazio ridotto, quindi, tramite l’analisi
delle componenti principali, si riduce il numero di dimensioni tenendo quelle più
significative. Proiettando l’immagine sconosciuta in questo spazio vettoriale possiamo
misurare la distanza tra questa e altre immagini di volti noti. Se la distanza è inferiore ad
una certa soglia, ovvero se l’immagine sconosciuta è sufficientemente vicina ad una nota,
allora si può dedurre che entrambe rappresentino la stessa persona.
L’algoritmo, ha bisogno di un trainingset di partenza sul quale calcolare il PCA e il nuovo
spazio vettoriale, e di un dataset di immagini con volti di persone note, per effettuare il
confronto
Nel caso del nostro sistema l’algoritmo di Eigenfaces originale non si può considerare
adatto, perché si basa su una dataset di facce note e in posizioni fisse, condizione ben
lontana da quella in cui ci troviamo. Tuttavia il punto di partenza, ovvero l’analisi delle
componenti principali per ottenere un sottospazio interessante delle facce e la proiezione
delle immagini in questo, saranno anche il nostro punto di partenza per il confronto tra
facce.
7.2. Analisi delle componenti principali
L’analisi delle componenti principali permette di trovare uno spazio vettoriale interessante
per la rappresentazione del vettore che associato all’immagine di un volto. Nel caso del
sistema in analisi si ha un vettore di 10000 elementi, dato dai pixel di altezza per quelli di
larghezza dell’immagine, e vogliamo considerare di queste componenti solo quelle più
rappresentative.
L’insieme di partenza, sul quale calcoleremo il PCA, è un dataset di 600 foto di personaggi
famosi scaricate da Internet, di queste ne verranno prese a caso 200 che saranno il
trainingset sul quale verrà fatta l’analisi delle componenti principali.
Definiamo Γ1 , Γ2 ,...ΓM le M facce che costituiscono il trainingset di partenza, la faccia
media è definita come:
1
∑
M
Ψ= n =1
Γn da cui ogni faccia differisce di Φ n = Γn − Ψ .
M
La PCA troverà gli M vettori ortonormali che meglio descrivono la distribuzione delle
informazioni. Il k-esimo vettore μ k scelto è scelto in modo tale che
23

29. 1
λk = ∑ (μ k Φ n ) 2
M T
n =1
M
{
sia massimizzata considerando
1,l = k
μ μk =
T
l
0 altrimenti
I vettori e gli scalari μ k e gli scalari λk rappresentano gli autovettori e gli autovalori della
matrice di covarianza
M
1
C=
M
∑Φ
n =1
n Φ T = AA T essendo A = [Φ1Φ 2 ...Φ n ]
n
Decidiamo quindi di prendere gli M’ autovettori con M’ < M corrispondenti agli auto
vettori maggiori, in modo da poter ridurre lo spazio dimensionale ma mantenendo la
percentuale dell’informazione delle facce al 90%. Facendo alcuni test è stato trovato che il
numero ottimale di autovettori da tenere per avere un’informazione del 90% è di 80.
A questo punto si ha un nuovo spazio vettoriale, ridotto da 10000 ad 80 dimensioni, nel
quale proiettare i vettori associati alle immagini.
7.3. Local Density Score
La valutazione dell’associazione tra nome è immagine verrà fatta attribuendo un punteggio
ad ogni faccia f’0, f’1,… presente nell’immagine I0 in funzione della sua vicinanza alle
facce dell’insieme Fn. Questo punteggio viene confrontato con una soglia S
opportunamente selezionata, e in caso il punteggio sia maggiore della soglia, allora il nome
n associato a Fn verrà considerato come valido per descrivere l’immagine I0.
Il punteggio viene calcolato in base al Local Density Score (LDS). Il valore del LDS sarà
pari alla media delle distanze dei K vettori di facce elementi di Fn più vicine al vettore
faccia f’
∑ f j∈Rk ( f ')
d ( f ', f j )
LDS ( f ' ) =
k
dove Rk(f’) è l’insieme dei k vettori più vicini al vettore f’, calcolati in base alla distanza
euclidea che li separa da f’, d(f’,fj) è la distanza tra f’ e fj e k è un parametro calcolato in
base al numero di elementi di Fn, come vedremo in seguito.
24

30. Parte integrante del calcolo del punteggio LDS è la valutazione di quale distanza d(f’,fj)
usare. Nel sistema sono stati pensati due tipi di distanze: la prima si basa sul numero di
vicini in comune tra f’ e fj, la seconda si basa sulla distanza euclidea tra i due vettori.
7.3.1. Shared neighbors20
Una delle metriche usate per calcolare il punteggio LDS si basa sul numero di vicini in
comune tra due punti. Se un vettore faccia f’ rappresenta un punto che cade in una zona
dello spazio vettoriale delle facce molto densa, la probabilità che il nome n associato
all’insieme Fn sia adatto per descrivere f’ è molto alta. Quindi, per verificare che f’ cada in
un cluster, prendiamo i k vettori più vicini a lui e contiamo quanti siano, in media, i k
vettori vicini ad entrambi.
Rk ( f ' ) ∪Rk ( f j )
d( f ', f j ) =
k
In questo modo il valore di d(f’,fj) sarà compreso tra 0 e 1 e sarà maggiore se f’ e fj
condividono un numero alto di vicini, tendente allo 0 se il vicino più prossimo di f’ è molto
più vicino ad altri punti rispetto a f’. La formula per il calcoldo di LDS diventa quindi:
∑ f j∈Rk ( f ')
Rk ( f ' ) ∪ Rk ( f j )
LDS ( f ' ) =
k2
A questo punto non rimane che determinare i valori di soglia S e di k ottimali per il
sistema. Per k si è pensato di scegliere un valore che fosse una percentuale D del numero di
facce scaricate da Internet, in modo da equilibrare il sistema in caso di variazioni di
risultati restituiti dai motori di ricerca. Sia per la soglia S che per la percentuale D di Fn si è
proceduto con dei test sperimentali ed è stato valutato il numero di falsi positivi (FP) e di
falsi negativi (FN) ottenuti al variare di S e di D .
L’esperimento è stato svolto prendendo 40 immagini di personaggi famosi dello spettacolo
e della politica e calcolando, per ognuno di essi, il punteggio LDS ottenuto dalla
20
Unsupervised Face Annotation by Mining the Web di Duy-Dinh Le e Shin’ichi Satoh
25

31. valutazione dell’associazione tra il proprio nome con la propria immagine e con altre 3
scelte a caso. Per ognuno dei nomi n si è:
1. Cercato il nome n sui tre motori di ricerca per immagini
2. Scaricato le foto ottenute dalla ricerca
3. Preparato un insieme di immagini da testare contenente un’immagine della persona
e 3 immagini di altre persone scelte a caso
4. Calcolato il punteggio LDS per ognuna delle immagini dell’insieme di test
5. Dato esito positivo in caso di anomaly detection, ovvero quando il punteggio LDS
era inferiore alla soglia S, esito negativo in caso contrario.
Come mostrato nel grafico in figura 7.1, che rappresenta le curve ROC (Receiver
Operating Characteristic), i valori di percentuale dei risultati D che migliorano le
prestazioni del sistema sono quelli bassi, in particolare il valore del 5%, per il quale
l’algoritmo riesce a classificare meglio le foto.
Figura 7.1 - Curve ROC per shared neighbors
Visti i migliori risultati per percentuali basse, teniamo come valore di D per l’algoritmo
shared neighbor il valore del 5% e, come si può vedere dal grafico riportato in figura 7.2
che mostra la variazione della percentuale di falsi positivi (FPR), falsi negativi (FNR) e
della percentuale di errore al variare della soglia, scegliamo un valore per la soglia S pari a
26

32. 0.4, in modo da minimizzare il numero di errori commessi. Essendo il numero totale di
casini positivi e di casi negativi squilibrato, essendo cioè maggiore il numero dei positivi,
la percentuale di errore riportata in figura 7.2 è calcolata come il totale degli errori
commessi sul totale dei test effettuati.
Figura 7.2 - Variazione delle percentuali di errore in funzione della soglia
7.3.2. Euclidea
Una variazione possibile all’algoritmo LDS è quella di valutare la distanza d(f’,fj) tra due
vettori usando la distanza media euclidea invece che la media dei vicini condivisi tra i due
vettori. Quindi:
∑( f ' − f )
80
2
i ji
i=1
d( f ' , f j ) =
k
dato che lo spazio in cui lavoriamo è ridotto ad 80 dimensioni dopo l’analisi delle
componenti principali.
27

33. Usando questa metrica l’algoritmo di verifica varia, infatti se una faccia f’ cade in una zona
densa di Fn, allora il punteggio LDS sarà basso, dato che i vettori sono vicini tra di loro e
quindi la distanza media è piccola, viceversa, se cade in una zona poco densa, il punteggio
sarà alto poiché crescono le distanze tra i vettori.
Anche in questo caso la soglia S e il valore di k, sempre una percentuale D del numero di
elementi di Fn, sono stati scelti dopo un’analisi sperimentale con la quale è stato valutato il
numero di falsi positivi (FP) e di falsi negativi (FN) ottenuti al variare di S e di D . Anche
per questo algoritmo si è svolto lo stesso esperimento svolto per lo shared neighbor, con la
sola differenza del punto 5 in cui si è scelto di segnalare l’anomaly detection nel caso di un
punteggio LDS maggiore della soglia S.
Nella figura 7.3 è riportato il grafico ROC per le varie percentuali di risultati provate con
l’algoritmo di LDS basato sulla distanza euclidea. Come si può vedere per k piccoli,
ovvero percentuali basse, l’algoritmo ha dato risultati migliori.
Figura 7.3 - Curve ROC per LDS con distanza euclidea
Partendo da questi dati è stata scelta come percentuale 1% e per questa è sono stati valutati
i valori di soglia che minimizzassero le percentuali di falsi negativi e falsi positivi. Come si
può notare dal grafico 7.4, il valore ottimale per la soglia S è di 525
28

34. Figura 7.4 - Variazione degli errori in funzione della soglia per LDS euclideo
7.3.3. Posizionamento motore di ricerca.
Per cercare di migliorare i risultati dell’algoritmo LDS si è pensato di pesare le immagini
ottenute da Internet in modo da dare più peso ai risultati ottenuti per primi. Il motivo di
questa scelta è stato che i risultati meglio posizionati nel motore di ricerca, quindi i primi,
potrebbero essere più adatti per il nome cercato.
Sono stati quindi effettuati di nuovo i test con le distanze shared neighbors ed euclidea
pesando i risultati ottenuti in base alla posizione dell’immagine dalla quale è stato estratto
il vettore fj nel motore di ricerca. Il nuovo punteggio LDS sarà quindi calcolato come:
∑ f j∈Rk ( f ')
d ( f ', f j ) ⋅ r( f j )
LDS ( f ' ) =
k
dove r(fj) è una funzione che associa a fj un appropriato valore tra 0 e 1 e che dipende dal
tipo di distanza calcolato, ovvero se si usa l’algoritmo shared neighbors o di distanza
euclidea. In particolare per shared neighbors è stata scelta la funzione
29

35. 1
r( f j ) = 1− m
− pos ( f j )
1 + (1 + η ) 2
con pos(fj) la posizione nel motore di ricerca dell’immagine da cui è stata estratta la faccia
fj, m il numero di risultati ottenuti dal motore di ricerca per il nome n e η una costante tra 0
e 1 per regolare la pendenza della sigmoide. Diversamente, per la distanza euclidea siamo
ricorsi alla funzione
1
r( f j ) = m
− pos ( f j )
1 + (1 + η ) 2
La funzione tiene in considerazione il numero di risultati ottenuti dal motore di ricerca per
non penalizzare eccessivamente le ricerche che offrono un gran numero di risultati:
normalmente queste riguardano persone molto famose di cui è possibile trovare molte
immagini. Al contrario, quando il numero di risultati della ricerca è basso e quindi la
persona risulta poco nota, il numero di immagini che realmente la contengono è molto più
basso.
Dopo aver deciso come modificare l’algoritmo per tenere conto del posizionamento delle
immagini nei motori di ricerca, è stato anche per questi due valutato il numero di falsi
positivi e falsi negativi in funzione dei parametri di soglia S e la percentuale di risultati D.
In figura 7.5 viene riportato il grafico ROC per il metodo shared neighbor corretto con la
posizione nel motore di ricerca dei risultati ottenuti. Come si può vedere pesare le
immagini non ha portato ad un miglioramento dei risultati.
30

36. Figura 7.5 - Curve ROC per shared neighbor pesato con la posizione nel motore di ricerca
Nel caso della distanza euclidea tenere in considerazione la posizione nel motore di ricerca
dell’immagine scaricata ha portato ad un peggioramento delle prestazioni dell’algoritmo.
Come si può vedere dal diagramma ROC in figura 7.6, l’algoritmo funziona bene per k che
assume valori bassi in percentuale al numero di risultati ottenuti.
Figura 7.6 - Curve ROC per LDS euclideo pesato
31

37. 8. Implementazione del sistema
Per la realizzazione del sistema si è scelto di usare il linguaggio Java. La prima parte dello
sviluppo del sistema si è basata sull’implementazione del modulo di riconoscimento dei
nomi propri di persona in un testo. In figura 8.1 viene mostrato uno schema riassuntivo
della struttura del sistema.
Figura 8.1 - Componenti del sistema
Partendo dalle analisi sperimentali, sono state mantenute solo le funzioni di ricerca dei
nomi basate sulle parole che iniziano per una maiuscola e sulla libreria OpenNLP,
aggregando i risultati di queste due in un insieme di nomi. L’esclusione delle tecniche di
term extraction è dovuta agli scarsi valori di recall raggiunti da entrambe e al fatto che non
aggiungessero nomi all’insieme delle parole maiuscole. Sia il metodo di ricerca della
maiuscole che quello di term extraction, infatti, si basano su un filtro di nomi propri e, dato
che il primo metodo ha valori di recall molto maggiori e che i nomi che non trova sono
imputabili esclusivamente alla mancanza di questi nella lista che è parte del filtro, risulta
che l’insieme dei nomi prodotti dai metodi basati su Yahoo! e Zemanta è interamente
contenuto nell’insieme prodotto dalla ricerca di parole maiuscole. Al contrario, la scelta di
tenere OpenNLP, seppur solo per la lingua Inglese, è dovuta al fatto che questo non
32

38. necessita del filtro dei nomi e potrebbe trovare gli eventuali nomi persi dal metodo basato
sulle maiuscole.
Il filtro dei nomi è stato realizzato creando una lista di oltre 9000 nomi italiani e circa 4000
inglesi. I primi li ho trovati su wikipedia, i secondi su un sito dedicato alla
categorizzazione dei nomi21.
Dopo il modulo per l’individuazione dei nomi è stata implementata la ricerca di immagini
relativi a questi. La ricerca si è basata su tutti e tre i motori presi in considerazione,
Google, Bing e Yahoo!, in modo da creare un insieme di immagini per il nome scelto il più
grande possibile. Per realizzare le chiamate REST ai motori di ricerca è stata usata la
libreria Java di Apache HttpConnection, che permette di inviare agevolmente i parametri
alle API online. Per quanto riguarda i risultati di Yahoo! e Bing è stato scritto un apposito
parser XML per interpretare i risultati, mentre per Google ho implementato un
meccanismo di riconoscimento del formato JSON usato dal suo motore di ricerca
immagini.
Ottenuti i risultati sono state scaricato le foto ed è iniziato, per ognuna di esse, il processo
di estrazione delle facce e di rettificazione.
L’estrazione delle facce si basa sull’uso della libreria OpenCV. Per questa, che è fornita da
Intel per i sistemi Windows, Unix e MacOS, esiste un wrapper22 Java che esporta le
funzioni di identificazione delle porzioni d’immagine interessanti. In particolare, per
l’identificazione delle facce, ho usato il classificatore di Intel HAAR_FRONTAL_FACE,
mentre per l’identificazione degli occhi, necessaria alla successiva rotazione delle facce
inclinate, è stato usato un classificatore costruito apposta per l’individuazione degli occhi.
Il processo di rettificazione dell’immagine, comprendente la rotazione dei volti inclinati e
l’equalizzazione della scala dei grigi, è stata interamente sviluppata in Java sfruttando le
librerie standard del linguaggio.
Siccome il processo di dowload ed estrazione delle facce richiede molto tempo, è stato
realizzato un meccanismo di caching in locale che permette, dato un nome, di evitare
l’intero processo di download ed estrazione nel caso il nome sia già stato cercato in
passato. Questo permette di ridurre notevolmente i tempi di attesa. Ovviamente, per non far
venire meno le capacità di web mining del progetto, i dati salvati in locale hanno una
validità di una settimana sul disco, dopodiché vengono sovrascritti da una nuova ricerca.
Una volta ottenuto un insieme di immagini contenenti volti opportunamente elaborate, è
venuto il momento di costruire lo spazio vettoriale adatto nel quale proiettare le immagini.
21
http://www.nomix.it/
22
http://ubaa.net/shared/processing/opencv/
33

39. Questo viene determinato dopo un’analisi delle componenti principali che riduce il vettore
immagine da 10000 ad 80 componenti. Per realizzare il PCA si è scelto di creare un
database di immagini contenenti un volto e di sceglierne, una tantum, 200 a caso. Per
ognuna di queste sono stati svolti i soliti passaggi di estrazione, tramite OpenCV, e di
rettificazione, poi è stato calcolato il PCA e salvato il risultato, ovvero la lista dei primi 80
autovettori, in un file ottenuto tramite la serializzazione di un apposito oggetto Java. Il
processo di analisi delle componenti principali è descritto nella figura 8.2.
Figura 8.2 - Passaggi per il setup del sistema
Dopo aver calcolato il PCA si passa alla proiezione delle facce scaricate da Internet nello
spazio vettoriale appena creato. A questo punto il sistema prende l’immagine I0 data come
input e vi applica l’intero processo di estrazione delle facce e di rettificazione, ottenendo
un insieme di immagini di 100px per 100px contenenti ciascuna uno dei volti delle persone
presenti nell’immagine I0. Per ognuna delle immagini di questo insieme viene calcolato un
punteggio LDS relativo ad ognuno degli insiemi di immagini scaricate per un nome n da
Internet. Se vengono soddisfatti i requisiti descritti per l’algoritmo shared neighbors, allora
il nome n è considerato come un tag valido per la foto I0.
Per testare il sistema è stato scelto di scaricare dal sito di Yahoo! Notizie un dataset di
articoli di sport e politica e le immagini associate a questi articoli. Sono stati scaricati 30
articoli in italiano e 30 in inglese, ognuno con un’immagine ad esso associata. Le notizie e
le immagini sono state raccolte in tre giornate differenti, 10 notizie per giornata, in modo
manuale, ovvero passando il testo dell’articolo e l’indirizzo di riferimento dell’immagine
direttamente come input al sistema. Con questo dataset sono iniziati i test al sistema
completo, segnando il numero di falsi positivi e falsi negativi in modo da valutarne le
prestazioni. In questo caso i falsi positivi sono rappresentati dai nomi annotati ad
un’immagine che non compaiono in essa, i falsi negativi invece si riferiscono alle persone
presenti nell’immagine, e citati nel testo, che non sono stati correttamente annotati.
Come si può vedere dalla tabella riportati in figura 8.3, il sistema ha dimostrato di essere in
grado di annotare correttamente una buona percentuale di immagini. Il risultato è buoni
perché, per questo progetto, è molto più importante annotare correttamente oltre la metà
delle immagini piuttosto che sbagliarne qualcuna o dimenticarne qualcuna.
34

40. Lingua Annotazioni Annotazioni errate Annotazioni
corrette mancanti
IT 54% 28% 18%
EN 58% 27% 15%
Figura 8.3 - Prestazioni del sistema
35

41. Conclusioni
L’obiettivo di questo progetto era quello di realizzare un sistema che annotasse le persone
presenti in una foto e citate in un testo ottenendo le percentuali di errore più basse
possibili.
Prendendo le singole componenti del sistema si può affermare che l’obiettivo di trovare i
nomi in un testo è stato raggiunto dati gli alti valori di recall del sistemi basato sulla
ricerca delle parole con lettera maiuscola unito con l’analisi del linguaggio naturale.
Tra i vari algoritmi provati per riconoscere una persona dato un insieme rumoroso che la
rappresenti, hanno dato risultati migliori quelli che tengono in considerazione la posizione
del risultato nel motore di ricerca, in particolare quelli basati sull’algoritmo LDS con
metrica di shared neighbors.
La validazione finale del sistema, infine, ha mostrato la fattibilità dell’annotazione di
un’immagine in base al testo ad essa collegato sfruttando la conoscenza ottenuta da
Internet.
Nonostante le basse percentuali di errore, il sistema risulta lento, soprattutto nelle fasi di
download ed estrazione delle facce. Inoltre i valori di precision ottenuti dall’estrazione dei
nomi dal testo indica una bassa efficienza, ovvero che il numero di interrogazioni inutili ai
motori di ricerca è alto. Ne risulta quindi che, in questo momento, il sistema è lontano dalla
fase di produzione e richiede un’ottimizzazione relativa ai tempi di esecuzione.
Un possibile miglioramento futuro del sistema potrebbe essere quello di automatizzare
l’individuazione del testo di un articolo e dell’immagine ad esso associata.
36