Your SlideShare is downloading. ×
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

PROGETTO E REALIZZAZIONE DI UN SISTEMA PER L’ANNOTAZIONE AUTOMATICA DI IMMAGINI CON TECNICHE DI WEB MINING

1,917

Published on

Published in: Technology, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,917
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
39
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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
  • 2. Ai miei nonni, ai miei genitori, a mia sorella ed a Monica. Grazie.
  • 3. 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
  • 4. 1
  • 5. 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
  • 6. 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
  • 7. 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
  • 8. 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
  • 9. 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
  • 10. 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
  • 11. 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
  • 12. 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
  • 13. 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
  • 14. 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
  • 15. 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
  • 16. 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
  • 17. 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
  • 18. 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
  • 19. 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
  • 20. 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
  • 21. 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
  • 22. 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
  • 23. 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
  • 24. 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
  • 25. 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
  • 26. 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
  • 27. 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
  • 28. 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
  • 29. 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
  • 30. 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
  • 31. 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
  • 32. 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
  • 33. 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
  • 34. 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
  • 35. 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
  • 36. 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
  • 37. 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
  • 38. Lingua Annotazioni Annotazioni errate Annotazioni corrette mancanti IT 54% 28% 18% EN 58% 27% 15% Figura 8.3 - Prestazioni del sistema 35
  • 39. 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

×