POLITECNICO DI MILANO - politesi.polimi.it · di dati da trattare e visualizzare è così grande da...

POLITECNICO DI MILANOFACOLTÀ DI INGEGNERIA DELL'INFORMAZIONECorso di Laurea in Ingegneria Informatica

Estrazione, sentiment analysis e rappresentazione di grandiquantità di messaggi pubblici tramite le tecnologie Big

Data

Relatore: Prof Letizia TancaCorrelatore: Ing. Emanuele MurruTesi di laurea di: Jacopo FarinaMatr: 765487Anno accademico 2012-2013

Dedicata ai miei genitori.

Ringraziamenti

Ringrazio innanzitutto i miei genitori, mia nonna e la mia famiglia, che con illoro sostegno hanno reso possibile, tra le altre cose, anche questo lavoro.

Ringrazio il Politecnico di Milano per la formazione o�erta, in particolare perl'opportunità di presentare un poster alla conferenza ACM HyperText 2011, e leassociazioni Folks, POuL e Poliedro per le esperienze di questi anni.

Colgo l'occasione per ringraziare la professoressa Letizia Tanca per il supportonella scrittura della tesi.

Ringrazio inoltre la professoressa Licia Sbattella e Roberto Tedesco per il corsodi Natural Language Processing, che ha fornito delle nozioni fondamentali per lascrittura di questa tesi.

Ringrazio la comunità Mozilla per la produzione, tra le altre cose, di Rhino,che ha agevolato notevolmente lo sviluppo delle applicazioni descritte ed è unprogramma estremamente interessante dal punto di vista tecnico.

Prefazione

Le aziende che interagiscono con il vasto pubblico hanno la costante necessitàdi essere consapevoli della propria immagine: è importante conoscere quanto ilmarchio e i singoli prodotti sono conosciuti e apprezzati, come la reputazione varinel corso del tempo e in base alle diverse zone geogra�che e come si ponga neiconfronti dei prodotti e dei marchi concorrenti.

Inoltre, le aziende devono sapere perché la reputazione cambi, ossia qualiaspetti di un prodotto e quali notizie hanno maggiore impatto sulla propria im-magine e quella delle concorrenti per poter poi, con cognizione di causa, prenderedelle decisioni sia riguardo all'o�erta di prodotti che alla promozione dei prodot-ti già esistenti, per esempio enfatizzando delle caratteristiche poco apprezzate odiversi�cando l'o�erta.

L'aumento vertiginoso della quantità di commenti pubblicamente disponibilinei social network da parte del vasto pubblico, avvenuto negli ultimi anni, unitoal costante miglioramento della tecnologia, permette ora di a�ancare alle clas-siche tecniche come l'indagine di mercato degli strumenti quasi completamenteautomatici per l'estrazione, l'analisi, la rappresentazione e l'esplorazione di questeinformazioni.

Questa tesi riguarda infatti lo sviluppo di un sistema software in grado diestrarre una grande quantità di commenti e messaggi pubblici da diverse sorgen-ti, come i forum o i social network, analizzarli per determinare la soddisfazioneespressa o meno dall'autore, identi�care i luoghi citati nel testo e mostrare dellesintesi gra�che di immediata comprensione permettendo all'utente di condurredelle analisi multidimensionali degli elementi, �ltrandoli e confrontandoli operan-do su più aspetti, come l'umore espresso, il periodo temporale, il luogo, la presenzadi parole chiave e la sorgente da cui è stato estratto il messaggio. La quantitàdi dati da trattare e visualizzare è così grande da richiedere l'uso di tecnichespeci�che per la loro manipolazione e rendere inutilizzabili i classici strumenti diestrazione, analisi e visualizzazione, una problematica nota come Big Data.

L'estrazione dei dati dal web è stata dapprima tentata con alcuni strumenti diampia di�usione che si sono dimostrati assolutamente ine�caci per il nostro casod'uso, quindi è stato studiato, implementato e testato uno strumento speci�co cheusando diversi accorgimenti che verranno discussi si dimostra ordini di grandezzapiù performante delle altre soluzioni esaminate, sia in termini di velocità che

8

di quantità massima dei dati che possono essere estratti, permette un'enorme�essibilità nella selezione degli elementi da estrarre e si integra facilmente conaltre soluzioni Big Data agevolando il passaggio alle successive fasi del processodi analisi.

Poiché la mole dei dati elaborati è ingente e rende inapplicabili le soluzioni dianalisi più classiche, sono state usate delle tecnologie speci�che per l'elaborazionemassiva su reti di computer che operano in parallelo, in particolare sfruttando ilparadigma per l'elaborazione parallela noto come Map/Reduce ideato da Google,che verrà spiegato e esaminato.

Saranno esaminate varie tecnologie e linguaggi potenzialmente adatti a svilup-pare questa applicazione e verrà mostrata IBM BigInsights, una piattaforma IBMbasata sul paradigma MapReduce e in particolare su una sua realizzazione praticachiamata Apache Hadoop.

L'aspetto dell'analisi automatica dell'umore espresso dall'autore di un testo,la cosiddetta sentiment analysis, verrà discusso per determinare quali siano irisultati riportati nelle pubblicazioni già esistenti e quanto questi siano applica-bili a questo caso d'uso, in particolare riguardo ai vincoli imposti dal modelloMapReduce e al tipo di testo da elaborare, ricco di errori grammaticali, stor-piature, emoticon e altri elementi colloquiali, sia in lingua italiana che in altrelingue, a di�erenza della maggior parte dei testi usati nei lavori accademici, inlingua inglese e grammaticalmente corretti.

Per a�rontare questo problema sarà discusso e implementato un algoritmo,precisamente un classi�catore naïve di Bayes, con diversi accorgimenti tali dapoter manipolare il testo in questione e operare in modalità distribuita sia perquanto riguarda la generazione del modello che per quanto riguarda la sua ap-plicazione, nonché per esaminarne l'e�cacia tramite la cross-validazione, ossia laconvalida di un modello.

Poiché lo sviluppo di applicazioni distribuite tramite MapReduce rende prati-camente impossibile lo sviluppo agile1, importante in un caso come questo doveè necessario sperimentare molte varianti, sarà sviluppato un framework che per-mette di eseguire la stessa operazione sia in modalità distribuita che localmente,in quest'ultimo caso rendendo fruibili i normali strumenti di identi�cazione deglierrori e analisi delle prestazioni. Tutte le operazioni sui messaggi saranno svolteall'interno di questo framework, compresa l'operazione di confronto dei risultatidella classi�cazione automatica con quelli della classi�cazione manuale.

Il problema della visualizzazione e soprattutto dell'esplorazione dei dati è criti-co nel caso di masse di informazioni così ingenti, ed è a�rontato con la creazionedi un'applicazione web basata sulle più recenti tecnologie, che permette all'utente�nale di visualizzare in forma sintetica i dati estratti e eseguire su di essi le co-

1ossia il tipo di sviluppo in cui un'applicazione può essere eseguita già in fase embrionale emodi�cata a piccoli passi aggiungendo le funzionalità richieste e testandola continuamente,in contrapposizione allo sviluppo in cui un'applicazione è progettata nella sua interezza eimplementata in una fase successiva con un'immagine d'insieme del risultato �nale.

9

muni operazioni analitiche agendo su più dimensioni (parole chiave, luoghi, date,umore espresso e fonte) e visualizzando i dati in tempo reale.

Per quest'ultimo aspetto è stato utilizzato un database relazionale, una soluzionenormalmente poco usata in ambito Big Data per via della bassa scalabilità, cheperò in questo caso d'uso può essere eseguito come database distribuito sotto op-portuni vincoli, che saranno ovviamente rispettati, e scalare linearmente rispettoal numero di nodi, come mostrato da uno studio[15] preesistente.

Indice

Elenco delle tabelle 15

1 Introduzione 17

2 Descrizione del problema 192.1 Presentazione e descrizione del problema . . . . . . . . . . . . . . 192.2 Obiettivi della tesi . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2.1 Il problema dell'estrazione di dati dalle pagine web . . . . 202.2.1.1 Gestione degli script e del contenuto caricato di-

namicamente . . . . . . . . . . . . . . . . . . . . 212.2.2 Sentiment analysis del testo . . . . . . . . . . . . . . . . . 222.2.3 Abbinamento dei messaggi alla posizione geogra�ca . . . . 222.2.4 Identi�cazione dell'argomento . . . . . . . . . . . . . . . . 232.2.5 Indicizzazione dei dati . . . . . . . . . . . . . . . . . . . . 232.2.6 Report gra�co . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.3 Le tecniche e le discipline esistenti . . . . . . . . . . . . . . . . . . 252.3.1 Machine Learning . . . . . . . . . . . . . . . . . . . . . . . 25

2.3.1.1 Classi�cazione di sequenze con le catene di Markov 282.3.1.2 Classi�cazione con un modello di Bayes . . . . . 292.3.1.3 Classi�cazione con una Support Vector Machine . 29

2.3.2 Natural Language Processing . . . . . . . . . . . . . . . . 312.3.2.1 Classi�cazione in base all'umore . . . . . . . . . . 32

2.4 Struttura generale della soluzione proposta . . . . . . . . . . . . . 32

3 La tematica Big Data 353.1 Cosa si intende per �Big Data� . . . . . . . . . . . . . . . . . . . 353.2 Contesti di utilizzo delle tecnologie Big Data . . . . . . . . . . . . 36

3.2.1 Previsioni meteorologiche . . . . . . . . . . . . . . . . . . . 363.2.2 Rilevamento delle frodi . . . . . . . . . . . . . . . . . . . . 373.2.3 Analisi dei social network . . . . . . . . . . . . . . . . . . 37

3.3 Cloud computing . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.4 Tecnologie e modelli per il big data . . . . . . . . . . . . . . . . . 39

3.4.1 ETL e ELT . . . . . . . . . . . . . . . . . . . . . . . . . . 39

12 INDICE

3.4.2 MapReduce . . . . . . . . . . . . . . . . . . . . . . . . . . 423.4.3 Hadoop . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.4.3.1 Architettura di una rete Hadoop . . . . . . . . . 463.4.3.2 Tolleranza ai guasti . . . . . . . . . . . . . . . . . 473.4.3.3 Politica di scheduling . . . . . . . . . . . . . . . . 483.4.3.4 Oozie . . . . . . . . . . . . . . . . . . . . . . . . 49

3.4.4 Filesystem distribuiti . . . . . . . . . . . . . . . . . . . . . 503.4.5 ZooKeeper . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.4.6 Lucene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.4.7 Solr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.4.8 Apache UIMA . . . . . . . . . . . . . . . . . . . . . . . . . 54

3.5 Database NoSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.5.1 Il CAP theorem . . . . . . . . . . . . . . . . . . . . . . . . 553.5.2 Classi�cazione dei database NoSQL . . . . . . . . . . . . . 563.5.3 MongoDB . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.5.3.1 I �ltri di Bloom . . . . . . . . . . . . . . . . . . . 663.6 Linguaggi utilizzati nei sistemi Big Data . . . . . . . . . . . . . . 68

3.6.1 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683.6.2 I linguaggi funzionali per la JVM: Groovy e Scala . . . . . 723.6.3 Scelta di non usare Scala . . . . . . . . . . . . . . . . . . . 763.6.4 Hive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.6.5 Pig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

3.6.5.1 Gestione del parallelismo con UDF arbitrarie . . 793.6.6 Jaql . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803.6.7 AQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

3.7 IBM BigInsights . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813.7.1 Presentazione della piattaforma e confronto con altre soluzioni 81

3.7.1.1 GPFS . . . . . . . . . . . . . . . . . . . . . . . . 833.7.2 Integrazione con altre tecnologie . . . . . . . . . . . . . . . 86

4 Progettazione e implementazione di una soluzione 894.1 Estrazione delle informazioni da siti web generici . . . . . . . . . . 89

4.1.1 Wget e HTTrack . . . . . . . . . . . . . . . . . . . . . . . 904.1.2 Esame di Apache Nutch . . . . . . . . . . . . . . . . . . . 914.1.3 Realizzazione di uno scraper . . . . . . . . . . . . . . . . . 92

4.1.3.1 Integrazione dello scraper con Mozilla Rhino . . . 964.1.4 Gestione del contesto e dei contenuti caricati dinamicamente 994.1.5 Esecuzione parallela dello scraper . . . . . . . . . . . . . . 1024.1.6 Analisi della scalabilità dello scraper . . . . . . . . . . . . 102

4.1.6.1 Progettazione di un benchmark . . . . . . . . . . 1034.1.6.2 Implementazione del benchmark . . . . . . . . . 1044.1.6.3 Risultati ottenuti e loro signi�cato . . . . . . . . 105

4.1.7 Implementazione di un �ltro di Bloom . . . . . . . . . . . 105

INDICE 13

4.1.8 Utilizzo di HBase per aumentare la scalabilità . . . . . . . 1094.2 Sentiment analysis dei messaggi . . . . . . . . . . . . . . . . . . . 110

4.2.1 Scelta delle categorie per la classi�cazione . . . . . . . . . 1124.2.2 Scelta delle feature . . . . . . . . . . . . . . . . . . . . . . 1124.2.3 Concatenamento di termini consecutivi per identi�care al-

cune strutture sintattiche . . . . . . . . . . . . . . . . . . . 1144.2.4 Stemming per eliminare le di�erenze morfologiche . . . . . 1144.2.5 Confronto tra algoritmi di Machine Learning . . . . . . . . 1184.2.6 Implementazione di un classi�catore naïve di Bayes paral-

lelo secondo il paradigma MapReduce . . . . . . . . . . . . 1204.3 Localizzazione geogra�ca dei messaggi . . . . . . . . . . . . . . . 122

4.3.1 Metodi di identi�cazione dei luoghi citati nel testo . . . . . 1224.3.1.1 Utilizzo del database GeoNames per trovare i no-

mi di luoghi nel testo . . . . . . . . . . . . . . . . 1234.3.1.2 Creazione di un NER per la ricerca dei nomi di

luoghi . . . . . . . . . . . . . . . . . . . . . . . . 1244.4 Ricerca dei legami tra i termini . . . . . . . . . . . . . . . . . . . 1274.5 Sviluppo di un framework per l'elaborazione di dati non strutturati 130

4.5.1 Estensione del framework tramite degli script caricati di-namicamente e semplice benchmarking della soluzione . . . 132

4.5.2 Estensione dinamica del framework tramite la re�ection . . 1334.5.3 Fasi del framework . . . . . . . . . . . . . . . . . . . . . . 1344.5.4 Utilizzo del framework per eseguire il K-folding . . . . . . 137

4.6 Indicizzazione dei dati . . . . . . . . . . . . . . . . . . . . . . . . 1384.7 Adattamento alle lingue asiatiche . . . . . . . . . . . . . . . . . . 140

4.7.1 Codi�ca dei caratteri . . . . . . . . . . . . . . . . . . . . . 1404.7.2 Tokening . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1414.7.3 Stemming . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

4.8 Rappresentazione dei dati estratti . . . . . . . . . . . . . . . . . . 1424.8.1 Applicazione web per l'analisi OLAP basata su Flask . . . 144

4.8.1.1 Filtraggio rapido dei dati . . . . . . . . . . . . . 1444.8.1.2 Drill up e rappresentazione gra�ca dei dati . . . . 1484.8.1.3 Heatmap geogra�ca . . . . . . . . . . . . . . . . 1544.8.1.4 Diagrammi a torta . . . . . . . . . . . . . . . . . 1564.8.1.5 Estrazione di elementi casuali . . . . . . . . . . . 158

4.8.2 Contestualizzazione dei dati . . . . . . . . . . . . . . . . . 158

5 Analisi dei risultati 1635.1 Accuratezza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1635.2 Velocità di esecuzione e consumo di memoria . . . . . . . . . . . . 166

5.2.1 Consumo di spazio su disco in modalità distribuita . . . . 1685.2.2 Consumo di memoria di lavoro da parte delle operazioni

map/reduce locali . . . . . . . . . . . . . . . . . . . . . . . 168

14 INDICE

5.2.3 Importazione nel database . . . . . . . . . . . . . . . . . . 169

6 Conclusioni 1716.1 Estrazione dei contenuti dal web . . . . . . . . . . . . . . . . . . . 1716.2 Elaborazione di grandi quantità di dati con un framework basato

su BigInsights sviluppato ad hoc . . . . . . . . . . . . . . . . . . . 1726.3 Sentiment Analysis con stemming euristico . . . . . . . . . . . . . 1726.4 Rappresentazione e�cace dei dati . . . . . . . . . . . . . . . . . . 1736.5 Sviluppi futuri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

6.5.1 Estrazione delle pagine web . . . . . . . . . . . . . . . . . 1736.5.2 Sentiment Analysis . . . . . . . . . . . . . . . . . . . . . . 1746.5.3 Analisi OLAP . . . . . . . . . . . . . . . . . . . . . . . . . 174

Bibliogra�a 1796.5.3.1 Test di MongoDB . . . . . . . . . . . . . . . . . . 184

6.5.4 Strumenti o�erti e procedura di installazione . . . . . . . . 1876.5.5 Gestione della piattaforma . . . . . . . . . . . . . . . . . . 190

6.6 WordCount.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1936.7 WordCount con Pig Latin . . . . . . . . . . . . . . . . . . . . . . 1956.8 WordCount in Jaql . . . . . . . . . . . . . . . . . . . . . . . . . . 195

Elenco delle tabelle

2.1 Le tre fasi dei �ussi ETL e ELT . . . . . . . . . . . . . . . . . . . 24

3.1 I tempi di esecuzione per l'inserimento delle voci di en.wiktionaryin singoli documenti di MongoDB a partire dal dump XML mem-orizzato in GridFS . . . . . . . . . . . . . . . . . . . . . . . . . . 63

3.2 Le probabilità di collisione di un elemento assegnato a un �ltro diBloom con k funzioni di hashing, p valori inseriti in precedenza eun array da m bit. . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4.1 I tempi di esecuzione del bytecode Java e di un codice analogo inJavaScript, compilato tramite Mozilla Rhino . . . . . . . . . . . . 133

4.4 Le fasi del framework per le applicazioni Map/Reduce implementato1354.7 Le fasi del framework per le applicazioni Map/Reduce implementato136

5.1 Le diverse sorgenti dei messaggi usati per generare e validare ilmodello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

5.2 L'accuratezza media della sentiment analysis, misurata con la crossvalidazione 2-folding, dei tre modi di applicazione dello stemmer.Si è usato un fattore di aggregazione pari a 5 e il dataset E . . . . 165

5.3 La massima accuratezza raggiunta nei vari dataset, e la con�gu-razione corrispondente . . . . . . . . . . . . . . . . . . . . . . . . 165

Capitolo 1

Introduzione

L'aumento continuo della capacità di memorizzazione, trasmissione e elaborazionedei dati o�erto dagli strumenti informatici, soprattutto in termini di hardware, hareso possibili nel corso del tempo operazioni impensabili solo un decennio prima,a un prezzo e a un consumo energetico sempre più bassi.

Tuttavia, i diversi indici delle prestazioni dell'hardware non aumentano con lastessa velocità, e mentre il rapporto tra prezzo e capacità della memoria di massaè sostanzialmente dimezzato ogni anno [7], la capacità di calcolo o�erta da unsingolo processore è cresciuta più lentamente (Figura 1.1) seguendo le previsionidi Moore [28]. Inoltre, poiché il consumo di potenza di un processore, e quindi ilsuo consumo di batteria nel caso di un laptop o un cellulare, cresce con il cubodella frequenza di clock, l'industria si è orientata sulla produzione di sistemi dielaborazione dotati di più processori capaci di operare in parallelo ma con unafrequenza più bassa.

Un'altra novità è la di�usione del cosiddetto cloud computing, ossia la venditamassiva e on demand di servizi e piattaforme, generalmente a�ttati per un tempoe un volume �essibili a aziende, enti e privati da parte di compagnie come Amazon,Microsoft o Google che possono sfruttare economie di scala per contenere i costidi gestione e o�rire un servizio capillare e robusto.

Inoltre, l'aumento esplosivo della di�usione dei dispositivi mobili con accessoa internet e dei social network nell'ultimo decennio ha aumentato a dismisura siala quantità di dati a cui è possibile accedere con costi e tempi ragionevolmentebassi che la loro varietà, aprendo la strada a nuove possibilità di business e anuovi servizi.

Diventa dunque fondamentale, per aziende e enti pubblici, predisporre nuovestrategie di elaborazione dei dati basate su reti di computer interconnessi chepossono essere ingrandite quando necessario sia comprando che a�ttando tramitecloud la capacità di calcolo, le quali pongono delle nuove s�de tecniche sia per

18 Introduzione

Figura 1.1: Anno di introduzione

Numero di transistor per processore dal 1971 al 2011

e confronto con la legge di Moore

Num

ero

di tr

an

sis

tor

la retta indica il raddoppio delle

prestazioni ogni due anni

L'aumento del numero di transistor per componente al passare del tempo, in scalalogaritmica. Si osservi che il consumo di energia e le dimensioni sono rimastipressoché costanti nel tempo.

quanto riguarda la parallelizzazione, l'elaborazione di elementi non strutturaticome testo puro, immagini e audio, la gestione di dati sparsi su numerosi nodiche possono rompersi o disconnettersi e la gestione di �ussi di dati prodotti inmaniera continua da più fonti come nel caso delle reti di sensori.

Capitolo 2

Descrizione del problema

2.1 Presentazione e descrizione del problema

Le aziende che svolgono un attività B2C1 hanno la costante necessità di conoscerei propri clienti, determinare quali siano le caratteristiche più apprezzate dei pro-pri prodotti o, viceversa, quali aspetti portano più frequentemente i consumatoria scegliere i prodotti di un'altra azienda. Per farlo, una soluzione classica èl'indagine di mercato, ossia la richiesta esplicita, tramite strumenti come l'inter-vista telefonica o di persona, da parte degli agenti. Vengono quindi stabilite delledomande rilevanti per gli obiettivi aziendali che vanno poi somministrate a uncampione rappresentativo della popolazione di riferimento e i risultati vengonoelaborati con delle semplici tecniche di data mining alla ricerca di conoscenzeutili che possano essere trasformate in valore aggiunto.

L'introduzione del web come piattaforma di vendita e di scambio di infor-mazioni e pareri sia tra consumatori che tra aziende e consumatori apre nuovepossibilità di analisi. È tecnicamente possibile accedere ai commenti pubblici fattida numerosi utenti su più canali, come i social network, i forum o i blog e analiz-zarli per ottenere conoscenze simili a quelle fornite dalle indagini di mercato. Cisono comunque delle notevoli di�erenze:

� L'indagine di mercato è piani�cata a priori, somministrata e in�ne analiz-zata, non si tratta di un processo interattivo e quindi bisogna sapere qualiinformazioni si vogliono cercare e attendere che venga portata a termine. Ilweb invece fornisce dati che implicitamente contengono già le informazionima bisogna estrarne conoscenza2, e questo processo, una volta implemen-tato, può essere eseguito in tempi brevi, un numero arbitrario di volte e intempi diversi.

1Business to Client, ossia interagiscono con il vasto pubblico composto da privati incontrapposizione con le Business to Business (B2B) che lavorano per altre imprese

2Il termine conoscenza, rispetto a informazione, indica l'aspetto dell'intenzionalità edell'utilità.

20 Descrizione del problema

� Mentre l'intervista è somministrata in un contesto controllato e con do-mande prestabilite, quindi si tratta di un processo attivo, i messaggi pub-blicati sul web sono scritti spontaneamente dagli utenti e vengono solamenteraccolti a posteriori con un processo passivo. Si tratta quindi di dati es-tremamente sporchi, non strutturati, e la loro analisi e�cace rappresentauna s�da per l'informatica.

� Il campione analizzato è diverso, perché da un lato si possono esaminaredei clienti che tendono a non sottoporsi alle interviste e si evitano deifenomeni di bias dovuti alla tendenza a rispondere alle domande in manierainesatta, dall'altro le persone che inviano più messaggi possono essere sovra-rappresentate.

� Il costo e il tempo per estrarre informazioni grezze dal web sono molto piùbassi di quelli necessari a eseguire un sondaggio o raccogliere opinioni libere,anche di vari ordini di grandezza.

2.2 Obiettivi della tesi

Si vuole quindi discutere e implementare una soluzione che permetta di estrarreinformazioni in grande quantità da delle fonti eterogenee sul web e analizzarlesfruttando le tecnologie big data esposte per estrarne conoscenze e quindi valore.L'analisi deve avvenire su più dimensioni, identi�cando argomenti, tempi, luoghi,riferimenti e umori dei messaggi in maniera massiva e mettendo in relazione questedimensioni.

2.2.1 Il problema dell'estrazione di dati dalle pagine web

I dati nei siti web, come i forum o i blog, non sono ovviamente rappresentati in unformato direttamente accessibile ai programmi ma bensì pensato per la visione el'esplorazione da parte degli utenti.

I dati sono organizzati in molte pagine distinte ma poste in relazione tradi loro grazie a dei collegamenti ipertestuali, dando origine a un grafo direttocon diverse problematiche. ogni pagina ha un URL3 che è una stringa univocache la identi�ca e permette di accedervi in qualsiasi momento. Innanzituttoalcune pagine non hanno contenuto di interesse, e a seconda dei casi devonoessere esaminate perché hanno dei collegamenti ipertestuali a pagine rilevanti, inaltri possono essere subito scartate.

Inoltre, esistono numerosissimi cicli e percorsi ridondanti, che rendono com-plessa la creazione di un attraversatore che visiti ogni nodo del grafo una e unasola volta.

3Uniform resource Locator

2.2 Obiettivi della tesi 21

Spesso, il contenuto di una pagina richiede di essere contestualizzato, peresempio il contenuto di un post in un forum deve essere integrato con il titolodel topic stesso, che potrebbe non essere presente nella stessa pagina ma bensìessere in una pagina visitata in precedenza. L'utente deve quindi poter de�nireun meccanismo per contestualizzare l'esame di ogni URL.

Le pagine web, poi, sono estremamente sporche: il codice HTML usato moltoraramente segue gli standard del W3C (il cosiddetto XHTML[38]) e spesso nonpresenta nemmeno una valida struttura ad albero dei tag. I browser nel corsodegli anni sono stati adattati a rendere gra�camente in maniera corretta le di-verse anomalie del codice, ma questo ha richiesto uno sforzo notevole da parte dinumerosi programmatori che non può essere verosimilmente replicato per creareun sistema software capace di estrarre del contenuto qualsiasi. È tuttavia pos-sibile de�nire una procedura molto elastica che permetta di de�nire al volo unestrattore speci�co per un certo sito con il minimo sforzo da parte dell'utente.

2.2.1.1 Gestione degli script e del contenuto caricato dinamicamente

Le moderne pagine web contengono una quantità sempre maggiore di contenutodinamico. Gli sviluppatori web, infatti, possono arricchire i normali ipertesti concodice JavaScript o animazioni Flash (nonché altre tecnologie come MicrosoftSilverlight o le applet, che sono però molto meno di�use). Questo codice vieneeseguito dal browser dell'utente e può modi�care l'aspetto della pagina e renderlainterattiva. È molto di�cile determinare automaticamente gli e�etti di questi ele-menti sul documento �nale, perché anche se si può eseguire un codice JavaScriptquesto deve avere accesso a un complesso framework di interfacce esposte dalbrowser, molto ricco e in continua evoluzione. D'altro canto, grossa parte dellemodi�che e�ettuate dal codice hanno �nalità estetiche e non alterano il contenutovero e proprio, quindi è possibile ignorarle.

Negli ultimi anni, però, ha trovato sempre maggiore di�usione una nuovamodalità di utilizzo del codice JavaScript, denominata AJAX 4. Questa tecnologiaaggiunge alle interfacce o�erte dal browser agli script la possibilità di caricareulteriori contenuti dallo stesso server che o�re la pagina, in un secondo temporispetto al caricamento della pagina vera e propria, per poi leggerli e integrarlia piacere nel suo contenuto. Così facendo, il web designer può costruire pagineche mostrano aggiornamenti senza dover essere completamente ricaricate, comeavviene con i siti di mappe quali Google Maps, Bing Maps o OpenStreetMap chesono in grado di caricare nuovi tile, ossia porzioni di mappa, al volo, rendendol'utilizzo molto più �uido di quanto avverrebbe se si dovesse ricaricare la paginaappena si sposta la visuale.

Se il contenuto caricato tramite AJAX è rilevante, uno scraper deve esserein grado di simulare funzionalmente le operazioni svolte dal contenuto attivo

4Asincronous Javascript And XML


caricando autonomamente i contenuti, e come per l'estrazione dei contenuti staticideve essere l'utente a speci�care una strategia ad hoc per il sito in questione maquesta deve essere il più semplice e immediata possibile.

2.2.2 Sentiment analysis del testo

Poiché si vuole estrarre conoscenza dal testo grezzo, bisogna fare uso delle tec-niche di Text Mining e Natural Language Processing. Esistono ad esempio deglistrumenti per determinare quali parole, nel testo, rappresentano nomi di aziende,prodotti o persone, la cosiddetta Named Entity Recognition, così come è possibilesvolgere un'attività di Sentiment Analysis, ossia determinare l'umore del con-tenuto di un certo testo (arrabbiato, soddisfatto, preoccupato, etc.). Quest'ulti-ma tecnica è usata frequentemente nei siti che esaminano recensioni di prodotti o�lm, che dispongono di dataset di commenti abbinati a punteggi numerici sull'ele-mento recensito e possono quindi generare dei modelli che mettano in relazione idue dati che rappresentano lo stato dell'arte.

La lingua italiana e l'origine dei dati pongono degli ostacoli all'implemen-tazione: innanzitutto la stragrande maggioranza degli strumenti per e�ettuarequeste operazioni o dei sottopassaggi sono fatti per manipolare la lingua inglese,per la quale esistono anche dei dataset di riferimento molto completi5 mentregli strumenti capaci di gestire l'italiano sono meno reperibili e, quando esistono,sono generalmente meno potenti.

Inoltre, le collezioni di documenti da cui sono estratti i modelli sono quasiesclusivamente composte da testo in italiano corretto, senza errori di battitura,con la punteggiatura inserita correttamente, gli accenti presenti e le frasi sep-arate da punti. Basta esaminare l'output di un qualsiasi strumento che estraeinformazioni dai social network per rendersi conto di quanto il testo sia sporco, ecome questo possa generare un problema in fase di analisi.

Alcune tecniche, però, sono robuste a questi errori, ed è sempre possibileaddestrare dei modelli ad hoc per esaminare l'italiano usato su internet.

2.2.3 Abbinamento dei messaggi alla posizione geogra�ca

Quando un'azienda opera su un territorio molto vasto, o addirittura su scalaglobale, è possibile che in diverse zone si abbiano diverse reazioni ai prodotti daparte dei clienti. Sulla vasta scala, gli abitanti di nazioni diverse, con abitudinie stili di vita diversi, possono trovare più o meno interessante un prodotto; inun ambito più locale, invece, possono esserci dei problemi con i punti d'acquistoposizionati nelle varie città e con l'uso dei prodotti. Per esempio, le persone cheabitano in una città con dei particolari vincoli alla circolazione (come l'Area C di

5Ad esempio il Brown Corpus, che contiene 500 articoli sugli argomenti più disparati per untotale di un milione di parole di cui è stata e�ettuata manualmente l'annotazione dettagliatadelle parti del discorso.

2.2 Obiettivi della tesi 23

Milano) o dei problemi di parcheggio tendono a giudicare caratteristiche come il�ltro anti-particolato o la lunghezza di un veicolo diversamente rispetto a quantofarebbero dei clienti che vivono in zone rurali.

Queste situazioni sono praticamente impossibili da rilevare a meno che nonsi eseguano continuamente delle indagini di mercato capillari, ma diversi socialnetwork, Twitter in primis, permettono di ottenere metadati geogra�ci qualoradisponibili, in particolare le coordinate GPS, e questi dati possono essere arricchi-ti considerando l'ora e la data di messaggio geo-localizzato per localizzare anchequelli temporalmente vicini da parte dello stesso utente. È possibile anche identi-�care la zona di un messaggio grazie alla presenza di termini espliciti come nomidi città o di monumenti, qualora si riescano a gestire le inevitabili ambiguità diquesti dati (ad esempio Corso Como non indica che il messaggio è relativo allacittà di Como�).

2.2.4 Identi�cazione dell'argomento

I messaggi che possono essere relativi a un'azienda o un prodotto non costituis-cono un insieme monolitico ma si possono dividere in più argomenti a secondadei casi. Ad esempio in uno dei casi concreti presi in esame, relativo a un'aziendache opera su scala mondiale, era possibile raggruppare i messaggi sostanzialmentein tre �loni: commenti sul servizio o�erto dall'azienda, commenti su notizie dicronaca relative all'azienda e commenti su eventi sportivi relativi a una squadrae uno stadio di proprietà dell'azienda stessa.

È evidente che questi casi hanno un valore diverso dal punto di vista delmercato, perché nel primo caso si tratta di riscontri diretti e personali sui prodotti,che possono mostrarne pregi e difetti percepiti, negli altri casi invece si tratta diriscontri sull'immagine generale dell'azienda.

Si vuole quindi sviluppare uno strumento che permetta sia di de�nire degliargomenti e identi�carli in maniera automatica, che riconoscere automaticamentedelle categorie tramite tecniche di text mining permettendo all'utente di accettar-le, ri�utarle o modi�carle.

2.2.5 Indicizzazione dei dati

Nelle prime fasi (scraping, sentiment analysis e identi�cazione dei luoghi e degliargomenti) lo strumento descritto è un estrattore che produce una mole di ele-menti in un formato uniforme. Per poterli sfruttare, però, è necessario indicizzarlie rappresentarli in un formato che ne renda possibile l'analisi e la sintesi, ossia ilsistema software deve agire come un ETL (Tabella 2.1)

Le operazioni possibili sui dati indicizzati devono essere, come minimo:

� Slicing - la selezione di un sottoinsieme di elementi posti entro certi inter-valli di valori nelle dimensioni ordinabili


Fase Descrizione

Extract Estrazione dei post dai forum, gestendo pagine AJAX eformati �sporchi� sia dell'HTML che della data e deltesto, isolando solo questi dati e rendendoli disponibili

all'elaborazione Map/ReduceTransform Sentiment analysis, identi�cazione dei luoghi geogra�ci

e dell'argomento. Il risultato sono delle strutture datiindipendenti tra loro con una struttura omogenea, ma

non indicizzati né pronti a un accesso veloce.Load Questa mole di dati strutturati viene indicizzata nelle

varie dimensioni, usando un datacube o un databaserelazionale, permettendone la sintesi veloce.

Tabella 2.1: Le tre fasi dei �ussi ETL e ELT

� Drill down - l'estrazione di alcuni dati speci�ci, per esempio un campione,corrispondenti a certi parametri

� Drill up - la sintesi di dati lungo una dimensione, per esempio contandoi post positivi e negativi e varie città su base settimanale, sintetizzandola dimensione temporale che così assume un dettaglio minore ma permetteuna visione d'insieme.

� Pivoting - la visualizzazione di certe dimensioni piuttosto che altre

� Conteggio - il calcolo della cardinalità dei dati in una certa dimensione

� Filtraggio con parole chiave - deve essere possibile �ltrare i dati in basealla presenza nei post di parole o espressioni arbitrarie

Queste operazioni devono essere componibili, per esempio si deve poter eseguirela selezione dei post contenenti la parola �mutuo�, la selezione di quelli del 2011e in�ne il conteggio in base alla città.

2.2.6 Report gra�co

Una volta estratti e indicizzati questi dati, è importante poterli visualizzare inmaniera rapida e e�cace. In particolare deve essere possibile:

� Visualizzare un istogramma dell'andamento dei commenti positivi e nega-tivi in base al tempo

� Visualizzare una mappa dei commenti positivi e negativi nei vari luoghi

2.3 Le tecniche e le discipline esistenti 25

� Mostrare dei diagrammi a torta sulla percentuale di commenti nelle treclassi, al variare delle dimensioni temporali e spaziali, o sulla quantità dicommenti relativi alle zone geogra�che

� Mostrare una selezione casuale del testo di alcuni post

2.3 Le tecniche e le discipline esistenti

Verranno ora brevemente descritti gli aspetti teorici di alcune discipline e deglistrumenti da esse usati citati in questo capitolo e usati nell'implementazione delsistema.

In particolare faremo riferimento alla disciplina del Machine Learning e alletecniche che questa ha messo a punto per la classi�cazione automatica, quindi auna disciplina strettamente legata al Machine Learning, ossia il Natural LanguageProcessing, che si occupa di elaborazione del linguaggio umano.

2.3.1 Machine Learning

Il Machine Learning è la branca dell'informatica che si occupa di studiare e svilup-pare sistemi in grado di �imparare� dai dati. Esempi di sistemi di questo tiposono:

� OCR (Optical Character Recognition) dei sistemi in grado di esaminare au-tomaticamente la scansione di un documento e stabilire quale sia il testoin esso contenuto identi�cando innanzitutto le zone dell'immagine che con-tengono del testo e quindi quali lettere e simboli siano presenti, accettandodiversi caratteri tipogra�ci e tollerando una certa quantità di rumore

� ASR (Automatic Speech Recognition), dei sistemi in grado di esaminareil suono della voce e riconoscere quali parole e frasi vengono pronunci-ate. Un esempio pratico di questa tecnologia è la dettatura vocale o�ertadagli smartphone con Android e iOS, o da prodotti come Dragon NaturallySpeaking

� Traduzione automatica, ossia la possibilità di tradurre automaticamente deltesto da una lingua all'altra, in maniera approssimativa ma generalmenteabbastanza chiara da permettere a una persona di coglierne il signi�cato

� Sistemi di raccomandazione, ossia strumenti in grado di suggerire a unapersona degli elementi di probabile interesse scelti da un insieme molto vas-to, basandosi sugli elementi precedentemente apprezzati dall'utente. Degli


esempi famosi sono la raccomandazione dei prodotti da parte di Amazon edei �lm da parte di Net�ix 6

� Rilevamento di volti, ossia la possibilità di individuare automaticamentela presenza di volti nelle immagini, usato dalle macchine fotogra�che e daicellulari per regolare la messa a fuoco e altre impostazioni di scatto privi-legiando i volti. Esiste anche la possibilità di riconoscere i volti, chiamatariconoscimento facciale.

� Filtri antispam, ossia la possibilità di identi�care automaticamente i mes-saggi pubblicitari indesiderati basandosi sul loro contenuto. Purtroppo an-che coloro che producono questi messaggi (gli spammer) conoscono questetecniche e possono quindi aggirarle frequentemente.

Queste sono solo alcune delle applicazioni del Machine Learning, quelle più evi-denti al vasto pubblico, e si possono identi�care due aspetti comuni, propri delMachine Learning:

� Questi sistemi sono approssimativi: a di�erenza di altri algoritmi, comeun algoritmo di ordinamento7, il risultato non è sempre corretto, ma soloprobabilmente corretto. Si tratta infatti di euristiche 8. Addirittura, non ènemmeno possibile de�nire formalmente quale sia il risultato corretto masolo a�darsi al confronto con una valutazione empirica svolta da un essereumano.

� Questi sistemi sono costruiti a partire dai dati, ossia si basano su unanalisi statistica di un campione di elementi già esaminati e trattati dagliesseri umani. Per esempio la traduzione automatica sfrutta delle raccolte ditesti già abbinati alle loro traduzioni da dei traduttori umani per deciderela correlazione tra i termini; il riconoscimento di volti sfrutta raccolte diimmagini in cui i volti sono stati marcati a mano per stabilire, statistica-mente, quali combinazioni di colori, forme e intensità luminose sono deivolti.

6Azienda americana che o�re �lm e altro materiale on-demand previo pagamento di uncanone �sso.

7un algoritmo che, data una lista di elementi e un criterio di ordinamento (numerico, al-fabetico, temporale, etc.), fornisce una lista con gli stessi elementi ordinati in base a talecriterio

8Un'euristica è una regola che fornisce soluzioni che non sono ottimali ma generalmentebuone. Si applica quando i dati e i modelli sono incerti oppure quando la ricerca della soluzioneottimale sarebbe impraticabile. In psicologia l'euristica è una regola empirica applicata da unessere umano, consapevolmente o meno, per a�rontare situazioni troppo complesse, rapide oincerte per esprimere un giudizio analitico.


� La macchina non comprende gli elementi che sta elaborando. Al di làdelle implicazioni �loso�che9 e psicologiche, che richiederebbero una trat-tazione molto lunga che comunque non esaurirebbe l'argomento, questosigni�ca che la macchina non ha un modello che descriva la natura deglielementi trattati.Nel caso per esempio del riconoscimento dei volti il sistema non ha nessunainformazione sul fatto che i volti nelle foto siano proiezioni bidimensionalidi un'entità a tre dimensioni, che è generalmente abbinata a un corpo, nésul fatto che le di�erenze di intensità luminosa siano causate dal modo incui la luce viene ri�essa o fermata dalle super�ci. Allo stesso modo un�ltro antispam non ha una descrizione concettuale di cosa siano il viagrao il casinò online. Questo ha delle importanti conseguenze pratiche: unumano riconosce un volto perché analizza contemporaneamente gli elemen-ti di un'immagine, determinando la situazione rappresentata, il luogo, iltempo atmosferico, le età, i generi e le etnie e da questi ricavando un con-testo molto profondo (per esempio da una foto di una persona che spegnedelle candele su una torta intuisce che si tratta di un compleanno e quellapersona è il festeggiato), potendo così riconoscere un volto anche qualorasia coperto, distorto o addirittura disegnato. Allo stesso modo sentendoun parlante della propria lingua le frasi vengono comprese e si intuiscono itermini usati anche quando il suono sia distorto, mentre i programmi attual-mente si limitano a �contestualizzare� i termini usando delle statistiche suitermini adiacenti in una certa lingua, motivo per cui da decenni l'accuratez-za dei sistemi ASR non cresce[19] e rimane molto inferiore a quella degliesseri umani. In sostanza, il Machine Learning mira a ottenere un'approssi-mazione dei risultati di un processo cognitivo senza nemmeno tentare direplicare il processo cognitivo stesso, approccio che �nora ha dato scarsirisultati anche per via della enorme di�erenza tra le capacità di calcolo diuna macchina e quelle di un cervello animale.

La classi�cazione è uno degli aspetti più frequenti del Machine Learning. Unproblema di classi�cazione è tipicamente de�nito da:

1. Una serie di categorie, o classi, de�nite a priori, a cui possono essereassegnati degli elementi

2. Una serie di elementi con una serie di caratteristiche, dette feature, chepossono essere valori numerici (età, intensità luminosa, larghezza, etc.),booleani (vero o falso) o altri.

3. Una serie di elementi già classi�cati da degli esseri umani

9A tal proposito si può studiare la letteratura riguardante il test di Turing e l'esperimentomentale della �stanza cinese�


Un algoritmo di machine learning esamina gli elementi già classi�cati e costruisceun modello statistico che permette di classi�care, approssimativamente, dei nuovielementi, basandosi sulle feature. Esiste un arsenale di metodi per costruire eapplicare questi modelli, qui verranno esposti i tre metodi di interesse per la tesi:catene di Markov, classi�catore di Bayes e Support Vector Machine.

2.3.1.1 Classi�cazione di sequenze con le catene di Markov

Per de�nire il susseguirsi delle sequenze di simboli, scelti da un alfabeto �nito, chepossono presentare vincoli sul loro concatenamento, si può usare un cosiddettoautoma a stati �niti.

Si tratta di un grafo i cui nodi rappresentano dei simboli dell'alfabeto e gliarchi i passaggi da un simbolo all'altro. Dato un automa a stati �niti e de�nitouno e uno solo dei nodi come stato iniziale è possibile esaminare una sequenzadi simboli iterando sui suoi componenti e seguendo di volta in volta l'arco cheporta a uno stato con il simbolo su cui si sta iterando a partire dal nodo correntee scegliendo il nodo di destinazione come nuovo nodo di riferimento.

Se si arriva alla �ne della sequenza senza mai riscontrare la mancanza di unarco dal nodo attuale, la sequenza è accettata dall'automa, altrimenti è ri�utata.Inoltre, è possibile aggiungere il requisito che il nodo di arrivo della sequenza siain un insieme di nodi detti stati �nali.

Una espressione regolare è un modo semplice di rappresentare un automa astati �niti con dei simboli presenti sulle tastiere, usato dai programmatori. Peresempio, l'espressione regolare ^v[a−z]+l [0−9]*$ indica un testo che inizia con lalettera v, prosegue con una sequenza di caratteri alfabetici di lunghezza qualsiasi,la lettera l, uno spazio e una sequenza di cifre di lunghezza arbitraria che puòanche essere assente.

La sintassi delle espressioni regolari non verrà qui trattata, basti sapere cheesistono dei grossi limiti alla possibilità data dagli automi di riconoscere dellesequenze di simboli, in particolare non è possibile avere memoria dei terminiincontrati, quindi non è possibile scrivere un'espressione regolare che riconoscauna sequenza del tipo �(())� veri�cando che le parentesi aperte combacino conquelle chiuse, perché sarebbe necessario contare gli elementi esaminati in attesache siano bilanciati.

Una catena di Markov è una generalizzazione di un automa a stati �niti cheabbina ad ogni arco una probabilità di transizione. Mentre un automa a stati�niti accetta o ri�uta nettamente una sequenza, la catena di Markov ne fornisceuna probabilità, dando un valore quantitativo alla corrispondenza con un modello.

Le applicazioni sono moltissime, per esempio è possibile decidere quale parolasia più adatta a essere inserita in un punto di una frase cercando la massimaprobabilità di riconoscimento della frase intera.


Un modello di Markov può essere generato automaticamente esaminando dellesequenze di simboli valide e contando i passaggi da un simbolo a un altro, e quindile probabilità degli archi abbinati a tali passaggi.

Una variante di�usissima del modello di Markov è il modello a catene nascostedi Markov, o HMM (Hidden Markov Model), che aggiunge a ogni stato una fun-zione probabilistica che permette di emettere un certo simbolo. Avendo unasequenza di simboli è così possibile incrementare l'accuratezza della loro identi�-cazione sapendo le probabilità che un simbolo sia presente dopo un altro. I sistemidi OCR, per esempio, se riconoscono la parola �muo� con maggiore probabilitàdi �mio� dopo aver identi�cato il termine �il� scelgono il secondo perché combi-nano la probabilità di riconoscimento del simbolo individuale con le probabilitàche quel simbolo si trovi in quel contesto.

2.3.1.2 Classi�cazione con un modello di Bayes

La formula per le probabilità condizionate di Bayes permette di calcolare, datele probabilità di un evento B in funzione di un evento A e le probabilità di unevento A preso singolarmente, le probabilità dell'evento A dato l'evento B, ossia:

P (A|B) =P (B|A)P (A)

P (B|A)P (A) + P (B|¬A)P (¬A)

La spiegazione è immediata (Figura 2.1), e può essere estesa a un numeroarbitrario di classi espandendo il termine generico ¬A speci�cando le diverseclassi alternative ad A.

L'applicazione alla classi�cazione è immediata: se l'evento A corrisponde a�l'elemento appartiene a una categoria� e l'evento B corrisponde a �l'elementopresenta certe feature�, è possibile calcolare le probabilità che un elemento ap-partenga a una certa categoria sapendo le probabilità che un elemento qualsiasiappartenga a quella categoria e le probabilità che un elemento con quelle featureappartenga a quella categoria.

Decidere la categoria più adatta a contenere un certo elemento, dunque, siriconduce a calcolare la categoria per cui la formula restituisce la probabilitàmaggiore.

2.3.1.3 Classi�cazione con una Support Vector Machine

Una SVM, Support Vector Machine, è un classi�catore che rappresenta ogni el-emento come un punto di uno spazio a N dimensioni, dove ogni dimensionecorrisponde al valore di una certa feature. Le diverse classi vengono così fattecorrispondere a diverse regioni di questo spazio.


Figura 2.1:

P(¬B,¬A)

P(B,¬A)

P(B,A)

P(¬B,A)

A ~A

Rappresentando lo spazio degli eventi in un quadrato di lato unitario, esso èpartizionabile in quattro zone corrispondenti alle 4 combinazioni degli eventi A eB, le cui aree sono pari alle rispettive probabilità. Con questa rappresentazionegra�ca è immediato osservare che le probabilità P (B|A) sono date dal rapportotra l'area del rettangolo in alto a sinistra e l'area totale dei due rettangoli in alto.


La SVM richiede che le classi siano divise da un iperpiano, quindi le chiusureconvesse delle regioni di spazio corrispondenti alle classi non possono sovrapporsi,altrimenti non è possibile separarle con un iperpiano.

Poiché questo nella realtà accade, si adotta una variazione chiamata kerneltrick: il vettore delle feature viene passato a una funzione chiamata kernel, chegenera un nuovo vettore applicando una trasformazione non lineare, quindi siprocede a classi�care questo nuovo vettore.

La non linearità è necessaria perché, ovviamente, una trasformazione linearemanterrebbe le sovrapposizioni tra le chiusure convesse delle regioni di spaziocorrispondenti alle diverse classi.

Inoltre, la funzione kernel è generalmente continua nello spazio delle feature,altrimenti la costruzione del modello potrebbe risultare impossibile.

La costruzione del modello10, detta addestramento o training è un problemadi ottimizzazione: dato un elemento si misura la sua distanza dal piano e quindila bontà della classi�cazione, detta �tness ; più il piano è lontano e più la classi�-cazione è forte e quindi ha una �tness alta, positive se la classi�cazione è corretta(quindi il punto si trova dalla parte desiderata del piano) e negative nel caso laclassi�cazione sia errata. Trovare l'iperpiano ottimale corrisponde a trovare ilmaggiore totale degli indici di �tness di ogni punto, un'operazione molto di�ciledal punto di vista computazionale e quindi gestita delle con librerie esterne cheimplementano degli avanzatissimi strumenti matematici.

2.3.2 Natural Language Processing

Il Natural Language Processing è la branca dell'informatica che si occupa di ma-nipolare le lingue umane, che sono intrinsecamente ambigue e variegate, dettenaturali per distinguerle dai linguaggi di programmazione che invece sono for-malmente de�niti e non hanno interpretazioni ambigue.

Proprio per l'intrinseca ambiguità delle lingue naturali, molti aspetti dellaloro elaborazione ricadono nel Machine Learning.

L'identi�cazione delle parti del discorso, come verbo, nome e aggettivo, è unproblema euristico poiché moltissime parole sono ambigue: �francese� può indi-care la lingua francese, un abitante della Francia o essere un aggettivo applicatoa un'altra parola, come �auto francese�. Gli HMM permettono di gestire ques-ta ambiguità e�cacemente proprio grazie alla loro, seppur limitata, capacità ditenere conto del contesto. Classi�cando dei termini si hanno infatti delle in-formazioni statistiche sulle probabilità che i termini successivi abbiano un certoruolo nella frase, per esempio un aggettivo spesso è successivo a un sostantivo,

10Esistono diversi tipi di SVM. Quella qui descritta utilizza una classi�cazione soft, gestendola possibilità che esista del rumore che sposta comunque alcuni punti da una regioen all'altra,quindi cerca un iperpiano che massimizzi la precisione senza classi�care comunque tutti glielementi.


quindi il termine �francese� può essere identi�cato come aggettivo nel caso seguail termine �auto�, che invece non è ambiguo.

2.3.2.1 Classi�cazione in base all'umore

Anche la classi�cazione dell'argomento, del registro e dell'umore di un testo pos-sono avvenire grazie a delle tecniche di machine learning: considerando la pre-senza o meno di una parola in un testo come una feature dello stesso, è possibileapplicare le tecniche sopra esposte per la classi�cazione automatica di nuovi testi,come avviene nel caso dei �ltri anti spam.

Leggendo e marcando in base all'umore dei messaggi di testo è possibile quindicostruire dei modelli che permettano di classi�care nuovi messaggi in tal senso, inmaniera automatica. Bisogna però determinare quale tecnica di machine learningsia più adatta e quali siano le sue prestazioni al variare della lingua, della fontee del contesto dei messaggi. La trasformazione del testo in un vettore di feature,poi, non è a�atto un'operazione lineare ma può essere fatta in molti modi, appli-cando delle manipolazioni e arricchendo questo vettore in vari modi che verrannodiscussi più avanti.

2.4 Struttura generale della soluzione proposta

La soluzione progettata e implementata in questa tesi, esposta in Figura 2.2,prevede un processo a cavallo tra i modelli ETL e ELT che fornisca i messaggi e irelativi metadati di rilievo in un formato �sso, permettendo di applicare delle op-erazioni di machine learning su grossi corpus per estrarne argomento, sentimentoe luogo geogra�co; si vuole poi rappresentare e�cacemente questi dati e permet-tere a un utente di manipolare i criteri per la loro classi�cazione e interrogare lacollezione di metadati generata in maniera simile a come si farebbe con un datacube OLAP.

Il sistema software è concepito per essere utilizzato da persone con buoneconoscenze informatiche ma non necessariamente esperte di machine learning.Poiché in particolare l'uso di Hadoop, e nello speci�co dell'intera piattaformaBigInsights, richiede delle conoscenze piuttosto approfondite, si cercherà di tenereabbastanza separate le componenti di controllo dell'elaborazione e visualizzazionedei risultati da quelle di elaborazione vera e propria, fornendo delle interfaccesempli�cate per queste ultime.

Questa scelta è comunque necessaria vista la grossa di�erenza tecnica e con-cettuale tra un programma MapReduce distribuito basato su Hadoop e un'appli-cazione web in termini tecnici, che rende sconveniente, se non impossibile, creareun'applicazione monolitica.

2.4 Struttura generale della soluzione proposta 33

Figura 2.2:

WEB

Informazioni estratte

(grezze)

Conoscenza

estratta

Modello

(preesistente e

addestrato)

Mappe

(heatmap, SOM delle

parole chiave)

Grafici andamento

occorrenze e sentiment

relazioni di interesse

configurazione Estrattore

Analisi

geografica

Sentiment

analysis

ReportingSelezione relazioni

di interesse

Validazione e

correzione

Ricerca di

relazioni

Analisi del

topic

Lo schema del sistema software che si intende realizzare, le frecce indicano la di-rezione dell'elaborazione dei dati, rappresentati dagli ovali, che passano attraversole di�erenti fasi rappresentate dai rettangoli.

Capitolo 3

La tematica Big Data

3.1 Cosa si intende per �Big Data�

Il termine Big Data indica in generale tutte le tecnologie adatte a elaborare daticapaci di gestire volumi, varietà e velocità tali da richiedere un cambiamentoqualitativo oltre che quantitativo.

Queste tre V, velocità, varietà e volume, descrivono la problematica del BigData. Infatti:

� I database relazionali che rispettano le proprietà ACID[4] subiscono un ab-bassamento delle prestazioni nel caso in cui gli accessi simultanei diventinomolto numerosi, dovendo garantire che le transazioni non interferiscano tradi loro, ma in alcuni casi, per esempio per quanto riguarda la gestione deipost in un social network, è possibile allentare questi vincoli e accettarel'inconsistenza del database purché sia temporanea.

� I normali database spesso non sono adatti a gestire dati non strutturaticome immagini, video, dati da sensori che hanno un'a�dabilità variabile econtenuti testuali, permettendo in genere solo di memorizzarli ma non die�ettuare ricerche al loro interno o elaborazioni.

� Spesso un dato ha un'utilità limitata nel tempo, alla �ne della quale il puòessere eliminato, in cui è fondamentale potervi accedere e�cacemente, è ilcaso per esempio dell'analisi dei log di errore, del rilevamento delle froditelematiche o della gestione del tra�co stradale. Le tradizionali soluzioniinformatiche basate sui database relazionali sono inadatte a questo tipo dioperazione; esiste un linguaggio ispirato all'SQL, chiamato StreamSQL, chepermette di gestire �ussi continui di dati, ma ha la limitazione di richiedereuno schema rigido, o�rire una scarsa integrazione con basi di dati perma-nenti, ed è inadatto a implementare e sfruttare strutture dati probabilistichecome i �ltri di Bloom.

36 La tematica Big Data

� Aumentando il volume delle informazioni diventa necessario aumentare inodi della rete e dividere i dati tra di essi per poterli elaborare in paralle-lo. Ma così facendo si aumenta inevitabilmente la frequenza di guasto conconseguente rischio di blocco dell'intero sistema e perdita di soldi e compet-itività; sarebbe meglio disporre di un sistema di elaborazione più tolleranteai guasti sia tramite la replicazione dei dati, che comunque è ottenibile an-che in un database tradizionale, che dividendo le operazioni sugli stessi intanti task eseguibili in parallelo la cui esecuzione è monitorata, in modo dapoter riavviare o riassegnare un task speci�co a un nodo della rete qualorail nodo originariamente responsabile dello stesso risulti guasto o irraggiun-gibile, senza bloccare l'intera operazione. Questa idea trova realizzazionenel paradigma Map Reduce che verrà esaminato nel dettaglio più avanti.

Un classico Data Warehouse aziendale, per esempio, è basato su uno o più servercentrali che contengono i dati, è tipicamente basato su un database relazionaleche rispetta le proprietà ACID e impone uno schema alle informazioni contenute.Questo tipo di base dati permette all'azienda di avere buone garanzie sul valoredei dati stessi e sulla loro accessibilità, rendendo possibile condurre analisi OLAP1

per estrarre conoscenza utile dalle informazioni.I processi OLAP, però, richiedono in genere di lavorare sui dati a freddo,

ossia mentre il database non sta venendo modi�cato oppure su una copia dellostesso in un certo istante detta snapshot. Integrare questo tipo di sistema con�ussi di dati provenienti continuamente da più fonti come i social network o deiweb service pubblicamente accessibili per per formare analisi elaborate come, adesempio, determinare statisticamente il livello di soddisfazione dei clienti nel corsodel tempo e in base alla zona geogra�ca a partire dall'analisi del testo dei varimessaggi, pubblicati sui social network o inviati direttamente all'azienda comereclami o suggerimenti, (la cosiddetta sentiment analysis, che verrà esaminatapiù avanti).

3.2 Contesti di utilizzo delle tecnologie Big Data

Le tecnologie Big Data possono essere adottate in tutti quei contesti in cui le treV sono di fondamentale importanza, alcuni di questi sono molto frequenti:

3.2.1 Previsioni meteorologiche

Le stazioni di rilevamento producono costantemente dei dati, che devono es-sere elaborati per generare un modello predittivo. Oltre alle comune previsioni,pubblicate quotidianamente sui giornali e su internet, esistono dei casi in cui

1On Line Analytical Process, l'analisi di una copia delle informazioni presenti nella base datiin un certo istante per ricercare proprietà e correlazioni interessanti

3.2 Contesti di utilizzo delle tecnologie Big Data 37

un'azienda o un ente governativo ha bisogno di previsioni estremamente precisein una zona ben de�nita.

In questo caso, le previsioni meteo su scala nazionale o mondiale non sonopiù su�cienti, non solo per via della precisione ma soprattutto per la scarsagranularità dei dati nella dimensione geogra�ca. Per esempio l'azienda daneseVesta, per ottimizzare gli investimenti, deve piazzare le proprie pale in posizioniottimali, dove il vento sia il più forte possibile nel corso dell'anno senza peròessere mai così forte da causare dei danni alle strutture. Dunque, utilizzandola tecnologia IBM BigInsights che verrà esposta più avanti2, Vesta ha elaboratooltre 6 Petabyte di dati con un cluster operante in parallelo, generando un modellometeorologico con una granularità di 10 metri.

3.2.2 Rilevamento delle frodi

L'analisi di una grande quantità di transazioni che avvengono nei sistemi di com-mercio elettronico e e-banking richiede una grande capacità di elaborazione edeve essere, per la natura stessa del problema, svolta in tempi brevi. È possi-bile svolgere tali analisi sfruttando le tecniche di machine learning[14], un casotipico è l'applicazione di algoritmi di clustering all'insieme delle transazioni perindividuare i casi tipici, per poi determinare automaticamente quali sono le at-tività �anomale� su cui concentrare l'attenzione. Questi cluster devono esserericalcolati continuamente per adattarsi ai cambiamenti della

Non è solo la generazione di modelli a essere computazionalmente pesante,ma anche la loro applicazione: poiché è necessario incrociare molti dati (ana-gra�ca degli utenti, database di cattivi pagatori esterni all'azienda, transazionisu dispositivi diversi, etc.) non è possibile integrare la logica anti-frodi nelle sin-gole applicazioni, per esempio nei front-end web, ma deve necessariamente esseresvolta in parallelo da una componente dedicata.

Un discorso simile vale per gli IDS 3, che però hanno requisiti di reattivitàancora più stringenti e elaborano volumi di dati relativamente piccoli, quindi letecniche BigData sono adatte principalmente per l'analisi massiva dei log e lagenerazione di modelli a posteriori.

3.2.3 Analisi dei social network

I social network, e più in generale tutte le piattaforme di interazione tra utentionline come i forum, forniscono una quantità di messaggi e commenti enorme, suqualsiasi argomento e in qualsiasi lingua. Da molti anni i motori di ricerca indiciz-zano le pagine di questi siti e generano degli indici in maniera distribuita, spesso

2http://www-03.ibm.com/press/us/en/pressrelease/35737.wss3Intrusion Detection System, dei programmi in grado di segnalare delle situazioni anomale

agli amministratori di una rete, che possono essere dei segni di un attacco in corso

http://www-03.ibm.com/press/us/en/pressrelease/35737.wss


con dei passaggi computazionalmente molto pesanti, come l'applicazione dell'al-goritmo PageRank, utilizzando il parallelismo, e proprio per costruire questi indiciGoogle ha sviluppato il paradigma MapReduce che verrà esaminato e utilizzatoa fondo nel corso di questa tesi.

Tuttavia, i dati testuali che è possibile ricavare dai social network possonofornire informazioni di interesse commerciale, per esempio è possibile determinarequanto spesso un certo prodotto viene citato, quali prodotti vengono usati con-temporaneamente dalle stesse persone, in quali zone geogra�che e con quale opin-ione. Grazie all'aumento della fetta di popolazione che utilizza il web, negli ultimianni la quantità di messaggi pubblici è aumentata notevolmente rendendo questapossibilità sempre più interessante.

Alcuni studi[36] esaminano come le opinioni si di�ondono all'interno del grafodelle conoscenze social network, permettendo di ottenere delle previsioni dei trendfuturi.

3.3 Cloud computing

Un'altra novità degli ultimi anni, ortogonale alle possibilità o�erte dalle tecnologieBig Data, è il cosiddetto cloud computing. In sostanza si tratta della possibilità diottenere spazio di archiviazione, potenza di calcolo e connettività on demand,pagando di conseguenza in proporzione all'utilizzo e�ettivo del servizio, che puòessere variato in qualsiasi momento.Il termine �cloud computing� indica in realtàun vasto assortimento di tecnologie, che spaziano dall'o�erta di una piattaformaper applicazioni speci�che, come Google App Engine che ospita applicazioni Javao Python che si interfacciano a delle speci�che API, a macchine complete su cuisi possono installare sistemi operativi e programmi a piacere come nel caso diAmazon EC2.

In questo ultimo caso, che è di nostro interesse perché permette di ospitare iprogrammi usati in alcune tecnologie Big Data, in particolare Hadoop, l'aziendache o�re il servizio fa un forte uso di economie di scala e sistemi di virtualizzazione.

La virtualizzazione permette di utilizzare un numero ridotto di server moltopotenti per eseguire e monitorare molte istanze simultanee di macchine virtuali,traendo vantaggio dal fatto che le loro attività sono indipendenti e per la maggiorparte del tempo sono scarse, presentando un pro�lo di attività �bursty�, ossiache alterna lunghi momenti di inazione con picchi improvvisi e intensi. Tramitela virtualizzazione è possibile spostare le istanze delle macchine virtuali tra i variserver �sici, che possono essere situati in continenti diversi, in modo trasparenteall'utilizzatore.

Dal punto di vista del cliente si ha la possibilità di scalare velocemente senzacomprare nuovo hardware, potendo così gestire dei volumi di richieste di serviziche variano nel tempo; le aziende che o�rono questi servizi invece traggono van-

3.4 Tecnologie e modelli per il big data 39

taggio da economie di scala che abbassano i costi per unità delle istanze dellemacchine virtuali aumentando, di conseguenza, i guadagni per l'azienda.

Amazon EC2

Amazon Elastic Compute Cloud (EC2), è stato uno dei primi servizi a o�rirecloud computing, ed è attualmente il più grande in termini di clienti, numero diistanze virtualizzate e quantità di dati elaborati. Tra gli altri, siti come Reddit,Foursquare e Tumblr utilizzano questo servizio. L'o�erta di Amazon è basata su12 tipi di istanza, con diverse prestazioni e prezzi, a cui si aggiunge un servizio ondemand per la memorizzazione dei dati, il Simple Storage Service (S3), che comel'EC2 può essere espanso on demand per memorizzare una quantità variabile didati.

Heroku

Heroku o�re un servizio di PAaS 4 come App Engine di Google, ma molto più�essibile in termini di varietà delle tecnologie utilizzabili. È possibile infatticaricare su Heroku applicazioni Java, Scala, Python, Ruby e node.js, che possonousufruire di numerosi database NoSQL, come MongoDB, Neo4j, Redis e altri cheverranno esposti più avanti. Questo rende la piattaforma molto interessante aglisviluppatori intenzionati a provare queste nuove tecnologie. Tuttavia, lo scopoprincipale del servizio è la pubblicazione di applicazioni web, e non si prestaall'elaborazione massiva di dati.

3.4 Tecnologie e modelli per il big data

3.4.1 ETL e ELT

Quando un'azienda acquisisce dei dati, questi richiedono quasi sempre di esseretrattati per poter essere inseriti nel data warehouse. In alcuni casi si tratta di uncambiamento �lineare�, applicato alla singola tupla, come nel caso dell'assimi-lazione di un �le CSV in un database SQL, mentre in altri casi i dati da integrarenel database richiedono un trattamento molto pesante. I possibili motivi pere�ettuare questo trattamento sono:

� I dati non sono immediatamente disponibili in una struttura monolitica,nella loro totalità, ma devono essere estratti uno a uno. È il caso di una se-rie di log in cartelle, che sono generalmente salvati in �le organizzati su basetemporale: a una certa ora o giorno il sistema di logging esegue un logrotate,ossia salva il log corrente con un nome indicativo (come log_2012012213.log

4Platform As a Service


per un blog salvato alle ore 13 del 22 ottobre 2012) e si prepara a usare unnuovo �le. Sarà dunque necessario esaminare ricorsivamente tutti i �le nellecartelle dei log, con eventuali sottocartelle, e estrarne il contenuto. A voltenon basta estrarre il contenuto di ogni �le ma è necessario contestualizzar-lo, per esempio perché i log riportano solo l'ora ma non il giorno (che ècontenuto nel nome del �le).

� I dati sono sporchi. Per esempio nel caso delle pagine web, nonostante esis-tano da anni degli standard rigorosi sul formato del codice web (il cosiddettoXHTML, che prevede anche la possibilità di validare automaticamente unapagina 5), è estremamente raro che una pagina abbia una struttura chiarae ordinata, dato che sono concepite per essere lette dai browser che sonofatti per leggere codice incorretto e mostrarlo agli utenti piuttosto che peressere lette automaticamente da dei programmi. Bisogna quindi creare delleapplicazioni ad hoc in grado di gestire le numerose irregolarità del codicee estrarne comunque il contenuto desiderato. Più avanti verrà discussa laprogettazione di un sistema software di questo tipo, un cosiddetto scraper,e ne verrà mostrata un'implementazione. Negli ultimi anni, l'introduzionedella tecnologia AJAX ha permesso agli sviluppatori web di caricare con-tenuti in maniera asincrona in qualsiasi momento e non solo al caricamentodella pagina, senza ricorrere a componenti aggiuntive come Adobe Flash.Spesso questa tecnologia è abusata portando al caricamento di tutto il con-tenuto tramite AJAX senza che questo sia necessario, rendendo di�cile peruno scraper, che non esegue il codice JavaScript, determinare il contenutovisto e�ettivamente dall'utente. Lo scraper realizzato propone una tecni-ca generale per gestire agilmente anche questa problematica e in generalequalsiasi contenuto caricato in un secondo tempo tramite Flash, Comet oanaloghi. La questione della validità del codice XHTML e della diversa in-terpretazione da parte dei browser verrà discussa anche per quanto riguardala realizzazione di un'interfaccia web per l'analisi OLAP.

� I dati sono ridondanti. Se i dati sono stati generati da più entità in-dipendenti, per esempio dei dispositivi mobili o dei laptop scollegati dallarete, è estremamente frequente che la stessa informazione abbia più occor-renze, per esempio perché presente in diversi formati o con diversi nomi.Bisogna quindi andare più in profondità e indicizzare il contenuto e�ettivoper identi�care le copie ridondanti di una tupla o un documento.

� I dati sono in un formato particolare. Se gestire collezioni di strutture datiin JSON, XML o CSV è in genere un'operazione triviale e ben supportatada molte librerie in qualsiasi linguaggio, lo stesso discorso non vale per deicomuni documenti di testo. Alcuni dei problemi che possono emergere sono:

5http://validator.w3.org/

http://validator.w3.org/


� La codi�ca non è nota: Un documento può essere in ASCII, UTF-8,UTF-16 o una delle numerose codi�che usate localmente come la ISO8859 che nelle sue varianti (specialmente la 8859-1, chiamata WesternEurope) è spesso usata nei paesi europei. Caricando un documento ènecessario sapere la sua codi�ca, ma non sempre questa informazione èdisponibile: come nel caso delle pagine web, si assume che il documen-to sia letto da un essere umano che ne comprende il signi�cato anche sele lettere accentate vengono sostituite da altri simboli o al più cambiala codi�ca a mano. Nel caso delle pagine web, le informazioni sul-la codi�ca sono inserite nell'intestazione HTTP, il cosiddetto header,ma questo potrebbe essere sbagliato. Poiché molti linguaggi e libreriesono stati sviluppati negli USA e quindi manipolino esclusivamentestringhe in lingua inglese, è frequente che usino la semplice codi�caASCII (che, come indica la sigla American Standard Code for Infor-mation Exchange, è stata concepita per gestire solo la lingua inglese)creando dei problemi quando si devono manipolare lingue contenenticaratteri accentati o dieresi, per non parlare di lingue come il cinese oil giapponese che utilizzando migliaia di ideogrammi distinti rendonoimpossibile la codi�ca a 8 bit. Utilizzando linguaggi come Java, Scalao Python (quest'ultimo dalla versione 3 in poi) si utilizza nativamentela codi�ca UTF-8 che supporta ogni carattere, ma rimane il problemadi assimilare documenti esterni.

� Il formato non ha una struttura chiaramente nota. Le versioni di Mi-crosoft O�ce precedenti al 2007 utilizzavano un formato proprietarioper salvare i documenti (i cosiddetti .doc e .xls, più altri formati)che non era pubblicamente noto, e solo nel 2006 è stato esaminatodettagliatamente[31]. Inoltre, la struttura interna dei �le .doc è cam-biata nel corso del tempo generando degli errori qualora si apra undocumento interpretandolo come se fosse di un'altra versione rispettoa quella reale. Ora i �le di O�ce seguono uno standard noto ed èpiù semplice esaminarli. Un discorso simile vale per il formato PDF,formato che col passare del tempo è stato arricchito con contenuti mul-timediali, �rme digitali, JavaScript e altre componenti molto di�cilida esaminare correttamente.

Il processo di assimilazione di nuovi dati, che presenta questi problemi è chiamatoETL, ossia Extract Transform Load, e può essere e�ettuato una tantum, comequando si crea una DWH per la prima volta, o regolarmente, come quando siimportano in un database centrale le informazioni sulle transazioni e�ettuate nelcorso della giornata nei diversi punti vendita sul territorio. Nel contesto del bigdata l'assimilazione può essere continua, cioè avvenire in tempo reale su datiprodotti in maniera irregolare. Per esempio una catena di supermercati può


estrarre valore dalle informazioni sulla vendita dei prodotti evitando che dellamerce molto richiesta non sia disponibile o proponendo o�erte in tempo reale.

Nel caso delle soluzioni big data è possibile eseguire la fase di trasformazionedei dati in un secondo tempo, sfruttando la nuova possibilità di memorizzaree esaminare dati non strutturati come testi e �le grezzi. Questa soluzione,detta semplicemente ELT, ossia Extract, Load Transform, presenta vantaggi esvantaggi:

Vantaggi:

� Se la fase di trasformazione era e�ettuata da un nodo della rete diversoda quello che esegue l'estrazione, si genera meno tra�co in rete

� Se è necessario accedere più volte a diversi dati non strutturati, comenel caso dell'eliminazione dei doppioni, è possibile sfruttare le capacitàdi indicizzazione dei dati non strutturati o�erte dai sistemi big data(per esempio Lucene, che verrà esaminato in seguito) per ottenere unaumento delle prestazioni

� Se è possibile che gli stessi dati grezzi vadano esaminati ulteriormentein futuro per eseguire altre trasformazioni, diventano accessibili confacilità in ogni momento.

Svantaggi:

� Se l'operazione di trasformazione è triviale o può comunque essere integratanella fase di estrazione, si ha un overhead per il caricamento dei dati grezzisenza ottenere nessun vantaggio.

� Molte delle librerie e dei tool per e�ettuare la trasformazione dei dati nonsono in grado di interfacciarsi con questi sistemi e di operare al loro interno,e devono essere adattati o sostituiti, il che a volte è impossibile.

3.4.2 MapReduce

Il paradigma MapReduce de�nisce una strategia per eseguire l'elaborazione deidati su sistemi distribuiti e con elevato parallelismo, descritta e implementataper la prima volta da Google[18] ma già presente in parte altri contesti comele funzioni map e reduce di Python che svolgono esattamente le operazioni cheverranno descritte ma senza imporre corrispondenze sui tipi di dato in input eoutput.

Questi sistemi sono generalmente composti da più computer indipendenti col-legati in rete divisi in più rack, ossia insiemi di computer connessi a uno stessoswitch (e quindi con una velocità di comunicazione tra loro maggiore di quel-la tra due nodi qualsiasi della rete, ma con il rischio di diventare inaccessibilicontemporaneamente in caso di rottura del collegamento).


Ogni processo di manipolazione dei dati viene diviso in due parti, denominatemap e reduce, del tipo:

map : (k1 × v1) 7→ set(k2 × v2) (3.1)

reduce : (k2 × set(v2)) 7→ k2 × set(v2) (3.2)

dove set(k2×v2) è l'insieme dei dati iniziali (come una collezione di documentie rispettivi nomi) e set indica una quantità variabile, anche nulla, di elementiomogenei.

Map: funzione che riceve in input una tupla, precisamente una coppia chiave-valore< k1, v1 >e genera come output List(< k2, v2 >), una lista di coppiechiave-valore non necessariamente dello stesso tipo di dato ricevuto in input.

Reduce: funzione che riceve una chiave k2 e un iteratore sulla lista dei valoria cui la chiave è stata abbinata precedentemente dalla funzione map. Apartire da questa struttura dati del tipo < k2, List(v2) >viene generatauna lista di valori List(v2).

È tipico introdurre il paradigma MapReduce con un esempio equivalente all'�Hello world� dei linguaggi di programmazione: il word count.

Supponiamo di avere una collezione di documenti di testo da cui estrarre unaconteggio delle parole distinte. Questa è un'operazione molto frequente se si vuolee�ettuare un'indicizzazione e una successiva ricerca dando un peso diverso a ogniparola, o se si vuole stabilire l'argomento di un documento.

La funzione map riceverà come input un documento e il suo titolo, e il suopseudocodice è:

map(nomeDocumento , contenutoTestua le ){per ogni paro la p in contenutoTestua le {

emett i l a coppia (p , 1 )}

}

Si noti che questa funzione non restituisce nulla direttamente, ma emette ivalori uno per uno. Questo è concettualmente analogo a creare una strutturadati che contenga una lista di un certo tipo di elemento, aggiungere un elementoalla volta a tale lista nel corso della funzione (anziché emetterlo) e in�ne resti-tuire la lista stessa. In questo modo, però, se la quantità di dati da elaborareè molto grande, la lista da restituire potrebbe non stare in memoria rendendoinsensata l'intera infrastruttura che serve proprio a elaborare grandi quantità didati scalando facilmente.

La funzione reduce, invece, avrà questa struttura:


reduce ( chiave , v a l o r i ){c rea l a v a r i a b i l e numerica n=0per ogni v in v a l o r i {

n=n+v}emett i ( chiave , n)

}

In questo caso riceviamo una parola e la lista dei conteggi ad essa relati-va, e dopo averli sommati emettiamo una tupla (parola,somma). Si noti che lastruttura dati emessa può essere data nuovamente in input alla funzione reduce.Infatti, la funzione reduce è fatta in maniera tale da poter dividere lo spazio dellechiavi e dei valori in diverse porzioni e elaborarle in parallelo, e applicare la reducestessa ai suoi output varie volte �no a ridurlo (da qui il nome della funzione) aun solo valore. In termini algebrici, la funzione reduce è idempotente, ossiadeve valere la proprietà

∀k,set(v)(reduce(k, reduce(k, set(v))) = reduce(k, set(v))) (3.3)

in particolare l'ordine di valutazione degli elementi non in�uenza il valorerestituito, quindi

∀k,v1,v2(reduce(k, {v1, v2}) = reduce(k, {v2, v1}))

Esempi classici di funzione reduce sono la funzione che restituisce il massimoo il minimo valore in un insieme o la media dei valori.

Nell'implementazione pratica, tuttavia, non sempre questa proprietà è richi-esta.

È molto importante sottolineare i vantaggi di questo paradigma:

� Sia la funzione map che la funzione reduce possono essere eseguite in paralle-lo, dividendo lo spazio dei valori in più porzioni esaminate individualmenteda diversi nodi della rete.

� È possibile iniziare a eseguire la funzione reduce sull'output parziale dellefunzioni map prima che terminino completamente l'esecuzione.

� Le funzioni map e reduce non richiedono, di base, di gestire strutture daticon dimensioni variabili, poiché emettono i dati man mano che vengonogenerati e iterano sui valori usando dei cursori generati esternamente, quin-di possono agire su quantità arbitrarie di dati senza rischio di esaurire lamemoria di lavoro. Chiaramente in esempi meno banali potrebbe sorgerel'esigenza di interrogare database o usare librerie particolari all'interno delledue funzioni, e in tal caso è necessario disporre di soluzioni adeguate pernon creare colli di bottiglia che vani�cherebbero la parallelizzazione.


� In caso di rottura o disconnessione di un nodo è possibile rieseguire il com-pito originariamente assegnatoli senza riavviare l'intera operazione. Questorichiede sistemi di monitoraggio e gestione dei compiti che verranno esam-inate nella prossima sezione per quanto riguarda Hadoop e più avanti perl'implementazione di IBM chiamata BigInsights.

Questo modello di elaborazione richiede di ripensare ogni algoritmo, ma è statodimostrato come sia possibile adattare a questa architettura molti classici algorit-mi di largo utilizzo. Per esempio, esistono implementazioni in MapReduce deglialgoritmi di ordinamento, implementai[20] come divisione in sezioni (bin) dei daticon limiti dei bin decisi, con una raccolta di campioni e ordinamento ricorsivodi ogni sezione con una sorta di divide e impera asincrono e di vari algoritmi dimachine learning come la Singular Value Decomposition, la Latent Dirichlet Allo-cation, le reti di Bayes, vari metodi di clustering e altri all'interno del frameworkMahout.

Nella nomenclatura del MapReduce si utilizza il termine job per indicare unintero ciclo di applicazioni di map e reduce �no alla �ne dell'elaborazione e taskper indicare una singola esecuzione di una delle due funzioni e�ettuata da unnodo.

3.4.3 Hadoop

La più di�usa, documentata, supportata e ricca implementazione del paradigmaMapReduce è senza dubbio Apache Hadoop, che rappresenta lo stato dell'arte inquesto campo.

Google utilizza internamente una sua implementazione non nota al pubblico,che è ovviamente esistente da prima di Hadoop (che è stato sviluppato in seguitoalla pubblicazione di un paper da parte di Google in cui viene descritta propriol'architettura del loro sistema, MapReduce appunto), ma non è da escludere chesia passato o passerà ad Hadoop visti gli investimenti in termini di soldi e oreuomo per il suo sviluppo e la creazione di una grande quantità di strumenti basatisullo stesso da parte della comunità degli sviluppatori e di aziende come IBM.

Hadoop è scritto in Java e Java è il linguaggio più usato per scrivere le fun-zioni map e reduce, ma è disponibile il supporto ad altri linguaggi come Python;su Hadoop sono stati sviluppati numerosi applicativi che verranno esaminati eutilizzati, formando un vero e proprio stack esposto in �gura 3.1 Inoltre, poichéHadoop utilizza direttamente il bytecode compilato per la macchina virtuale Java(la cosiddetta JVM), è possibile scrivere dei task MapReduce usando altri lin-guaggi compilabili nello stesso linguaggio, come Groovy o Scala. Quest'ultimolinguaggio è di grande interesse perché, oltre ad avere una sintassi molto concisache agevola la scrittura e la modi�ca delle applicazioni, ha un supporto moltoesteso al parallelismo sia in locale che in un cluster e all'elaborazione di sequenzedi dati di lunghezza non nota a priori e verrà esaminato più avanti.


Figura 3.1:

Java Virtual Machine

Oozie HadoopHDFS

HBaseHive Pig Jaql

ZooKeeper

Applicazioni

Lo stack Hadoop con le componenti più importanti. Si osservi da subito chele applicazioni possono utilizzare Hadoop direttamente o tramite dei linguaggicome Pig, Jaql o Hive, nonché integrarsi con programmi non gestiti da Hadoopo addirittura non distribuiti.

3.4.3.1 Architettura di una rete Hadoop

Hadoop può essere utilizzato su un singolo computer sia in modalità stand alone,con una sola istanza, che pseudo-distributed, ossia con più processi indipendentiche simulano più nodi di una rete su una stessa macchina, ma queste modalitàsono pensate solo per facilitare lo sviluppo di applicazioni MapReduce, visto chel'esecuzione in fase di produzione del programma avviene su una rete di computer.

Hadoop prevede quattro ruoli per i nodi, che possono anche coincidere:

JobTracker: ne esiste uno solo per rete, tiene traccia dello stato dell'esecuzionedi un job, dividendolo in vari task e assegnandoli, tutti o in parte, ai varinodi disponibili. Monitora poi lo stato dell'esecuzione di ogni task dandoin esecuzione nuovi task ai nodi liberi e riassegnando i task falliti perchéil nodo che li eseguiva ha delle anomalie o risulta disconnesso. Si possonoapplicare molte diverse politiche per la divisione di un job in task e per illoro scheduling, in particolare si cerca di assegnare ogni task a un nodo checontiene i dati da elaborare o che li può ottenere da nodi dello stesso rack,per aumentare le prestazioni.

TaskTracker: esegue un certo numero di task richiesti dal JobTracker, moni-torandoli e fornendo informazioni sul loro avanzamento quando richiesto.


NameNode: ne esiste uno solo, tiene traccia della distribuzione dei dati all'in-terno della rete, ordinando la creazione di copie distribuite con dei criteridi ridondanza e accessibilità illustrati nella sezione 3.4.4 e funge da indiceper informare i nodi sulla posizione dei dati all'interno della rete.

DataNode: contiene dei dati indicizzati in un NameNode e li fornisce ai nodiche ne fanno richiesta.

Come spiegato, un nodo può svolgere più ruoli contemporaneamente, �no al casoestremo di un singolo nodo che esegue tutte e quattro le operazioni. Tipicamente,però i DataNode e i TaskTracker coincidono, per permettere l'esecuzione di quantipiù task possibili sui nodi stessi che contengono i dati da elaborare per aumentarela velocità di esecuzione.

3.4.3.2 Tolleranza ai guasti

È fatto noto che la probabilità di guasto di almeno un nodo all'interno di unarete aumenta vertiginosamente con l'aumentare dei nodi. Più rigorosamente, sesi modellizza la probabilità di guasto con una variabile esponenziale, si ha che leprobabilità che il sistema non abbia avuto guasti al tempo t considerando che erafunzionante all'istante t = 0 sono

p(t) = 1− e−kt (3.4)

dove k è una costante dipendente dal sistema, più è alta e più frequentementeun sistema tende a guastarsi. È noto che la distribuzione esponenziale è senzamemoria, infatti se il sistema risulta ancora funzionante al tempo t1 (con t1 > t)le probabilità che sarà ancora funzionante al tempo t2 = t1 + ∆t sono

p(t2|t1) =P (t2)

P (t1)=

(1− e−kt2)

(1− e−kt1)=

(1− e−k(t1+∆t))

(1− e−kt1)

=(1− e−kt1)(1− e−k∆t)

(1− e−kt1)= (1− e−k∆t) = P (∆t)

ossia si ignorano i guasti dovuti all'usura e o ai difetti di fabbricazione, che simanifestano con probabilità diverse al variare del tempo e si assume che il MTTF(Mean Time To Fail), ossia il tempo medio tra due guasti, sia costante nel tempo,ipotesi che sono empiricamente dimostrate[25]. Nel caso di una distribuzioneesponenziale questo valore è 1

k. In una rete, avendo N nodi con uguale costante

k si ha che il MTTF di almeno un nodo all'interno della rete è

MTTFrete =1∑Ni=1 ki

=1

Nk(3.5)


Infatti la distribuzione del valore minimo tra un insieme di variabili aleatorieesponenziali è una variabile aleatoria esponenziale con parametro k pari alla som-ma dei parametri k delle distribuzioni, che in questo caso sono uguali e quindi siha semplicementeNk.

Se quindi si ha un sistema formato da N = 200 sistemi hardware con unMTTF tra i 3 e i 5 anni si ha un tempo medio tra un guasto e l'altro di almenoun componente che è tra i 5 e i 9 giorni, contando solo i guasti hardware eignorando i crash software che sono più rapidi da riparare (generalmente è neces-sario solo un riavvio) ma portano comunque al fallimento dell'intera operazionese non si ha a disposizione la ridondanza dei dati e un sistema di monitoraggiodei nodi e riassegnazione a run time dei task interrotti.

Se però il fallimento di un TaskTracker o un DataNode, o la disconnessionedi un rack, non porta al fallimento di un intero job ma solo al riavvio dei taskad esso assegnati e alla copia dei dati di backup corrispondenti per mantenerela ridondanza, il discorso cambia. Il MTTF dunque, in base alla formula 3.5,sarà di 1

2knel caso in cui TaskTracker e NameNode siano separati. Questi due

nodi costituiscono infatti un single point of failure nell'architettura Hadoop.È possibile anche speci�care un Secondary NameNode, che non permette però dicontinuare le operazioni a caldo come nel caso della caduta di un TaskTracker, marende semplicemente più veloce il ripristino in caso di fallimento del NameNodetramite una replicazione master-slave. Esistono delle piattaforme commercialiche o�rono delle versioni modi�cate di Hadoop che risolvono questo problema,per esempio la piattaforma IBM BigInsights che verrà descritta fra non molto.

3.4.3.3 Politica di scheduling

I criteri adottati per stabilire la granularità con cui dividere le operazioni intask e l'assegnazione di questi ultimi ai diversi nodi costituiscono la politica discheduling.

Il problema non è a�atto semplice: scegliendo una granularità troppo alta siavrà un forte overhead di rete dovuto al continuo trasferimento ordini e noti�chee maggiori chances di assegnare un task a un TaskNode che non è adiacente alDataNode che contiene gli elementi da elaborare causandone il trasferimento;scegliendo invece una granularità scarsa si avrà un maggiore ritardo qualora unnodo fallisca e il suo task vada riavviato e una minore e�cienza dovuta ai nodiche rimangono inattivi mentre aspettano che altri nodi terminino i loro grossitask.

Inoltre, Hadoop può avere più di un job in esecuzione, quindi bisognaanche bilanciare il carico tra diversi job evitando che uno di loro consumi tropperisorse: anche in questo caso esagerando con la granularità si potrebbe avere unasituazione di congestione in cui le risorse devono continuamente essere riassegnate,il cosiddetto thrashing.


La prima politica di scheduling adottata da Hadoop è stata una semplicecoda FIFO6, dove i diversi task dei diversi job sono eseguiti nell'ordine in cuisono richiesti. Se un'operazione è pesante e richiede molto tempo macchina tuttele altre in attesa sono bloccate, e non è possibile speci�care diverse priorità.Inoltre, se un utente lancia in esecuzione molti job riceve risorse di elaborazionein proporzione con il rischio di rendere inutilizzabile il sistema per utenti con unsolo job.

Per risolvere questi problemi è stato quindi sviluppato lo scheduler Fair [?], cheè ora lo scheduler di default di Hadoop. Lo scheduler Fair è basato sull'idea cheogni job abbia una certa fetta di tempo di calcolo che gli spetta, che è calcolatadurante l'inizializzazione del job stesso basandosi sull'utente che l'ha lanciato,sulla presenza di altri job e su altri modi�catori della priorità speci�cati dagliamministratori di sistema.

Periodicamente, più volte al secondo, viene monitorata la quantità di tempodi elaborazione che è stata consumata da ogni task, e quindi il de�cit tra le risorsea cui dovrebbe avere diritto un job e quelle che gli sono state date. Quando silibera un TaskNode esso viene assegnato all'esecuzione del task in attesa del jobcon il maggiore de�cit, ottenendo a regime un'assegnazione e�ettiva delle risorseche si avvicina sempre di più a quella stabilita inizialmente.

3.4.3.4 Oozie

Come accennato, Hadoop è in grado di eseguire più job gestendone lo scheduling.Il modello MapReduce, come visto, pone dei vincoli sul tipo di dati in ingresso euscita dalle due funzioni che possono essere problematici qualora un'operazionevada divisa in più passaggi con tipi diversi di dato.

In questa situazione, molto frequente, la soluzione più logica è utilizzare diversijob MapReduce per creare una pipeline che esegua una dopo l'altra le operazionirichieste �no a giungere all'output �nale. Inoltre, è frequente dover svolgere delleoperazioni in maniera periodica come la rigenerazione degli indici o la sincroniz-zazione di basi di dati eterogenee. Ancora, può essere che in base all'esito diun'operazione o al suo output ne seguano diverse, a volte da lanciare in parallelocon parametri diversi.

Essendo queste delle esigenze molto comuni è stato sviluppato un programmachiamato Oozie che, integrandosi con Hadoop, permette di de�nire dei work-�ow che descrivono i casi elencati precedentemente e altre operazioni con un�le XML. Oozie semplicemente interpreta questo �le e progressivamente svolgele operazioni descritte, lanciando in esecuzione i Job richiesti nell'ordine indi-cato. Oozie descrive anche un'architettura con cui diversi tipi di applicazionipossono essere integrate, aggregando in un solo processo di elaborazione delle ap-plicazioni MapReduce in Java, applicazioni in Python, programmi non distribuiti

6First In-First Out


(che svolgono operazioni che non possono essere parallelizzate o non ne avrebberovantaggio) e fornendo un'architettura per il passaggio di parametri tra uno stadioe l'altro con vincoli sui tipi di dato.

3.4.4 Filesystem distribuiti

Un aspetto basilare del trattamento di ingenti moli di dati è riuscire a memoriz-zarli e accedervi da più nodi della rete. Ogni nodo della rete può avere una suamemoria, sotto forma di disco �sso o array RAID, e renderla accessibile agli altrinodi, e l'accesso ai dati potrebbe essere e�ettuato direttamente dall'applicazioneusando protocolli come FTP o SMB, ma questo creerebbe diversi problemi:

� L'applicazione deve sapere quale nodo contiene un certo dato, quindi deveessere presente un servizio di indicizzazione continuamente aggiornato.

� I �le possono cambiare di dimensione superando la capacità di un singo-lo nodo, rendendo necessario gestire la divisione del �le in frammenti piùpiccoli e l'indicizzazione degli stessi.

� I nodi possono rompersi o disconnettersi, e anche se il paradigma MapRe-duce prevede il monitoraggio dei task e il riavvio dell'operazione su unaltro nodo i dati inaccessibili sono un discorso a parte, che richiede di im-plementare un meccanismo che generi più copie di ogni �le in diversi nodie le mantenga sincronizzate

� La rete potrebbe divenire congestionata a causa dell'accesso simultaneo aidati, quindi l'applicazione dovrebbe allocare i �le in nodi topologicamentevicini a quelli che eseguono i task associati, viceversa, le copie di backupdovrebbero essere lontane in modo da ottenere robustezza nei confrontidella rottura di link che portino un intero rack della rete a essere isolato.

Per evitare che le applicazioni debbano gestire tutti questi problemi, sono staticreati dei �lesystem distribuiti, ossia dei middleware che mostrano alle appli-cazioni un solo, grosso, �lesystem e si prendono carico della ridondanza e delladistribuzione dei dati tra i vari cluster.

HDFS

L'Hadoop Distributed File System è la soluzione integrata in Hadoop per lacreazione di un �lesystem distribuito. HDFS prevede la divisione di ogni �lein blocchi di dimensione �ssa chiamati chunk, generalmente di 64 MB ma ladimensione può essere modi�cata, e produce per ogni chunk un certo numero dicopie, generalmente 3, assegnate ognuna a un diverso DataNode. Di queste 3copie due si trovano nello stesso rack e una in un rack separato, in modo chel'elaborazione possa sfruttare due copie locali di ogni dato per ridurre il tempo


di trasferimento e l'uso della rete ma ci sia sempre un'ulteriore copia disponibilenel caso un intero rack perda la connessione. Perché ciò sia possibile, HDFSdeve conoscere la struttura della rete e sapere in che rack si trovano i diversinodi, quindi durante l'installazione è necessario speci�care queste informazioni inappositi �le di con�gurazione.

Le applicazioni eseguite in un cluster Hadoop possono utilizzare HDFS inmaniera simile a un comune �lesystem, eliminando, copiando, leggendo e modif-icando i �le al suo interno che saranno in realtà divisi in frammenti ridondanti esparsi nella rete. Purtroppo HDFS non è un �lesystem POSIX, in quanto:

� Non prevede un sistema di gestione degli accessi, quindi diversi utenti nonhanno permessi di lettura, scrittura o esecuzione di�erenziati come avvienenei comuni �lesystem Linux (come ext3, ext4 o Btrfs), creando dei possibiliproblemi di sicurezza

� Non prevede l'accesso casuale a punti qualsiasi dei �le, ma è orientato al-la lettura e alla scrittura sequenziali. L'e�etto più importante di questalimitazione è l'impossibilità di usare alcuni database come Lucene o Neo4jall'interno di HDFS se non con una perdita di prestazioni enorme

� Le modi�che ai �le e�ettuate dai task sono scritte e�ettivamente in HDFSsolo al raggiungimento delle dimensioni di un blocco o alla chiusura del task,altrimenti sono memorizzate in un �le temporaneo locale al DataNode. Seil NameNode fallisce prima di questa scrittura o del termine del task i datisono persi. Bisogna notare che tuttavia in caso di fallimento del NameNodesi avrebbe comunque un fallimento dei job

Normalmente si accede ad HDFS con delle API simili alle librerie per l'accessoai �le di Java, quindi è possibile pensare al �lesystem distribuito come a undatabase particolare che gestisce una struttura dati simile a un �lesystem. Èpossibile comunque montare HDFS come un'unità �sica utilizzando un moduloFUSE. I moduli FUSE sono estensioni del kernel Linux eseguite nello spazio dimemoria dei singoli utenti (e quindi con meno problemi di sicurezza e stabilitàrispetto ai normali �lesystem e senza richiedere permessi particolari per e�ettuareil mount) che mostrano un �lesystem virtuale come parte di quello �sico, inmodo che le normali applicazioni possano accedervi e manipolarlo senza bisognodi adattamenti.

GFS

Il Google File System, noto anche come BigFile, è un �lesystem distribuito pro-prietario di Google e usato internamente dall'azienda. Questa tecnologia non èdisponibile come software libero né venduta se non come parte di altri prodottienterprise, quindi sono disponibili poche informazioni sulle sue caratteristiche, ed


è citato in questa tesi perché è stato il primo modello di �lesystem distribuito diqueste dimensioni e utilizzato con MapReduce. È basato sulla divisione dei �le inchunk da 64MB, ognuno con un'etichetta univoca da 64 bit generata al momentodella creazione e replicato su un certo numero di nodi. I DataNode contengonodegli indici della posizione di ogni chunk permettendo ai client di ottenerli surichiesta, in maniera simile a HDFS.

La di�erenza principale tra i due sistemi è che i chunk di GFS non possonoessere modi�cati dopo la creazione, e devono essere ricreati da capo. Questoperché le esigenze di Google non richiedono di modi�care spesso i dati (si pensialle copie in cache delle pagine indicizzate o alle mappe con foto satellitari) madi poterli accumulare e leggere continuamente.

GPFS

Il General Parallel File System è un �lesystem sviluppato da IBM a partiredal 1998, molto prima della comparsa del paradigma MapReduce, per scopi in-izialmente diversi dall'elaborazione massiva di dati. Si pone come un �lesystemdistribuito totalmente POSIX-compliant, quindi può essere usato come un vero�lesystem, su cui possono essere letti e scritti documenti e eseguibili con tuttii permessi (Read Write e Execute) assegnati in base all'utente e ai suoi gruppi,come avviene nei �lesystem locali come Ext7. Inoltre, rispetto a HDFS ha lacapacità di gestire e�cacemente �le piccoli o che vengono modi�cati leggermentee frequentemente, può seguire certi vincoli sulla memorizzazione �sica dei dati(per esempio memorizzare i dati riservati in dischi interni all'azienda, o i �le piùimportanti in dischi più resistenti o con maggiori performance) e memorizza imetadati insieme ai dati stessi, distribuendo così il carico sui nodi. Ne esiste unaversione recente che utilizza diversi namenode di riserva che risolvono il problemadel single point of failure proprio di HDFS: qualora un namenode smettesse difunzionare, altri nodi di riserva eleggerebbero un nuovo nodo centrale mantenendol'operatività del cluster.

Allo stato attuale, GPFS è l'unico �lesystem distribuito adatto alle operazioniMapReduce a poter operare in modalità non-SPoF, mentre esistono dei proget-ti ancora in fase prototiale per introdurre questa capacità (sotto forma di unnamenode secondario che velocizzi la ripresa) in HDFS.

3.4.5 ZooKeeper

Gestendo un cluster sorge la necessità di gestire e aggiornare decine o centinaiadi nodi in modo che abbiano i vari �le di con�gurazione sincronizzati con quellimodi�cati dall'amministratore, eseguano certi processi e possano avere in ognimomento degli hostname consistenti e noti.

7Extended �lesystem, il �lesystem più usato in ambito Linux


ZooKeeper è un programma sviluppato inizialmente come parte integrantedi Hadoop e poi esteso ad altre possibili applicazioni, che o�re un'infrastrutturaridondante perché i diversi nodi della rete possano avere sempre un nodo masterda contattare e da cui ricevere gli aggiornamenti del caso. I nodi master sono ingenere più di uno e gli aggiornamenti vengono replicati completamente tra uno el'altro, in modo che in caso di fallimento di uno di questi nodi gli altri possanoimmediatamente rimpiazzarlo. Utilizzando dei timestamp, ZooKeeper mantieneun rigido ordinamento delle richieste di read e update, totalmente transazionali,inoltrate dai nodi in maniera analoga a quanto fanno i database che rispettanole proprietà ACID per evitare la perdita di consistenza qualora un nodo Masterfalisca durante una transazione.

ZooKeeper si pone all'esterno dell'utilizzo in Hadoop come un'infrastruttura,su cui i programmatori possono implementare i loro servizi di sincronizzazionee monitoraggio delegando la gestione della ridondanza e dell'autenticazione, manon si occupa direttamente di elaborare i dati.

3.4.6 Lucene

Lucene è un sistema di indicizzazione e ricerca di testo presente all'interno didiversi campi in una collezione di documenti potenzialmente eterogenei.

Questa astrazione sul tipo di dato indicizzato permette di utilizzare Luceneper gestire documenti testuali, pagine web, PDF, documenti di O�ce e altrorimanendo agnostico nei confronti del tipo di documento in esame e o�rendoun'interfaccia unica per la ricerca.

I pregi di Lucene sono le elevate prestazioni con un basso consumo di memoria[5]sia di lavoro che come spazio occupato dall'indice, nonché la varietà di strumentidi ricerca avanzati, come il ranking dei risultati, la ricerca con espressioni rego-lari, la de�nizione di query con range di valori numerici o date o l'ordinamentodei risultati in base a un campo arbitrario.

Un grande vantaggio di Lucene è la possibilità di aggiornare l'indice senzabloccare le ricerche, ottenendo un aumento dell'uptime e la possibilità di integrarel'indice con dei dati nuovi in maniera continua.

Purtroppo Lucene richiede l'accesso non sequenziale ai �le di indice, quindinon è possibile utilizzarlo all'interno di HDFS e può essere interrogato dai taskHadoop solo via rete con un'istanza memorizzata localmente in un nodo, con ilimiti di scalabilità che questo comporta. È possibile invece usarlo con GPFS.

3.4.7 Solr

Apache Solr è una piattaforma di ricerca enterprise che integra Lucene arricchen-done l'utilizzo e aumentandone la scalabilità. Un aspetto molto interessante inambito BigData è che replicando e mantenendo sincronizzati gli indici su più mac-chine permette la ricerca distribuita e l'aggiornamento continuo degli indici come


avviene con le semplici istanze di Lucene. Oltre a questo, la ricerca viene poten-ziata con la possibilità di aggiungere uno schema ai dati, tipicamente applicatosolo su alcuni campi poiché Lucene è pensato per gestire dati non strutturati, laricerca di parole dal suono simile, l'indicizzazione di dati geogra�ci, l'integrazionecon database relazionali e l'integrazione con UIMA per la creazione e l'utilizzo diannotazioni nella ricerca.

3.4.8 Apache UIMA

L'Unstructured Information Management Architecture è un modello per la ges-tione di dati non strutturati sviluppato da IBM e donato alla comunità con ilrilascio come software open source, ed è gestito ora dalla fondazione Apache.

Per quanto riguarda la gestione del testo, che è il tipo di applicazione piùfrequente, l'infrastruttura UIMA è basata sulla creazione di annotazioni che siaggiungono al testo grezzo marcandone delle porzioni arbitrarie. Un sistema soft-ware basato su UIMA che genera delle annotazioni è chiamato Annotation En-gine. Un Annotation Engine è composto da uno o più annotator, delle componentisoftware che ricevono in input un testo con eventuali annotazioni e aggiungonoulteriori annotazioni; gli annotator vengono scritti per poter essere eseguiti in par-allelo su più documenti o anche su più porzioni dello stesso documento. UIMAdi per sé non si occupa di e�ettuare l'analisi vera e propria del testo, ma solo difornire un framework per gestirla e renderla scalabile, tuttavia gli annotator sonoriutilizzabili e ne esistono dei repository pubblici8 per eseguire le operazioni piùcomuni come il POS9 tagging, l'identi�cazione di stringhe speci�che o il labelingtramite catene di Markov per citarne alcune.

Il nucleo di UIMA è il cosiddetto CAS, Common Analysis Structure, un ogget-to condiviso da tutti gli annotator che contiene sia le annotazioni che il sistemadi tipi delle stesse.

Ogni annotazione, infatti, possiede un tipo, un concetto simile a quello diclasse: esistono dei tipi primitivi, come intero o booleano, da cui è possibilecostruire array di tipi e tipi composti, espandibili tramite l'ereditarietà. Ogni tipoè dichiarato esplicitamente nel Type System Descriptor da parte del programma-tore usando un descrittore XML, e ogni annotazione avrà un tipo speci�co cheevita ambiguità nel processo di analisi.

3.5 Database NoSQL

Come anticipato, la soluzione più di�usa per la gestione dei dati da parte di entio aziende è costituita dai database relazionali e transazionali che rispettano leproprietà ACID. Queste proprietà sono:

8https://uima.apache.org/sandbox.html9Part Of Speech, le diverse componenti del discorso come aggettivi o sostantivi

https://uima.apache.org/sandbox.html

3.5 Database NoSQL 55

Atomicità: Ogni transazione è un'entità indivisibile, non è possibile compiereuna transazione parzialmente o osservare il contenuto in una fase intermediadella transazione, il database si comporta come se questa avvenisse total-mente o non avvenisse a�atto (internamente, tiene traccia delle modi�cheparziali e le annulla in caso di fallimento con un rollback).

Consistenza: Data una serie di vincoli sulle singole tuple o sulle tabelle, comei vincoli di integrità referenziale, se questi vincoli sono rispettati prima diuna transazione lo sono anche dopo.

Isolamento: Ogni transazione avviene in un preciso istante temporale, anchese possono essere eseguite più transazioni contemporaneamente, e normal-mente avviene, l'e�etto �nale sulle tabelle deve essere lo stesssso che siavrebbe avuto con un'esecuzione seriale.

Durabilità: Gli e�etti delle modi�che alle tabelle devono essere permanenti.Questo lo si ottiene con un sistema di journaling che annota nella memoriadi massa le operazioni che vengono svolte permettendo, in caso di anomalia,di ripristinare tutte le transazioni che erano state segnalate come eseguitee annullare completamente quelle non terminate.

Tipicamente l'interrogazione di questi database avviene con il linguaggio SQL,Structured Query Language, un linguaggio dichiarativo le cui query possono essereconvertite in espressioni dell'algebra relazionale, che è stata studiata e esaminataa fondo nel corso di vari decenni producendo delle tecniche per la creazione diun piano di esecuzione ottimale di una query allo stato dell'arte che di�cilmentepotranno essere ulteriormente perfezionate.

Esiste però una classe di database che negli ultimi anni ha riscosso sempre piùinteresse da parte degli informatici che è quella dei database NoSQL. Il termineNoSQL è un termine molto generico, tanto da essere usato a volte come buzzword,che indica sia i database non relazionali ma che rispettano le proprietà acide,che i database che non le rispettano o che propongono un modello distribuito(come CouchDB, che addirittura prevede la disconnessione dei nodi e l'isolamentodei dati) in cui il concetto di transazione perde di senso. Nonostante il nome,esistono dei database che entrano in questa classi�cazione ma o�rono in e�ettiun'interfaccia di interrogazione in SQL come OrientDB, un database a grafo edocumentale interrogabile anche con SQL nonostante la struttura sottostantenon sia tabellare. Esistono poi degli strumenti che trasformano delle query similiall'SQL in manipolazioni di basi di dati Big Data come avviene con Hive, cheverrà illustrato più avanti.

3.5.1 Il CAP theorem

Un importante e recente risultato dell'informatica nel campo delle proprietà for-mali delle basi di dati è il cosiddetto CAP theorem, dimostrato formalmente nel


2002[29], che a�erma che non è possibile ottenere contemporaneamente consis-tenza, disponibilità e tolleranza alle partizioni. I database relazionali classici siconcentrano chiaramente sulle prime due, Consistence e Availability, con l'intentodi fornire un'alta a�dabilità, mentre in altri contesti la resistenza al partizion-amento può essere più importante, e si può ottenere rilassando il vincolo sullaconsistenza con la cosiddetta eventual consistency.

Senza entrare troppo nel dettaglio, il con�itto tra le tre proprietà è compren-sibile immaginando la situazione in cui due nodi del cluster ricevono due richiestecontrastanti (per esempio due diversi aggiornamenti dello stesso dato, replicatosui due cluster) e questi due nodi non possono comunicare a causa della rotturadel link. Se un nodo annulla la transazione e segnala l'errore al client viola i vin-coli di availability, se la esegue localmente genera una potenziale (in questo casocerta) inconsistenza poiché il database mostrerà contenuti diversi in base al nodointerrogato e se rispetta entrambe queste due proprietà solo a rete perfettamentefunzionante viola il principio di tolleranza al partizionamento.

La eventual consistency si ottiene abbinando alle modi�che al contenuto deldatabase dei metadati che permettano di contestualizzarle, in particolare untimestamp. Quando si veri�ca un partizionamento si continuano a accettarele query e eseguirle sulla copia locale dei dati, ottenendo un'inconsistenza, male modi�che sono marcate in maniera tale che al momento della riconnessione sipossa ottenere una versione �nalmente consistente risolvendo i con�itti, da cui ilnome.

Il CAP theorem avrà un ruolo fondamentale più avanti, per esaminare lapossibilità di memorizzare tutte le pagine manipolate da uno scraper in temporeale e in maniera e�ciente.

3.5.2 Classi�cazione dei database NoSQL

I database NoSQL si possono dividere in base al tipo di struttura che manipolanonativamente:

grafo: I database a grafo, come Neo4j o OrientDB, gestiscono collezioni di nodie relazioni tra gli stessi, nonché proprietà assegnate arbitrariamente a ogninodo. Ogni nodo ha generalmente un indice delle relazioni entranti e uscentiche permette di avere un rapido accesso ai nodi topologicamente adiacen-ti. Questa struttura si presta naturalmente a contenere dati fortementestrutturati, come il grafo delle amicizie su un social network o un'ontologia.In un precedente lavoro[24] ho utilizzato proprio Neo4j per rappresentare eanalizzare la struttura delle categorie di Wikipedia, osservando come questodatabase sia estremamente performante nelle operazioni di attraversamen-to del grafo (circa 30 minuti per attraversare 7 milioni di nodi e 40 milionidi relazioni su un normale laptop). Inoltre, vengono forniti dei linguaggiestremamente concisi per manipolare i gra� e estrarne i dati come Cypher


o Gremlin. Il punto debole di questi database è la di�coltà di accederedirettamente a un nodo con certe proprietà come si accederebbe a una tu-pla in un database SQL, non durante un attraversamento. Per permetterequesta operazione Neo4j si a�da a Lucene, che come illustrato permette digestire documenti qualsiasi. Inoltre, i database a grafo sono praticamenteimpossibili da adattare a architetture distribuite perché la natura dei con-tenuti rende di�cilissimo stabilire un criterio e�cace per assegnare i nodi aiserver; In�niteGraph è un database a grafo distribuito ma si tratta di unareplicazione master-slave e della creazione di più gra� sconnessi accessibilicon una sola connessioen al database, non di un solo grafo distribuito supiù nodi della rete.

chiave-valore: I database chiave valore gestiscono una struttura analoga aidizionari dei più comuni linguaggi di programmazione (come le HashMapdi Java). Questa struttura è assimilabile a una tabella di un database re-lazionale con soli due campi, ma con la di�erenza che le ricerche vengonofatte solo su una delle due colonne, la chiave, per recuperare il contenu-to dell'altra colonna, il valore. Quest'ultimo è spesso un oggetto binario,privo di tipo, e spesso si memorizzano direttamente interi oggetti usandoi linguaggi OO. È la categoria più estesa, con numerose varianti al suo in-terno come i database gerarchici, per esempio GT.M, che permettono dimemorizzare altre strutture a dizionario come valori. Redis è un databasechiave-valore che memorizza tutti i dati in RAM permettendo al più deidump periodici sulla memoria di massa, utilizza dei tipi di dato primitivicome stringhe e interi ed ha delle prestazioni notevoli che lo rendono unabuona scelta per sistemi di caching ausiliari ad altri database.

documento: Nel caso si debba accedere e ricercare frequentemente in una collezionedi documenti indipendenti e eterogenei, quindi generalmente senza schema,i database documentali sono la prima opzione da esaminare. SoluzionicomeMongoDB o CouchDB permettono di inserire documenti de�niti comedizionari chiave-valore i cui valori sono tipi primitivi, liste di tipi primitivio altre struture a dizionario. Questo tipo di struttura ad albero trova co-moda rappresentazione nel linguaggio JSON, usato dai due database citati,o alternativamente in XML, usato da database come eXist che sono ori-entati alla memorizzazione e all'esame di grossi documenti con strutturaad albero. Il fatto che i documenti siano indipendenti uno dall'altro per-mette una facile e e�ciente distribuzione o replicazione degli stessi su piùserver e l'implementazione di meccanismi di sincronizzazione impensabilicon altre strutture. CouchDB, per esempio, permette ai nodi di modi�careil database anche quando sono sconnessi (un nodo potrebbe anche essereuno smartphone, tanto che esiste una versione di CouchDB per Android)gestendo le possibili inconsistenze usando i timestamp. Proprio per via di


questo modello orientato a unità di elaborazione non sempre connesse pi-uttosto che cluster di computer questo database non è stato considerato inquesta tesi.

tabella: esistono dei database con struttura tabellare che però sono molto di-versi dai normali database relazionali. Un esempio sono i database attivicome Accumulo, sviluppato dalla NSA e poi preso in carico dalla fondazioneApache, che è in grado di e�ettuare molte manipolazioni sui dati in manieraautonoma direttamente sul server, aumentando le prestazioni qualora ques-ta operazione non debba più essere svolta da un altra componente conl'overhead aggiuntivo del trasferimento dei dati tramite la rete. AncheHBase è un database tabellare con molte caratteristiche interessanti cheverrà esaminato più avanti.

Questa divisione è comunque solo indicativa, poiché molti database hanno carat-teristiche ibride, come OrientDB che è sia a grafo che a documenti, oltre asupportare delle query SQL-like e i database di una certa categoria possonoavere delle limitazioni sui dati e sulle operazioni che non hanno altri della stessacategoria.

Cassandra

Cassandra è un database chiave-valore e colonnare, fortemente distribuito, pro-gettato per fornire un'elevata scalabilità e robustezza con diversi livelli di consis-tenza, permettendo di ignorare, su alcune operazioni a scelta, le proprietà acideper ottenere un aumento delle prestazioni.

Il database è stato sviluppato da Facebook e ora il suo sviluppo è seguitodalla ASF. È stato pensato �n dal principio per o�rire un'elevata robustezza edisponibilità dei dati grazie all'uso massiccio di cluster di computer che possonoessere geogra�camente distanti tra loro come appunto i data center di Facebook.

Ogni elemento memorizzato in Cassandra è identi�cato da una chiave a cuicorrisponde un insieme di valori divisi in colonne. Le colonne a loro volta sonodivise in famiglie, che sono de�nite alla creazione della base dati e non possonoessere modi�cate in seguito, mentre è possibile aggiungere colonne nuove allefamiglie. Il punto fondamentale di questo modello è che ogni riga può avere omeno dei valori nelle varie colonne. È possibile modellizzare undatabase di questotipo come una matrice sparsa dove ogni chiave può avere o meno dei valori perle varie colonne e grossa parte dei valori saranno inde�niti. Un altro modo diimmaginare questa struttura è fare riferimento a un database documentale chepresenta uno schema inclusivo sui possibili campi, ossia de�nisce quali elementipuò avere un documento ma non quali deve avere.

Le query vengono e�ettuate sia fornendo una chiave e un insieme di colonnedi interesse che facendo richieste basate sui valori delle colonne. A di�erenza


di un database relazionale, dove speci�cando dei campi diversi all'interno delSELECT si evita semplicemente l'overhead della trasmissione di dati inutili, inCassandra evitando delle colonne in una query si possono risparmiare diverserichieste ai server o ai data center in cui queste colonne, o più frequentemente leloro famiglie, sono memorizzate, aumentando sensibilmente le prestazioni. Questoè conveniente in pro�li di accesso come quello di Facebook perché se le famigliedi colonne sono organizzate in base al caso d'uso (per esempio una famiglia dicolonne per le applicazioni, una per gli amici, una per i post, per i gruppi e cosìvia) allora la stragrande maggioranza degli accessi richiederà di interrogare unapiccola parte dei cluster alla volta.

Un database di questo tipo, come grossa parte dei database non relazionali,si mostra carente proprio nelle operazioni di confronto incrociato tra i valori, inquesto caso le coppie chiave-valori, il cosiddetto JOIN. Cassandra è poco indicatoanche per operazioni di ricerca di elementi con query che non siano elementari ecoinvolgano più campi[6].

3.5.3 MongoDB

Nonostante il grande sviluppo di Hadoop e la nascita di innumerevoli strumentibasati su di esso, esiste un sistema di elaborazione NoSQL che o�re la possibilitàdi memorizzare dati non strutturati su cluster di nodi e applicare elaborazionicon MapReduce che continua a trovare ampio utilizzo, chiamata MongoDB10, cheper molti versi è parallela alle soluzioni viste �nora.

MongoDB, o più semplicemente Mongo, è un database orientato ai documenti,fornito da 10gen come software open source, che fa largo uso del formato JSON,o più precisamente di una variante che permette di gestire dati binari chiamataBSON 11. Ogni documento in Mongo è quindi un dizionario che associa a dellechiavi alfanumeriche dei valori che possono essere stringhe, numeri, coordinategeogra�che oppure liste di questi valori o altri dizionari (ossia un documento puòcontenere al suo interno dei sotto-documenti), �no a un limite che attualmente èdi 16MB.

I documenti sono raccolti in collezioni, e ogni query speci�ca esplicitamente suquali collezioni deve essere eseguita e in quale collezione esportare un eventualeoutput. Similmente ai normali database relazionali lo sviluppatore può speci�-care degli indici su alcuni campi per velocizzare le query che li coinvolgono, conla di�erenza che, mancando uno schema, solo i documenti che possiedono quelcampo saranno indicizzati. Inoltre, poiché il valore di un campo può essere a suavolta un dizionario con altri campi, è possibile creare degli indici su questi campiannidati con la tipica sintassi dei package Java o Python

campo . sottocampo . sottosottocampo

10http://www.mongodb.org/11Abbreviazione di Binary JSON

http://www.mongodb.org/


Mongo fornisce un supporto nativo alla gestione delle coordinate geogra�che,permettendo la ricerca e�ciente di punti spazialmente vicini, funzione molto im-portante in certi ambiti e abbastanza rara: al momento, è o�erta direttamentesolo da PostgreSQL (con un'estensione che è attivabile tramite un comando SQLil primo database a implementarla e ampiamente usato in ambito GIS12) e Mi-crosoft SQL Server (dal 2008); altri database come MySQL o Neo4j permettonodi memorizzare questi dati usando dei wrapper che indicizzano le coordinatecon delle strutture diverse proprie del database, per esempio nel caso di Neo4jusando Neo4j-spatial vengono creati dei nodi e delle relazioni che formano unB-tree e la relazione next che lega i punti spazialmente vicini ed è possibile im-portare le mappe direttamente dai dump xml di OpenStreetMap, ma questowrapper è estremamente complesso (ha decine di dipendenze) e pressoché privodi documentazione.

L'inserimento di un documento in MongoDB è e�ettuato speci�candone lastruttura JSON, per esempio dalla shell nativa:

doc = { t i t o l o : ' Gattaca ' , a t t o r i : [{nome : ' Ethan Hawke ' , per sonagg io : ' Vincent Freeman ' } ,{nome : 'Uma Thurman ' , per sonagg io : ' I r ene Cass in i ' }] ,anno : 1997 }

db . f i lm . i n s e r t ( doc ) ;

si inserisce così un documento doc nella collezione �lm. La ricerca avvienedescrivendo un archetipo di documento che sarà poi restituito, e di campi richiesti:

db . f i lm . f i nd ({ t i t o l o : ' Gattaca ' } , { ' a t t o r i ' : 1 } ) ;

Sono permesse anche query più elaborate con degli operatori speci�ci:

db . f i lm . f i nd ( { a t t o r i : { $ in : [ 'Uma Thurman ' , ' Keanu Reeves ' ] } } )

questa query resituisce i �lm in cui hanno recitato Uma Thurman o KeanuReeves.

Per quanto riguarda la parallelizzazione, MongoDB permette di utilizzare piùserver distribuendo i documenti, sia replicandoli con un'architettura master-slaveche assegnandoli a server diversi tramite lo sharding13 che è e�ettuato sulle singolecollezioni sulla base si una shard key.

In sostanza gli sviluppatori possono speci�care una chiave che preveda unordinamento (come una data, un numero o una stringa, ma naturalmente non unbooleano o delle coordinate geogra�che) e lasciare che Mongo divida i documentitra i vari server in base al valore di questa chiave, spostandoli automaticamentequalora la distribuzione risulti troppo sbilanciata.

12Geographical Information System13il partizionamento di un insieme di dati per facilitarne l'accesso concorrente


Lo sharding aumenta la velocità di scrittura, perché dato un documento èpossibile sapere quale server dovrà contenerlo direttamente dal valore della suachiave, senza overhead dovuti a richieste inutili, e la velocità di ricerca se le queryesplicitano dei valori sulla shard key e possono quindi essere rivolte solo al serverche può contenere quei valori. Tuttavia ci sono delle possibili problematicheriguardanti lo sharding:

� La shard key deve essere presente in tutti i documenti della collezione.

� La shard key non deve presentare tante occorrenze di uno stesso valorealtrimenti il bilanciamento è ine�ciente.

� I valori abbinati alla shard key non possono essere modi�cati in manierapesante altrimenti lo spostamento massivo dei documenti causato dal loadbalancing avrebbe e�etti catastro�ci sull'e�cienza del database.

� Applicare lo sharding quando il sistema è già vicino all'esaurimento dellerisorse si avrà un grosso impatto sulle prestazioni nella fase di transizione,infatti la guida allo sharding[?] suggerisce di farlo con largo anticipo rispettoa quando ci si aspetta di averne bisogno.

� Mongo non è un database transazionale, quindi delle modi�che con-correnti possono vedere versioni inconsistenti dei dati memorizzati, anchese i singoli documenti non presentano questo problema (le modi�che aidocumenti sono atomiche).

� Non esiste un log su disco delle modi�che. Questo signi�ca che se un no-do fallisce alcune modi�che già scritte dalle applicazioni possono andareperse, e i �le del database possono risultare corrotti al riavvio, richiedendol'utilizzo di alcuni strumenti forniti con Mongo per ripristinarli.

Mongo o�re un �lesystem distribuito molto simile a HDFS, chiamato GridFS, chedivide i �le in chunk abbastanza piccoli da essere divisi (splitting) e trasformati indiversi comuni documenti (che tramite BSON gestiscono i dati binari) insieme aimetadati necessari a gestire lo splitting, e quindi memorizzate in collezioni createad hoc. Questo, combinato con lo sharding, dà vita a un �lesystem distribuito.Come nel caso di HDFS, GridFS non segue lo standard POSIX ed è utilizzabilesolo tramite delle API che forniscono un sottoinsieme delle comuni operazioni sui�le. Rispetto ad HDFS però presenta alcune possibili carenze:

� Non ha una struttura a cartelle, quindi eventuali gerarchie devono esseregestite dalle applicazioni usando dei metadati a parte o una nomenclaturadei nomi dei �le che ne ri�etta la posizione nell'albero delle directory. Inogni caso, operazioni come eliminare o copiare un'intera �cartella� non sonodirettamente possibili e risultano macchinose.


� Non esiste, al momento, un modulo FUSE stabile come quello di HDFS

� GridFS è orientato all'accesso casuale a porzioni speci�che dei dati, mentreHDFS è orientato all'elaborazione in modalità batch per analisi massicce,e i diversi orientamenti si ri�ettono nelle rispettive performance.

� Le API di GridFS forniscono molti meno strumenti di quelle di HDFS, inparticolare richiedono di gestire esplicitamente i chunk[1], ponendosi piùcome un'estensione del database per blob di lunghezza arbitraria che comeun �lesystem vero e proprio

Un altro aspetto estremamente interessante di MongoDB è la possibilità di es-eguire nativamente delle elaborazioni con il metodo MapReduce, presentate[8]come l'analogo NoSQL del GROUP BY dei database relazionali.

Mongo utilizza JavaScript come linguaggio di scripting per de�nire le funzionimap e reduce, e accetta un job sotto forma di una query che speci�ca il codicedelle due funzioni, le collezioni di input e output e eventuali query per de�nireun sottoinsieme di documenti su cui e�ettuare l'operazione. Questa funzionalitàserve ad applicare l'elaborazione MapReduce in maniera incrementale, solo sulsottoinsieme dei documenti aggiunti o modi�cati, aggiungendo l'output a unacollezione già esistente e elaborata in precedenza, disponendo di dati lavoratiaggiornati molto più frequentemente.

L'esecuzione è distribuita in maniera totalmente trasparente sui vari serverqualora sia attivo lo sharding, e tutta l'operazione è eseguita dal lato del server,come avviene in Hadoop. Il monitoraggio di un'esecuzione però è praticamenteimpossibile, non esistono infatti dei meccanismi di logging e si può sapere lo statodell'esecuzione solo eseguendo delle query in parallelo (per esempio contando idocumenti nella collezione di output) o intercettando le singole operazioni sui nodicon uno strumento chiamato mongosni� fornito con Mongo, ma in questo caso siosserverebbero le singole modi�che ai documenti e bisognerebbe contestualizzarle.

Gli aspetti più tecnici dell'installazione e dello sviluppo di programmi conMongoDB sono discussi nella sezione in appendice 6.5.3.

È stato sviluppato un programma ad hoc che si occupa di inserire nel databaseuna grande quantità di documenti, variando il numero di elementi inseriti simul-taneamente e misurando la velocità dell'operazione, ottenendo il comportamentoin Tabella 3.1 e in Figura 3.2.

Tuttavia, MongoDB non sarà usato per la scarsa integrazione con altri databasee sistemi software o�erta.

HBase

HBase è un database column-oriented distribuito, che dispone di un meccanis-mo di gestione della granularità delle transazioni molto elaborato e pensato per


Figura 3.2:I tempi di caricamento indicati nella tabella 3.1, si osserva che variando la quan-tità di documenti salvati per ogni singolo commit si variano le prestazioni com-plessive, perdendo prestazioni qualora questo valore sia troppo alto o troppobasso.

Numero di documenti per commit tempo di esecuzione (s)

1 6351100 5032550 50351000 48432000 5238

Tabella 3.1: I tempi di esecuzione per l'inserimento delle voci di en.wiktionary insingoli documenti di MongoDB a partire dal dump XML memorizzato in GridFS


Figura 3.3:

Chiave1

Famiglia di colonne 1

Colonna A Colonna B Colonna A

Chiave2

Chiave3

valoreTimestamp

Timestamp

Timestamp

valore

valorevalore

valore

Famiglia di colonne 2

Una tabella di HBase, con due famiglie di colonne ognuna con delle colonnespeci�che. Si osserva che non tutte le righe hanno un valore in ogni colonna

gestire tabelle sparse, ossia dove è molto frequente che una cella non contengaalcun valore.

La struttura di una tabella HBase (Figura 3.5.3) è basata su un insieme difamiglie di colonne, de�nite alla sua creazione e modi�cate raramente, ognunacontenente diverse colonne, che possono essere aggiunte in tempo reale duranteil normale funzionamento del database. Questa struttura si pone a cavallo traquella di un database relazionale, con campi rigidi e che di norma non vengonomai modi�cati (anche se è possibile, è un'operazione e�ettuata manualmente) eun database come MongoDB dove ogni documento ha dei campi arbitrari.

L'esistenza delle famiglie di colonne è dovuta a motivi di e�cienza: diversefamiglie di colonne vengono gestite da diversi server e quindi, se un'applicazionetende a usare solo una certa famiglia alla volta, è possibile ridurre notevolmente ilnumero di richieste ai nodi. Sia le famiglie che le singole colonne sono identi�catetramite un nome, che è un array di byte e non una semplice stringa.

Le righe sono identi�cate da una chiave, un array di byte di lunghezza qualsi-asi, come avviene in un database chiave-valore. È quindi chiara la natura ibridadi HBase, che è sia column-oriented che chiave-valore. È possibile model-lizzare HBase come un dizionario in cui il valore memorizzato è a sua volta undizionario di dizionari:

tabella : chiave 7→ dizionario1

dizionario1 : famiglia 7→ dizionario2


dizionario2 : colonna 7→ valore

In un linguaggio funzionale come quelli che verranno trattati nella successivasezione questa struttura può essere implementata grazie al currying, ossia de�niretabella come una funzione che restituisce un'altra funzione, dizionario1, che asua volta restituisce la funzione dizionario2 che �nalmente restituisce il valoredesiderato.

Una query al database avviene speci�cando la riga e eventualmente qualifamiglie di colonne o singole colonne recuperare (per aumentare le prestazionievitando l'onerosa estrazione di famiglie inutili), e non sono possibili �ltri sulcontenuto delle colonne, come invece avviene normalmente in un database re-lazionale. Esistono quattro tipi di operazione:

get: recupera una riga, o più frequentemente solo alcune colonne, data la chiavea essa abbinata

put: inserisce una nuova cella abbinata a una riga con alcuni valori de�niti,aggiornando eventuali valori già esistenti per la stessa riga

scan: restituisce tutte le righe, iterandovi usando un cursore

delete: elimina una certa coppia chiave/colonna o più celle corrispondenti aun'intera famiglia di colonne per una certa chiave

È possibile però, in un caso molto speci�co, �ltrare i dati recuperati basandosisul loro timestamp (Evidenziato in �gura 3.5.3).

Versioning basato sui timestamp HBase supporta il versioning basato suitimestamp. A patto che tutti i nodi su cui è distribuito il database abbiano gliorologi di sistema sincronizzati tra di loro (risultato ottenibile sfruttando un time-server, servizio disponibile già a livello del kernel Linux), è possibile determinarecon esattezza l'ordine di creazione di varie versioni e eliminazioni di ogni cella daparte di più nodi e il suo stato nel corso del tempo. Le operazioni sul databasevengono quindi ride�nite:

get: recupera l'ultima versione di una riga (quella con il timestamp più alto), o surichiesta le ultime N versioni non cancellate. Permette anche di recuperaresolo le versioni comprese in un certo range temporale.

put: inserisce una nuova cella con il timestamp attuale, di default, o con untimestamp diverso speci�cato esplicitamente

scan: essendo una sequenza di get, restituisce l'ultima versione o le ultime Nversioni di ogni riga


delete: elimina le versioni di una cella precedenti un certo timestamp, gen-eralmente quello attuale. Questo è e�ettuato inserendo una versione spe-ciale della cella chiamata tombstone (una tecnica usata frequentemente neidizionari basati sugli hash), che segnala l'avvenuta eliminazione senza can-cellare e�ettivamente le altre versioni. Questo permette a un get con unrange temporale di leggere i valori della cella precedenti alla delete.

Il versioning può introdurre dei comportamenti apparentemente bizzarri ma inrealtà assolutamente corretti; per esempio, se una delete viene fatta con untimestamp futuro le successive put saranno invisibili (ma correttamente esegui-te) poiché la tombstone sarà successiva ai timestamp delle nuove versioni create.Allo stesso modo, è possibile e�ettuare una put nel passato che non modi�chi ilrisultato di una get che vedrà l'ultima versione.

3.5.3.1 I �ltri di Bloom

Una funzione estremamente interessante di HBase, e uno dei motivi per cui èstato usato in questa tesi, sono i cosiddetti �ltri di Bloom. Si tratta di unastruttura dati probabilistica, ideata dal matematico Burton Howard Bloom nel1970; questa struttura permette di determinare se una proprietà della base datiè vera o falsa in maniera probabilistica, ossia con un risultato che ha probabilitànon totali, ma comunque estremamente alte, di non essere corretto.

Nel caso speci�co dei �ltri di Bloom, questa proprietà è l'appartenenza di unelemento a un set, e i �ltri di Bloom possono fornire falsi positivi (ossia indicarel'appartenenza quando in realtà non esiste) ma non falsi negativi, almeno nellaversione più di�usa (ossia non può accadere che un elemento sia indicato nonappartenente al set quando invece vi appartiene).

Un �ltro di Bloom consiste in un array di m bit inizialmente posti a 0 e uninsieme di k funzioni di hashing distinte hi(x) de�nite sull'insieme di possibilielementi E, di cardinalità generalmente molto maggiore di m tali che

∀x∈E∀i<k(0 < hi(x) < m)

Inoltre, le funzioni di hash sono indipendenti, quindi non devono esserci, ideal-mente, correlazioni tra i loro valori, ossia P (hi(x) < a|hj(x) < b) = P (hi(x) <a)(h(x) < b) quando i 6= j e con a e b qualsiasi.

Inoltre, come è comune, le funzioni di hash devono essere ottimali, ossia ognibit dovrebbe avere la stessa probabilità di essere scelto dato un elemento casualedi E Quando si inserisce un elemento nuovo al set, se ne calcolano le k funzioni dihash ottenendo k valori compresi tra 0 e m, che possono non essere tutti distinti.Si impostano quindi i bit corrispondenti a tali valori a 1, se non lo erano già.

Dato un elemento, per veri�care che appartenga al set basta calcolare le kfunzioni e veri�care che tutti i bit indicati siano pari a 1. Se non lo sono tutti,allora l'elemento sicuramente non appartiene al set, ma se invece sono tutti pari


m k p Probabilità collisione

100 3 10 0.0176368341000 3 10 0.0000258531000 3 100 0.0174330031000 5 100 0.00944912521000 5 10 0.00000027651000 5 20 0.0000078228

Tabella 3.2: Le probabilità di collisione di un elemento assegnato a un �ltro diBloom con k funzioni di hashing, p valori inseriti in precedenza e un array da mbit.

a 1 non è garantito che l'elemento sia e�ettivamente contenuto nel set, perchépotrebbe essere presente un altro elemento che è mappato sugli stessi bit, o piùelementi che insieme coprono gli stessi valori.

Nell'ipotesi di ottimalità delle funzioni di hashing, le probabilità di scegliereun certo bit sono 1

m, e quelle che un certo bit non sia posto a 1 dall'aggiunta di un

elemento qualsiasi, considerata l'indipendenza delle funzioni hi, sono (1− 1m

)k.Mantenendo le assunzioni di ottimalità e indipendenza, inoltre, si ha che in-

serendo p elementi le probabilità che un certo bit rimanga 0 sono (1 − 1m

)kp equindi le probabilità di trovare tutti i bit corrispondenti a un nuovo elemento giàpari a 1 dopo aver inserito p elementi distinti, ossia avere una collisione e quindiun falso positivo, sono:

(1− (1− 1

m)kp)k

(3.6)

Dalla tabella 3.5.3.1 si osserva come questo valore diminuisca all'aumentare dik, infatti più funzioni di hash distinte si usano, e più è di�cile che due elementisi sovrappongano. Tuttavia all'aumentare di k si rischia di saturare velocementel'array di bit; se invece k = 1 si ha una struttura dati simile alle HashMap diJava, con la di�erenza che queste ultime anziché contenere singoli bit contengonoun array degli elementi con l'hash indicato.

I vantaggi dell'utilizzo di un �ltro di Bloom sono evidenti: essendo una strut-tura dati di dimensione m prestabilita e scelta arbitrariamente, può essere com-pletamente tenuta in memoria e usata come meccanismo per velocizzare dellerichieste a un database. Quando si deve veri�care la presenza di una chiave,se ne testa la presenza con questo meccanismo: se non è presente, allora nonsi prosegue nella ricerca del dato poiché non ci possono essere falsi negativi; seinvece è presente, si può cercare la chiave nelle tabelle con alte probabilità ditrovarla realmente, ma senza poterne essere certi (poiché possono esserci dei falsipositivi).


HBase utilizza i �ltri di Bloom intensivamente per aumentare la velocità diestrazione delle chiavi e delle celle, poiché dovendo gestire dei valori sparsi siavranno molte colonne, o intere famiglie di colonne, vuote data una certa riga, equindi si possono evitare onerose ricerche che nel caso delle colonne di famigliepossono addirittura riguardare datacenter remoti.

3.6 Linguaggi utilizzati nei sistemi Big Data

I sistemi BigData usano sia linguaggi general-purpose come Java, estesi con dellelibrerie apposite, che DSL14 creati speci�catamente per gestire il parallelismo inuna rete distribuita, come Hive, Pig o Jaql.

3.6.1 Java

Java è un linguaggio di programmazione orientato agli oggetti creato da SunMicrosystem il cui primo rilascio è avvenuto nel 1995.

L'aspetto più interessante di Java, assolutamente innovativo all'epoca del suorilascio, è il suo modello di esecuzione.

I processori, e l'hardware in generale, infatti, possono eseguire solo istruzioniaritmetiche e logiche molto elementari, espresse solitamente nel cosiddetto lin-guaggio assembly e un programma che svolga un'operazione �utile� (come mostrareuna foto o gestire del testo formattato) richiederebbe una grande quantità diistruzioni elementari, rendendo la sua scrittura molto lunga, costosa e pronaad errori. Inoltre, diversi tipi di processore richiedono diversi tipi di assemblye diversi sistemi operativi forniscono diverse funzionalità e librerie con diversimeccanismi per chiamarle e usarle, rendendo complessa la distribuzione di unapplicativo a sistemi diversi.

Da questo problema nasce l'esigenza dei linguaggi di programmazione: utiliz-zando un linguaggio di programmazione i programmatori possono rappresentarecon poche istruzioni astratte (ossia di alto livello) quelle che altrimenti sarebberostate migliaia, se non milioni, di istruzioni assembly e nella maggior parte deilinguaggi possono de�nire delle proprie istruzioni assemblando istruzioni più sem-plici, rendere disponibili queste operazioni ad altri programmatori e organizzarela struttura del programma in moduli indipendenti che sempli�chino il riutilizzodelle componenti e abbassino i costi di sviluppo (poiché se un programma è divisoin moduli indipendenti che comunicano con delle interfacce ben de�nite in genereè più semplice identi�care in che modulo si veri�ca un problema e modi�carlosenza avere e�etti collaterali a distanza su altre parti del codice).

Però, le istruzioni di alto livello devono comunque essere convertite in istruzioniassembly per poter essere concretamente eseguite; per farlo esistono due approcci:

14Domain Speci�c Language

3.6 Linguaggi utilizzati nei sistemi Big Data 69

compilazione: Il programmatore dà il codice di alto livello del programmaa un compilatore, che converte le istruzioni astratte nelle corrispondentiistruzioni assembly e le chiamate generiche al sistema operativo in chia-mate vere e proprie per un sistema operativo speci�co ottenendo un codiceassembly per una certa architettura e per un certo sistema operativo. È unapproccio e�ciente per quanto riguarda l'esecuzione del programma com-pilato (che è immediatamente pronto ad essere eseguito) ma richiede diricompilare lo stesso per ogni architettura e per ogni sistema operativo,e spesso di riscrivere alcune porzioni del codice che dipendono da libreriespeci�che di un sistema operativo. È l'approccio adottato dal C/C++, dalFortran e dal Pascal per citarne alcuni ed è necessario quando si devonousare funzioni di basso livello (per esempio per costruire driver, interi sis-temi operativi o software di controllo per macchine speci�che) o ottenereprestazioni elevatissime (come nel caso dei videogiochi o delle simulazioniscienti�che)

interpretazione: L'utente esegue direttamente il codice sorgente, e questo èletto al momento da un interprete, ossia un programma che comprendele istruzioni astratte del linguaggio e le chiamate a librerie speci�che del-lo stesso e le converte in tempo reale in operazioni hardware e chiamateal sistema operativo speci�co vere e proprie. Questo permette allo stessoprogramma di essere eseguito su sistemi eterogenei (che avranno diverseversioni dell'interprete speci�che per l'architettura e il sistema operativoconcreto) senza modi�che, al prezzo di una perdita di prestazioni dovutaalle operazioni di interpretazione e traduzione svolte continuamente dall'in-terprete. È l'approccio adottato, per esempio, da Python, Ruby e PHP. Èbene notare che quasi sempre l'interprete funziona internamente come uncompilatore, traducendo le porzioni più critiche del programma da eseguirein codice assembly e eseguendo poi quest'ultimo per ottenere una maggioree�cienza.

Java propone un approccio ibrido tra i due, chiamato pseudocompilazione o com-pilazione in bytecode. In sostanza i programmi Java utilizzano una libreria stan-dard, speci�ca di Java, che viene usata al posto delle librerie speci�che fornitedai vari sistemi operativi e vengono poi compilati. La compilazione però nongenera un codice assembly di un'architettura speci�ca ma bensì un codice perun'architettura virtuale chiamato bytecode.

Per permettere l'esecuzione del bytecode compilato bisogna disporre di unaMacchina Virtuale Java (JVM ) che interpreta le istruzioni del bytecode tra-ducendole nelle istruzioni assembly e�ettivamente presenti nell'architettura speci-�ca. Similmente, le chiamate alle librerie Java e�ettuate dal programma vengonotradotte a chiamate a librerie equivalenti nel sistema operativo della macchinache esegue il software.


L'approccio di Java è quindi una via di mezzo tra compilazione e interpre-tazione: interpretare il bytecode è un'operazione molto meno pesante che in-terpretare un codice astratto, poiché sono comunque istruzioni simili alle realiistruzioni assembly e spesso si traducono linearmente proprio in queste ultime(anche la JVM esegue in genere una compilazione dietro le quinte come i normaliinterpreti, detta Just in time, JIT ).

Questo approccio, pubblicizzato come �write once, run everywhere� è la ra-gione del successo iniziale di Java. Inoltre, l'approccio interpretato permettedi eseguire un'applicazione isolandola dal sistema operativo e controllandone lepossibilità di manipolazione. Quindi, è stata sviluppata una tecnologia chiama-ta applet : un'applet è un programma in Java incorporato in una pagina web eeseguito nel computer dell'utente senza poter, di norma, accedere al �lesystemlocale o eseguire operazioni pericolose, arricchendo l'esperienza della navigazionesul web.

Di fatto, i tempi di caricamento della JVM necessaria a eseguire un'applet,la loro scarsa integrazione con le pagine web, l'assenza di Java nel software dibase di Microsoft Windows, il sistema operativo più di�uso in ambito desktop,e in�ne la comparsa di soluzioni concorrenti senza questi difetti (in particolareMacromedia Flash, ora a sua volta sempre meno usato in favore della famiglia distandard HTML5 ) hanno portato al quasi totale disuso di questa tecnologia.

Invece, Java ha avuto un grande successo in applicazioni embedded, special-mente per cellulari, in particolare il sistema operativo Android utilizza questolinguaggio per le sue applicazioni (tradotte però internamente dal bytecode Javaa un linguaggio chiamato Dalvik). Anche in ambito server Java è molto usatoper la gestione di database, siti web e applicazioni service oriented.

Oltre alla portabilità su diverse piattaforme Java o�re altri vantaggi alleaziende:

� La gestione della memoria è totalmente a�data a un componente chiamatogarbage collector, che rileva automaticamente quali strutture dati presentiin memoria non possono essere più usate e le elimina regolarmente. Altrilinguaggi, come il C++, dispongono di strumenti del genere che possonoperò essere usati, se il programmatore lo richiede, solo su alcuni tipi distrutture dati (per esempio non sono applicabili a strutture con riferimen-ti ciclici), mentre per il resto l'allocazione e il rilascio della memoria sonoa�dati al programmatore e se non gestiti correttamente portano un pro-cesso a consumare sempre più spazio nel corso dell'esecuzione �no a doveressere terminato. Nel caso di applicazioni eseguite continuamente come unserver web o un applicativo gestionale questo è inaccettabile e quindi Javaè preferibile.

� Java è uno dei linguaggi più usati al mondo[9] e quindi è disponibile unanotevole forza lavoro che abbassa i costi di sviluppo e mantenimento delsoftware.


� L'ampio utilizzo di Java nel corso degli anni ha portato alla produzionee al perfezionamento di un gigantesco arsenale di ambienti di sviluppo,debugger, pro�ler e sistemi di build per questo linguaggio che risulta il piùfornito sotto questo punto di vista.

� Un altro e�etto dell'ampia adozione di Java è la presenza abbondante ecapillare di API per qualsiasi servizio.

� La rigidità di Java induce i programmatori a seguire degli approcci miglioridal punto di vista ingegneristico mantenendo una struttura ordinata delcodice, anche se può causare degli e�etti negativi che verranno illustrati trapoco.

� Java ha un supporto nativo molto semplice al multithreading, evitandoal programmatore di dover ricorrere a librerie esterne e poco portabili esempli�cando la gestione della concorrenza

Naturalmente Java presenta anche dei difetti, in particolare:

� L'assenza di strumenti per la manipolazione di liste analoghi a quelli di altrilinguaggi come il Python (map e reduce su strutture dati locali, �lter, slic-ing, etc.) rende alcune operazioni altrimenti triviali estremamente verbosee prone ad errori.

� L'assenza della chiusura di funzioni, che è alla base di molti pattern adottatiin linguaggi funzionali come Lisp o Clojure (ad esempio le monadi o ilcurrying), porta spesso il programmatore a scrivere codici molto più lunghie complessi del necessario.

� Java obbliga il programmatore a gestire alcuni tipi di eccezioni (le checkedexceptions). Anche se nelle intenzioni degli sviluppatori questo avrebbedovuto portare alla creazione di programmi che gestiscono gli errori inmaniera più e�cace (per esempio registrandoli in un log, noti�cando l'u-tente in maniera user-friendly e annullando l'operazione speci�ca senzaterminare l'intera applicazione), l'e�etto concreto è che i programmatoriscrivono dei blocchi try/catch inutili o che producono solo l'esposizione del-lo stack, aggirando così il compilatore che non può veri�care che il codiceper la gestione di un'eccezione sia e�ettivamente utile.

� Java non supporta i metodi builtin (i cosiddetti magic methods del PHP)

� La rigidità di Java spesso impedisce la creazione di programmi concisi,dato che, per esempio, ogni classe deve avere un suo �le, non è concessal'ereditarietà multipla nemmeno dalle classi astratte e non esiste l'overloaddegli operatori. Questo, pur evitando che i programmatori meno accorticompiano certi tipi di errori nel de�nire la struttura di un programma,


genera una sintassi prolissa e porta a un'esplosione del numero di classi, �lee righe di codice.

Java è il linguaggio con cui è stato scritto Hadoop, e per i motivi esposti, inparticolare la portabilità e la gestione della memoria, è il linguaggio più usatoper scrivere applicazioni MapReduce.

Scrivere un'applicazione per Hadoop in Java consiste nell'ereditare da delleclassi fornite dalle librerie del framework e eseguire l'override dei metodi mape reduce. Ad esempio l'applicazione WordCount (in 6.6) costituisce un esempioclassico.

Si noti che l'applicazione dispone anche di un metodo main. Questo metodosarà eseguito una volta per job e serve a de�nire dei parametri generali per l'interaesecuzione del job stesso all'interno di Hadoop, quali:

� Il formato di input e output e i percorsi dei �le all'interno del �lesystemHDFS

� Il nome del job (che apparirà nelle console di comando)

� L'eventuale esecuzione di altri job sia in serie che in parallelo.

Bisogna sottolineare come il job sia visto internamente dall'applicazione comeuna semplice istanza della classe Job, che non è un singleton, non incorporameccanismi per evitare l'istanziazione multipla nella stessa applicazione e puòquindi essere usata più volte speci�cando varie operazioni. Questo tuttavia èfortemente sconsigliato perché esistono altri strumenti più indicati per ot-tenere questo risultato, come Oozie, che forniscono il monitoraggio e il control-lo a runtime delle operazioni, la ripresa di work�ow interrotti, lo scheduling dijob da eseguire periodicamente e molto altro, nonché una maggiore �essibilità eintegrabilità con interfacce standard e ben documentate.

3.6.2 I linguaggi funzionali per la JVM: Groovy e Scala

Come spiegato in precedenza, il termine Java indica sia un linguaggio di pro-grammazione che una macchina virtuale in grado di eseguire il bytecode generatoda un programma scritto tale linguaggio. Tuttavia, è possibile progettare al-tri linguaggi o adattare dei linguaggi già esistenti per poter essere compilati nelbytecode eseguito dalla JVM quindi essere eseguiti da questa come del normalesoftware Java.

Questa possibilità permette da un lato di usufruire di linguaggi speci�ci percerti usi, i cosiddetti DSL15, e dall'altro di poter sfruttare l'ubiquità della JVMe l'abbondanza delle librerie e delle API disponibili per Java costruendo appli-cazioni che mescolino Java vero e proprio e altri linguaggi compilati per la JVM,abbassando i tempi e i costi di sviluppo.



Negli ultimi anno si è veri�cata un'esplosione di queste soluzioni. Per esempioGroovy è un linguaggio molto simile a Java ma con un maggiore supporto allamanipolazione delle liste, l'overload degli operatori e la gestione dei linguaggi dimarkup come l'XML. Per esempio, per mostrare tutti i numeri pari tra 1 e 200separati da un trattino il codice è:

( 1 . . 2 0 0 ) . grep { i t % 2 } . j o i n ("−")

una sintassi estremamente concisa simile a quella di Python

'− ' . j o i n (map( s t r , f i l t e r ( lambda x : x%2==0,xrange ( 1 , 2 0 0 ) ) ) )

si noti l'uso in questo esempio della keyword lambda, che permette di de�niree usare direttamente funzioni anonime, la funzione map che concettualmente èproprio la map di MapReduce ma applicata localmente, per convertire gli interiin stringhe, e la funzione �lter, che è una funzione di secondo ordine, ossia cheaccetta come parametro un'altra funzione (qui un'espressione lambda, che è sem-plicemente un metodo conciso per creare funzioni anonime al volo) che speci�cacome �ltrare la lista.

Il vantaggio dell'utilizzo di map, reduce, �lter e altre operazioni sulle liste inquesti linguaggi è non solo la brevità e la semplicità che rendono più semplice ildebugging e leggibile il codice, ma la possibilità di parallelizzarne e ottimizzarnel'esecuzione: un compilatore potrebbe avviare diversi thread per e�ettuare l'op-erazione di map o �lter in parallelo, o eseguirle solo su piccole porzioni della listaal momento della richiesta, la cosiddetta valutazione lazy. In e�etti, la funzionexrange non genera una lista ma solo un iteratore, e in Python 3 o superiori l'interaespressione viene valutata un valore alla volta permettendo l'esecuzione anche suvalori molto grandi. Addirittura, l'esecuzione potrebbe essere automaticamenteeseguita in un cluster con una parallelizzazione massiva in maniera trasparenteallo sviluppatore.

Queste ottimizzazioni (parallelizzazione e modi�ca dell'ordine di esecuzione)analoghe a quelle eseguite dai database relazionali sfruttando l'algebra relazionalee le euristiche sul contenuto delle tabelle, richiedono però l'esistenza di vincoli sulfunzionamento interno del software, in particolare le operazioni parallelizzateautomaticamente devono essere funzioni pure, ossia non possono eseguireoperazioni di I/O o cambiare lo stato del sistema ma limitarsi a elaborare l'input efornire un output in maniera deterministica. Il motivo è evidente: se delle funzionicome la str o la grep usate nell'esempio avessero internamente modi�cato un �leo un database o comunicato tramite la rete con altre entità, allora modi�candonel'ordine di esecuzione o parallelizzandole si sarebbero avuti degli e�etti collaterali(side e�ect) imprevedibili. Un linguaggio che è orientato all'utilizzo di funzionipure e all'utilizzo di funzioni di secondo ordine è detto linguaggio funzionale,ne sono esempi il Lisp, lo Scheme e il Clojure. Quest'ultimo è un linguaggiopuramente funzionale compilabile per la JVM (nonché per la piattaforma .NETe altri ambienti), e quindi è interessante in questo ambito.


La programmazione puramente funzionale, però, è poco adatta alla manipo-lazione dei dati su database e �le proprio per l'ovvia presenza di side e�ect, eper la di�coltà nell'utilizzo di librerie e framework concepiti per uno stile diprogrammazione imperativo dell'utilizzatore. Esistono delle strutture, chiamatemonadi, che permettono di incapsulare l'esecuzione di alcune operazioni e de�nirela concatenazione di operazioni, ritardandole, parallelizzandole, e cambiandonel'ordine di esecuzione in modo da gestire, tra le altre cose, le operazioni con deiside e�ect, la cui discussione è estranea ai contenuti di questa tesi.

Il linguaggio Scala, invece, presenta un ibrido tra programmazione funzionale eimperativa permettendo di combinarle in base alle esigenze e spaziare nei sorgentida uno stile completamente imperativo a uno puramente funzionale. Inoltre, cercadi risolvere i problemi di Java sopra esposti, ossia:

� Sono presenti le funzioni di map, reduce, �lter e molte altre, fornendo unadelle librerie più complete esistenti tra quelle o�erte dai linguaggi generalpurpose.

� La chiusura di funzioni è un'operazione elementare e ben integrata nellinguaggio

� L'overload degli operatori è completo e permette di de�nirne sia per ilconfronto che per la manipolazione, composti da uno o più caratteri, perottenere dei DSL16

� Si possono de�nire dei metodi builtin, anche per la chiamata di funzioni.Ossia è possibile chiamare un'istanza di una classe come se fosse una fun-zione e stabilirne il comportamento. Questo meccanismo si può usare ancheper manipolare agilmente gli e�etti della modi�ca di un campo di un'istanzadi una classe senza ricorrere ai getters e a i setters di Java (che rimangonocomunque possibili).

� I tipi primitivi sono gestiti come delle classi (ossia in esistono int e In-teger ma solo Int), evitando al programmatore di dover e�ettuare delleconversioni e fornendo una maggiore consistenza.

� La gestione delle eccezioni è opzionale, il programma viene compilato anchese non ci sono blocchi try/catch.

� La distribuzione delle classi nei �le è arbitraria, si possono inserire più classipubbliche in un solo �le e non c'è obbligo di corrispondenza tra il nome del�le e quello della classe contenuta.

In aggiunta a questo, esistono delle librerie speci�che per Scala che forniscono unasintassi molto potente per interfacciarsi con alcune tecnologie tra cui Hadoop e



MongoDB. Essendo compilato nel bytecode Java (o opzionalmente in CL17 per lapiattaforma .NET), Scala permette di utilizzare nativamente le librerie Java e uncodice Scala può essere direttamente compilato e incapsulato in un JAR18 e usatoin un progetto Java esattamente come una qualsiasi libreria, senza nemmeno cheil programmatore Java debba sapere che la libreria è e�ettivamente scritta inScala.

Altri aspetti fondamentali di Scala sono la presenza di una comunità di svilup-patori molto vasta e attiva con conseguente abbondanza di supporto e documen-tazione e la presenza di uno strumento di build chiamato SBT, Scala BuildingTool, analogo a Maven e Ant e con la possibilità di usare nativamente i reposito-ry di questi ultimi e estendere il comportamento del programma con dei plug-inintegrati nei progetti.

Inoltre, Scala ha un avanzato supporto alla programmazione concorrente, cheestende quella di Java (che è comunque presente) con il concetto di attore.

Gli attori e il framework Akka

Un attore è simile a un comune thread con la di�erenza che anziché usare imeccanismi di lock, wait e join gli attori comunicano tra loro tramite lo scambioasincrono di messaggi. Ogni attore dispone di una funzione receiver che vienechiamata in maniera asincrona quando vi sono dei messaggi (che sono sempliciistanze di qualsiasi classe) in coda e può a sua volta inviare messaggi ad altriattori. La coda dei messaggi è gestita in maniera trasparente dal linguaggio chegarantisce che saranno elaborati nell'ordine di ricezione.

Il framework Akka è una libreria Scala/Java che estende ulteriormente il con-cetto di attore aggiungendo la possibilità di passare messaggi ad attori eseguitiin altre JVM o direttamente altre macchine in maniera trasparente, ottenendouna scalabilità molto elevata. Questa tecnologia si distingue dalla RMI di Javaper diversi aspetti:

� I messaggi sono asincroni, l'esecuzione del programma continua subito dopoavere mandato dei messaggi ed è possibile mandarne altri

� La creazione di un attore è un'operazione triviale, non richiede di estendereapposite interfacce e il framework permette di accedere a un attore in unasola riga speci�candone nome e host

� Gli attori hanno una gerarchia che permette a ognuno di lanciare delleeccezioni che saranno gestite dall'attore chiamante che a sua volta potràgestirle o passarle all'attore superiore.

17Common Language, l'analogo del bytecode Java per il framework .NET di Microsoft18Java ARchive, un �le compresso che contiene del software Java con dei metadati e altre

risorse, lo standard per la di�usione di librerie e programmi Java


� Gli attori possono essere spostati automaticamente da un nodo all'altro incaso si veri�chino dei crash o delle disconnessioni.

� È possibile lanciare test in interi cluster usando un plug-in di SBT.

� Esistono, ma sono al momento in fase di beta[3] e non verranno quindiprovate, delle funzionalità per lo spostamento degli attori tra i nodi durantel'esecuzione e in maniera trasparente all'attore chiamante, e per l'esecuzionedi attori remoti eseguiti tramite servizi di cloud computing.

3.6.3 Scelta di non usare Scala

Per esaminare il linguaggio Scala ho sviluppato una libreria per il riconoscimentodei linguaggi naturali chiamata SmellsLikeLanguage19, un programma in gradodi determinare quale sia il linguaggio più probabile di un testo esaminando la suasimilitudine con dei campioni di testi nelle varie lingue, abbinato a un datasetdi 117 lingue generato da 30 articoli di Wikipedia per ognuna. Per fare ciò ilprogramma conta tutte le comparse di sequenze di k (nel nostro dataset k =3) caratteri consecutivi e genera un vettore dei conteggi. Il confronto tra duelinguaggi avviene con la cosine similarity dei due vettori:

cosine similarity =A ·B‖A‖‖B‖

=

n∑i=1

Ai ×Bi√n∑

i=1

(Ai)2 ×√

n∑i=1

(Bi)2

Questo valore è 1 se i vettori sono identici, 0 se non hanno nulla in comune,viene quindi scelta la lingua con il valore di similarity più alto.

Il programma fa forte uso delle caratteristiche di Scala, in particolare la listcomprehension, tanto che la similarità si riduce all'istruzione

o . f r e qu en c i e s . keys .map( s=>o . f r e qu en c i e s ( s ) * f r e qu en c i e s .getOrElse ( s , 0 ) ) . reduce ( ( a , b )=>a+b)

/math . s q r t ( o . quickSquare *quickSquare )

inoltre le peculiarità di Scala si mostrano molto interessanti anche per svolgerele operazioni di estrazione di un testo da pagine web o feed RSS, nonché per ilsalvataggio e il caricamento dei modelli in �le XML.

Sviluppandolo ho però osservato che:

� I tempi di compilazione di Scala sono terribilmente lunghi, si può arrivare�no a un minuto di elaborazione durante il quale le risorse del computer sonoassorbite dall'operazione. Infatti Scala compila tutto il codice in Java, perpoi eseguire la compilazione da Java al bytecode della JVM. La versione

19https://github.com/jacopofar/SmellsLikeLanguage

https://github.com/jacopofar/SmellsLikeLanguage


2.10, uscita in corso di scrittura della tesi, pare avere delle performancemigliori, pur essendo piuttosto lenta.

� Il supporto dei tool è molto scarso. Esiste un plug-in di Eclipse per Scala,ma è instabile, lento e genera messaggi assolutamente poco chiari.

� Le librerie presentano dei comportamenti anomali improvvisi, per esempioci sono stati dei problemi di codi�ca dei caratteri nella lettura di una pag-ina web, cosa che in Java sarebbe stata un'operazione sicura anche se piùprolissa in termini di codice.

� Il debugger di Eclipse (così come degli altri IDE) non è al momento applica-bile a Scala, e gli stack delle eccezioni sono incomprensibili poiché durantela compilazione vengono create automaticamente delle classi sintetiche perrappresentare il codice Scala in Java, che vengono poi mostrate a runtime.

� Anche se il codice è bytecode eseguito dalla JVM, ci si deve comunqueappoggiare a una libreria esterna, scala.jar, che deve essere sempre associataal programma

� La documentazione, per quanto l'impegno a produrla sia lodevole, è perforza di cose ordini di grandezza più scarsa rispetto a quella di Java

Per questi motivi, nonostante Scala sia un linguaggio estremamente promet-tente, ho deciso di sviluppare il sistema software in Java (e altri linguaggi comeJavaScript e Python per alcune componenti).

3.6.4 Hive

Hive ha una sintassi simile all'SQL ed è stato sviluppato come strumento internoa Facebook e poi donato alla ASF.

È molto simile a un linguaggio per l'interrogazione di database relazionali, alpunto che sono disponibili dei connettori ODBC e JDBC, in modo da renderlo ilpiù comodo e accessibile possibile agli sviluppatori provenienti dagli ambiti piùsvariati (web, applicazioni mobili, DBA, etc.) che spesso conoscono già l'SQL. Èpossibile creare delle �tabelle� con il comando CREATE TABLE come in SQL eeseguire delle query su di esse, che saranno internamente memorizzate come �leHDFS, come vere tabelle in database relazionali o come tabelle in un databaseHBase. Per importare facilmente i dati Hive aggiunge agli strumenti base diHadoop come Flume degli strumenti per l'importazione, ad esempio

CREATE TABLE input ( l i n e STRING) ;LOAD DATA LOCAL INPATH ' input . tsv ' OVERWRITE INTO TABLE

input ;


permette di caricare un �le e inserirlo direttamente in una tabella dotata dischema. Tutti i dati manipolati da Hive, infatti, devono avere uno schema comeavviene con l'SQL.

Hive può anche attaccarsi a delle tabelle già esistenti sotto forma di �le oservizi esterni (come dei database relazionali) nel qual caso le operazioni CREATETABLE e DROP TABLE non fanno altro che creare e eliminare dei metadati perrendere il contenuto della tabella visibile o meno alle successive query, mentre lasorgente e�ettiva è condivisa con le altre applicazioni anche esterne ad Hadoop.

L'applicazione WordCount si riduce quindi a

SELECT word , COUNT(* ) FROM inputLATERAL VIEW explode ( s p l i t ( text , ' ' ) ) lTable as word

GROUP BY word ;

che legge la tabella creata precedentemente e ne crea una view contenente lafrequenza delle parole.

Hive, come l'SQL, è un linguaggio dichiarativo, e non o�re strumenti di con-trollo sull'e�ettiva esecuzione delle query, che sarà stabilita dall'ottimizzatore checreerà un query execution plan di volta in volta.

3.6.5 Pig

Similmente a Hive, Pig è una piattaforma sviluppata da Yahoo! e mantenutadalla fondazione Apache per de�nire delle operazioni MapReduce da eseguire suHadoop con un linguaggio di alto livello e ispirato all'SQL chiamato Pig Latin20.È fatto per elaborare dati qualsiasi (da cui il nome), a�dandosi a delle UDF 21

se necessario, e può operare sia all'interno di Hadoop che localmente.La sintassi è così concisa che un'operazione come il WordCount che in Java

(Sorgente 6.6) richiede circa 60 righe si traduce in un codice (Sorgente 6.7) diappena 7 righe e�ettive estremamente intuitive che e�ettua in più l'ordinamentodelle parole in base alle frequenze, operazione che sarebbe stata molto laboriosada implementare con un job MapReduce de�nito esplicitamente.

Bisogna osservare che le operazioni sono de�nite sotto forma di lista, per-ché Pig Latin è un linguaggio imperativo mentre SQL è dichiarativo, e la lorosomiglianza è solo sintattica e serve a rendere più veloce l'apprendimento di Pig.Anche se le operazioni sono de�nite in sequenza, Pig internamente può alterarnel'ordine e parallelizzarle in maniera tale che diversi nodi lavorino a diverse fasidell'esecuzione migliorando le prestazioni. Per farlo, viene creato un DAG22 cheè una relazione d'ordine parziale sulle istruzioni e speci�ca formalmente quali

20Un gioco di parole, il pig latin è una lingua inventata simile all'alfabeto farfallino usato neipaesi anglofoni

21User De�ned Functions22Direct Acyclic Graph


operazioni sono disponibili in ogni fase, similmente a quanto fanno i processoricon il pipelining delle istruzioni assembly.

Il programmatore può modi�care il �usso di controllo per esempio aggiungen-do dei checkpoint, ad esempio il codice

UserGeo = j o i n UserCl i cks by ipaddr , Geoinfo by ipaddr ;s t o r e UserGeo in to ' UserGeoIntermediate ' ;ByDMA = group UserGeo by dma ;

richiede di salvare un prodotto intermedio dell'elaborazione in un �le. Così,ferma restando la strategia di Hadoop per recuperare i task falliti a causa deiTaskTracker, è possibile avere dei �le di backup nelle fasi critiche.

I programmatori possono espanderne le funzioni scrivendo i propri plug-inin Java, Python o JavaScript e chiamandoli dall'interno di un codice Pig Latin.Inoltre, un'applicazione Java può utilizzare Pig internamente, permettendo diincapsularlo in Job standardizzati che possono essere integrati nei work�ow Oozie.

3.6.5.1 Gestione del parallelismo con UDF arbitrarie

Un aspetto critico della gestione delle funzioni de�nite dall'utente è che non èdirettamente possibile eseguirle in parallelo su più nodi o cambiare l'ordine diesecuzione a meno che non ci siano garanzie molto rigide sul loro funzionamentointerno, per esempio che siano funzioni pure.

Inoltre, in molti casi la UDF non è una black box che opera sui dati senzanessuna indicazione sul suo e�ettivo operato, ma ha una semantica dei tipi di datoin ingresso e uscita tale da poter essere integrata in un linguaggio di alto livellocome appunto Pig Latin; se si vuole �ltrare dei dati, la funzione riceverà in inputun elemento (una tupla, una riga o un documento, in base ai casi) e restituirà unvalore booleano. Sapendo questo, la funzione può non essere solo chiamata conun'operazione atomica ma essere integrata nei costrutti di PigLatin. Ad esempio:

REGISTER ./ t u t o r i a l . j a r ;

−− Cal l the NonURLDetector UDF to remove r e co rd s i f thequery f i e l d i s empty or a URL.

c l ean1 = FILTER raw BY org . apache . p ig . t u t o r i a l .NonURLDetector ( query ) ;

La prima riga importa in Pig un �le jar contenente le UDF desiderate, inseguito una di queste funzioni, che si occupa di determinare se una stringa sia omeno un URL, viene chiamata sulle tuple di un database e restituisce per ognunaun valore di verità che permette di �ltrare i dati. È quindi chiaro che la suaesecuzione può essere divisa in processi paralleli senza side e�ects, il motore diPig potrà fornire il jar a tutti i nodi e iterare su diversi chunk della tabella inparallelo, grazie alla de�nizione del valore di output della UDF NonURLDetector.


Si può osservare che NonURLDetector è in realtà una classe: allo stesso mododelle classi MapReduce complete, si permette al programmatore di predisporredelle attività preventive, per istanziare eventuali strutture dati o connessioni usatedalla UDF, che verranno eseguite in ogni nodo una sola volta alla prima chiamatadella UDF.

3.6.6 Jaql

Mentre Hive si concentra su dati strutturati come tuple di un database relazionalee Pig su dati qualsiasi, Jaql è orientato alla manipolazione di documenti JSON enon cerca di avere una sintassi simile all'SQL.

Si tratta infatti di un linguaggio Turing completo, mentre Hive e Pig Latinlo sono solo tramite l'aggiunta di UDF, e permette di de�nire variabili e cicli,nonché dichiarare funzioni da chiamare in altri punti dello script.

Il WordCount (Sorgente 6.8) è anche in questo caso molto sintetico, e permettedi accedere ai campi degli elementi in JSON con una sintassi molto semplice.

La sintassi a pipe de�nisce sequenze di trasformazioni (pipe) sui dati che sonorappresentati da variabili, per esempio:

read ( f i l e (" messaggi . j s on ") )−> f i l t e r $ . utente == 'Nerone '−> wr i t e ( hdfs (" so l one rone . j son ") )

legge un �le locale, ne estrae gli elementi con il campo utente uguale a�Nerone� e salva i risultati in un �le HDFS. C'è una forte somiglianza alle pipebash, che in questo caso sarebbe

cat "messaggi . j s on " | grep \" utente " :" Nerone"\ >so lone rone .j son ; hadoop f s −copyFromLocal so l one rone . j sonsolonerone_shared . j son

che però è un metodo poco indicato per �le le cui dimensioni potrebberocrescere molto nel tempo.

3.6.7 AQL

L'Annotation Query Language è un linguaggio sviluppato da IBM per manipolaredelle annotazioni su testi parzialmente o completamente non strutturati. L'ideaalla base di AQL è la stessa di UIMA, e può essere usato come un semplicecomponente (annotatore) di quest'ultimo. Anche AQL cerca di ottenere unasomiglianza con SQL, per facilitare l'uso ai nuovi utenti, e rappresenta il testo e leannotazioni come elementi di alcune tabelle, e gli sviluppatori possono aggiungerenuovi annotatori sotto forma di view che mostreranno nuove tabelle con deglielementi �ltrati, uniti o modi�cati.

Un esempio di vista AQL è:

3.7 IBM BigInsights 81

create view Company asextractd i c t i ona ry 'CompanyNames ' on D. text as companyfrom Document D;

questa vista individua all'interno del campo text di ogni documento tutti itermini che sono contenuti in un dizionario, ossia una tabella con un solo campodi tipo testo, e li aggiunge al campo company, e successive view potranno accederea questo campo per aggiungere ulteriori annotazioni.

Si osservi che il testo non presenta necessariamente una divisione in parole,infatti alcune lingue, come il cinese o il giapponese, non utilizzano gli spazi equindi un linguaggio che prevede una segmentazione del testo in singole pa-role non sarebbe applicabile a documenti in queste lingue. Il confronto con ildizionario avviene infatti su sequenze contigue di caratteri, ossia sotto-stringhe,non necessariamente circondate da spazi o punteggiatura.

Se si desidera individuare le singole parole, per esempio per e�ettuare analisi difrequenza o del topic, è comunque possibile farlo usando delle espressioni regolariche sfruttino gli spazi e la punteggiatura oppure, nel caso delle lingue asiatiche,usando dei tokenizer che separino le parole sfruttando delle euristiche, che sonostati sviluppati per l'architettura UIMA.

3.7 IBM BigInsights

Lo stack di soluzioni basate su Hadoop rappresenta lo stato dell'arte per quantoriguarda le soluzioni Big Data, ma si tratta comunque di un progetto in continuaevoluzione e l'uso tipico prevede di utilizzare più programmi orchestrandone lacoordinazione. Nei casi in cui la velocità di elaborazione dei dati sia un fattorechiave per un'azienda, può essere utile un pacchetto unico che da un lato integriquesti strumenti e ne sempli�chi la gestione, dando delle garanzie sulla stabil-ità e la compatibilità delle componenti, fornendo degli strumenti aggiuntivi perl'integrazione con alcuni database di largo utilizzo in ambito enterprise come lesoluzioni Oracle o DB2 e dall'altro lo perfezioni con alcune ottimizzazioni frut-to della ricerca scienti�ca. La piattaforma esaminata in questa sezione è IBMInfosphere BigInsights.

3.7.1 Presentazione della piattaforma e confronto con altresoluzioni

Flex Scheduler e Adaptive MapReduce

L'e�cienza dell'esecuzione di un job dipende dal modo in cui questo è diviso tra inodi e alternato con altri job. In particolare l'e�cienza aumenta quando si riescea:


� Assegnare ogni task al nodo più adatto, senza sbilanciarsi sull'assegnazionedi troppo carico a un solo task ma evitando anche il più possibile di asseg-nare i task a nodi lontani dai dati manipolati

� Evitare che un job consumi tutte le risorse sottraendole agli altri job, mapermettere a dei lavori con alta priorità di essere eseguiti, appunto, piùrapidamente

� Variare certi parametri delle operazioni di I/O, come la quantità di datielaborati da un singolo task o la dimensione dei chunk estratti da undatabase ad ogni passata, in modo tale da giungere ai parametri ottimali.Questi possono variare nel tempo in base al carico complessivo, quindi vannomonitorati e adattati continuamente

Hadoop gestisce i primi due problemi con lo scheduler Fair esposto precedente-mente, mentre BigInsights permette di utilizzare, se lo si desidera, lo schedulerFLEX.

Questo scheduler adotta, anziché il tesso medio di utilizzo delle risorse da partedi ogni job, il tempo medio di risposta (Average Response Time), con l'obiettivo digarantire una rapida esecuzione ai job più piccoli; tale scelta avvantaggia l'utilizzointerattivo di BigInsights tramite lo strumento di reportistica integrato BigSheets.

FLEX, come Fair, supporta anche la possibilità che diversi job abbiano diversepriorità. Un codice Jaql, per esempio, può modi�care la propria priorità con

setOpt ions ( { conf : { " f l e x . p r i o r i t y " : 1} } ) ;

Per quanto riguarda la gestione dei parametri di gestione dell'I/O, è assentein Hadoop, e sono scelti dal programmatore in fase di sviluppo. Naturalmentelo sviluppatore può predisporre dei meccanismi di adattamento dal lato dell'ap-plicazione, ma oltre ad essere molto laborioso potrebbero sorgere dei probleminel caso più istanze attive nel cluster cerchino contemporaneamente di adattarsi,dando origine a fenomeni di risonanza (ossia più nodi potrebbero indipenden-temente modi�care un parametro senza tenere conto della variazione introdottadagli altri).

Poniamo infatti che il criterio per variare un parametro di I/O pt che indi-ca la quantità di dati elaborati in un ciclo al tempo t chiamando dtla duratadell'esecuzione di un ciclo al tempo t sia una sorta di regressione logistica:

pt = pt−1 + (pt−1

dt−1

− pt−2

dt−2

)(pt−1 − pt−2)k + r(t)

con r(t) che è un valore casuale generato ogni volta per evitare lo stallo. Insostanza, ad ogni ciclo si aumenta il parametro p se nei precedenti due cicli è au-mentato ed è aumentata la velocità (ossia il rapporto tra dati elaborati e tempod'esecuzione) o è diminuito ed è diminuita la velocità. È evidente che, se nonci sono dinamiche particolari nel sistema (come delle cache), il valore di p farà


raggiungere all'applicazione il massimo locale della velocità di elaborazione. Seperò la durata di un singolo task dipende anche da una risorsa condivisa tra piùnodi che seguono questo principio, può veri�carsi un fenomeno di risonanza. Im-maginiamo che il nodo A e il nodo B abbiano un parametro p alto e eseguano unarichiesta alla stessa risorsa. Il primo che accede vedrà un aumento dell'e�cien-za, quindi aumenterà p, l'altro nodo invece lo abbasserà, portando al prossimociclo al ripetersi del fenomeno, e in alcuni casi addirittura all'aumento esponen-ziale dei parametri. Quest'ultima anomalia si può evitare ponendo 0 < k < 1,ma comunque in una rete di dimensioni non note a priori con risorse condivisel'ottimizzazione dei parametri rimane un problema aperto.

La soluzione di IBM è quindi basata sul monitoraggio continuo delle prestazionie dell'accesso alle risorse all'esterno dell'applicazione, e più precisamente al liv-ello di ZooKeeper. Le applicazioni possono quindi in ogni momento, su richiesta,veri�care il consumo di risorse globale e adattarsi senza rischiare fenomeni dirisonanza. Questa tecnica è chiamata Adaptive MapReduce (AMR).

Purtroppo, la documentazione su come accedere e�ettivamente ad AMR èpressoché introvabile al momento, e non è stato possibile esaminarne più a fondoil funzionamento. Inoltre, per e�ettuare una prova sarebbe necessario un clustervisto che per sua natura non avrebbe senso usare un singolo nodo.

3.7.1.1 GPFS

Come accennato, uno dei più importanti punti di forza della piattaforma BigIn-sights rispetto a una semplice installazione di Hadoop e altri componenti è il�lesystem distribuito GPFS usato, se lo si desidera, in sostituzione a HDFS.

Il General Parallel File System è un progetto avviato da IBM nel 1993 con loscopo di ottenere un elevato throughput in applicazioni multimediali e di calcoloscienti�co, trasformato in un �lesystem parallelo nel 1995. Quindi, mentre le altrecaratteristiche come l'Adaptive MapReduce sono modi�che di sistemi software giàesistenti, questo è un componente creato da zero molto prima dello sviluppo diMapReduce, Hadoop e dell'HDFS.

Come HDFS, lo scopo di GPFS è distribuire dei dati su più nodi, ancheeterogenei, di un cluster rendendoli disponibili per un gran numero di letture escritture richieste da più parti gestendo sia la concorrenza degli accessi che laridondanza dei dati per evitarne la perdita.

Tuttavia, GPFS presenta diversi vantaggi fondamentali su HDFS:

� Aderisce completamente allo standard POSIX, permettendo di applicare ipermessi sui �le propri dei sistemi UNIX/Linux (lettura, scrittura e ese-cuzione per diversi utenti e gruppi) e di eseguire su di esso molti applicativinon pensati nativamente per l'esecuzione in un sistema distribuito, comesistemi di backup, database e ambienti di sviluppo, permettendo l'utiliz-zo di soluzioni preesistenti su cui un'azienda potrebbe avere sviluppato uncerto know-how che altrimenti andrebbe perso.


� Può essere montato come un normale �lesystem[10] e non solo tramiteFUSE, ed essere usato pienamente in questo modo e non solo con le API diHadoop.

� Permette l'accesso casuale ai dati, e non solo sequenziale. In questo modoè possibile, tra le altre cose, eseguire database come Neo4j o Lucene che nefanno largo uso, senza la limitazione delle dimensioni di un singolo disco.Neo4j, per esempio, può arrivare a memorizzare �no a 234 nodi e altrettanterelazioni, una cifra su�ciente per qualsiasi utilizzo pratico (comunque sipossono aprire più istanze a piacere), e supporta l'accesso multiplo in let-tura e segue gli standard HA, quindi è perfettamente utilizzabile in questoambito, così come Lucene, e senza disporre di un �lesystem con accessocasuale ci si priverebbe di queste risorse o si dovrebbe memorizzarle su unsingolo nodo con inevitabili problemi di dimensioni e concorrenza.

� Le modi�che concorrenti allo stesso �le sono possibili utilizzando, oltre alclassico lock sull'intero documento, dei lock applicati a range di byte, per-mettendo una granularità molto �ne e una conseguente riduzione dei collidi bottiglia.

� È possibile speci�care diversi tipi di dischi e speci�care delle a�nità tradati e gruppi di dischi, memorizzando i dati più importanti sui nodi piùa�dabili o i dati che si prevede di andare a manipolare più frequentementesui nodi più performanti, mentre HDFS tratta tutti i dati allo stesso modosenza possibilità di con�gurazione.

� Tutti i metadati (nome, dimensioni, data di creazione, ecc.) sono memoriz-zati insieme ai �le stessi e distribuiti sui DataNode. Questo ne garantisce laridondanza e aumenta le prestazioni dell'accesso, in particolare se si ha ungran numero di �le piccoli che su HDFS richiederebbero numerose richiesteal NameNode. Inoltre, in caso di rottura dello stesso non devono essererecuperati ricorrendo al Secondary NameNode con una notevole perdita diuptime e rischio di data loss.

� GPFS nelle sue versioni recenti ha un'architettura senza Single Point ofFailure[10], che permette di avere un cluster che continua a funzionare incaso di fallimento di qualsiasi nodo, compresi i NameNode o i JobTracker,a di�erenza di Hadoop che non può gestire il fallimento di un nodo centralema solo di un DataNode o un TaskTracker.

Quest'ultimo aspetto in particolare richiede un'architettura radicalmente diversada quella di HDFS e l'implementazione di alcune soluzioni particolari che oraverranno esposte.


Storage pools Gli storage pools sono degli insiemi di dischi con caratteristichesimili in termini di a�dabilità e prestazioni, che possono essere sia singoli dis-chi che diversi sistemi RAID23. Mentre HDFS non permette di speci�care delledi�erenze tra i dischi, GPFS dà agli amministratori di sistema una maggiorepossibilità di tuning permettendo di speci�care le a�nità tra dati e contenitori.Questo avviene con la de�nizione di tre tipi di entità:

1. Gli storage pools, insiemi di dischi e insiemi RAID con prestazioni e MTTFsimili

2. I Filesets, insiemi di �le con esigenze di disponibilità, riservatezza e persis-tenza diverse

3. Le Placement policies, che de�niscono in quale storage pool deve esserememorizzato ogni �lesets

Grazie a questa architettura un'azienda può, ad esempio, condividere i suoi daticon altre aziende o in una rete pubblica abbassando i rischi di accessi non autor-izzati poiché i dati riservati non sono �sicamente presenti nei nodi collegati allereti meno protette.

Condivisione tra più cluster Nel caso si disponga di più datacenter geogra�-camente distribuiti o si vogliano scambiare dei dati con altri enti (aziende, uni-versità o PA), GPFS permette di collegare più cluster per accedere da uno aidati dell'altro in remoto, rendendo trasparente la loro posizione e�ettiva e au-mentando la ridondanza per evitare data loss in caso di catastro� (come incendio allagamenti) che coinvolgono interi cluster.

Nodi quorum e eliminazione del SPoF Il meccanismo introdotto da IBMper evitare che il collasso di un nodo come il NameNode o il JobNode di Hadoopporti al blocco dell'intero cluster è basato sul concetto di quorum. L'idea allabase di questo meccanismo è che esista un numero minimo di nodi in gradodi rappresentare la maggioranza del cluster (un quorum, appunto) e eleggere ilnuovo nodo centrale in caso di fallimento, in maniera trasparente alle applicazioniMapReduce.

I nodi quorum sono speci�cati manualmente, non possono essere più di otto edovrebbero essere macchine a�dabili contenute ognuna in un rack diverso. Ogninodo quorum veri�ca continuamente che gli altri nodi quorum siano funzionanti.

Un nodo centrale chiamato Cluster Manager svolge un ruolo analogo al JobN-ode di Hadoop, coordinando l'esecuzione delle operazioni MapReduce nel cluster.Il Cluster Manager indica un altro nodo chiamato File System Manager che svolge

23Redundant Array of Inexpensive Disks, una tecnologia che permette di usare più dischi�sici come un unico disco logico parallelizzando l'accesso e/o mantenendo i dati ridondanti. Neesistono varie versioni che non verranno qui discusse.


un ruolo analogo al NameNode in HDFS. In caso di fallimento del FSM è il Clus-ter Manager a indicarne uno nuovo a runtime, si ricordi che in un �lesystemGPFS i metadati sono memorizzati insieme ai dati a di�erenza di HDFS.

La di�erenza sostanziale è la gestione del fallimento del Cluster Manager. InHadoop questo evento richiederebbe il ripristino manuale del sistema, e costitu-isce quindi un Single Point of Failure. Il sistema dei quorum, invece, prevedeche i nodi quorum eleggano all'occorrenza un nuovo Cluster Manager che con-tinui le operazioni, in maniera trasparente alle applicazioni in esecuzione. Si notiche l'elezione avviene solo da parte dei nodi quorum che riescono a veri�care ilfunzionamento della maggior parte dei nodi quorum. Questo è necessario per-ché in caso di partizionamento della rete si corre il rischio che dei nodi isolatide�niscano dei cluster manager e continuino a operare autonomamente generan-do un'inconsistenza nei dati. Se uno o più nodi quorum rimangono isolati in unapartizione della rete, le attività in quella partizione rimangono bloccate �no allariconnessione.

Metanode Un altra modi�ca alla topologia di Hadoop introdotta da IBM è lapresenza dei Metanode. Un Metanode è un nodo designato a tenere traccia deimetadati abbinati a uno speci�co �le e gestire le modi�che concorrenti. Mentre lemodi�che ai dati in sé possono essere eseguite sfruttando direttamente ai DataN-ode che li contengono, per rinominare un �le bisogna rivolgersi al MetaNode adesso abbinato, che è generalmente il nodo che ha tenuto aperto per più tempo il�le, e può cambiare nel corso del tempo man mano che esso viene aperto e chiusodalle applicazioni, in maniera trasparente.

3.7.2 Integrazione con altre tecnologie

Poiché BigInsights utilizza internamente Hadoop, Jaql e le altre tecnologie de-scritte, tutti i programmi che si interfacciano con esse possono di norma essereusati senza modi�che. Tuttavia, è da osservare che per fornire una versione bentestata IBM non inserisce nella piattaforma l'ultima versione delle componenti,che risultano quindi poco aggiornate. L'e�etto è che alcune attività possono pre-sentare anomalie non presenti nella documentazione su internet. Per esempio,durante il debugging del sistema software che verrà presentato più avanti è ac-caduto che alcuni importanti messaggi di log non venissero salvati insieme aglialtri; una ricerca su internet ha mostrato che si tratta di un problema noto24 erisolto nelle ultime versioni di Oozie, ma non in quelle presente nella piattaformaBigInsights.

In aggiunta a BigInsights IBM o�re le librerie per accedere a dei database re-lazionali in modo da importarne e esportarne facilmente il contenuto in HDFS, inparticolare per quanto riguarda i database DB2, molto usati in ambito aziendale.

24http://goo.gl/eN0HS


Dalla versione 2.0, uscita nel corso della scrittura di questa tesi, è presente unacomponente per integrare BigInsights con il pacchetto R per l'analisi statistica,tramite delle UDF per JAQL che vi comunicano con oggetti JSON, usandoloa livello dei singoli nodi; non è quindi applicabile all'elaborazione massiccia deidati, altrimenti lo si sarebbe potuto usare per la sentiment analysis, a meno chenon si abbia bisogno di manipolarli con una granularità molto �ne.

In generale, è di�cile seguire l'esecuzione di un'applicazione e analizzarecome si siano veri�cati eventuali errori, problema intrinseco delle applicazionidistribuite, motivo per cui verrà sviluppato un framework per l'esecuzione delleoperazioni sia in modalità locale che distribuita, per agevolare lo sviluppo.

Capitolo 4

Progettazione e implementazione di

una soluzione

4.1 Estrazione delle informazioni da siti web gener-

ici

L'estrazione dei post pubblici da FaceBook e Twitter è e�ettuata utilizzandole rispettive API pubbliche da alcuni programmi già implementati, tra cui unestrattore da Twitter sviluppato nel corso di questa tesi che però non presentaparticolari elementi di interesse e non verrà trattato. Molti commenti, invece,non sono sui classici social network ma su altri siti sparsi come forum e blog.

Bisogna quindi progettare un programma per estrarre i dati dalle pagine webcon facilità, gestendo i molti problemi relativi all'attraversamento del grafo degliipertesti (cicli e percorsi ridondanti), al codice HTML anomalo, al contenuto car-icato in un secondo tempo tramite AJAX e alla contestualizzazione del contenutodi una pagina in base a quello presente nelle pagine con le quali è stata raggiunta.

Per gestire l'esplorazione del grafo in un'architettura parallela è necessarioavere due strutture dati condivise che memorizzino in ogni istante gli URL daesplorare e quelli già analizzati. Gli attraversatori, eseguiti in parallelo, con-sumeranno un URL in attesa, esamineranno la pagina in questione estraendoneeventuali contenuti rilevanti e aggiungendo ogni URL trovato alla struttura datiche elenca le pagine in attesa, a meno che non sia già presente nell'elenco dellepagine esaminate. Quando l'elenco degli URL da esaminare risulta vuoto l'esplo-razione è terminata. Per gestire questa operazione è stato provato l'applicativoApache Nutch ed è stato deciso di sviluppare un nuovo strumento, da zero, chesegua i requisiti esposti nella sezione 2.2.1 e si integri al meglio nelle soluzioniBig Data.

90 Progettazione e implementazione di una soluzione

4.1.1 Wget e HTTrack

Wget è un comando disponibile nella quasi totalità delle distribuzioni Linux chepermette di scaricare un �le via web. Questo programma è estremamente usatoe con�gurabile, e tra le sue funzioni c'è lo scaricamento di interi siti web. Ilcomando

wget −vrc www. example . com

per esempio scaricherà ricorsivamente (r), con un output verboso (v) e ripren-dendo eventuali scaricamenti interrotti (c) il sito www.example.com. In mancanzadi impostazioni speci�che, l'attraversamento proseguirà esplorando i collegamentipresenti in ogni pagina ricorsivamente �no a una profondità pari a 5. È possibilespeci�care, oltre alla profondità, delle espressioni regolari che devono essere omeno corrispondenti ai collegamenti da seguire.

Si hanno però diversi problemi:

� Lo scaricamento delle pagine non avviene in parallelo, abbassando la veloc-ità di scaricamento a una frazione di quella possibile, perché il programmarimane in stallo mentre invia la richiesta e attende la risposta, usando unapiccola parte della banda disponibile

� I contenuti caricati tramite AJAX sono completamente ignorati

� Le pagine non sono contestualizzate, non è possibile sapere in quale paginaè stato trovato l'URL di un'altra pagina né cosa contenesse.

Inoltre, Wget è un programma per lo scaricamento di �le tramite HTTP, quindiovviamente non esegue alcuna sintesi del contenuto, limitandosi a scaricare i�le interi. Questo non è necessariamente un problema, poiché come si è vistoesistono delle tecniche ELT che e�ettuano l'elaborazione dei dati grezzi in untempo successivo al loro scaricamento, sfruttando appositi database in grado digestire al meglio i dati così �diluiti�. Però, Wget salva i dati nel �lesystem localee non in un database e nemmeno HDFS o GPFS (salvo che questi non sianomontati tramite FUSE o con l'apposito modulo del kernel di GPFS).

Un altro strumento speci�co per lo scaricamento di interi siti web è HTTrack,che è nato direttamente come strumento per la navigazione o�ine dei contenuti.Una prova mostra però che ha le stesse caratteristiche di Wget, a parte un mag-giore parallelismo e la possibilità di speci�care diversi pro�li di scaricamento perpiù siti web alla volta.

I due strumenti non sono quindi soddisfacenti perché inadatti all'esecuzione inun contesto parallelo, privi di funzioni di estrazione delle informazioni, inadatti acontestualizzare l'estrazione di una pagina e senza funzioni per gestire i contenutidinamici come AJAX.

4.1 Estrazione delle informazioni da siti web generici 91

4.1.2 Esame di Apache Nutch

Apache Nutch è un software sviluppato dalla ASF che si occupa di scaricareintere pagine web e seguire gli URL presenti al loro interno. Il progetto Hadoop,originariamente, è nato proprio come motore per parallelizzare l'esecuzione diquesto scraper e solo in seguito è diventato un progetto autonomo volto a gestirequalsiasi operazione parallela su cluster.

IBM BigInsights fornisce un certo numero di applicazioni di esempio tra cui èpresente proprio Apache Nutch. Eseguendola realmente su un forum di commentisulla categoria di prodotti di interesse sorge il primo ostacolo. L'applicazione in-fatti non utilizza il proxy aziendale e non riesce a connettersi, inoltre il problemanon è immediatamente chiaro e viene scoperto solo leggendo il log dell'appli-cazione trovato usando il comando locate. Modi�cando il codice sorgente Javaper impostare il proxy il problema persiste, infatti il �usso di esecuzione prevededi:

1. Caricare i parametri dell'estrazione (URL di partenza, profondità massimadell'attraversamento, espressioni regolari degli URL da evitare, etc.) dallaconsole web di BigInsights sfruttando Oozie

2. Creare un �le di con�gurazione temporaneo contenente queste impostazioni

3. Incapsulare tale �le in un �le con estensione .job incorporato nell'appli-cazione stessa

4. Lanciare in esecuzione su Hadoop, con un nuovo processo, tale �le

Questa sequenza di operazioni non è spiegata nel codice né è stato possibiletrovare informazioni su internet. Un'analisi del �le .job con il comando �le diLinux mostra che è un �le compresso la cui struttura è identica a quella di un�le .jar. Questo �le contiene un gran numero di �le .class e di �le di con�gu-razione in XML e altri formati, ed è proprio questo a contenere i binari e i �le dicon�gurazione di Nutch.

Poiché questo �le compresso viene lanciato in esecuzione manualmente dal-l'applicazione, le impostazioni del proxy vengono perse perché si trovano nell'am-biente di esecuzione originale. Inoltre, questa tecnica di lancio indiretto di Nutchha il problema di alterare l'esecuzione dei work�ow di Oozie: poiché si possonode�nire delle operazioni diverse in base al codice di uscita di un'applicazione,chiamando Nutch in maniera indiretta questo valore viene perso e non si possonopredisporre dei work�ow di�erenziati.

Comunque, esaminando il programma si scopre che uno dei �le di con�gu-razione nel �le .job contiene le impostazioni del proxy, e modi�candolo e avvian-dolo manualmente è possibile lanciare in esecuzione lo scraper in modo che tengaconto del proxy.


L'esecuzione diretta di Nutch risulta di�coltosa poiché il programma si aspet-ta di trovare la sua con�gurazione in un �le nel �lesystem locale e non su HDFS,e non gestisce direttamente i parametri forniti da Oozie.

La documentazione di Nutch è un po' frammentata, ma fornisce un tutorialche indica come scaricare una serie di URL seguendo i collegamenti ipertestualie salvandoli ciclicamente in un database. Inoltre, viene spiegato come indicizzarein Solr il contenuto testuale delle pagine scaricate. Paradossalmente, nonostantele origini di Nutch come sistema distribuito per l'indicizzazione delle pagine web,le FAQ riportano1 che non è indicato per il crawling parallelo, ma il parallelismo èutilizzato, tramite MapReduce e un �lesystem distribuito chiamato NDFS 2, soloper l'elaborazione dei dati.

Neanche Nutch, inoltre, fornisce delle funzioni per gestire i contenuti caricatidinamicamente, né per contestualizzare lo scaricamento delle pagine.

Per queste ragioni, è opportuno sviluppare un programma speci�co per ef-fettuare lo scraping delle pagine, l'estrazione dei contenuti rilevanti, la gestionedel contenuto caricato dinamicamente, la contestualizzazione dello stesso e l'es-portazione in un �lesystem distribuito e in un formato comodo come JSON.

4.1.3 Realizzazione di uno scraper

La prima architettura dello scraper, molto primitiva, si occupa di gestire il par-allelismo in un singolo nodo e lasciare all'utente la possibilità di speci�care leimpostazioni elementari come le pagine da cui iniziare, eventuali proxy e la pro-fondità dello scaricamento. In questo �le di con�gurazione è speci�cato anche ilcontenuto da estrarre dalla pagina tramite un selettore CSS. Per sempli�care lagestione delle pagine web e dei collegamenti è stata utilizzata la libreria JSoup,che implementa un parser del codice HTML che ignora i tag errati (aperti e nonchiusi).

I selettori CSS Un selettore CSS è un'espressione che indica uno o più puntidella struttura ad albero di una pagina web, usato dai fogli di stile per indicarequali elementi sono soggetti a ricevere un certo stile. Per esempio, l'espressione

div . contenuto img [ s r c$=.png ]

indica tutte le immagini con attributo src che termina in �.png� e che sitrovano sotto un tag div con classe �contenuto�. Poiché il testo deve ricevereun suo stile speci�co, deve essere identi�cabile con un selettore CSS, quindi loscraper potrebbe utilizzare questo tipo di espressione per permettere all'utentedi speci�care direttamente un segmento della pagina rilevante. Si osservi cheun selettore potrebbe corrispondere a più elementi distinti (nel caso esposto, più

1https://wiki.apache.org/nutch/FAQ#Will_Nutch_use_a_distributed_crawler.2C_

like_Grub.3F2Nutch Distributed File System

https://wiki.apache.org/nutch/FAQ#Will_Nutch_use_a_distributed_crawler.2C_like_Grub.3F

https://wiki.apache.org/nutch/FAQ#Will_Nutch_use_a_distributed_crawler.2C_like_Grub.3F


immagini PNG e/o più div con classe �contenuto�) o a nessun elemento, portandoall'estrazione di un numero variabile di documenti da ogni URL.

Come formato per il �le di input ho adottato il formato JSON. Questo formatoè infatti molto adatto a de�nire documenti con contenuti strutturati, e un esempiodi �le è:

{" s t a r t_ur l s " : [{" u r l " : " http ://www. esempio . com/forum/ de f au l t . asp " ,"TTL" : 5 ,} ,{" u r l " : " http ://www. esempio2 . com/wik i /" , "TTL":8}] ,"output_file_name " :" es t rat t i_forum . txt " ,"max_threads_number " : 30 ,"proxy_host " : " proxy . dominio . i t " ,"proxy_port " :"8080" ," connection_timeout " :60000 ," download_se lectors " : [ " div . r ep ly " ] ," f o l l ow_exte rna l_ l inks " : f a l s e , " r e j e c t L i s t " : [".+#.*" ,"www. esempio . com/[^ f ] .+" ,".+ pop_pro f i l e \\ . asp .+" ,".+method=Reply .+" ,".+method=ReplyQuote .+" ,".+\\. jpg " ," .+\\. g i f " ," .+\\. png " ," .+\\.mpeg" ," .+\\.mp3"] }

Il campo �start_urls� de�nisce un array di URL iniziali da cui avviare ildownload, e per ognuno speci�ca un TTL, ossia un Time To Live. A ogni linkseguito in una pagina, il TTL viene decrementato di un'unità; quando si esaminauna pagina con TTL pari a 0 i link al suo interno non vengono seguiti, e così sigestisce la profondità dello scaricamento evidanto che prosegua all'in�nito.

Si osservi che i diversi URL iniziali possono avere diversi TTL, ottenendodiverse profondità di estrazione in diversi siti. Inoltre, poiché i �le JSON nonhanno uno schema, è possibile speci�care un campo �ttizio chiamato �commento�che non essendo richiesto dallo scraper verrà semplicemente ignorato, mentreusando un �le XML la struttura sarebbe potuta risultare invalida con alcuniparser.

Il campo �rejectList� indica una serie di espressioni regolari indicanti gli URLda non seguire; la regex �www.esempio.com/[^f].+� indica di non seguire le


pagine che si trovano nel dominio esempio.com ma non iniziano con la letteraf, in modo da non fuoriuscire dal forum pur rimanendo nel dominio (uscire daldominio è impossibile grazie all'opzione �follow_external_links� che, impostataa false, indica di non seguire i link verso domini diversi da quelli esaminati.

Gli altri campi hanno un nome che rende ovvio lo scopo, a parte �down-load_selectors�: questo campo indica proprio il selettore CSS da utilizzare perestrarre i dati, in questo caso sarà estratto il testo dei tag div con classe reply.

Si osservi che tutte le informazioni relative all'operazione da svolgere sonocontenute in un solo �le, il cui percorso è indicato a sua volta allo scrapertramite un comando passato al metodo main, permettendo di integrare l'ese-cuzione dell'applicazione in Oozie e predisporre più �le di con�gurazione dascegliere arbitrariamente a di�erenza di quanto avviene con Nutch.

Salvataggio dei dati in un �lesystem distribuito I dati estratti dallo scrap-er saranno salvati direttamente in un �lesystem HDFS, se disponibile, altrimentiin un comune �lesystem locale.

Si controlla il contesto di esecuzione sfruttando un metodo di Hadoop cheveri�ca la con�gurazione del �lesystem: se il programma sta venendo eseguitosu Hadoop allora la si ottiene e implicitamente si ha conferma della presenzadi HDFS, altrimenti si ha un'eccezione che indica che ci si trova in un contestolocale.

A seconda dei casi, si crea un bu�er per un �le locale o per HDFS e lo si usain seguito senza più preoccuparsi del tipo speci�co di �lesystem usato.

Il parallelismo è gestito con un'architettura molto semplice (Figura 4.1) basatasu un numero di thread stabilito dall'utente.

Grazie al parallelismo si osserva un aumento deciso delle prestazioni: mentrecon Wget si aveva un tempo di circa 1s per pagina, ora è sceso a 96 ms per il sitodi riferimento (un forum).

La soluzione è però ancora insoddisfacente:

� Il selettore CSS non è in realtà una soluzione universale per stabilire qualisegmenti estrarre: il sito esaminato presenta un contorto layout senza tagDIV e con tabelle annidate una dentro l'altra per tre livelli costruito igno-rando completamente gli standard del W3C e con alcune pagine modi�catecon altre tabelle che vengono interpretate erroneamente come contenutorilevante dallo scraper.

� Alcuni elementi sfuggono per loro natura ai selettori CSS, per esempio iltesto �Inviato il 10/23/2001 alle ore 4.30PM� andrebbe essere trasformatoin �2001-10-23 16:30:00�, un formato molto simile allo standard ISO 8601e che permette il confronto immediato tra date (l'ordinamento alfabeticocorrisponde all'ordinamento cronologico).


Figura 4.1:

Gestore

scraper

HDFS/

filesystem locale

Strutture dati condivise:

lista elementi esaminati

e da esaminare

Estrattore

pagine

(thread)

Avvio Caricamento

configurazione JSON

Inizializzazione liste

Avvio e passaggio parametri

Consumo URL

pendenti

Scrittura ultimi

segmenti estratti

Aggiunta URL

scoperti

Consumazione

ultimo elemento

Nessun URL

nuovo, struttura

inutile verifica

starvation

chiusura

file

verifica

starvation

Il sequence diagram della prima soluzione implementata, con gli estrattori chesono un numero variabile e sono eseguiti parallelamente.

� Il contenuto AJAX non è gestito dal programma, ma nel primo caso d'usoesaminato non era comunque presente del contenuto attivo signi�cativo.

� Le pagine non sono contestualizzate, non è dato sapere quale link sia statoseguito per arrivare a un certo URL, ma questo potrebbe contenere dei datiutili.

� I dati estratti non sono strutturati, si potrebbero voler de�nire dei campidiversi come il contenuto del post, il nickname e la data della pubbli-cazione, ma questa implementazione si limita a estrarre i segmenti di HTMLcorrispondenti al selettore e salvare il testo riga per riga in un �le.

Scelta di un sistema di scripting per aumentare la �essibilità Per gestirel'estrazione del testo in maniera più precisa di quanto è possibile con un selettoreCSS, una soluzione elementare potrebbe essere aggiungere al �le di con�gurazionedelle liste di espressioni regolari per e�ettuare il confronto tra i segmenti individ-uati dal selettore e dei pattern de�niti dall'utente, con eventuali sostituzioni. Inquesto modo operazioni come l'estrazione della data e la sua trasformazione in unformato standard. È però chiaro che questo non risolverebbe il problema: i pat-tern per e�ettuare l'estrazione potrebbero essere ancora più complessi, richieden-


do di introdurre della grammatiche generative o altre strutture più �essibili delleregex.

Modi�cando direttamente lo scraper si potrebbe adattarlo a qualsiasi con-tenuto, ma in questo modo si mancherebbe l'obiettivo di creare uno strumentosoftware adattabile al volo a nuovi contenuti, e si costringerebbe l'utente a rein-viare nuovi versioni dello scraper ai server, distinguerle e e�ettuare il debuggingche in un ambito del genere è molto meno semplice di quello di un'applicazionedesktop. Esiste però una soluzione a cavallo tra la comodità di un �le di con�gu-razione conciso e caricato direttamente su HDFS e la �essibilità di una modi�cadel codice dell'applicazione, ossia l'estensione del comportamento del programmatramite lo scripting.

4.1.3.1 Integrazione dello scraper con Mozilla Rhino

Mozilla Rhino è un progetto della fondazione Mozilla per l'esecuzione e la ges-tione di codici JavaScript all'interno di Java. Grazie a questa tecnologia un'ap-plicazione Java può, in tempo reale, caricare un codice JavaScript e eseguirlo,fornendogli delle strutture dati arbitrarie e ricevendo eventuali risultati dell'ese-cuzione.

Nel caso d'interesse, lo scraper può essere espanso speci�cando nel �le di con-�gurazione JSON il percorso di un �le contenente del codice JavaScript, che saràcreato dall'utente e caricato anch'esso nel �lesystem HDFS. Tale �le conterràuna funzione che sarà chiamata ad ogni pagina, ricevendo in input la rappresen-tazione fornita da JSOUP della pagina stessa, e potrà manipolare tale strutturadati estraendone con facilità contenuti arbitrari.

Compilazione a runtime del codice JavaScript e esecuzione concor-rente L'utilizzo di Mozilla Rhino non porta a dei problemi di e�cienza: ilcodice JavaScript è infatti compilato all'avvio dello scraper in bytecode Java, edè poi tale codice ad essere eseguito direttamente dai diversi thread che gestisconolo scaricamento. Una prova con un sito mostra che lo stesso codice, eseguitotramite Rhino o riscritto in Java direttamente nel programma, ha prestazioni as-solutamente identiche, in entrambi i casi il tempo medio per scaricare una paginarisulta di 98 millisecondi.

Un problema più insidioso, invece, è l'esecuzione in parallelo di più istanzedella stessa funzione JavaScript. Rhino richiede di creare un contesto di ese-cuzione che deve esistere nel momento in cui si chiama una funzione, e che nonè threadsafe. La creazione di un contesto però richiede qualche frazione di sec-ondo, e non può quindi essere e�ettuata a ogni pagina scaricata. La soluzioneadottata è quindi creare un contesto di esecuzione (che non è threadsafe) distintoper ognuno dei thread, all'avvio dell'applicazione, e riutilizzarlo all'interno dellostesso thread che, manipolando un solo documento alla volta, non avrà problemidi concorrenza.


Per veri�care la �essibilità fornita da questa soluzione si veda questo codicereale:

1 var elem_posts = doc . s e l e c t ( " td . messaggio " ) ;2 var pos t s = [ ] ;3 for ( var i = 0 ; i < elem_posts . s i z e ( ) ; i++) {4 pos t s . push ( elem_posts . get ( i ) . t ex t ( ) ) ;5 LOG. debug ( "JS : post : "+elem_posts . get ( i ) . t ex t ( ) ) ;6 }7 // g l i o ra r i sono tag f on t che i d e n t i f i c o da l contenuto

t e s t u a l e8 var p o s s i b i l i _ o r a r i = doc . s e l e c t ( "p font " ) ;9 var o r a r i = [ ] ;10 for ( var i = 0 ; i < p o s s i b i l i _ o r a r i . s i z e ( ) ; i++) {11 i f ( p o s s i b i l i _ o r a r i . get ( i ) . t ex t ( ) . indexOf ( " Inv i a to i l " )

!= −1){12 var o r a r i o=p o s s i b i l i _ o r a r i . get ( i ) . t ex t ( ) . r ep l a c e ( "

Inv i a to i l " , "" ) . r ep l a c e ( " a l l e ore " , " " ) ;13 // i n s e r i s c o g l i o ra r i ne l formato YYYY−MM−DD hh :mm: ss14 var num=ora r i o . s p l i t ( " " ) [ 0 ] . s p l i t ( "/" ) ;15 o r a r i . push (num[2]+ "−"+num[1]+ "−"+num[0]+16 " "+o r a r i o . s p l i t ( " " ) [ 2 ] . r ep l a c e ( " . " , " : " ) ) ;17 }18 }19 // g l i u t e n t i sono l i n k che portano a una s p e c i f i c a

pagina20 var l i nk_utent i = doc . s e l e c t ( "b > a [ h r e f^=i n v i a t i . asp ?da

=]" ) ;21 var u t en t i = [ ] ;22 for ( var i = 0 ; i < l ink_utent i . s i z e ( ) ; i++) {23 u t en t i . push ( l i nk_utent i . get ( i ) . t ex t ( ) ) ;24 LOG. debug ( "JS : utente "+l ink_utent i . get ( i ) . t ex t ( ) ) ;25 }

Questo codice riesce a estrarre da una pagina tutti i sottorami del codiceHTML contenenti un elemento TD di classe messaggio per determinare i post.Poi estrae degli elementi HTML candidati a contenere gli orari, che sono contenutiin tag FONT (deprecati da anni ma ancora in uso) all'interno di tag P, e scegliequali sono e�ettivamente orari e quali contenuti indipendenti controllandone iltesto all'interno.

Per ogni stringa che indica un orario vengono applicate due sostituzioni condelle espressioni regolari che trasformano data e ora in un formato standard.

I nomi utente vengono invece estratti sfruttando il fatto che sono collegamentiipertestuali che portano al pro�lo dell'utente stesso.


Si noti che estrarre un contenuto del genere sarebbe stato impossibile usan-do semplicemente delle espressioni regolari e dei selettori CSS, ma il codice èestremamente conciso (19 righe e�ettive, ulteriormente diminuibili inserendo neicicli for la creazione degli array di candidati su cui iterare) e leggibile. Inoltre,si possono vedere due chiamate ai metodi oggetto LOG. Questo è un'istanzadella classe Log4j 3 utilizzata dallo scraper stesso, che permette all'utente, se lodesidera, di e�ettuare un monitoraggio delle operazioni svolte dallo script, il cuioutput sarà gestito dallo scraper e salvato in un �le che è a sua volta disponibileall'interno del �lesystem distribuito, rendendo il debugging del codice JavaScriptestremamente rapido.

Il codice deve poi generare l'output e restituirlo allo scraper, e anche questoè e�ettuato in maniera concisa:

1 //ora ho u t en t i , pos t e orar i , l i devo mettere in JSON2 var r i s u l t a t o="" ;3 for ( var i = 0 ; i < u t en t i . l ength ; i++) {4 var p=post s [ i ] . t oS t r i ng ( )+" " ;5 LOG. debug ( "JS : pos t s : "+p) ;6 r i s u l t a t o=r i s u l t a t o+JSON. s t r i n g i f y ({ " post " : p ,

" th r ead_t i t l e " :JSON. parse (conte s to ) . t i t l e ,

7 " user " : u t en t i [ i ]+"" ,8 "date " : o r a r i [ i ]+"" })+"\n" ;9 }10 LOG. debug ( "JS : RESTITUISCO: "+r i s u l t a t o ) ;11 return r i s u l t a t o ;

L'output è, in questo caso, una serie di stringhe JSON, una per riga, cheincapsulano nickname, post, data e titolo del post. Il titolo del post è un datoestratto dal contesto, ossia dalle informazioni sulle pagine in cui è stato trovato ilcollegamento ipertestuale a quella attualmente in esame. Questa funzione verràspiegata a breve.

La generazione di stringhe JSON in JavaScript è molto semplice (infatti JSONsigni�ca proprio JavaScript Object Notation, ed è gestito nativamente dal linguag-gio), e nel caso la pagina non contenga nessun post viene semplicemente restituitaallo scraper una stringa vuota. Lo scraper si occupa solo di chiamare il codiceJavaScript fornendogli un contesto di esecuzione adeguatamente ricco e memo-rizzare il risultato nel �lesystem locale o HDFS, gestendo la concorrenza, ma èagnostico rispetto al formato e�ettivamente usato, che potrebbe essereJSON, XML, CSV, YAML o qualsiasi altro.

3un sistema di logging fortemente estendibile prodotto dalla ASF


4.1.4 Gestione del contesto e dei contenuti caricati dinami-camente

Lo scraper deve poter gestire, all'occorrenza, la possibilità che il contenuto di unapagina vada contestualizzato, ossia che si debbano integrare i contenuti estrattidirettamente dalla pagina con altre informazioni contenute nelle pagine in cui èstato trovato l'URL della pagina corrente e visitate quindi in precedenza.

Un metodo semplice per ottenere questo risultato è utilizzare una strutturadati, o meglio ancora un database, che tenga traccia di ogni pagina esaminata, deisuoi contenuti e dei link seguiti, in modo che lo scraper possa sempre e�ettuare unbacktracking e esaminare l'intera successione di elementi esaminati per arrivare aquello corrente, e anche altre pagine. Questa soluzione tuttavia non è ideale:

� L'overhead per inserire tutte queste informazioni in un database ad ognipagina esaminata può essere notevole e diventare un collo di bottiglia. Inbase al CAP theorem infatti:

1. Se si sceglie un database che o�re le proprietà Consistency e Avail-ability si avranno problemi nell'esecuzione in parallelo su un cluster,che dovrà essere bloccata in caso di partizione. Inoltre l'overhead perottenere la transazionalità potrebbe essere notevole.

2. Se si sceglie un database che o�re le proprietà Availability e Partitiontolerance si avranno delle letture inconsistenti dovute al forte par-allelismo di letture e scritture. Questo è assolutamente inaccettabileperché la mancata ricostruzione di un contesto porterebbe a errori nel-lo scaricamento di una pagina e di conseguenza errori a catena durantel'esplorazione delle pagine successive.

3. Un database che o�re Consistency e Partition tolerance potrebbe averedelle prestazioni molto scarse dovendo mettere in attesa i thread �noall'ottenimento di uno stato consistente.

� Nella maggior parte dei casi, il contesto non è necessario o si riduce a unapiccola parte ben de�nita delle informazioni totali che può essere gestitadall'utente, come nel caso del titolo dei topic nel codice precedente, quindicreare un contesto completo porta a uno spreco di memoria e tempo dielaborazione.

Anziché memorizzare il contesto grezzo e estrarne le informazioni al momentodell'esplorazione di una nuova pagina, è più e�ciente per i motivi esposti estrarrele informazioni che costituiscono il contesto, se esistono, nel momento in cui siesaminano le pagina, per passarle allo scraper che le memorizzerà e le fornirà inseguito al codice JavaScript stesso in una successiva esecuzione.

Poiché non è noto a priori in cosa consisterà questo contesto, che potrebbeessere un dizionario chiave-valore, una stringa, un numero, una struttura più


complessa o semplicemente non esserci, il formato più adatto a gestire il contestoè JSON. Lo script de�nito dall'utente potrà quindi leggere il documento JSONabbinato a una pagina e indicare allo scraper quale contesto abbinare alle pagineaggiunte espandendo il nodo corrente.

Inoltre, poiché questo formato è perfettamente serializzabile e de-serializzabilein una stringa, è possibile memorizzare tutti i contesti in un database o su �le etrasferirli a altri nodi, permettendo la parallelizzazione dello scraper.

Estrazione agile dei contenuti caricati dinamicamente Alcuni siti webcaricano molto contenuto dinamicamente. In questo caso, poiché lo scraper noninterpreta i codici Javascript o gli oggetti Flash contenuti nella pagina, tale con-tenuto di norma non sarà esaminato. Come discusso, è impensabile creare unostrumento in grado di eseguire il contenuto attivo in maniera soddisfacente, acausa della complessità dei browser; è possibile appoggiarsi a un comune browsera cui delegare il rendering della pagina, per esempio tramite il progetto Seleni-um4, ma l'overhead per questa operazione è di ordini di grandezza superiore aitempi e al consumo di memoria dello scraper in sé, rendendo inapplicabile questasoluzione a una grande quantità di pagine.

Per aggirare il problema, proponiamo una soluzione basata sulla replicazionead hoc delle operazioni svolte dal contenuto attivo per estrarre comunque leinformazioni desiderate.

Considerando infatti che strumenti di largo utilizzo come gli strumenti persviluppatori di Google Chrome o Firebug di Firefox rendono l'analisi del contenutoattivo un'operazione semplice e rapida, è possibile determinare manualmente lalogica delle richieste AJAX o simili e�ettuate dagli script server side e replicarlain poche righe nello script fornito dall'utente allo scraper.

Perché questo processo sia davvero rapido, il programma deve essere ripensatoper fornire un'interfaccia comoda per entrare nel processo di estrazione dei linkpermettendo allo stesso tempo di non doversene occupare nel caso non ci siacontenuto caricato dinamicamente di interesse.

Per questo, sono state aggiunte allo scraper alcune nuove funzioni:

aggiungiEsplorazione(PaginaInAttesa,int) aggiunge una pagina, ossia unURL con eventuale contesto, alla struttura dati contenente le pagine inattesa, con un TTL dato (generalmente TTLricevuto − 1)

ignoraLinkCorrenti() indica allo scraper di ignorare, per questa speci�ca pag-ina, i collegamenti ipertestuali, che di default sarebbero esaminati. Nonin�uenza le pagine già fornite con il metodo aggiungiEsplorazione(..), chesaranno comunque esaminate. È un metodo pensato per siti con un uti-lizzo massivo di AJAX dove i link sono totalmente inutili, in genere non ènecessario farvi uso.

4http://seleniumhq.org/

http://seleniumhq.org/


Figura 4.2:

Gestore

scraper

HDFS/

filesystem locale

Strutture dati condivise:

lista elementi esaminati

e da esaminare

Estrattore

pagine

(thread)

Mozilla

Rhino

AvvioCaricamento

configurazione JSON

e JavaScript

Inizializzazione liste

Passaggio parametri e script compilato

Consumo URL

pendenti

Scrittura ultimi

segmenti estratti

Aggiunta URL

scoperti con il

contesto

Consumazione

ultimo elemento

Nessun URL

nuovo, struttura

inutile verifica

starvation

chiusura

file

verifica

starvation

Compilazione codice JavaScript

Il sequence diagram UML dello scraper esteso con la gestione del contesto e deicontenuti attivi con gli script JavaScript gestiti da Mozilla Rhino.

La nuova versione dello scraper (Figura 4.2) presenta le caratteristiche cercate,ossia:

� È possibile modi�carla con facilità per adattare lo scraper all'estrazione dicontenuti molto �sporchi�.

� È in grado di gestire il contesto con un overhead minimo grazie al passagggiodi elementi JSON senza schema.

� È in grado di caricare i contenuti dinamici con agilità.

� Può essere adattata a un sito completamente nuovo modi�cando solo dei�le caricati direttamente sul �lesystem distribuito o locale, senza dover maimodi�care l'applicazione.

� I dati sono estratti e memorizzati direttamente su HDFS, se disponibile,pronti all'elaborazione con il software dello stack Hadoop/BigInsights, inun formato usato direttamente dalle tecniche di sentiment analysis, topicanalysis e localizzazione geogra�ca che verranno illustrate in seguito.

� Lo scraper dispone di un elevato parallelismo, che può portare i tempi medidi scaricamento e estrazione di una singola pagina a meno di 100ms.


4.1.5 Esecuzione parallela dello scraper

Finora questo strumento software è stato descritto come un'applicazione da es-eguire in un singolo computer, con più thread simultanei per evitare lo stallodovuto all'attesa di una pagina.

Nonostante la velocità sia già di almeno un ordine di grandezza superiorealle altre soluzioni testate, potrebbe essere interessante aumentarla ulteriormenteeseguendo più istanze parallele del programma. Non è comunque sicuro chequesto sia possibile o conveniente, per due motivi:

1. Il collo di bottiglia potrebbe essere la capacità di upload del webserv-er, che potrebbe fornire meno pagine di quante un'applicazione così �ag-gressiva� possa chiederne anche con una sola istanza, rendendo inutile laparallellizzazione

2. La sincronizzazione tra le istanze parallele dovrebbe essere capillare, datoche si tratta di un'esplorazione di un grafo, e sostanzialmente ogni istanzadovrebbe noti�care alle altre tutte le pagine che esamina, in tempo reale.L'overhead per e�ettuare questa sincronizzazione potrebbe addirittura su-perare l'aumento di prestazioni dovuto al parallelismo.

Bisogna osservare che il problema del punto 2 potrebbe essere aggirabile sfrut-tando le tecniche di sharding ben note nell'ambito dei database distribuiti, comequelle spiegate riguardo a MongoDB, e assegnare le pagine ai nodi in base almodulo dell'hash del loro indirizzo, così senza comunicazioni inutili ogni nodosaprebbe quale elemento della rete è responsabile di una pagina speci�ca. Quin-di, dopo aver discusso e implementato delle ottimizzazioni riguardanti le dimen-sioni massime del grafo delle pagine che è possibile attraversare, verrà usato etestato proprio un database distribuito per veri�care l'opportunità di eseguirecontemporaneamente diverse istanze del programma su più nodi.

4.1.6 Analisi della scalabilità dello scraper

L'utilizzo concreto dello scraper su diversi siti mostra l'assenza di grossi difettifunzionali, ma sarebbe utile sapere quanto sia scalabile il programma e come sicomporti in condizioni di forte stress che potrebbero veri�carsi in un ambiente diesecuzione reale, ossia in fase di produzione.

In particolare il programma, per come è stato descritto, ha un potenziale prob-lema di scalabilità: la lista delle pagine esaminate e delle tuple< contesto, URL, TTL >inattesa di analisi è totalmente gestita con delle strutture dati in RAM. Quindimentre i �ussi di input e output possono crescere a dismisura sfruttando HDFSe la dimensione delle pagine web è tale da poter essere mantenute nella memoriadi lavoro per tutta la durata dell'analisi, il semplice numero di pagine potrebbeessere troppo grande e costituire una limitazione al suo utilizzo.


Bisogna quindi progettare e implementare un test, o meglio un benchmark, chestressi l'applicazione portandola a dover gestire sempre più elementi, mettendoquindi alla prova la scalabilità.

Se questa non sarà soddisfacente, si dovranno valutare nuove soluzioni chefacciano uso della memoria di massa.

4.1.6.1 Progettazione di un benchmark

Per simulare un caso d'uso di�cile da gestire, si creerà un server web, ospitato inuna macchina esterna, in grado di fornire all'in�nito delle pagine web, generatedinamicamente, e contenenti vari collegamenti ipertestuali ad altre pagine sullostesso server.

Per evitare che le librerie usate come Jsoup o Rhino applichino dei meccan-ismi di caching del contenuto alterando la validità dei risultati, le pagine fornitedovranno sempre essere diverse. Si osservi che non ci sono informazioni riguardan-ti la concreta presenza meccanismi di caching, infatti l'analisi del codice di Jsoupmostra come venga creata una nuova istanza per ogni pagina mentre Rhino, nonrichiedendo funzioni pure (quella usata dall'applicazione non lo è), non può ap-plicare alcuna memoizzazione5. Tuttavia, è bene prendere questa precauzione inmodo che la validità del benchmark non sia annullata da possibili future modi-�che che aggiungano meccanismi di caching, così come da meccanismi di cachinginterni alla JVM.

Un altro problema che ci poniamo è la produzione di pagine con un contenutoche segua una certa logica, in maniera tale da veri�care che un certo dato estrattosia corretto e identi�care le anomalie.

Ho quindi scelto di utilizzare una funzione matematica molto nota e sempliceda gestire per generare dei valori, chiamata funzione di Collatz.

Questa funzione è così de�nita:

f(n) =

{n/2 se nè pari

3n + 1 altrimenti

la congettura di Collatz a�erma che per applicando ricorsivamente questafunzione a un qualsiasi numero intero si arriverà a 1 in un numero �nito di passi,e la sua dimostrazione è un problema ancora aperto della matematica. Comunque,è stato dimostrato con il calcolo che questa proprietà è valida �no a 1018, quindinel nostro caso si può usare per avere un contesto noto a priori per ogni paginama che varia in maniera non lineare da una pagina all'altra.

Si potrà quindi eseguire l'estrazione delle pagine insieme al contesto costituitodal numero contenuto nelle pagine esaminate in precedenza veri�cando con facilità

5La memorizzazione dei parametri in input e corrispondenti parametri in output visti nel-l'esecuzione di una funzione pura per poterli o�rire direttamente in caso di chiamate successive.Sostanzialmente, un meccanismo di caching.


la correttezza dei dati estratti senza che degli eventuali meccanismi di cachingalterino i risultati.

4.1.6.2 Implementazione del benchmark

Per creare un server web che generi dinamicamente le pagine, ho scelto CherryPy.Si tratta di un framework minimale per la creazione di siti dinamici in Pythoncon il supporto nativo al multithreading.

La creazione di un'applicazione server che fornisca pagine secondo quantoindicato prima si è mostrata estremamente semplice, richiedendo solo 50 righe dicodice e meno di un'ora totale per apprendere l'utilizzo del framework, scrivereil codice e eseguirne il debugging �no ad avere un'applicazione funzionante.

Questo server si pone in ascolto su una certa porta e fornisce come paginainiziale un piccolo �le XHTML contenente dei link del tipo

i n d i r i z z o h o s t : porta /A/632i n d i r i z z o h o s t : porta /B/48

seguendoli, verrà chiamato nuovamente il server che fornirà per ogni paginadella forma /X/Y una pagina contenente dei link dello stesso formato dove Xrimane uguale e Y è sostituito da Y

2e 3Y + 1 a seconda dei casi, più un collega-

mento generato con dei valori casuali. Quando Y è pari a 1 (cosa che si veri�casempre seguendo i link) gli URL indicati porteranno entrambi a dei valori X e Ycasuali.

Oltre a questo, in ogni pagina sono contenute delle stringhe di testo casualiche vengono estratte insieme ai numeri e al contesto che indica i numeri e lelettere contenuti nelle pagine precedenti.

Il server è multithreaded e registra ogni richiesta in un semplice �le di log:contando periodicamente il numero di righe in tale �le con il comando bash

while true ; do s l e e p 10 ; wc a c c e s s i . log>>andamento . txt ;done

si ottiene un semplice riscontro delle prestazioni dello scraper nel corso deltempo indipendente dal log interno dell'applicazione.

L'output sarà un �le contenente riga per riga degli oggetti JSON del tipo

{" s t r i n g a " : " cerd oarpn ivanrocausnsceeevaze rconse bvh i j " ," conte s to " : "{\" precedente \":\"2037496\"} " , "numero : " : "

1018748"}

dove la stringa è casuale, il contesto indica il numero della pagina di prove-nienza e il numero è il numero della pagina attuale. In questo caso si osservache il numero del contesto è il doppio del numero attuale. Il valore della chiavecontesto è a sua volta una stringa JSON su cui è stato eseguito l'escape. Questoaccade perché, non usando il contesto per estrarre dati ma solo per e�ettuare il


Figura 4.3:L'andamento della quantità di pagine scaricate durante l'esecuzione dello scraper,prima del suo previsto crash per la memoria esaurita.

debugging, si è preferito riportarlo in formato grezzo e non estrarne le variabili,ottenendo questa conversione.

4.1.6.3 Risultati ottenuti e loro signi�cato

Eseguendo l'applicazione sulla macchina di prova, un computer con 4GB dimemoria RAM, lo scraper viene eseguito per circa 1 ora e mezza scaricando eestraendo il contenuto di 1022001 pagine, prima di fermarsi con un errore Out-OfMemoryError come previsto. L'andamento della quantità di pagine esaminatenel corso del tempo è esposto in Figura 4.3 e si può osservare come la funzionenon sia lineare bensì tenda a crescere sempre più lentamente: è un e�etto delmodo in cui Java (e in generale qualsiasi linguaggio) gestisce le HashMap: al rag-giungimento di una certa quota di riempimento, i dati devono essere indicizzati;inoltre man mano che si inseriscono elementi aumentano le collisioni e quindi iltempo medio necessario a recuperare un certo dato.

Questa quantità è abbastanza buona, per ottenere un confronto basti consid-erare che i due siti su cui è stato testato in precedenza erano di 20.000 e 40.000pagine rispettivamente, quindi ben al di sotto del limite appena esposto.

4.1.7 Implementazione di un �ltro di Bloom

Il programma utilizza una struttura dati, una mappa, per memorizzare le paginein attesa di essere esaminate, e un'altra struttura per tenere traccia degli URLgià esaminati per ignorarli, come avviene tipicamente nel caso di algoritmi cheesplorano gra�.

Quest'ultima struttura dati, nella sua implementazione originale, memorizzatutti questi URL e i loro contesti e controlla se un elemento è già presente prima


tramite il suo hash (per motivi di e�cienza) e in�ne confrontandolo e�ettivamentecon i candidati il cui hash coincide.

In questo modo si ha un riscontro rigoroso, ma si consuma una quantitàdi memoria eccessiva, se si considera che il nostro caso d'uso non richiede diesaminare il contenuto di questo set o rimuoverne elementi, ma solo di inseriredei dati e veri�care se questi sono già presenti.

I �ltri di Bloom permettono di svolgere esattamente questa operazione veloce-mente e con una quantità di memoria �ssa al costo di una probabilità, calcolabilea priori e generalmente molto bassa, di avere dei falsi positivi e considerare unapagina come già esaminata anche se non lo è. Il funzionamento di queste strut-ture dati è già stato spiegato, l'implementazione in questo caso prevede 8 funzionidi hashing indipendenti e un vettore di bit grande 20MB.

La prima versione del �ltro è stata realizzata con un hash crittogra�co, chiam-ato md56, e iterando su stringhe della forma

www. forumsempio . i t / forum/pagina . php?q=###

dove ### è un numero consecutivo, si ha la prima collisione dopo 3.860.757 dielementi inseriti, per un totale di 565 collisioni su 107 elementi distinti inseriti,di cui 271 sono dopo i 9 milioni di stringhe aggiunte.

L'algoritmo md5, però, è molto pesante dal punto di vista computazionale,quindi ho implementato diverse funzioni di hashing basate sull'iterazione suicaratteri della stringa in esame e sulla loro somma, applicando delle operazioninon lineari, ossia moltiplicandoli di volta in volta per un valore cambiato tramitemoltiplicazioni e moduli con dei numeri primi, scelti per rendere meno probabileche stringhe distinte diano lo stesso hash. Nello speci�co la funzione di hashingè:

private int mioHash ( int k , S t r ing s ) {int r e s=s . l ength ( ) ;int m=683+k ;for (char c : s . toCharArray ( ) ) {

r e s*=m;r e s+=c ;

}r e s=r e s%dimens ion i ;i f ( res <0) r e s=−r e s ;return r e s ;

}

6L'md5 è stato recentemente violato, in particolare il virus noto come Flame utilizza unatecnica per individuarne delle collisioni, quindi sta cadendo in disuso. Nel nostro caso, però,è su�ciente che rispetti le proprietà statistiche delle funzioni di hash, cosa che e�ettivamenteavviene.


Figura 4.4:La crescita del numero di collisioni all'aumentare del numero di stringhe mem-orizzate. La linea blu indica l'hash md5, mentre quella verde è la funzione dihashing indicata. Le prestazioni nel caso d'uso sono pressoché identiche, mentreil tempo di esecuzione su 10 milioni di stringhe, ognuna indicata in un �le di log emostrata a schermo, passa da 40 a 8 minuti. Le funzioni in giallo sono e arancionesono ottenute sostituendo �res*=m;� con �res+=m;� e scegliendo numeri primipiù piccoli, e sono mostrate come esempio di cattiva funzione di hashing.

dove k è il numero della funzione di hashing speci�ca, che varia da 0 a 8,mentre dimensioni è la dimensione in bit dell'array usato internamente dal �ltro.

La funzione così de�nita viene quindi confrontata con l'md5, scelto comepunto di riferimento, e si osserva (Figura 4.4 e 4.5) come, pur avendo dei tempidi esecuzione abbassati di un ordine di grandezza, le probabilità di collisione sianoquasi uguali.

Eseguendo nuovamente il test, si arriva a 3 milioni di pagine esaminate primadi avere una collisione, con successive collisioni molto rare, inferiori all'1% �no a6 milioni, un numero su�ciente per praticamente qualsiasi sito7.

7A titolo di paragone, si consideri che uno dei siti più vasti al mondo, en.Wikipedia inlingua inglese, ha al momento circa 3 milioni di pagine, e quella in italiano meno di 1 milione.Inoltre, i test sono stati svolti in un computer con 4 GB di memoria RAM, molto meno di uncomune server, quindi è ragionevole aspettarsi almeno un raddoppiamento dei limiti in fase diproduzione.


Figura 4.5:Rappresentazione �heatmap� dell'hash di un URL al variare di alcuni parametriGET in esso contenuti. La scarsa regolarità dell'immagine è indice della validitàdella funzione di hash.


4.1.8 Utilizzo di HBase per aumentare la scalabilità

Lo strumento appena prodotto, pur scalando a su�cienza per quanto riguardail numero di pagine, estraendo i dati molto velocemente grazie a un parallelismospinto e memorizzando i dati direttamente nel �lesystem distribuito, non sfruttacomunque il parallelismo ancora più elevato o�erto da un cluster di nodi collegatiin rete.

Mentre distribuire la lista delle pagine pendenti è semplice, dato che possonoessere assegnate a un nodo qualsiasi in maniera asincrona, la condivisione del-la lista degli elementi analizzati, ora implementata come �ltro di Bloom, è piùdi�cile. Ogni elemento analizzato deve essere noti�cato a tutti i nodi primache questi possano analizzarlo nuovamente, ma questo può avvenire in qualsiasimomento. Mettere dei lock farebbe crollare le prestazioni in quanto ogni esamedi ogni pagina dovrebbe attendere le noti�che degli altri nodi, avendo quindiun'esecuzione, di fatto, sequenziale.

Non è nemmeno possibile esaminare a priori le pagine secondo una specu-lazione ottimistica, annullando l'operazione qualora si rivelasse sbagliata, poichéin caso di rollback bisognerebbe eliminare le pagine aggiunte alla lista delle paginependenti frutto dell'esplorazione stessa, operazione resa impossibile dal fatto che ilgrafo delle pagine web non è una struttura ad albero e alcuni elementi potrebberoessere stati aggiunti contemporaneamente sia da un'esplorazione da annullareche da un'esplorazione legittima, e non sarebbe possibile distinguere i due casise non implementando un sistema di backtracking che richiederebbe moltissimamemoria.

È quindi opportuno esaminare soluzioni già esistenti e allo stato dell'arte pergestire una struttura dati condivisa, e tra queste HBase pare la più appropriata.

Infatti HBase si integra nativamente con Hadoop e serve proprio a gestire inmaniera performante strutture dati associative permettendo l'accesso su cluster.

È stato dunque implementato un wrapper della Map di Java che utilizzaHBase per memorizzare e recuperare i dati.

L'implementazione si è rivelata piuttosto ostica: la documentazione di HBaseè scarsa e poco aggiornata, tra le varie versioni che si sono susseguite veloce-mente negli ultimi anni sono state cambiate molte interfacce rendendo di�cileriutilizzare il codice di altri progetti.

Il problema principale è il consumo di una riga. HBase infatti non permettedirettamente di estrarre una riga qualsiasi, e questa operazione deve essere im-plementata con una query che accetti ogni valore impostata in maniera tale danon applicare meccanismi di caching poiché non intendiamo esaminare tutti i datiestratti ma solo il primo, e sfruttando il meccanismo di locking molto �essibiledel database per bloccare la riga e evitare che altre istanze la consumino.

Lo scraper basato su HBase si è rivelato estremamente lento, addirittura scen-dendo a una media di decine di secondi per esaminare ogni pagina. Un'analisi deilog ha mostrato la causa di tali prestazioni: la continua richiesta di nuove righe


da parte dei diversi thread porta il database a essere perennemente bloccato permantenere la consistenza durante le scansioni.

Inoltre, un semplice test di inserimento seriale di elementi casuali, senza let-ture e scritture parallele, ha evidenziato come il database sia comunque lentoanche in queste condizioni ottimali: dovendo garantire il versioning e la disponi-bilità dei dati in caso di partizionamento della rete, entrambe funzioni super�uein questo caso d'uso, si ha un calo di prestazioni.

4.2 Sentiment analysis dei messaggi

Il problema della sentiment analysis è, naturalmente, un problema aperto. Nonesistono al momento dei sistemi software in grado di comprendere e manipolaree�cacemente la semantica di un testo in lingua naturale in maniera lontanamentecomparabile a quella degli esseri umani, nemmeno per quanto riguarda testi moltosemplici e di un dominio prestabilito. Gli approcci più tipici sono:

� Produrre una grammatica che riconosca le varie strutture sintattiche e neestragga quindi la semantica. Questa tecnica riconosce solo una piccolaporzione delle frasi possibili, richiede un grande lavoro manuale da partedei linguisti per costruire la grammatica che deve essere progettata per ilcaso d'uso speci�co e comunque è prona alle ambiguità nel caso di frasigenerali. Per esempio, una grammatica potrebbe non gestire la di�erenzasemantica tra �Lavoro a Milano� e �Vado a piedi� poiché hanno la stessastruttura �verbo 'a' sostantivo�.

� Utilizzare delle euristiche che sfruttino dei modelli generati a partire dal-l'analisi di grandi quantità di testo, eventualmente marcato manualmenteper segnalare al programma le informazioni che dovrebbe estrarre. Un es-empio sono le traduzioni automatiche, che sono in genere basate sull'analisidi corpus di coppie di documenti tradotti manualmente nelle varie lingue,o l'estrazione di N-grammi8 per stabilire la parola più probabile in caso dierrori di battitura, come fanno i motori di ricerca quando suggeriscono dellecorrezioni alle chiavi usate.

Quest'ultimo approccio ha avuto nell'ultimo decennio sempre più successo, grazieall'aumento esplosivo di dataset accessibili tramite il web, come Wikipedia, eall'abbassamento del costo di memorizzazione e elaborazione dei dati.

Poiché stabilire il contenuto emotivo di un testo richiede a un essere umano dicapirne il signi�cato e immedesimarsi nella persona, confrontando il fatto descrit-to con i sentimenti che si pensa che quella persona abbia, è evidente che questa

8Un N-gramma è una sequenza di N parole consecutive in un testo. In lingue come il cinese,il coreano o il giapponese non è immediato separare le parole poiché non ci sono gli spazi, ebisogna prima usare delle euristiche per e�ettuare il tokening.

4.2 Sentiment analysis dei messaggi 111

operazione è ancora più di�cile del semplice riconoscimento della struttura logi-ca, perché richiederebbe una sorta di modello del signi�cato emotivo delle entitàche si possono incontrare nel testo, oltre che del loro ruolo all'interno della frase.

Determinare l'umore di un testo molto semplice come �u�a, anche oggi c'ètra�co� richiede di:

� Sapere che la presenza di tra�co è un fatto considerato sgradevole dallamaggior parte della gente

� Riconoscere che la frase descrive il fatto che qualcuno sta subendo il tra�coe non è un fatto impersonale come nella frase �A Torino c'è meno tra�coche a Milano�

� Identi�care l'entità a cui si riferisce la parola tra�co, che è diversa da quellaidenti�cata dai termini �tra�co dati� o �tra�co di droga�

� Identi�care che la frase è positiva, a di�erenza di �nemmeno oggi c'è traf-�co�

Questo caso è in realtà relativamente semplice, perché la frase non presenta ironiané signi�cati dipendenti dalla persona, come nel caso di un commento su uncantante o una ricetta che dipende dai gusti personali del comunicante, eppurenon esistono al momento degli algoritmi in grado di stabilire la negatività dellafrase comprendendola né è verosimile che ne vengano prodotti nell'immediatofuturo. Non solo: gli stessi esseri umani possono discordare nel considerare unafrase come positiva o negativa qualora esponga più fatti allo stesso tempo.

Possiamo però utilizzare un approccio euristico che stimi la polarità delle frasibasandosi sulle proprietà statistiche un set di testi classi�cati manualmente.

L'idea è un essere umano itera su un piccolo corpus di a�ermazioni, sceltein maniera tale da essere il più simili possibili a quelle che si prevede di doveranalizzare come lingua, registro e contenuti, e leggendole ne marca la polaritàmanualmente, applicando il processo cognitivo indicato sopra; in seguito un pro-gramma, facendo uso di tecniche di machine learning, estrarrà delle feature daitesti e quindi un modello che abbini tali feature alle polarità stabilite manual-mente. In seguito, dato un testo, se ne estrarranno le feature e sfruttando ilmodello generato in precedenza si assegnerà la polarità più probabile.

Questo approccio non richiede quindi nessun modello speci�co del linguaggioné ontologie che rappresentino le relazioni tra concetti, bensì di selezionare dellefeature opportune. È da notare che questo approccio può essere integrato facil-mente con delle grammatiche o altri metodi formali semplicemente inserendolicome feature.


4.2.1 Scelta delle categorie per la classi�cazione

La de�nizione dell'insieme delle classi di sentimento di un testo è strettamentelegata alla natura dei dati elaborati. Alcuni studi [33][37][13] utilizzano semplice-mente due classi, positive e negative, che è la con�gurazione più semplice, mentrealtri[32][12] prevedono diversi gradi di intensità del sentimento, quindi ogni testoriceverà da 1 a 5 stelle come avviene in molti siti che permettono di esprimererecensioni come Amazon o Rotten tomatoes e che hanno quindi prodotto unasorta di standard.

Gli studi [23] evidenziano come la scelta del numero ottimale di classi dipen-da dalla psicologia sottostante la valutazione dei dati esaminati: se si tratta ditele�lm o videogiochi che sono soggetti alla passione dei fan la distribuzione deipunteggi tende a essere bimodale (approvato completamente o totalmente riget-tato), mentre in altri casi il giudizio è più �freddo� e può avere senso assegnarepunteggi più granulari.

Osservando i dati estratti da Twitter e contenenti le parole chiave di rilievoper il nostro caso d'uso è emerso che non ha senso assegnare dei punteggi a diverseintensità: la varietà degli argomenti e dei contesti delle frasi è così grande chenon si possono scegliere dei livelli di riferimento. I testi spaziano dai semplicicommenti sul design dei pacchetti e sull'architettura delle sedi delle aziende avere e proprie notizie di cronaca e accese lamentele nei confronti dell'azienda, chenon si possono comparare in maniera consistente. Inoltre, molti commenti nonhanno una carica emotiva, ad esempio alcune persone usano Twitter per segnalarela propria posizione, con messaggi del tipo �I'm at the Walmart�, che si possonoconsiderare neutrali.

È bene osservare che la scelta di un'alta granularità delle classi è poco e�caceper questo tipo di classi�cazione perché anche i valutatori umani discordano nelclassi�care il sentimento una fetta consistente dei messaggi, superiore al 40% [33],soprattutto nel caso di testi brevi[11], quindi aumentando le classi si avrebbeun'accuratezza molto bassa.

È stato dunque adottato un sistema a tre classi, positive, negative e neutral.Una volta selezionate le classi rimane il problema della scelta delle feature e deglialgoritmi da adottare.

4.2.2 Scelta delle feature

Poiché un testo di per sé è un dato non strutturato, per applicare qualsiasi tecnicadi classi�cazione automatica è necessario generare un opportuno vettore di featureche lo rappresenti, dove ogni feature sarà o un dato numerico, ossia un intero oreale de�nito su un dominio che può o meno essere in�nito, oppure un elementonominale, ossia de�nito su un insieme di valori possibili e noti che possono nonessere comparabili, come ad esempio i colori.


Una feature molto comune in questo tipo di analisi è la semplice presenza diuna parola: per ogni parola di un dizionario si avrà una feature di tipo booleano,che varrà true in caso di presenza della parola nel messaggio, altrimenti false.Nelle lingue europee la separazione tra le parole è semplice grazie alla presenzadegli spazi, mentre per lingue come il cinese, il giapponese o il coreano è nec-essario in una fase preliminare utilizzare delle librerie che individuino le singoleparole sfruttando delle euristiche; in questa tesi, tuttavia, verranno esaminatisolo messaggi in lingua inglese e italiana dove questo problema non si pone.

Uso di termini stabiliti manualmente

Un metodo molto basilare consiste nel determinare arbitrariamente una lista ditermini positivi e negativi, quasi sempre aggettivi, e classi�care le frasi in base allapresenza di queste parole. Questo approccio è stato adottato in molti casi, spessocome estensione del database lessicale WordNet[35][34], il che permette di unirefacilmente questa analisi ad altre operazioni che sfruttino le conoscenze lessicalicontenute nel database lessicale stesso. Non è detto che le liste siano piccole:il database LIWC9 ne contiene oltre 900 solo per le due classi da noi scelte.Anche con una scelta molto accurata, tuttavia, non si tiene conto delle sfumaturepiù sottili del linguaggio e non si possono identi�care testi contenenti entrambele classi di parole in uguale misura oppure nessuna parola. Le singole parole,infatti, non hanno una polarità o al più ne hanno una discreta, quindi in casodi occorrenze contemporanee di termini contrastanti i programmi così costruitinon possono eseguire la classi�cazione con successo. Questo approccio è statoinfatti superato dalle tecniche basate su modelli generati dal testo classi�catomanualmente, spesso dagli stessi utenti, man mano che questi sono diventatifacilmente reperibili grazie al web[21].

Over�tting in caso di utilizzo della frequenza al posto della presenzadei termini

Invece della presenza di una parola è possibile usare la sua frequenza, ossia ilnumero e�ettivo di occorrenze dei termini in ogni messaggio piuttosto che lasemplice presenza; in tal modo si manterrebbe questa informazione e si potrebbe,in linea di principio, avere un aumento dell'accuratezza.

Tuttavia, gli studi mostrano[37] come questo miglioramento non avvenga maanzi si abbia un peggioramento. Questo è dovuto al fenomeno noto nell'ambito delsoft computing come over�tting. Poiché i diversi valori di frequenza sono trattatidai modelli come delle modalità distinte di una feature avviene che un termineche appare due volte in una frase contrassegnata come negative e una volta inun'altra abbia una polarità (ossia una capacità di in�uenzare il classi�catore con

9Linguistic Inquiry and Word Count, www.liwc.net

www.liwc.net


la sua presenza, una sorta di peso) minore poiché viene trattato alla stregua didue feature distinte.

Si rischia dunque che, a causa delle grandi dimensioni del dizionario e dellaristrettezza del dataset di testi categorizzati manualmente, aumentando il numerodi feature considerando la frequenza dei termini porti a un conseguente aumen-to del rumore che annulla il potenziale vantaggio dato dalla produzione di piùfeature.

4.2.3 Concatenamento di termini consecutivi per identi�-care alcune strutture sintattiche

Il linguaggio naturale prevede, ovviamente, che aggregati di parole abbiano unsigni�cato totalmente diverso da quello dei termini presi singolarmente. Questofatto così evidente implica che considerando la presenza delle singole parole comeelementi per la classi�cazione si avrebbero degli errori, ad esempio le frasi �nonè bello, vero?� e �bello, non è vero?� contengono le stesse parole, addirittura lastessa punteggiatura, ma hanno un signi�cato diametralmente opposto.

Fermo restando che, come spiegato prima, non è possibile esaminare la strut-tura così a fondo da interpretare i due casi, è possibile adottare degli accorgimentieuristici per poterli comunque distinguere entro i limiti del possibile.

Per far ciò, non basta considerare ogni singola parola come una feature a séstante ma si devono estrarre anche le sequenze di termini adiacenti, �no a unadistanza k scelta a piacere, nel nostro caso pari a5. Una distanza alta genererebbetantissime feature, mentre un valore troppo basso mancherebbe certe strutture,il valore 5 è stato scelto empiricamente osservando varie frasi perché individua lecombinazioni più frequenti.

La frase �bello, non è vero?� viene quindi scomposta nei token:bello non èvero bello_1_non non_1_è

bello_2_è non_2_vero bello_3_veroè_1_vero

e ognuno di essi viene trattato come una feature diversa, gestendo la presenzadi modi�catori degli aggettivi come bello�molto bello o anche nomi composti,come �Stati Uniti�.

4.2.4 Stemming per eliminare le di�erenze morfologiche

In molte lingue, tra cui l'italiano e l'inglese, alcune classi di parole sono formateaggiungendo dei su�ssi a una radice. Per esempio la parola caldissimo utiliz-za la radice della parola caldo e il su�sso -issimo per ottenere il superlativo.Similmente, si possono formare plurali e singolari, cambiare il tempo dei verbi eprodurre avverbi a partire da aggettivi.


La branca della linguistica che studia come si possono modi�care le paroletramite su�ssi e pre�ssi è la morfologia, e ogni lingua ha una morfologia diversadalle altre. Alcune lingue, come il giapponese o il turco, sono fortemente agglu-tinanti e permettono di aggiungere a una radice molti su�ssi che speci�cano, adesempio, il ruolo all'interno della frase o forme passive e attive del verbo, funzionisvolte in italiano da altri termini distinti.

Dal punto di vista di un'analisi del sentimento della frase svolta con tecniche dimachine learning potrebbe essere conveniente eliminare la struttura morfologicadelle parole lasciando solo la radice, un'operazione nota come stemming. Questoperché parole come bello e bellissimo, pur avendo un signi�cato molto simile,sarebbero considerate come feature distinte da un classi�catore e potrebbero nonessere sfruttate al meglio.

Bisogna quindi veri�care se, nel caso sia possibile e�ettuare lo stemmingdelle parole sia meglio mantenere i termini così come sono, approccio abbas-tanza frequente[13][12], mantenendo i diversi gradi, numeri e tempi delle parolema senza che il classi�catore ne possa sfruttare la radice comune.

In alternativa si può eseguire lo stemming, come è stato fatto nel caso di alcunepubblicazioni[30], e far sì che l'algoritmo di machine learning scelto non sia con-fuso dalle varianti morfologiche della stessa parola, perdendo però le informazionirelative alle diverse sfumature delle parole.

Una terza soluzione, di cui non sono note precedenti implementazioni, è, perogni messaggio, formare un messaggio �ttizio contenente il messaggio normaleconcatenato con il messaggio che ha subito lo stemming.

Tecniche per lo stemming

Per eseguire lo stemming l'approccio più comune consiste nell'applicazione di unaserie di semplici regole scritte manualmente. Per esempio lo stemmer Snowballper l'italiano 10 contiene al suo interno sia i diversi su�ssi introdotti dai tempiverbali e dalle persone, che quelli usati per formare nuove parole, come ad esempio-logia per estrarre la radice dalle parole come ecologia o -abile per gli aggettivigenerati a partire da verbi, come lavabile. Il pregio di questo meccanismo è che èla sua implementazione è estremamente veloce e leggera, funziona in tempo O(n),e non richiede di svolgere confronti con grossi modelli esterni. I difetti sono invecetre:

1. Alcune parole, come labile o vista, verranno ricondotte erroneamente a �l�o�v�. Per evitare che ciò accada si potrebbe fornire allo stemmer una listadi termini della lingua di interesse con cui veri�care la correttezza, ma inquesto modo il peso di questa componente software aumenterebbe di variordini di grandezza sia in termini di memoria consumata che in termini dirisorse di calcolo. Dal punto di vista della classi�cazione del sentimento,

10http://snowball.tartarus.org/algorithms/italian/stemmer.html

http://snowball.tartarus.org/algorithms/italian/stemmer.html


tuttavia, questi errori non sono gravi poiché per un algoritmo di machinelearning le feature �v� e �vista� sono ugualmente utili, salvo il caso in cuiparole distinte vengano ricondotte alla stessa radice.

2. Gli stemmer sono fatti per essere usati su una lingua speci�ca, quindi inun testo che usa molti termini stranieri, come avviene spesso su Twitter oin altri social network, non viene applicato alle parole di altre lingue, peresempio �io sono choosy� non verrà trasformato in �io sono choos�

3. Gli stemmer basati su regole scritte manualmente non funzionano benenel caso di slang o espressioni anomale, per esempio �sono bellissimeee�non viene ovviamente ricondotto a �sono bell�, ma queste espressioni sonofrequentissime nel linguaggio e�ettivamente usato nei forum!

Stemming euristico per gestire i termini colloquiali

La soluzione qui proposta è dunque uno stemmer costruito a partire dall'analisi diun corpus testuale con un origine simile a quello che si intende analizzare. L'ideadi base è che, analizzando una grande quantità di testo e estraendone i su�ssipiù frequenti, sia possibile costruire uno stemmer capace di gestire anche i su�ssidialettali, colloquiali o provenienti da altre lingue. La procedura è la seguente:

� Si itera sulle parole di un corpus di testo contemporaneo estratto da inter-net, generando un dizionario dei termini distinti dopo aver reso minuscolotutto il testo.

� Per ogni coppia di parole che hanno le prime k lettere in comune si determi-na il più lungo pre�sso comune e di conseguenza i su�ssi a esso applicati.Alcuni di questi saranno sbagliati, come �zo� e �mo� derivanti dalla coppia�<schermo�,�scherzo�>.

� Si contano i su�ssi più di�usi e si tengono quelli che appaiono più di mvolte, dove m è una soglia stabilita manualmente.

� Questi su�ssi costituiscono un modello analogo alle regole scritte manual-mente in Snowball che però, essendo generato a partire da un corpus reale,gestisce anche gli slang e i termini �anomali� usati su internet.

I valori di k em devono essere stabiliti empiricamente e variano in base alla linguae al registro (slang di internet, testi formali, ecc.) su cui si intende lavorare.

Scegliendo un valore di k troppo alto si ignorerebbero le parole corte, mentrescegliendone uno basso si otterrebbero molti falsi positivi. Considerando che lalunghezza media delle parole in italiano è compresa fra 4 e 5 (Ad esempio, lalunghezza media delle parole ne �I promessi sposi� è 4.93) e che i falsi positiviverrebbero comunque �ltrati nel passaggio successivo, è stato scelto un valore dik pari a 4.


Il rischio di questa tecnica è che, poiché il programma procede �alla cieca�,possono essere rilevati dei su�ssi inesistenti; sarà quindi necessario un lavoromanuale di veri�ca e eventuale eliminazione, anziché di scrittura, applicato alleregole generate.

L'algoritmo è stato implementato, con opportune ottimizzazioni che non necambiano la logica di funzionamento, e eseguito utilizzando come input una rac-colta di 556545 post di varie lunghezze e fonti, estratti da un forum utilizzandolo scraper descritto in precedenza e scritti da centinaia di utenti distinti nel corsodi 7 anni, dal 2003 al 2012, contenente circa 40 milioni di parole in italiano einglese colloquiale.

Sono stati individuati 14 milioni di match, ossia parole distinte che hanno iprimi 4 caratteri in comune.

La distribuzione di frequenza dei su�ssi è interessante. Come accade spessonell'ambito dell'elaborazione del linguaggio naturale, si osserva (Figura 4.6) chesi hanno molti su�ssi che appaiono poche volte e un ristretto gruppo di stringheche hanno invece una frequenza di ordini di grandezza maggiore.

Figura 4.6:La distribuzione dei su�ssi, sull'asse X si ha la classe di frequenza del conteggio,sull'asse Y la dimensione della classe, in scala logaritmica. Si hanno moltissimisu�ssi poco frequenti e un piccolo numero di su�ssi estremamente più di�usi.

Un'osservazione manuale porta a scegliere i su�ssi che appaiono almeno 3000volte nell'elenco, che sono 289. Il generatore di stemmer ordina questi su�ssi inordine di lunghezza e genera direttamente il �le sorgente Java della funzione chedata una parola ne elimina i su�ssi identi�cati. L'ordinamento per lunghezza ènecessario in quanto un su�sso può essere contenuto in un altro, e in tal caso sideve eliminare quello più lungo.


Il testo viene quindi analizzato tre volte: senza stemming, con stemming econcatenando elemento per elemento la versione originale con quella senza su�ssi.Le prove, discusse più avanti, hanno mostrato come l'accuratezza nei casi del testosenza su�ssi e della sua assenza rimanga pressoché uguale, mentre invece aumentinel caso del testo concatenato.

4.2.5 Confronto tra algoritmi di Machine Learning

Gli algoritmi di Machine Learning che si possono adottare per questo tipo diproblema sono vari. Le ricerche [27] mostrano come i due modelli più e�cacisiano la SVM e i classi�catori di Bayes.

Support Vector Machine

La Support Vector Machine è basata sull'individuazione di un iperpiano, nellospazio a d dimensioni delle feature, che separi i punti appartenenti a una classeda quelli che non le appartengono. È una logica molto simile a quella del percep-tron, si tratta sempre di un modello lineare, ma a di�erenza di quest'ultimo nonviene addestrata tramite la regressione esaminando uno alla volta degli elementidel dataset per il training, ma tramite metodi analitici che cercano l'iperpianoottimale.

Il modello dunque consiste in un vettore m di dimensione d da cui, per unvettore v da classi�care, si calcola

f(v) = mv

che è il prodotto scalare dei due vettori. Quando tale valore supera una certasoglia s il vettore è classi�cato in una categoria, altrimenti nell'altra. È chiaroche la soglia d può essere portata a un valore arbitrario, per esempio 1, variandoil vettore m di conseguenza.

In questo modo si è costretti a tracciare dei piani, ma per gestire iperspaziconcavi che non possono essere separati così facilmente sono state ideate dellefunzioni, chiamate kernel trick, che sostanzialmente modi�cano il vettore vin modo da ottenere delle dimensioni ��ttizie� con operazioni non lineari, adesempio

f(v) = (mv + c)k

dove k e c sono scalari stabiliti arbitrariamente. Esistono varie funzioni delgenere, e la scelta tra di loro non è triviale: bisogna conoscere quali sono le piùadatte per un certo caso d'uso, altrimenti andare per tentativi.

I metodi per la ricerca del vettore m possono essere estremamente pesantidal punto di vista computazionale, e il più utilizzato, per via della complessitàrelativamente minore, è la Sequential minimal optimization. I processi algebrici


necessari ad applicarla sono molto complessi, e non è stato possibile trovarneimplementazioni basate sul paradigma MapReduce.

Il progetto della fondazione Apache Mahout mira a creare un framework peril Machine Learning che si possa usare in un contesto fortemente parallelo graziea Hadoop. È stato dunque testato in modo da poterne veri�care l'uso, ma sonosorti diversi problemi illustrati nella Sezione 6.5.5 che hanno reso preferibile losviluppo di una soluzione autonoma.

Classi�catore di Bayes

I classi�catori di Bayes permettono di classi�care un vettore di elementi, cal-colando a posteriori le probabilità che il vettore appartenga a una certa classe.

La formula di Bayes per le probabilità a�erma che le probabilità che un el-emento B appartenga a una classe Ai(presa da un insieme di classi A1...Aj)sono:

P (Ai|B) =P (B|Ai)P (Ai)∑j

P (B|Aj)P (Aj)

Quindi, avendo un dataset di vettori di feature le cui classi sono note, èpossibile per ognuno di essi determinare empiricamente le probabilità di osservarloin una certa classe e quindi ottenere i termini delle forma P (B|Ak) da usare nellaformula di Bayes. Sorgono però due problemi:

1. Essendo la probabilità di osservare un certo vettore in una certa categoriacalcolate empiricamente (ossia contando le occorrenze di tale vettore dentrola categoria o meno), nel caso in cui un vettore appaia solo una volta pere�etto del rumore si calcolerebbe una probabilità pari a1di assegnarlo allacategoria speci�ca in cui appare, il che è ovviamente un errore.

2. Considerando i vettori nella loro interezza, si hanno 2d possibili vettorida tenere in conto, un numero enorme che, oltre ad essere ingestibile anchecon l'approccio Big Data, rende impossibile trovare delle regole generali perabbinare i vettori alle classi, diluendoli in un immenso insieme di possibilità.

Per gestire questi due problemi è stato adottato un modello naïve con un pas-saggio di smoothing, che verrà ora brevemente esposto.

Modello naïve di Bayes

L'idea alla base di un modello naïve di Bayes è che le feature che compongonoun vettore sono variabili aleatorie indipendenti, o comunque con una correlazionetrascurabile. Quindi se prima il vettore B veniva considerato nel suo complesso,ora lo si scompone nelle singole componenti, ossia:

P (B|A) = P (B1|A)P (B2|A) ...P (Bd|A)


dove Bk è la feature k del vettore. A questo punto la formula di Bayes siriduce a:

P (Ai|B) =P (Ai)

∏dl=1 P (Bl|Ai)∑

j

P (B|Aj)P (Aj)

che dipende solo dai d elementi di ogni vettore presi singolarmente. Inoltre,poiché il denominatore dipende solo dal vettore preso in esame ed è sempre positi-vo, per classi�care un vettore è su�ciente calcolare il numeratore per ogni classe,e scegliere la classe che fornisce la probabilità di appartenenza più alta. Nellafase di training, per lo stesso motivo, è su�ciente calcolare e memorizzare solo itermini che compongono il numeratore.

Smoothing di Laplace

Nel caso in cui una certa feature non comparisse mai in una certa classe, pere�etto del rumore, si calcolerebbe una probabilità P (Ai|Bl) = 0, che falserebbeil risultato. Inoltre, se quella feature non dovesse apparire in nessuna classe siavrebbe un denominatore nullo e la classi�cazione sarebbe impossibile. Perciò,sorge la necessità di attutire il rumore e impedire che si abbiano probabilità diappartenenza nulle. Per farlo, la tecnica più comune è lo smoothing di Laplace.

Questo metodo consiste semplicemente nell'aggiungere al modello un elemento�ttizio per ogni coppia < feature, classe >; quindi se si hanno j classi e unafeature appare s volte nel dataset, sempre per la classe k, si calcolerà che leprobabilità P (Ak|Bf ) = 1+Vk

j+sdove Vk varrà s per la classe in cui si è osservata

la feature, 0 altrimenti. Man mano che aumenta il valore di s le probabilitàcalcolate per le classi in cui non si hanno comparse diminuiscono, avvicinandosiasintoticamente a 0 ma senza raggiungerlo.

4.2.6 Implementazione di un classi�catore naïve di Bayesparallelo secondo il paradigma MapReduce

Si vorrebbe ora implementare un classi�catore naïve di Bayes che si possa es-eguire in modalità distribuita tramite l'uso del paradigma MapReduce. L'idealeè parallelizzare anche la fase di training oltre a quella di classi�cazione, in mododa poterla applicare a grossi dataset di testi classi�cati, magari utilizzando unaclassi�cazione del sentimento già presente, come nel caso di certe piattaforme webdove gli utenti indicano il proprio umore insieme ai post.

Training del modello

In input abbiamo un insieme di stringhe di testo con un certo tag che indica ilsentiment, in output vogliamo fornire un modello che sia possibile usare in se-


guito per e�ettuare la classi�cazione. Come visto tale modello consiste solo neiparametri che compongono l'espressione P (Ai)

∏dl=1 P (Bl|Ai), infatti il denom-

inatore nella formula di Bayes non in�uenza la classi�cazione. Inoltre, si puòriscrivere immediatamente la formula come

∏dl=1 P (Ai)P (Bl|Ai), così il calcolo

del modello si riduce a calcolare, per ogni feature (detta qui anche token), il tassodi comparse in ogni categoria, al netto delle operazioni di smoothing, stemminge normalizzazione. Lo pseudocodice della sequenza di operazioni MapReduce è:

� Ricevo in input le coppie chiave valore < testo, sentiment >

� MAP - Per ognuna applico normalizzazione, stemming e generazione ditoken aggregati, e emetto le coppie< token, sentiment >

� REDUCE - per ogni token, ricevo i sentiment ad esso abbinati, li conto eaggiungo un unità �ttizia (smoothing), emettendo le coppie< token, contatori dei sentiment > dove il valore contiene i contatori perle classi di sentiment

� MAP - ricevo le tuple < token, contatori dei sentiment > e emetto le tuple< token, percentuali dei sentiment >, per normalizzare i valori

� REDUCE - fase saltata, l'output sono le chiavi già prodotte dalla fasemap

Il risultato è la lista dei token con relative percentuali di appartenenza alle classidi sentiment, che non sono mai nulle per e�etto dello smoothing.

Utilizzo del modello

� Carico il modello generato nella fase di training

� Ricevo le coppie < chiave fittizia, testo > dove chiave �ttizia sarà il nu-mero di riga o qualche metadato che non è rilevante per il calcolo, vienesolo mantenuto

� MAP - normalizzo e scompongo come prima il testo in token. Per ognitoken cerco la sua presenza nel modello e moltiplico tutte le percentuali rela-tive ai diversi sentiment. Il sentiment associato al prodotto maggiore è quel-lo scelto, emetto dunque la coppia < testo + chiave fittizia, sentiment >.

È bene osservare che il prodotto dei valori è un numero che non ha signi�catodi per sé, poiché andrebbe normalizzato utilizzando un coe�ciente che, comevisto, non è stato calcolato e tantomeno memorizzato . Inoltre, poiché questivalori sono minori di 1, il loro prodotto sarebbe così piccolo da essere ignorato


dalla rappresentazione binaria usata dal calcolatore, quindi durante i calcoli siutilizzano le proprietà dei logaritmi, ossia:

a ∗ b ∗ ... ∗ z = eln(a)+ln(b)+...+ln(z)

dove i logaritmi saranno valori negativi e la loro somma non darà problemi dirappresentazione. Poiché ex è una funzione monotona crescente, e a noi interes-sa confrontare i prodotti piuttosto che calcolarli, si confrontano direttamente lesomme dei logaritmi, per maggiore e�cienza.

4.3 Localizzazione geogra�ca dei messaggi

Un'altra dimensione di interesse nell'analisi dei messaggi è la localizzazione deiluoghi in cui sono stati scritti o a cui fanno riferimento. Questo si può fare in tremodi:

1. Utilizzare direttamente i dati geogra�ci forniti con i messaggi, funzioneo�erta da Twitter, Facebook e altre piattaforme, ovviamente deve essereattivata dall'utente che deve avere un dispositivo in grado in quel momentodi calcolare e trasmettere la propria posizione.

2. Cercare nel testo dei riferimenti a nomi propri di luoghi, e abbinarli allecorrispondenti coordinate geogra�che

3. Costruire un modello che abbini il testo ai luoghi basandosi sui post giàlocalizzati, in modo da sfruttare espressioni dialettali tipiche di una car-ta zona e nomi di luoghi o di eventi (es. �o bei o bei� o �madonnina�)per stimare la località di quanti più post possibile anche senza riferimentiespliciti

La terza opzione è stata scartata dopo un rapido esame dei dati: meno dell'1% deitweet scaricati presenta delle coordinate geogra�che, quindi si dovrebbe costruireun classi�catore che usa un dataset di training estremamente piccolo e ha unnumero di classi elevato, nell'ordine delle centinaia. Un'operazione praticamenteimpossibile da svolgere con un'accuratezza apprezzabile.

4.3.1 Metodi di identi�cazione dei luoghi citati nel testo

L'operazione di ricerca dei riferimenti a nomi di luoghi richiede di poter ri-conoscere quali parole del testo esaminato fanno riferimento a un luogo geogra�co.Questo si può svolgere in due modi:

1. Cercando i nomi propri dei luoghi geogra�ci (es. �Milano�, �Roma�, ecc.)utilizzando una lista di nomi possibili.

4.3 Localizzazione geogra�ca dei messaggi 123

2. Cercando le strutture sintattiche usate per indicare dei luoghi (es. �voglioandare a X�, �abito a X�, ecc.) e sviluppando quindi una componenteNER11 ad hoc o usarne una già fatta.

I due approcci sono ortogonali, e poiché l'implementazione del secondo può dipen-dere dal primo nel caso si costruisca un NER ad hoc e si abbia bisogno di undataset di testo con i nomi di luoghi già marcati, per prima cosa si sono identi�catii nomi propri.

4.3.1.1 Utilizzo del database GeoNames per trovare i nomi di luoghinel testo

Il database GeoNames 12 è un database di nomi di luoghi geogra�ci pubblicamentedisponibile e scaricabile nei più comuni formati. È aggiornato e molto completo,e per ogni luogo fornisce i nomi in varie lingue, le coordinate geogra�che, lapopolazione e altri dati utili (stato, provincia, elevazione, ecc.) che non sono dinostro interesse. Inoltre, il database fornisce una descrizione OWL del propriocontenuto, che permetterebbe di integrarlo facilmente, se in futuro dovesse esserenecessario, con una delle tantissime risorse dati disponibili nel progetto openlinked data.

Una volta scaricato il dataset corrispondente ai luoghi italiani, di nostrointeresse, identi�carli nel testo è apparentemente triviale:

� carica il database in memoria o collegati a un DBMS (relazionale, non cisono motivi di usare un NoSQL) che lo contiene

� MAP - ricevi la coppia < metadati, testo del messaggio >, itera sul suocontenuto cercando i nomi nel database e emetti la coppia< metadati, testomarcato >

� REDUCE - assente

Tuttavia sorgono tre problemi:

1. Il caricamento del database in memoria o in un RDBMS potrebbe crearedei problemi di scalabilità

2. Iterando sulle singole parole si ignorano i nomi composti come �CiniselloBalsamo�

3. Moltissimi termini generano falsi positivi. Esistono città di nome �fermo�,�chiari�, �cento� e simili, e vengono identi�cate quando appaiono comesostantivi comuni senza riferirsi davvero a luoghi geogra�ci

11named entity recognition12http://www.geonames.org/

http://www.geonames.org/


Il primo problema è in realtà inesistente. L'intero dataset GeoNames, non solol'estratto relativo all'Italia usato ora, consta di 8 milioni di elementi, e non c'èmotivo di aspettarsi aumenti vertiginosi in futuro, certamente non tali da superarela crescita delle dimensioni delle memorie RAM. Quindi è possibile caricarlo inmemoria senza problemi, o se lo si desidera utilizzare dei RDBMS locali ai singolinodi, per esempio utilizzando banalmente SQLLite, quando non un databasecentralizzato con un sistema di caching che sfrutti la caratteristica del databasedi essere read-only.

Anche l'identi�cazione dei termini composti si risolve facilmente; osservandoil dataset è evidente che i nomi più so�sticati sono composti da 4 parole, quindibasta modi�care l'operazione map per iterare sulle combinazioni di 4 terminiconsecutivi e cercare questi nella lista delle città.

Eliminazione di nomi di luoghi ambigui Per eliminare o comunque mini-mizzare il numero di falsi positivi, il primo approccio è consistito nella creazionedi una blacklist di termini ambigui da ignorare. Inserendo in questo �le terminicome �fermo� l'operazione di ricerca viene istruita a ignorarli, evitando così, inteoria, i falsi riscontri.

In realtà, dopo aver inserito nella blacklist i termini più frequenti si notache rimangono ancora molti errori; continuando a aggiungere elementi si hannocomunque degli errori. Inoltre, questo approccio richiede un'aggiunta manualedei parametri che lo rende poco �essibile, dato che andrebbe ricreata una blacklistogni volta che si cambia luogo e lingua.

Dunque, sfruttando il fatto che il dataset indica anche la popolazione di un lu-ogo, si sono tenute solo le località con un numero su�cientemente alto di abitanti,nel nostro caso è stata scelta la soglia di 20.000 unità, scelta empiricamente pernon avere più falsi riscontri ma estrarre comunque una buona quantità di nomi.

Si ha anche una diminuzione dei tempi di elaborazione, tuttavia trascurabiledato che il caricamento dei dati è e�ettuato una volta sola rispetto all'elaborazionedei messaggi, mentre l'accesso alla lista avviene in tempo medio O(1), utilizzandostrutture come la HashMap di Java.

4.3.1.2 Creazione di un NER per la ricerca dei nomi di luoghi

Sfruttando le annotazioni al testo generate nella fase precedente, possiamo oracercare di sviluppare un NER, che sfrutti un modello statistico della sintassicon cui sono inseriti i nomi di luoghi nelle frasi per identi�care i termini che siriferiscono a entità geogra�che.

Generalmente questi algoritmi sfruttano modelli generativi come le catene diMarkov, o più precisamente degli Hidden Markov Model, che non verranno quidiscussi dettagliatamente. Ai �ni del discorso, basti sapere semplicemente cheuna HMM è un automa a stati �niti dove a ogni arco è associata una probabilità

4.3 Localizzazione geogra�ca dei messaggi 125

di transizione e ad ogni stato è associata una serie di valori di probabilità di emet-tere un certo simbolo. L'utilità del modello è che, data una sequenza di simboliemessi, è possibile stabilire lo stato che li ha emessi con maggiore probabilitàtenendo conto non solo del simbolo emesso ma anche degli stati ricostruiti prece-dentemente. Ad esempio, un ASR13 che ha ricostruito la frase �mangio una�potrà stabilire che la parola successiva è mela piuttosto che vela combinando leprobabilità di aver sentito la parola con le probabilità che tale parola completi lasequenza, abbassando drasticamente le possibilità di sbagliare.

L'addestramento di un modello del genere richiede quindi di assegnare diversitag ai termini, come �persona�, �aggettivo�, �mezzo di trasporto� in modo dausarli per identi�care meglio il tag �luogo� che è quello davvero di nostro inter-esse. La generazione di un dataset per il training è un'operazione molto lunga,quindi abbiamo esaminato dei modelli già disponibili.

Prova del NER Annie Annie[16] è un NER basato su un modello HMM, ingrado di identi�care nomi di persone, date, luoghi, quantità di denaro, percentu-ali, indirizzi e nomi di organizzazioni. Un breve test del software (Figura 4.7)mostra come i risultati siano troppo poco accurati anche su un testo scritto initaliano corretto.

NER integrato in BigInsights BigInsights o�re una serie di strumenti perla creazione e la manipolazione di annotazioni sul testo. In particolare, tramite illinguaggio AQL si possono esprimere delle regole, in forma dichiarativa simile allequery SELECT del linguaggio SQL, che assegnano delle etichette a delle porzionidel testo. Tali regole si possono applicare a cascata, in modo da sfruttare delleetichette già assegnate come informazione per la creazione di nuove etichette.Il tool si occuperà poi di ottimizzare e eseguire in parallelo la sequenza delleoperazioni.

Esistono degli strumenti integrati in AQL che eseguono l'analisi NER del testo,in varie lingue tra cui l'italiano; tuttavia, una prova di tali strumenti con variefrasi di esempio ha mostrato come quasi sicuramente non siano basati su HMMma bensì su dei dizionari precostituiti di termini da annotare. L'e�etto è che solopochi nomi di città importanti vengono riconosciuti. Si possono aggiungere regoleulteriori in AQL, ma l'e�etto sarebbe equivalente alla ricerca delle corrispondenzecon i dati di GeoNames.

Costruzione di un riconoscitore di pattern da usare come NER

Un ultimo approccio che è stato tentato è la ricerca di strutture ricorrenti checircondano i nomi dei luoghi. La sequenza di operazioni è questa:

13Automatic Speech Recognition, un programma in grado di trascrivere testualmente ciò cheviene detto a voce da un essere umano


Figura 4.7:Le entità identi�cate dal NER Annie su una pagina di Wikipedia, marcate incolori diversi a seconda del tipo assegnato (rosa=persona, blu=data). Alcunitermini come Pio VII, Napoleone, Francia e 2 agosto non vengono identi�cati,mentre si ha il falso positivo Nel. I risultati non sono buoni, considerando che ilprogramma rappresenta lo stato dell'arte[16].

4.4 Ricerca dei legami tra i termini 127

� Si carica il database GeoNames, ignorando i nomi di luoghi con meno di20.000 abitanti

� Si ricevono in input i valori < metadati, testo del post >

� MAP - Per ogni testo contenente un nome di luogo, estraggo le 3 paroleprecedenti e successive, emettendo la struttura< espressione estratta,metadati >doveespressione estratta è un testo della forma "al_palagiustizia_di_X_seduto_al_"dove X è un segnaposto per il nome del luogo identi�cato.

� REDUCE - Per ogni espressione, se ne contano le occorrenze e la si emettetale e quale solo se tale valore è superiore a una soglia da identi�careempiricamente, altrimenti non si emette nulla

Sono state così estratte 65.660 strutture da altrettanti nomi contenuti in undataset di 379.000 post. Di queste, 319 appaiono più di una volta.

La sequenza con più comparse, ben 138, è:

palermo_palermo_palermo_X_palermo_palermo_

ovviamente errata e dovuta alla presenza di rumore (spam) nel testo.Poi si osserva la sequenza

_università_di_X_prof_arch_

e anche strutture come

il_questore_di_X_vincenzo_giacobbe_

e

del_comune_di_X_la_sfilata

Questi ultimi pattern marcano chiaramente nomi di città, ma sono estrema-mente speci�ci, infatti appaiono una decina di volta su 379.000 post. Inoltre,molti altri sono errati, come

per_pubblicizzare_la_X_ecologica_rendiamo

che potrebbe benissimo contenere parole come �cultura� o �politica� oltre chenomi di luoghi geogra�ci.

Dunque, visto che i risultati ottenuti con i due NER testati e con il NERcostruito ad hoc sono stati decisamente insoddisfacenti, si utilizzeranno solo i no-mi di luoghi identi�cati direttamente grazie a GeoNames e le eventuali coordinatefornite dai social network per assegnare una posizione �sica ai messaggi.

4.4 Ricerca dei legami tra i termini

Una volta classi�cati i messaggi in base al sentiment e alla località, può essereutile determinare quali sono i contenuti, in termini di argomenti e parole chiave,


sia per poter evidenziare il legame tra sentiment, luogo e parole chiave, che perdeterminare i legami tra le parole chiave stesse. La correlazione si può indicarecon il coe�ciente di Pearson, ossia, date due parole i e j di un dizionario D cheappaiono nei post P :

P (i, j) =s +

∑p∈P I(p)i∈p∧j∈p

ks +∑

p∈P I(p)i∈p⊕j∈p

dove s e k sono dei parametri di smoothing funzionalmente equivalente allosmoothing di Laplace implementato nel classi�catore di Bayes, che impongonouna correlazione pari 1

kin mancanza di valori. In sostanza la correlazione è

indicata come il rapporto tra la quantità di documenti (post) in cui appaionoentrambe le parole e la quantità di documenti in cui appare almeno una di esse.Questo numero, al lordo dello smoothing, varia tra 0, nel caso le co-occorrenzesiano nulle, a 1, nel caso le parole appaiano sempre e solo insieme.

Il calcolo del coe�ciente con il paradigma Map/Reduce è piuttosto laborioso:iterando sui post, si ottengono per ognuno le coppie di parole co-occorrenti, quindibisogna contare, per ogni coppia individuata, quante volte appare e quante voltealmeno una delle parole appare in un documento.

Un primo approccio approssimativo è questo:

� Ricevo in input la collezione di documenti

� MAP - per ogni coppia di parole distinte presenti nel documento, generola tupla < parola1, parola2 >, e per ogni parola distinta genero la tupla< parola1, SEGNAPOSTO >

� REDUCE - per ogni chiave parola1 conto quante volte ricevo la parola2rispetto alle occorrenze totali (ossia le presenze di SEGNAPOSTO)

Questa operazione non genera però il coe�ciente di Pearson esposto prima, bensìquesta variante:

P (i, j) =s +

∑p∈P I(p)i∈p∧j∈p

ks +∑

p∈P I(p)i∈p

che rispetto al coe�ciente di Pearson è asimmetrica, infatti può veri�carsi,e normalmente si veri�ca, che P (i, j) 6= P (j, i). In sostanza questa correlazioneindica le probabilità che, osservando la parola parola1 nella frase, sia presenteanche la parola parola2.

La di�coltà del calcolo distribuito di questo valore è intuibile formalizzandolocome un calcolo sulla matrice delle co-occorrenze. Se si immagina di avere unamatrice DxD dove D è il numero di parole nel dizionario, l'elemento Di,j è ilnumero di documenti contenenti entrambe le parole, e il calcolo del coe�cientedi Pearson richiede di calcolare, per ogni parola, il rapporto tra Di,j e il numero

4.4 Ricerca dei legami tra i termini 129

di occorrenze di almeno una parola, che è il valore sulla diagonale Di,i per ogniparola i.

La matrice delle co-occorrenze è simmetrica, infatti è ovvio che Di,j = Dj,i.Calcolare P (i, j) corrisponde a calcolare i valori di Di,j e renderli disponibili

alla fase di reduce, che dovrà poter accedere anche ai valori Di,i e Dj,j, chedovranno quindi essere emessi insieme, eventualmente in maniera incrementaleper ogni documento. Questo richiede di sapere a priori, per ogni documento, qualisono le parole del dizionario esistenti, in modo da incapsulare queste informazioninell'emissione delle chiavi.

Dovendo conoscere il dizionario già nella fase di map, quindi, la procedurasviluppata è divisa in due fasi:

� Ricevo in input la collezione di documenti

� MAP - per ogni parola distinta incontrata in un documento genero la tupla< parola, 0 >

� REDUCE - per ogni chiave, ignoro i valori e restituisco la coppia <parola, 1 >una sola volta indipendentemente dal numero di chiavi

In sostanza questo è un WordCount, come quello esposto nell', ma la fase di countè eliminata, poiché non ci serve sapere il numero di occorrenze delle parole masolo la loro esistenza. Il risultato infatti è una lista di tutte le parole trovate.

Quindi, è possibile e�ettuare questa operazione:

� Carico il dizionario creato precedentemente in RAM

� Ricevo in input la collezione dei documenti

� MAP - per ogni parola p del dizionario e ogni parola d distinta nel doc-umento, produco le coppie < p,< d, 1 > solo se p < d nell'ordine alfa-betico (o in base all'hash o qualsiasi altra funzione). Produco anche lecoppie < p,< n, 0 >per ogni parola n presente nel dizionario ma non neldocumento e tale che p < n, assieme a < n,< p, 0 > qualora p > n.

� REDUCE - per ogni parola p conto quante volte è comparsa assieme aogni parola n o da sola (contando le comparse di < p,< n, 0 >, che ha unruolo simile al SEGNAPOSTO dell'implementazione precedente) e calcoloil coe�ciente di Pearson.

Per la dimensione del dizionario si possono fare delle considerazioni analoghe aquelle sul database GeoNames: non è necessario usare le tecniche Big Data permemorizzare tale lista, sarà sempre abbastanza piccola da essere memorizzata inRAM, inoltre è read-only una volta generata quindi è possibile memorizzarla indatabase relazionali indipendenti replicati sui singoli nodi.

Questa tecnica presenta due problemi: il carico di lavoro e l'utilità dei risultati.


Se si lavora su un dizionario di 50.000 termini distinti, un valore molto bassose si conta che le parole di un dizionario sono oltre 100.000[2] e un forum suinternet è ricco di nomi propri di prodotti, aziende e persone che non compaiononei vocabolari, e si ha 1 milione di post con una media di 50 parole l'uno, sigenereranno nella fase di map

50.000 ∗ 1.000.000 ∗ 50 = 2, 5 ∗ 1012

ossia oltre 2500 miliardi di tuple, anche in queste condizioni ottimistiche, unnumero decisamente eccessivo. È possibile abbassare di molto il valore ignorandole stopword, ossia i termini come �del�, �il� o altre parole molto frequenti maprive di un signi�cato proprio, una tecnica molto di�usa [17][17] che ha permessodi abbassare di circa 4 volte il numero di chiavi prodotte, che rimane comunqueelevatissimo.

Testando l'algoritmo su un dataset di prova, da 1000 post, l'esecuzione duracirca due ore. I risultati non sono incoraggianti: leggendo la lista si osservache molte coppie di parole con un'alta correlazione non hanno evidenti legamisemantici

4.5 Sviluppo di un framework per l'elaborazione

di dati non strutturati

Durante l'implementazione e il testing dei prototipi delle componenti descritte,sono emersi alcuni problemi.

� Il deploy e l'avvio e�ettivo richiedono tempo e rendono laboriosa la provanel caso di piccole modi�che

� Il debugging è di�cile a causa del gran numero di �le di log divisi per jobe attempt che comprende i log interni di Hadoop

� I tipi di dato usati da Hadoop sono diversi da quelli tipici di Java, rendendomeno intuitiva la loro manipolazione e più di�cile l'integrazione con libreriegià esistenti.

� Creare catene di operazioni MapReduce e variarne i parametri richiededi usare Oozie con�gurato tramite un �le XML, che però è inadatto allade�nizione di catene complesse con parametri di�cili da manipolare.Inoltrela modi�ca di un work�ow è laboriosa.

Lo scenario della validazione di un modello per la sentiment analysis si scontra contutti questi fattori. Bisogna infatti de�nire un'operazione che divida il datasetin due porzioni di dimensioni date, generi il modello a partire dalla porzione ditraining, usi tale modello per classi�care gli elementi nella porzione di validazione,

4.5 Sviluppo di un framework per l'elaborazione di dati nonstrutturati 131

e confronti le classi assegnate automaticamente con quelle scelte manualmente,generando un breve report che indichi le corrispondenze contate.

Se si vuole e�ettuare il K-folding, come nel nostro caso, bisogna eseguirequeste operazioni k volte, con un criterio di partizionamento del set diverso ognivolta (o casuale, ma in tal caso sarebbe di�cile esaminare dei risultati anomaliriproducendone le condizioni), e scegliendo ogni volta una diversa destinazioneper il report. Questo ciclo, che in un linguaggio dichiarativo è un'operazionetriviale, richiede un'implementazione macchinosa nel caso si utilizzi un work�owOozie.

Per questi motivi, è stato sviluppata una tecnica che permette da un lato ditestare le applicazioni in maniera rapida su piccole quantità di dati come avvieneper il software desktop, dall'altro di eseguire la stessa applicazione in un ambientedistribuito, nello speci�co la piattaforma BigInsights, che sfrutti il parallelismodi un cluster per eseguire delle operazioni pesanti in batch dopo averle testatelocalmente.

L'idea alla base dell'applicazione è che poiché il paradigmaMapReduce prevede,per permettere il parallelismo, un incapsulamento delle due operazioni che devonoessere agnostiche rispetto alla presenza di altre istanze e al sito e�ettivo di ese-cuzione, per motivi di e�cienza, si può sfruttare questa autonomia per renderleautonome anche rispetto al fatto che stiano venendo eseguite in un'applicazionelocale piuttosto che in istanze parallele tramite Hadoop. Utilizzando poi deigenerici oggetti JSON come formato per i dati in input e output è possibilede�nire diverse strutture dati utilizzando sempre gli stessi tipi nativi.

La de�nizione di sequenze di operazioni complesse è e�ettuata tramite uncodice JavaScript eseguito tramite Mozilla Rhino, il quale richiede l'esecuzionedelle diverse fasi e ne speci�ca i parametri operativi rivolgendosi a un'entitàchiamata esecutore. Neanche questo �le JavaScript è dipendente dal contesto diesecuzione: è l'esecutore a presentare sempre la stessa interfaccia e a svolgere, aseconda dei casi, le operazioni in modalità locale o remota.

Per lo stesso motivo, i mapper e i reducer non utilizzano il �lesystem di-rettamente ma sempre e solo tramite due wrapper, chiamati GenericFileReadere GenericFileWriter. Questi wrapper, con�gurati insieme all'esecutore, presen-tano un'interfaccia unica che gestisce i diversi �lesystem, locale o distribuito,permettendo ai mapper e ai reducer JSON di accedervi.

Ad esempio:

f unc t i on workflow ( e s e cu to r e ){// i l pe r co r so d e l l a c a r t e l l a che conte r rà i f i l evar perc="/home/biadmin/TagAss istant /" ;// genero i due mode l l i per i l k−f o l d i n ge s e cu to r e . impostaConf iguraz ione (JSON. s t r i n g i f y ({" f i l t e r_ typ e " :" hash " ," seed " : i ,


"max" :"100" ," th r e sho ld " :"20" ," c r i t e r i o n " :" g r e a t e r " } ) ) ;e s e cu to r e . e s egu iFase (" f i l t r a " , perc+"tag_yt . j son " , perc+"t r a i n i n g . j son " ) ;}

la chiamata a impostaCon�gurazione prima della fase ne speci�ca i parametrigrazie al formato JSON, che è molto semplice da gestire in JavaScript.

La fase poi utilizzerà questi parametri, e leggerà e scriverà dai due �le (chepossono anche non essere �le nel senso classico, ma altre strutture come tabelledi un database).

Poiché gli oggetti in ingresso al reducer e in uscita dal mapper devono avereuna struttura chiave-valore è stato de�nito uno speciale tipo di oggetto JSONche impone di fornire questi due campi e applica delle ottimizzazioni per esserememorizzato e estratto in maniera performante in un'esecuzione di un job.

In�ne, poiché Hadoop o�re un cosiddetto sink per ricevere i dati man manoche vengono generati (emessi) in modo da non attendere la �ne dell'esecuzionedel task per iniziare a elaborarli, un suo equivalente JSON è fornito ai nostrioperatori.

È da notare che il mapper JSON non richiede di avere in ingresso una coppiachiave-valore. Infatti, nella stragrande maggioranza dei casi, quando si elaboranodei dati grezzi la chiave fornita corrisponde al numero di riga o altri metadati eviene ignorata. Allentando i vincoli sul tipo di dato in entrata si delega la respon-sabilità di gestirne lo schema al mapper JSON, che dovrà gestire la possibilità diricevere oggetti JSON senza la struttura chiave-valore.

4.5.1 Estensione del framework tramite degli script cari-cati dinamicamente e semplice benchmarking dellasoluzione

Questa fase consiste nell'esecuzione di una funzione JavaScript passata dal work-�ow come Mapper JSON.

Il vantaggio di un �le script esterno rispetto a un'operazione de�nita diretta-mente in Java è che questo può essere caricato esternamente, anche da un URL,senza dover e�ettuare nuovamente il deploy dell'intera applicazione, che comeillustrato in precedenza è un'operazione onerosa. Poiché la con�gurazione di unafase MapReduce JSON del framework è e�ettuata a sua volta con una con�g-urazione JSON, è possibile direttamente sviluppare una fase che carichi dallacon�gurazione il codice dello script da eseguire, compilandolo e eseguendolo almomento.

La funzione viene compilata all'avvio del job, quindi non comporta minoree�cienza rispetto a una fase Java, Rhino mostra uno stack degli errori informativo


Operazione Tempo (ms)

Compilazione dello script 411Esecuzione dello script compilato 33489

Esecuzione dello script non compilato 39653Istanziazione della classe Java <1 (non misurabile)Esecuzione del metodo Java 922

Tabella 4.1: I tempi di esecuzione del bytecode Java e di un codice analogo inJavaScript, compilato tramite Mozilla Rhino

come quello del normale codice Java e abbiamo così la possibilità di modi�caredelle operazioni senza ripetere il deploy.

I �le JavaScript eseguiti tramite Rhino possono però presentare dei problemidi prestazioni rispetto al codice Java nativo. Per veri�care l'entità di questadi�erenza, è stato ideato un semplice benchmark. Questo benchmark è basatosull'esecuzione di un ciclo che applica iterativamente una funzione a un valore econta quante sono le iterazioni necessarie perché tale valore diventi 1; la funzionescelta è la funzione di Collatz esposta precedentemente, ed è noto che per valoriinferiori a 108 converge sempre a 1.

Questa funzione viene chiamata su tutti gli interi tra 1 e 10 milioni e restituiscela somma del numero di iterazioni necessarie a ognuno per giungere a 1.

Implementando la funzione in Java e in JavaScript usando o meno la compi-lazione in bytecode si hanno i risultati illustrati nella tabella4.1.

È quindi evidente come Rhino sia più lento di Java anche nel caso si usi lacompilazione. Tuttavia, in un contesto di elevato throughput come questo ladi�erenza è quasi sempre trascurabile. Nel caso serva una maggiore e�cienzanel puro calcolo, verrà ora esposto un altro metodo di estensione dinamica delframework.

4.5.2 Estensione dinamica del framework tramite la re�ec-tion

Un'ulteriore possibilità per rendere più �essibile il �usso dell'esecuzione e manipo-larlo senza eseguire il redeploy è o�erta dalla funzione di Java chiamata re�ection.Come detto, la JVM esegue un codice simile all'assembly chiamato bytecode.Così come le applicazioni in assembly possono, entro certi limiti, caricare, mod-i�care e eseguire dinamicamente porzioni di codice assembly, e esaminare quellogià esistente compreso il proprio, anche Java permette di caricare delle classi di-namicamente, ottenendo il bytecode da una fonte arbitraria e/o generandolo alvolo.

Questo non è a�atto un problema nel caso del work�ow, dato che non es-egue direttamente operazioni critiche, ma lo è nel caso dei Mapper e Reducer


JavaScript. Per evitare questo problema, è possibile caricare delle vere e pro-prie classi Java da un JAR esterno a runtime e usarle come fasi, a patto cheimplementino le interfacce JSONMapper e JSONReducer. Il JAR dovrà esserepubblicato a un URL visibile dall'applicazione, oppure nel �lesystem locale, eindicato dal codice JavaScript. Questa classe può fare tutto quello che fannole classi Java del programma stesso, Il caricamento e l'inserimento sono gestititramite la re�ection e chiamati dal work�ow. Per sfruttarli basta chiedere l'utiliz-zo della fase 'external', speci�cando nella con�gurazione JSON le chiavi "mapper"e "reduce", che corrisponderanno a due oggetti JSON con i campi URL e classche indicano l'URL del JAR (o il percorso nel �le system locale, non HDFS) e ilnome della classe. Omettendo mapper o reducer la parte corrispondente dell'op-erazione verrà saltata. Questa istruzione carica un JAR (in questo caso dal FSlocale), seleziona una classe di questo �le e la rende accessibile in seguito comeuna normale fase (con il solo mapper) con il nome indicato. È possibile cari-care sia il mapper che il reducer in questo modo, sono assolutamente ortogonali.Tuttavia il caricamento di classi in questo modo presenta tre grossi problemi:

sicurezza: poiché una classe è a tutti gli e�etti un programma, un attaccanteche riuscisse ad avere accesso al server contenente i dati, o semplicementea manipolare il tra�co di rete abbastanza da intercettare la richiesta alserver legittimo e forgiare una risposta fasulla. In tal caso l'integrità e lariservatezza dei dati sarebbero compromesse, così come l'intero contenutodel server.

a�dabilità: nel caso la rete o il server non funzionino correttamente, l'interaapplicazione sarebbe impossibilitata a operare

consistenza: nel caso si fornisca al programma una classe compilata corrispon-dente a una versione diversa dell'applicazione, si avrebbero dei comporta-menti anomali e di�cili da rilevare. Anche le normali informazioni di debug-ging, come gli stack delle eccezioni presenti nei log, risulterebbero di di�cileinterpretazione perché i numeri di riga potrebbero non corrispondere.

4.5.3 Fasi del framework

Il framework mette a disposizione delle fasi, che sono illustrate in tabella 4.4.A queste fasi si aggiunge la fase external, che carica il mapper e il reducer

JSON da un �le JAR disponibile a un URL indicato, e la fase generaNER e�conta corrispondenze� che sono state usate nelle prove per costruire il sistemasoftware ma non fanno parte del �usso di elaborazione �nale.


Nomedella fase

Operazione map abbinata Operazione reduceabbinata

conta tags Dato un post con un tag abbinato,genera i diversi token (secondo le

operazioni di stemming e aggregamentoillustrate) e emette le

coppie< token,< tag, 1 >>

Riceve i token e i tag con icontatori ad essi abbinati, egenera le tuple < token,<sentiment, conteggio >>.

Simile al reduce delWordCount illustrato nell',

ma con più contatoriindipendenti

�ltra Emette l'oggetto ricevuto se corrispondea certi parametri, altrimenti nulla. Iparametri possono essere vincoli sul

valore di un campo numerico arbitrario,sul valore dell'hash dell'oggetto stesso esulla presenza o meno di una chiave.

non presente

individualuoghi

Emette l'oggetto ricevuto aggiungendoil campo places che contiene un array dinomi di luoghi riconosciuti e relative

coordinate, che può contenere anche piùluoghi o nessuno

non presente

javascript Invia l'oggetto a uno script fornitodall'esterno e a�da allo stessol'emissione arbitraria di tuple

non presente

polarity Dato un oggetto con diversi contatori,emette lo stesso con i valori relativi

percentuali dei contatori

non presente

Tabella 4.4: Le fasi del framework per le applicazioni Map/Reduce implementato


Nomedella fase

Operazione map abbinata Operazione reduceabbinata

smoothing Dato un oggetto con diversi contatori,aggiunge 1 a ognuno, creandone nel

caso l'oggetto manchi di alcunicontatori speci�cati in una lista fornita

nella con�gurazione

non presente

contacorrispon-denze

Dato un oggetto ne confronta duecampi speci�cati e emette le tuple< corretto, 1 >o< scorretto, 1 >aseconda che corrispondano o meno

Conta gli elementi corretti escorretti totali (è il reducerusato dalla fase di conta

tags)

conta bin Dato un oggetto, esegue su di esso unoscript fornito dalla con�gurazione pergenerare una chiave del bin abbinato

opportuna

Conta il numero di oggetticoi vari tag contenuti nei

vari bin

esportazioneJDBC

Dato un oggetto, esporta i campiindicati da uno script in una tabellaJDBC. La connessione, i campi e lecaratteristiche della tabella sonoindicati dalla con�gurazione.

non presente (la fase ha soloside e�ects, non manipola i

dati in Hadoop)

classi�ca Dato un post, lo tokenizzio comedescritto e lo classi�co con un modellonaïve di Bayesiano fornito, aggiungendo

il risultato della classi�cazione eemettendolo

non presente

Tabella 4.7: Le fasi del framework per le applicazioni Map/Reduce implementato


4.5.4 Utilizzo del framework per eseguire il K-folding

Il metodo per la sentiment analysis descritto deve essere validato, tramite il k-folding. La procedura è la seguente:

� Si estrae una porzione casuale di dati dal dataset di post con il tag senti-mentale assegnato manualmente; tale porzione è chiamata dataset training,il resto forma il dataset di validazione

� Si costruisce il modello Naïve di Bayes per la classi�cazione

� Si usa questo modello sugli elementi del dataset di validazione, classi�can-doli

� Si confronta il sentiment assegnato arti�cialmente tramite il modello conquello assegnato a mano, calcolando l'accuratezza come percentuale di clas-si�cazioni corrispondenti

� Si ripete tutta la procedura k volte (da cui il nome), ogni volta scegliendodiversamente i due dataset a partire dalla classi�cazione manuale dei post

È semplice eseguire questa operazione con il framework, infatti

� L'estrazione dei due dataset casuali si esegue usando la fase �lter con lafunzione di hashing con un valore di salt diverso a ogni ciclo

� Il modello di Bayes è costruito applicando le fasi conta tags, smoothinge polarity in ordine

� Il dataset di validazione è classi�cato con la fase classi�ca

� La fase conta corrispondenze fornisce un conteggio degli assegnamenticorretti e scorretti

� Il work�ow JavaScript incapsula le chiamate in un ciclo for, variando ilnome del �le in output della fase conta corrispondenze e il valore delsalt della funzione di hash

Il risultato è una cartella di �le contenente ognuno un piccolo oggetto JSON coni due valori corretto e scorretto che indicano i due conteggi.

L'esecuzione di un k-folding con k = 4000 richiede circa mezz'ora in modalitàlocale e quasi il doppio in modalità pseudo-distribuita con BigInsights/Hadoop.Il maggiore tempo di esecuzione in questo caso è dovuto all'oneroso overhead perl'inizializzazione dei job e la scrittura dei log interni, che richiede un I/O chesupera quello dell'operazione stessa.


4.6 Indicizzazione dei dati

A questo punto, sono stati estratti i messaggi da varie fonti, per ognuno è statae�ettuata la sentiment analysis e la localizzazione dei luoghi geogra�ci citati.Inoltre, per ogni post abbiamo ora e data in un formato standard.

Questi dati si trovano in un �le di testo dove ogni riga è una rappresen-tazione JSON del post in questione, salvato nel �lesystem locale o nel �lesystemdistribuito.

Per estrarre e�ettivamente conoscenza dai dati, tuttavia, è necessario gener-are dei report sintetici, e possibilmente in forma gra�ca. Poiché i dati sonomultidimensionali (data, sentiment, e luogo, più contenuti testuali), hanno unacardinalità elevata e devono essere analizzati secondo logiche non note a priori, lostrumento più indicato sembra essere il cosiddetto data cube, che o�re proprio unasorta di manipolazione multidimensionale. Un'altra possibilità è usare un nor-male database relazionale o un indice come Lucene e costruire un'applicazioneche esegua queste operazioni appoggiandosi ad esso.

Non esistono molti strumenti di questo genere, e da un confronto tra lesoluzioni più di�use (Pentaho Business Analytics, PostgreSQL, MongoDB e Lucene)il più adatto al nostro scopo pare essere PostgreSQL, per diversi motivi:

� È un database molto di�uso, quindi è facile trovare documentazione e driverper i diversi linguaggi, a di�erenza di PBA

� È un programma relativamente vecchio, esistente da decenni e giunto allaversione 9, quindi o�re una stabilità molto alta. È presente direttamentenei repository della maggior parte delle distribuzioni Linux

� O�re un elevatissimo grado di personalizzazione, permettendo di aggiun-gere moduli, trigger e stored procedure che si integrano direttamente neldatabase estendendone le funzioni senza alterare l'interfaccia

� Gestisce nativamente le coordinate geogra�che, consentendo ricerche e�ci-enti di punti vicini usando degli indici opportuni, funzione o�erta solo daMongoDB nell'ambito dei DBMS esaminati.

� Permette la ricerca del testo esatta o euristica (per esempio può cercareparole simili come scrittura o pronuncia a un termine dato) con delle esten-sioni di installazione immediata e consente nativamente la manipolazionedei dati con espressioni regolari, mentre MongoDB non ha supporto peroperazioni del genere se non in alcune modalità molto elementari. PBApermette operazioni del genere e anche più complesse, ma devono esserespeci�cate nel dettaglio senza poter usare query concise.

� Esiste un'implementazione distribuita[15] che ne permette la scalabilità lin-eare all'aumentare dei nodi con replicazione ridondante al costo di alcune

4.6 Indicizzazione dei dati 139

operazioni di JOIN che non sono più possibili. Non verranno quindi usatiJOIN, né operazioni che li implicano, per non perdere la scalabilità.

Inoltre, è estremamente leggero in termini di risorse di sistema consumate, peresempio durante le prove è stata eseguita la query

SELECT DISTINCT regexp_spl i t_to_table ( post , ' [^a−zA−ZèéàòùìÈÉÀÒÙÌ ] ' )

AS nome INTO t e rmin i FROM pos t s ;

che genera la tabella termini contenente il campo nome dove ogni record èuna parola distinta tra tutte quelle trovate nei valori del campo post della tabellaposts che presenta 550.000 elementi per un totale di circa 400 MB, considerandocome parola una sequenza di caratteri alfabetici (compresi quelli accentati). Laquery è relativamente pesante, e la sua esecuzione dura 32 minuti, ma in questotempo le operazioni su disco e l'uso della memoria di lavoro sono così bassi danon creare alcun problema alle altre applicazioni in esecuzione sulla macchina,permettendo l'esecuzione di un webserver sulla stessa senza problemi.

L'operazione di caricamento dei dati contenuti nel �lesystem in una tabellaPostgreSQL è molto semplice: alle fasi del framework ne viene aggiunta una,chiamata �esportazione JDBC� che si collega a un database usando un URL eun nome canonico del driver JDBC forniti dal work�ow JavaScript, e chiama unoscript de�nito dall'utente per l'estrazione dei dati e il loro inserimento nei campi,che verrà poi chiamato all'interno di un'operazione map eseguita in locale o inparallelo su Hadoop:

1 e s e cu to r e . impostaConf iguraz ione (JSON. s t r i n g i f y ({2 "table_name" : " pos t s " ,3 "columns" : "post , sentiment , p laces , date " ,4 " setup " : "CREATE TABLE post s5 ( post TEXT, sent iment TEXT, p l a c e s TEXT, date TEXT) ; \ n"6 +" c r ea t e index indp l a c e s on pos t s ( p l a c e s )

; "7 +" c r ea t e index inddate on pos t s ( date ) ; " ,8 "JScode" : " func t i on generaSQL ( obs , mapper ) {"9 +"var ob=JSON. parse ( obs . t oS t r i ng ( ) ) ; \ n"

10 +"\nmapper . eseguiQuery ( "11 +" [ ob . key . post , ob . va lue . newtag_sentiment ,12 ( ' p l a c e s ' in ob . va lue ) ? JSON. s t r i n g i f y ( ob . va lue . p l a c e s )

: ' ' , ob . key . date ] ) ; \ n"13 +"}\n" ,14 " d r i v e r_c l a s s " : " org . p o s t g r e s q l . Dr iver " ,15 "JDBC_URL" : " jdbc : p o s t g r e s q l : // l o c a l h o s t /

databasename?16 user=acc e s s o j ava&password=XXX"


17 }) ) ;18 e s e cu to r e . e s egu iFase ( " e spor ta JDBC" , perc+spec+"

sentiment_e_luogo . j son " , "/tmp/ el iminami " ) ;

La chiamata a impostaCon�gurazione speci�ca l'URL e la classe Java per laconnessione JDBC, il nome della tabella, i nomi dei campi, delle istruzioni perla creazione della tabella e degli indici (viene creata al momento) e uno scriptJavaScript inserito come campo di un oggetto JSON che estrae i dati del post inquestione e li invia al framework per l'inserimento vero e proprio.

4.7 Adattamento alle lingue asiatiche

Il lavoro di questa tesi è stato svolto su raccolte di messaggi in italiano e in inglese,è quindi legittimo chiedersi quanto le tecniche sviluppate siano valide nel caso dialtre lingue e, se lo siano, quanto sia agevole l'adattamento.

Le lingue asiatiche come il cinese o il giapponese, ma anche altri idiomi comeil turco o il mongolo pongono dei problemi per via della diversa morfologia e/odell'assenza degli spazi o altri separatori espliciti tra le parole. Verranno oraesaminati i diversi aspetti problematici e il modo in cui sono stati gestiti nellosviluppo del sistema software.

4.7.1 Codi�ca dei caratteri

Utilizzando 8 bit per carattere si possono rappresentare 28 = 256 elementi, unnumero su�ciente per l'inglese e, con opportuni adattamenti, anche per le lingueusate nell'attuale Unione Europea. Lo standard ISO/IEC 8859-1 in partico-lare gestisce gli accenti, le dieresi e altre peculiarità delle lingue dell'Europaoccidentale usando una codi�ca a 8 bit.

Il cinese e il giapponese, però, utilizzano migliaia di ideogrammi distinti erichiedono una codi�ca diversa; un discorso analogo si ha per altre lingue comel'ebraico, l'arabo o l'hindi, che pur possedendo meno di 256 caratteri non sonocodi�cabili senza sacri�care i caratteri latini.

Dunque, è necessario utilizzare una codi�ca che sfrutti, sistematicamente osolo se necessario, più di 8 bit; la codi�ca UTF-8 è perfetta a questo scopo perchéutilizza 16 bit solo quando necessario, rimanendo retro-compatibile con la codi�caASCII, rappresentando gli accenti, ideogrammi, gli alfabeti come l'Hiragana enaturalmente anche i caratteri latini delle tabelle ASCII.

Java utilizza di default questa codi�ca, quindi il framework in sé non haproblemi al riguardo. I �le di con�gurazione esterni, come il database GeoNames,sono anch'essi codi�cati con UTF-8. Python invece, nelle versioni precedenti alla3, purtroppo ancora molto utilizzate, utilizza una codi�ca a 8 bit di defaultfornendo un supporto molto contorto alle stringhe Unicode. Il framework Flask,comunque, utilizza internamente la rappresentazione UTF-8, così come il motore

4.7 Adattamento alle lingue asiatiche 141

Jinja2 e il database PostgreSQL, se viene con�gurata. L'applicazione web è stataquindi costruita in modo da utilizzare sempre le stringhe Unicode. Il browserriceve, nei response HTTP, il valore:

Content−Type : t ex t /html ; cha r s e t=utf−8

che indica la codi�ca UTF-8 della pagina, compreso il codice JavaScript e irisultati delle richieste AJAX.

4.7.2 Tokening

La separazione del testo in singole parole è, in italiano o in inglese, un'operazionecosì semplice che spesso non viene nemmeno discussa: è su�ciente utilizzare glispazi e i segni di punteggiatura come separatori, con una semplice espressioneregolare.

In alcune lingue come il cinese o il giapponese, invece, non si inseriscono spazitra le parole; è il lettore, dal signi�cato del testo e dalla struttura della frase, adistinguere le parole. Questo problema è critico per le operazioni di elaborazionedel linguaggio naturale come la nostra, perché senza individuare i singoli tokennon è possibile e�ettuare la sentiment analysis.

Essendo questo problema molto frequente (per esempio nel caso della ricercatestuale), sono stati sviluppati numerosi metodi per individuare i punti di sepa-razione tra le parole automaticamente, generalmente basati sulla costruzione diun modello a partire da testo in cui le parole sono contrassegnate che permettadi individuare i punti con la massima probabilità di contenere uno spazio.

Il framework dunque a�da il tokening a una sola funzione, sebbene si tratti diuna semplice espressione regolare, in modo da agevolare il passaggio a una linguasenza spazi richiedendo di modi�care la minima quantità di codice.

Per gestire i commenti in cinese, è stata implementata, proprio nella funzionedi tokening, una tecnica piuttosto rudimentale:

1. Cerca nel messaggio i 10 ideogrammi più usati nella lingua cinese, tabulatinel programma stesso

2. Se non sono presenti, utilizza il tokening tradizionale basato sui simboli nonalfabetici

3. Se sono presenti, considera ogni carattere come un singolo token, e divididi conseguenza

Questo metodo sfrutta la maggiore signi�catività degli ideogrammi rispetto allelettere degli alfabeti latini: poiché molti ideogrammi sono e�ettivamente parole,e grazie all'aggregazione il modello considera anche le combinazioni di token adia-centi, è possibile così classi�care anche il testo in cinese seppure con un'accuratez-za più bassa. Questa funzione agisce anche nel caso del testo in giapponese, con


minore e�cacia poiché quest'ultima lingua utilizza anche dei sillabari analoghiall'alfabeto latino.

Per l'arabo e l'hindi non sono state trovate soluzioni immediate, poiché questelingue, pur senza usare gli spazi, sono basate su un alfabeto non ideogra�co e sirende necessario aggiungere un tokener speci�co.

4.7.3 Stemming

Ogni lingua ha una morfologia diversa: mentre alcune, come il cinese, lascianoqualsiasi parola invariata in base a tempo, numero o caso, altre, come il turco oil giapponese, prevedono l'aggiunta di su�ssi per indicare concetti che in italianosarebbero espressi con una parola indipendente o non sarebbero espressi a�atto.

Per esempio il termine giapponese �taberareru� signi�ca �poter mangiare�(o �essere mangiato�), due casi (passivo e potenziale) che in italiano sono resicon dei verbi ausiliari (�essere� e �potere�). Allo stesso modo vengono coniugatigli aggettivi, oltre ai verbi, in base al tempo, si modi�cano le parole in base allaformalità che si vuole esprimere tra diversi gradi di gentilezza e si usano aggettivicardinali e ordinali diversi a seconda dell'entità che viene contata (per esempiopersone, animali, oggetti pesanti, oggetti sottili, periodi di tempo, ecc.).

L'approccio euristico allo stemming adottato però permette di individuareautomaticamente queste peculiarità, posto che sia fornito un campione di testorappresentativo della lingua usata. Per esempio, sempre nel caso del giapponese,un modello per esaminare dei forum non può essere costruito a partire dal testo dialcuni libri per il di�erente grado di formalità. Anche in italiano, come spiegato,si ha un vincolo del genere dovuto ai diversi registri linguistici dei forum e, peresempio, degli articoli di giornale.

Comunque, il numero di occorrenze di un su�sso per poter essere aggiuntoallo stemmer deve essere stabilito empiricamente lingua per lingua, variandolo eosservando i risultati.

Un discorso analogo può essere applicato ai pre�ssi, che non sono stati con-siderati poiché in italiano e in inglese non variano in base a tempo, genere enumero ma modi�cano il senso di una parola, anche ribaltandolo, quindi si èpreferito non eliminarli.

4.8 Rappresentazione dei dati estratti

Una volta estratti, elaborati e indicizzati i dati è necessario mostrarli all'utentedando un colpo d'occhio sul contenuto e agevolando le operazioni di �ltraggio deidati.

Esistono tre modi per e�ettuare questa operazione:

1. Sviluppare un'interfaccia da linea di comando

4.8 Rappresentazione dei dati estratti 143

2. Sviluppare un'applicazione con una GUI

3. Sviluppare un'applicazione web usata attraverso un browser

I primi due approcci permettono di far funzionare l'applicativo in modalità o�ine,senza che il computer dell'utente debba essere collegato al cluster che esegue leoperazioni Map/Reduce, ma perché ciò sia possibile è necessario memorizzaretutti i dati indicizzati in un database locale, che potrebbe essere molto pesante edi di�cile installazione.

Un'interfaccia a linea di comando può essere usata in remoto tramite SSH,mentre una GUI in Java deve essere eseguita localmente (i sistemi Windows nonpermettono di aprire singole applicazioni gra�che se il server non possiede undesktop completo, tramite il tunneling X11 con SSH)

Inoltre, il deploy di un'applicazione gra�ca Java richiede la presenza di unaJVM su�cientemente aggiornata, che spesso non è disponibile.

Un'applicazione web può invece essere eseguita in remoto o in locale da qual-siasi computer dotato di un browser aggiornato, disponibile in qualsiasi sistemaoperativo mainstream.

Un altro vantaggio delle applicazioni web è la grande disponibilità di libreriee strumenti per interagire con l'utente, che è un aspetto fondamentale di ogniapplicazione di questo tipo.

Esiste una pletora di framework e librerie per lo sviluppo di applicazioni web.Quella che si intende sviluppare è relativamente piccola, non ha esigenze di ele-vato parallelismo e deve essere semplice da modi�care, in più farà un forte usodi AJAX. I linguaggi più adatti a sviluppare questo tipo di applicazione sonoPython, Scala e PHP, perché permettono di manipolare con facilità strutturedati complesse e sono usati in ambito web. Il PHP però dispone di pochi stru-menti per il debugging, e si presta poco a svolgere operazioni lontane dall'ambitoweb come accedere al �lesystem, eseguire calcoli o lanciare comandi (attività pos-sibili ma scomode), mentre per gli altri queste operazioni sono piuttosto comuni,essendo linguaggi generici.

Sono dunque stati provati tre diversi framework: Django, Play e Flask.

Play è un framework basato su Scala e Java. Pone molta enfasi alla concorren-za delle applicazioni e sull'interazione con l'utente per mezzo di AJAX eComet14. Utilizza SBT per automatizzare il deploy e il testing di un server,che diventa così molto portabile e facile da aggiornare, infatti le librerie diScala sono incluse nell'installazione.

Django è un framework Python molto di�uso, basato come quasi tutti i frame-work web sull'architettura MVC15, dispone di una buona documentazione

14Una tecnologia simile a AJAX, e generalmente ottenuta tramite esso, che permette al serverdi inviare dati in maniera asincrona al client.

15Model View Controller, la separazione tra manipolazione, memorizzazione e visualizzazionedei dati


e svolge in automatico molte operazioni, in particolare genera automatica-mente il codice per manipolare un database, mostrare un interfaccia perinserirvi i dati e validare i dati che vi vengono inseriti

Flask è un framework Python improntato al minimalismo: consiste solo di duecomponenti principali, un motore di rendering dei template, Jinja2, e unsistema di routing delle richieste,Werkzeug. A ciò si aggiungono degli helperassolutamente opzionali, in modo da permettere una grande �essibilità estabilità (il programmatore può realisticamente correggere il framework nelcaso trovi un bug). Non fornisce strumenti per manipolare il database, maesistono diversi moduli aggiuntivi per agevolare l'operazione.

Il framework Play è stato escluso per una serie di problemi tecnici esposti nellaSezione 6.5.5.

Django invece si è dimostrato molto stabile e intuitivo. Inoltre, esiste unalibreria chiamata Dajax che agevola lo sviluppo di applicazioni AJAX facendoun uso intenso della chiusura di funzioni per gestire l'asincronismo proprio diquesto tipo di interazione client-server.

Tuttavia, Dajax risulta e�cace solo per dei casi d'uso prede�niti, tra i qualiovviamente non è presente l'analisi OLAP, e d'altro canto l'architettura di Djangoè studiata per sempli�care le operazioni comuni al costo di �imporre� certe carat-teristiche al funzionamento interno dell'applicazione sviluppata, contrastando losviluppo nei casi d'uso particolari come questo.

Dunque è stato scelto Flask, che permette uno sviluppo agile e sicuro diapplicazioni molto �essibili. Inoltre, Flask ha la caratteristica unica di fornire undebugger nella pagina web stessa in caso di errore, permettendo di ispezionarele variabili e eseguire codice arbitrario nei vari contesti di esecuzione dell'interostack di errore, compreso il codice interno del framework.

4.8.1 Applicazione web per l'analisi OLAP basata su Flask

L'applicazione sviluppata per l'analisi OLAP è piuttosto complessa. Innanzitut-to, integra un database SQLLite che contiene i metadati del database vero e pro-prio. Ogni collezione di post è dunque catalogata in questo piccolo database, cheindica il nome, la descrizione fornita dall'utente e i parametri come l'estensionetemporale e le restrizioni di keyword e luogo applicate.

L'utente visualizza una lista dei dataset con relativi metadati, e per ognuno hala possibilità di esaminare delle visualizzazioni gra�che e generare nuove collezioniapplicando dei �ltri.

4.8.1.1 Filtraggio rapido dei dati

Il �ltraggio è eseguito direttamente sulla tabella del database PostgreSQL dal-l'applicazione, che fornisce anche il codice della query eseguita e il work�ow


Figura 4.8:

dataset gra co

gra codataset dataset

ltraggio

sintesi

drill up

ltraggio

Schema logico del pannello di controllo. Da un dataset è possibile ottenerne unonuovo, immutabile, tramite il �ltraggio. Tutti i dataset possono essere mostratigra�camente e il drill up viene eseguito

JavaScript in grado di svolgere l'operazione nel framework Map/Reduce descrittoprecedentemente, nel caso si voglia passare dall'analisi OLAP alla stessa oper-azione svolta in modalità batch e distribuita.

Per sempli�care la gestione dei metadati e non confondere l'utente, i datasetsono immutabili, ossia una volta creati non vengono mai modi�cati; è possibilesolo eliminarli o generarne di nuovi tramite il �ltraggio (Figura 4.8).

Dalla schermata principale del pannello di controllo (Figura 4.9) l'utenteaccede direttamente al menù per il �ltraggio (Figura 4.10).

Le opzioni o�erte per il �ltraggio sono:

� Data minima e massima: se speci�cate, indicano una data nel formatoYYYY−MM−DD hh:mm:ss per degli estremi temporali da analizzare. Èpossibile indicare solo una data di inizio o una data di �ne, e si possonousare diverse granularità, quindi sono accettate date come:

� 2009

� 2007-10

� 2013-07-02

� 2003-09-11 12:24

� Parole chiave arbitrarie, separate da una virgola. Possono contenere deglispazi e dei numeri, la ricerca è case insensitive

� Luoghi, sono accettati sia nomi propri che rettangoli di coordinate spaziali,ad esempio:

� Milano

� Cinisello Balsamo


� [41.2,12.9,43.1,13.1]Le quattro coordinate indicano rispettivamente latitudine e longitu-dine dell'angolo a nordovest e dell'angolo a sudest

� Classi di sentimento accettate, se si desidera �ltrarle. L'applicazione igno-ra completamente le classi di sentiment fornite, richiede solo che sianoun numero �nito. È possibile aggiungere nuovi tipi di sentiment senzamodi�care il pannello di controllo né la struttura del database

L'applicazione riceve i parametri su cui e�ettuare lo slicing del data cube, insiemeal nome del nuovo cubo immutabile che deve essere generato.

Nel passaggio successivo è possibile osservare, per chiarezza, la query SQLche ci si appresta a eseguire, e lo snippet javascript che permette di eseguirequel �ltraggio direttamente all'interno di BigInsights, generando il data cube già�ltrato in modalità distribuita.

L'utente può quindi eseguire il �ltraggio all'interno dell'applicazione web stes-sa, la quale:

� Eseguirà la query SQL sul database PostgreSQL

� Esaminerà la tabella così generata per calcolare la data massima e minime.Si noti che anche qualora vengano speci�cate, potrebbero essere diverse daquelle presenti; per esempio se si speci�ca �2001� come data minima ma ilmessaggio più vecchio è datato �2003-12-08 23:10:09� allora quest'ultimosarà l'e�ettiva data minima contenuto nel dataset.Discorso analogo per i sentiment, che vengono estratti a posteriori per man-tenere l'indipendenza dell'applicazione dalle classi di sentimento de�nitedall'esterno.

� Inserirà i parametri calcolati nel database dei metadati ad uso interno

� Mostrerà nuovamente la schermata iniziale, che ora conterrà anche il nuovocubo OLAP, pronto ad essere visualizzato o ulteriormente �ltrato.

� Utilizzando una funzione del motore di templating Jinja2 chiamata ��ash�,mostrerà un messaggio riassuntivo dell'operazione svolta


Figura 4.9:

La schermata iniziale del pannello di controllo. Di ogni dataset vengono mostratii metadati e i �ltri applicati a sentiment, luogo e parole chiave. È possibileeliminare, visualizzare e �ltrare i dataset.

Figura 4.10:Le opzioni per il �ltraggio di un dataset fornite dall'applicazione, per e�ettuarelo sclicing del cubo OLAP in più dimensioni: temporale, spaziale, in base alsentiment e in base alle parole chiave. La casella attiva è evidenziata in azzurrograzie alla libreria Bootstrap rilasciata da Twitter.


Figura 4.11:

La query SQL generata e il corrispondente work�ow JavaScript da eseguire conl'applicazione per BigInsights. Per motivi di sicurezza, l'hash SHA-256 dellaquery concatenata a una chiave segreta viene scritto nella pagina e restituito alserver con la query, per evitare che questa possa essere alterata dal client; primadell'esecuzione la query e l'hash vengono confrontati per testarne l'integrità. Ilcodice SQL è colorato tramite la libreria prettify.

L'eliminazione di un dataset è e�ettuata velocemente con una semplice richi-esta di conferma tramite AJAX, il cui aspetto gra�co è omesso per brevità, ecorrisponde a due operazioni:

1. Eliminazione del record corrispondente nel database dei metadati

2. Eliminazione della tabella (DROP TABLE) nella base dati PostgreSQL

4.8.1.2 Drill up e rappresentazione gra�ca dei dati

Manipolando grandi quantità di dati, è necessario fornire all'utente degli stru-menti speci�ci per la loro visualizzazione: non è possibile leggerli direttamentené inserirli in un comune foglio di calcolo. Anche gli applicativi di analisi e gra�-ca più evoluti come MATLAB o GNUPlot non riescono a gestire le moli di datidi cui si parla (il dataset più piccolo di quelli analizzati contiene 120.000 post),anche ipotizzando di avere già e�ettuato lo slicing desiderato.

Inoltre, un'analisi OLAP deve permettere il cosiddetto drill up dei dati, ossiacondensarli in una dimensione speci�ca, operazione tutt'altro che triviale usandodegli strumenti generici.

Dobbiamo quindi sviluppare uno strumento di rappresentazione speci�co. Perfare ciò esistono due soluzioni alternative, ossia generare le rappresentazioni nelserver o nel client:


pregi: difetti:

lato server indipendenza dal browser gra�co staticolato client più accattivante, l'utente può esplorare i dati possibile pesantezza

Se si generano le rappresentazioni nel browser, potrebbero sorgere dei prob-lemi dovuti al diverso modo in cui i browser interpretano lo stesso codice, an-che nel caso rispetti gli standard de�niti dal W3C descritti in precedenza. Ingenere il problema viene �risolto� visualizzando una pagina con diversi browsermainstream e modi�candola qualora i risultati non siano quelli desiderati.

Nel nostro caso la realizzazione di un gra�co lato client è un'operazione cosìcomplessa che, nel caso questo non venga visualizzato correttamente, sarebbepraticamente impossibile correggerlo. Esistono però delle alternative:

� Sviluppare l'applicazione testandola solo su un browser, suggerendo all'u-tente di usare quello

� Sviluppare l'applicazione usando delle librerie di larghissima di�usione,ampiamente testate su molti browser e casi d'uso, riducendo (comunque,non del tutto) le chances di riscontrare anomalie

Dunque verrà usato Google Chrome come browser di riferimento, perché ha unottimo supporto alle pagine che fanno un uso intenso di JavaScript e elemen-ti HTML5 come l'inserimento diretto di immagini SVG16, è gratuito e multi-piattaforma. In particolare, Google Chrome possiede un motore per l'esecuzionedel codice JavaScript, V8, che è attualmente il più performante, usato anche comemotore nel server Node.js.

Per gestire il problema della pesantezza, la sintesi dei dati sarà svolta nelserver, il client dovrà solo visualizzare i dati contenuti nel report, che sarannocaricati in un secondo momento tramite AJAX per rendere più gradevole[22]l'interazione con il programma dando all'utente una migliore percezione dellostato di avanzamento dell'operazione.

L'utente deve poter �navigare� tra i dati, e e�ettuare l'operazione di drillup. Quindi, una volta �ltrati i commenti sulla dimensione temporale, su quellaspaziale e sulle parole chiave, è necessario permettere la navigazione sulle duedimensioni navigabili, ossia quella spaziale e temporale.

Sulla dimensione temporale il gra�co varia in base a tre caratteristiche in-dipendenti:

granularità: Il gra�co può avere una scala annuale, mensile, giornaliera o ad-dirittura oraria

proporzione: Possono venire mostrate le proporzioni relative dei tre sentimento le quantità assolute, per evidenziare il volume complessivo dei messaggial variare del tempo oltre che la loro positività

16Scalable Vector Graphics, un formato simile all'XML per rappresentare le immaginivettoriali


drill up: È possibile non solo avere un gra�co dell'andamento temporale, maanche una sintesi dell'andamento del sentiment in base al mese dell'anno oall'ora del giorno. In sostanza è come se l'asse delle ordinate non fosse piùil tempo t ma il suo modulo t mod k dove k è la scala scelta per il drillup.

La sintesi dei dati è eseguita dal server, che sfrutta gli indici per generare velo-cemente un piccolo report con i dati richiesti, e fornirlo su richiesta in formatoJSON, sfruttando il formato della data adottato.

Per esempio, nel caso si richiedano un drill up dei dati su base oraria l'appli-cazione farà una richiesta AJAX all'indirizzo

/ a j a x s e r v i c e s / sent iment_report /NOME_DATASET/3/ grouping /11

che indica di selezionare 3 caratteri a partire dal carattere numero 11 e eseguireil drill up su di essi. Questi caratteri indicano l'ora, si osservi che nel caso unvalore della data sia minore di 10 viene aggiunto uno 0, in modo che ogni elementodella data e dell'ora si trovi sempre nello stesso punto della stringa.

Il server raggrupperà tutti i post in base alle posizioni indicate nella richiestae fornirà una struttura AJAX di questo tipo:

{ " v a l o r i " : [{

" datebin " : " 00" ," contegg io " : 836 ,

" sent iment " : " negat ive "} ,{" datebin " : " 01" ," contegg io " : 378 ,

" sent iment " : " negat ive "} ,{

" datebin " : " 02" ," contegg io " : 151 ," sent iment " : " negat ive "

} ,

le cui dimensioni complessive dipendono solo dall'ampiezza dell'intervallo tem-porale e dal numero di classi di sentiment, non dal numero dei post. In questo ca-so, essendo un drill up su scala oraria e avendo tre sentiment, si hanno 24∗3 = 72elementi, un valore tranquillamente gestibile dal browser.

Per agevolare la selezione delle diverse modalità di rappresentazione, è statousato AJAX, in modo che, come anticipato, l'utente possa avere un'idea dellostato dell'operazione, vedendo dei messaggi come �in attesa dei dati dal serv-er...� o �elaborazione dati in corso...�. Le richieste AJAX vengono svolte tramite


jQuery, una libreria JavaScript di ampissimo utilizzo che gestisce le di�erentisintassi usate dai browser per eseguire tali richieste e attenderne i risultati.

jQuery è alla base di altre operazioni comuni come la selezione di alcunielementi nella pagina, ed è ampiamente usata in questa applicazione.

Disegnare un gra�co è un'operazione poco comune in JavaScript, e �no apochi anni fa era praticamente impossibile. Ora però esistono i canvas, areebidimensionali della pagina su cui è possibile disegnare programmaticamente allapari dei Graphics di Java, e le SVG, immagini vettoriali con una rappresentazioneXML manipolabile tramite JavaScript.

Si è scelto di usare una libreria chiamata d3js17, Data Driven Document, chefornisce risultati gra�camente accattivanti a partire da dati scaricati in temporeale in formato JSON, CSV o altri, che è esattamente il nostro caso d'uso.

La libreria fornisce delle funzioni per abbinare una serie di dati a degli ogget-ti nella pagina, comprese delle componenti gra�che in un'immagine vettoriale,richiedendo allo sviluppatore di de�nire la logica con cui abbinare i dati alleproprietà degli oggetti e speci�care come gestire i nuovi elementi. Nel caso d'u-so speci�co, però, c'è bisogno di un controllo piuttosto dettagliato sulla rap-presentazione, quindi è stata usata la libreria d3js per disegnare le immaginiSVG più facilmente, senza però sfruttarne le funzioni per abbinare i dati allavisualizzazione.

Il risultato è un istogramma a pila i cui diversi colori rappresentano di diversisentiment. Nel caso l'utente richieda i valori assoluti, ha un resoconto gra�co sulvolume dei commenti più che del valore della dimensione sentiment, utile nel casosi voglia stimare in quali orari (Figura 4.12) della giornata o mesi dell'anno gliutenti sono più attivi.

Naturalmente è possibile ottenere una classica rappresentazione gra�ca del-l'andamento del sentiment senza drill up in una scala temporale mensile o gior-naliera su tutto il periodo temporale del dataset in questione (Figura 4.13).

Tale rappresentazione permette anche di rilevare anomalie come un periododi malfunzionamento di una sorgente, che si manifesta come un periodo di valorinulli o molto bassi. È anche possibile rilevare le perdite dei dati dal databaseo degli errori di estrazione da parte dello scraper, che si distinguono dai periodidi malfunzionamento dei siti web perché in questo caso la ripresa del volume deicommenti pre-anomalia è graduale, perché serve del tempo a�nché gli utenti siaccorgano che il sito è tornato funzionante e ritornino a usarlo.

17http://d3js.org

http://d3js.org


Figura 4.12:

L'andamento temporale dei valori assoluti delle classi di sentiment, con un drillup su base oraria. Prevedibilmente, negli orari notturni si hanno molti menocommenti, con un picco nell'immediato pomeriggio. Non è evidente la percentualedi commenti positivi (verdi) e negativi (rossi), ancora meno quelli neutrali (neri).

Figura 4.13:

L'andamento temporale dei valori assoluti delle classi di sentiment, su base men-sile in un periodo da marzo 2003 a novembre 2012 (visibile nella schermata). Nelperiodo marzo-agosto 2006 il forum ha avuto dei malfunzionamenti, è possibiledistinguere un malfunzionamento del forum da una perdita di dati a posterioriper il fatto che il volume dei commenti riprende gradualmente dopo il �buco�.


Figura 4.14:

L'andamento temporale dei valori relativi delle classi di sentiment, su base mensilein un periodo da marzo 2003 a novembre 2012 (visibile nella schermata). Il bucoè visibile perché, in questo caso, si tratta di un periodo di totale assenza e non divolume basso ma non nullo. È ora possibile osservare come il sentiment globale,in generale, non vari signi�cativamente nel tempo.


Il gra�co su scala relativa 4.14, invece, ignora il volume ma mostra come variala positività dei commenti. Notando che globalmente, considerando l'intero forumin questione, il sentiment dei post non varia, è possibile ora eseguire la stessaanalisi sul data cube estratto in base a delle parole chiave, �formula uno,formula1,pista,pilota,piloti,pole position� per determinare come cambi il sentiment nelcorso del tempo. Eseguendo lo slicing in questo modo si osserva che il volumenon varia signi�cativamente nel tempo, escluso un picco corrispondente al 25maggio 2008, data in cui si è disputata una corsa di formula 1 a Monaco che èstata molto seguita nel forum esaminato. Si nota inoltre che l'anno 2008 è quelloper cui si ha in generale il maggior volume di commenti sulle corse, e secondoWikipedia �The 2008 Formula 1 season was one of the closest in the history ofthe sport�, il che potrebbe spiegare il motivo dell'attenzione.

4.8.1.3 Heatmap geogra�ca

Mentre la dimensione temporale è lineare, quindi può essere rappresentata con unistogramma, la dimensione spaziale richiede uno strumento più so�sticato, poichési hanno sia le due dimensioni spaziali (latitudine e longitudine) che il valore darappresentare (volume dei post corrispondenti nel data cube).

Il metodo più immediato per rappresentare queste informazioni è una mappatermica, ossia un'immagine che mostra i diversi valori abbinati ai punti spazialicon diversi colori, ordinati dal più freddo al più caldo.

È stata quindi modi�cata la libreria JavaHeatChart, capace di generare heatmapin scala di grigi, per aggiungere i colori. La libreria così generata è stata chiamataJHC-morecolour 18, ed è stata usata anche per rappresentare le funzioni di hashper il �ltro di Bloom (Figura 4.5).

Tuttavia, la mappa così ottenuta è statica, mentre il vantaggio di un'appli-cazione web è l'alta interattività con l'utente. È stata dunque implementata unavisualizzazione dei dati basata su Google Maps, che mostra il volume dei postsotto forma di mappa termica sovrapposto alle mappe, permettendo all'utente dizoomare e muovere la visuale a piacere, e anche passare dalle foto satellitari allemappe stradali.

Nel caso del data cube delle corse visto in precedenza, si ottiene una map-pa molto signi�cativa (Figura 4.15), perché mostra le posizioni degli autodromiitaliani (Imola, Maranello, Monza, Adria).

Le mappe termiche sono utili per determinare in quali parti del mondo (o diuna zona speci�ca) sono più citati certi brand. Analizzando un dataset di tweetriguardanti una casa automobilistica europea si ha una mappa (Figura 4.16) siosserva che la maggior parte dei occorrenze di nomi di luoghi riguardano paesi

18https: // github. com/ jacopofar/ jhc-06-morecolours

https://github.com/jacopofar/jhc-06-morecolours


Figura 4.15:

La mappa termica del data cube sulle corse automobilistiche selezionato inprecedenza. Si notano dei picchi in presenza di Imola, Maranello, Monza e Adria.


Figura 4.16:

La mappa termica di un data cube contenente dei tweet riguardanti una casaautomobilistica europea. Si ha un picco a Roma causato dalla notizia della spon-sorizzazione di una squadra di calcio da parte dell'azienda, commentata nei socialnetwork nel corso della settimana di raccolta dei dati.

europei e le coste degli stati uniti, corrispondendo grosso modo a una mappa delladensità di popolazione che non tiene conto dei paesi asiatici che, ad esclusionedel Giappone che infatti è presente, non hanno case automobilistiche famose néospitano importanti saloni o gare di formula 1.

4.8.1.4 Diagrammi a torta

Un utente potrebbe desiderare una semplice indicazione della quantità di mes-saggi positivi, negativi o neutrali presenti in un dataset. La visualizzazione piùlogica è il diagramma a torta, che mostra le classi di sentiment ripartendo uncerchio in settori con un angolo proporzionale alla fetta rappresentata.


Figura 4.17:

Un diagramma a torta generato dinamicamente. Nella legenda si possono vederei valori assoluti corrispondenti alle diverse fette.

La libreria jqplot19 permette di disegnare agilmente questo tipo di diagramma(Figura 4.17), che come gli altri è generato al volo nel browser dell'utente a partiredai dati forniti dal server tramite AJAX.

Utilizzando AJAX per caricare i dati dinamicamente è possibile incrementarei report a�ancando più diagrammi a torta aggiunti in momenti diversi, consen-tendo all'utente un'esplorazione interattiva del datacube.

Inserendo una parola chiave nella casella di testo e premendo invio l'appli-cazione genera il diagramma a torta delle classi di sentiment riferito ai post con-tenenti quella parola chiave, che viene appeso alla pagina (Figura 4.18) insiemeai diagrammi già presenti non appena è pronto.

Per migliorare l'interazione, considerando che la generazione di questo gra�copuò richiedere qualche secondo, è possibile generare più diagrammi in paralle-lo, quindi l'utente può inserire una parola chiave e premere invio prima che ilsistema generi il gra�co di quella attuale; entrambi i gra�ci verranno generati,naturalmente questo accade anche nel caso estremo di più di due gra�ci. Tale

19http://www.jqplot.com

http://www.jqplot.com


parallelismo è permesso dal paradigma funzionale usato da JavaScript: come sp-iegato nella sezione 3.6.2, la programmazione funzionale fornisce delle garanziedi non-interferenza tra le operazioni.

4.8.1.5 Estrazione di elementi casuali

L'applicazione o�re anche la possibilità di visualizzare degli elementi casuali conla relativa classi�cazione (Figura 4.19).

Il sentimento identi�cato viene indicato, intuitivamente, con i colori verde,rosso e bianco. Il caricamento di questi dati è fatto, al solito, tramite AJAX, edè possibile per l'utente ricaricare 20 nuovi post in maniera asincrona cliccando suun apposito collegamento.

Questa interfaccia permette anche di indicare degli errori nella classi�cazionedei messaggi, che saranno, se lo si desidera, aggiunti al modello per a�nare lesuccessive analisi.

4.8.2 Contestualizzazione dei dati

Una funzione molto utile dal punti di vista dell'esperienza dell'utente è la pos-sibilità di osservare i dati nel loro contesto. Anche se il sistema software ha loscopo di esporre una sintesi di una grandi quantità di elementi dandone una vi-sione d'insieme, è possibile per l'utente ottenere dei post casuali da un datacube,in modo da trovare spunti per le successive analisi.

Per esempio, un utente potrebbe leggere delle lamentele riferite a un certoprodotto e decidere di fare una selezione per parola chiave sul nome del prodottostesso. Un'altra applicazione si ha nel caso in cui l'utente noti un picco deicommenti positivi o negativi in un certo momento e voglia capire da cosa siacausato, oppure nel caso si abbia una concentrazione di commenti in una zonageogra�ca sconosciuta, e si voglia determinare se non ci siano omonimie.

Sarebbe utile, dal punto di vista dell'impatto visivo, poter contestualizzarei singoli commenti indicando la fonte e, possibilmente, inserendoli in un layoutgra�co simile a quello originale, incrementato con i messaggi.

L'operazione è tutt'altro che triviale, visto che le sorgenti sono diverse: i com-menti su YouTube, i forum, i messaggi da Twitter e quelli da Facebook richiedonoun layout gra�co totalmente diverso, e in alcuni casi si possono ricondurre a unapagina precisa, come nel caso dei Tweet, mentre in altri sono all'interno di elenchidi messaggi, come nel caso dei commenti ai video di YouTube.

Per gestire questa varietà, ancora una volta è stato usato il formato JSON: aogni messaggio viene aggiunto un campo chiamato source. Il contenuto di questocampo è un oggetto JSON che a sua volta contiene il campo type che indica iltipo di sorgente, e altri campi variabili in base al tipo speci�cato. In questo modo


Figura 4.18:

Due diagrammi a torta generati dall'utente. Il nuovo diagramma (ricambi) èstato appeso alla pagina. Sfruttando il parallelismo di JavaScript l'utente puòrichiedere più diagrammi in parallelo senza che ci siano problemi di concorrenza.


Figura 4.19:

Un'estrazione di post casuali. Il colore indica il sentiment assegnato automati-camente, e a sinistra si notano i bottoni per indicare una classi�cazione errata ecorreggerla, perfezionando il modello.

è possibile per l'applicazione web determinare se il contenuto è gestibile o menoe, nel caso non lo sia, evitare di generare errori.

Un'altra funzione è la possibilità di organizzare i dati per sorgenti, allo scopodi individuare i video su YouTube, le pagine su Facebook o altri elementi nel cuicontesto si ha la maggior concentrazione di elementi positivi o negativi, ossia ilmaggiore impatto (Figura 4.20).

Nel probabile caso di aggiunta di nuove fonti dati, in questo modo, l'ap-plicazione non potrà contestualizzarli ma sarà comunque in grado di o�rire lecapacità OLAP illustrate in precedenza.


Figura 4.20:Una porzione dell'interfaccia per la ricerca dei video di maggior impatto. Vengonomostrati i tre video su YouTube con la maggiore quantità di commenti positivi ei tre video con la maggiore quantità di commenti negativi. Per ognuno di essi èpossibile direttamente visualizzare i commenti e il video stesso.

Capitolo 5

Analisi dei risultati

5.1 Accuratezza

Il framework permette di eseguire il K-folding usando le fasi già esistenti, inquesto modo:

1. Itera sui valori i da 1 a k. Per ogni valore i:

(a) Applica la fase �ltra con metodo �hash�, seme i e soglia pari al 20%,generando un partizionamento 80%-20% del dataset corrispondente aidue dataset di training e validazione

(b) Genera il modello a partire dal dataset training come esposto in prece-denza

(c) Applica il modello generato al dataset validazione per eseguirne lasentiment analysis

(d) Applica la fase �conta corrispondenze� e conta quanti messaggi hannoricevuto una classi�cazione automatica uguale a quella manuale

(e) Allo stesso modo, genera la matrice di confusione

In questo modo viene eseguita la cross-validazione tramite 2-folding ed è possibilestimare l'accuratezza del modello al variare del fattore di aggregazione (la dis-tanza a cui le parole possono essere unite per formare token congiunti) e dell'usoo meno dello stemming.

Il dataset di elementi classi�cati manualmente contiene 1612 messaggi, la cuiprovenienza è illustrata nella tabella 5.1.

Il dataset in inglese serve a determinare quanto il modello sia in�uenzato dallapresenza di più lingue. Il dataset di recensioni presenta alcuni messaggi piuttosto

164 Analisi dei risultati

Numero identi�cativo Tipologia

295 A messaggi brevi da Twitter, in inglese, riguardanti una�nanziaria

202 B messaggi brevi da Twitter, in italiano, su qualsiasiargomento

245 C brevi recensioni di prodotti �nanziari, forse consistentiin spam

324 D messaggi brevi da Twitter, in italiano, sulle elezionipolitiche del febbraio 2013

212 E messaggi lunghi, in italiano, da un forum diautomobilismo

147 F messaggi lunghi, in italiano, da un forum di prodotti�nanziari

96 G messaggi brevi da Twitter, in italiano, su una catena disupermercati

Tabella 5.1: Le diverse sorgenti dei messaggi usati per generare e validare ilmodello

simili, quindi è possibile che alcuni, se non tutti, non siano recensioni di utentireali ma bensì pubblicità (positive e negative) scritte da spammer. Tuttaviaè possibile che anche i messaggi pubblicitari, portando comunque un valore disentiment, possano accrescere l'accuratezza del modello.

Aggregandoli vengono formati due dataset:

1. sporchi_tutti, da 1521 messaggi, che contiene tutti i messaggi, compresiquelli in inglese e quelli sospettati di essere spam

2. tutti, che contiene solo i 981 messaggi in italiano esclusi quelli sospettatidi essere spam

La cross-validazione tramite 2-folding viene eseguita sia su tutto il dataset chesulle porzioni della tabella prese separatamente, con un valore k pari a 40. Possi-amo quindi calcolare l'accuratezza e determinare quanto questa vari partizionan-do casualmente il dataset nelle due porzioni di training e validazione.

Come accennato nella sezione 4.2.4, è stato eseguito un confronto tra l'accu-ratezza della sentiment analysis nel caso del testo originale, del testo normalizzatocon lo stemmer e del testo originale concatenato alla sua versione normalizzata.La tabella 5.2 mostra come la variazione dell'accuratezza sia molto bassa.

In generale, per ognuno dei dataset sopra indicati si esegue la cross-validazioneper 40 volte, con diversi fattori di aggregazione, da 1 a 9, e con o senza stem-ming. L'elaborazione è molto pesante (il modello deve essere calcolato, applicatoe validato per 40 ∗ 9 ∗ 2 = 720 volte) ed è durata circa 30 ore.

5.1 Accuratezza 165

Uso dello stemmer Accuratezza

testo originale 0.575testo senza su�ssi 0.566

testo originale concatenato al testo con stemming 0.586

Tabella 5.2: L'accuratezza media della sentiment analysis, misurata con la crossvalidazione 2-folding, dei tre modi di applicazione dello stemmer. Si è usato unfattore di aggregazione pari a 5 e il dataset E

dataset massimaaccuratezza

con�gurazioneottimale:fattore di

aggregazione

con�gurazioneottimale:stem

A 0.576 3 NOB 0.501 2 NOC 0.583 6 NOD 0.628 5 NOE 0.421 1 SIF 0.465 1 NOG 0.620 4 SI

tutti 0.507 2 NOsporchi_tutti 0.527 4 NO

Tabella 5.3: La massima accuratezza raggiunta nei vari dataset, e lacon�gurazione corrispondente


I risultati, esposti nella tabella 5.3, mostrano come sia la modalità di utilizzo(o non utilizzo) dello stemming che il fattore di aggregazione ottimali varino inbase ai dataset presi in esame.

Inoltre, si osserva che i dataset riguardanti gli argomenti più circoscritti (leelezioni politiche del febbraio 2013 e i tweet sulla catena di supermercati) sonoquelli con la maggiore accuratezza.

È interessante osservare come i dataset di probabile spam e di tweet sulleelezioni politiche abbiano un fattore di aggregazione più alto. Il motivo è di�cileda determinare, può darsi che in entrambi i casi esistano delle strutture retorichedelle frasi molto di�use, e il riconoscimento sia basato sulla rilevazione dellasintassi più che delle parole chiave speci�che.

Il dataset �tutti� è il più grosso e pulito, dato che non contiene i tweetin inglese né quelli di potenziale spam, quindi ne viene calcolata la matrice diconfusione, visibile in �gura 5.1.

Si osserva come ci sia un bias positivo verso il sentiment negative, che vieneassegnato più frequentemente di quanto appaia in realtà. È di�cile determinarele cause di questo fenomeno, ma è possibile che sia dovuto al dataset F. Questodataset contiene quasi solo commenti negativi (si tratta di lamentele per cattivesituazioni economiche e problemi con istituti di credito) e generalmente moltolunghi, quindi è possibile che �inquini� il modello con un gran numero di to-ken assegnati alla classe negative, infatti nelle altre matrici di confusione questoproblema non si veri�ca.

Una possibile soluzione a questo problema è discussa nella sezione 6.5.2, main generale il programma sarà addestrato e usato sullo stesso dataset, quindi ilproblema non dovrebbe presentarsi.

Nel caso dei messaggi estratti da un forum automobilistico, che sono lunghi,riferiti a un argomento speci�co e non nettamente negativi, si ha una matrice diconfusione (Figura 5.2) più equilibrata, ma sempre con una forte predominanzadei messaggi negativi sia nella classi�cazione manuale che in quella automatica.

5.2 Velocità di esecuzione e consumo di memoria

Il framework utilizza il paradigma map/reduce, quindi scala linearmente rispettoal numero di nodi presenti nel cluster. Il consumo di memoria di lavoro dipende daHadoop/BigInsights e dalla con�gurazione speci�ca utilizzata, mentre il consumodi memoria di massa è predicibile. In modalità locale, invece, le prestazioni sonopiuttosto statiche anche per quanto riguarda la memoria volatile ed è quindipossibile esaminarle con facilità.

5.2 Velocità di esecuzione e consumo di memoria 167

Figura 5.1:

Page 1

positive negative neutral

positive 182 1331 50 1563

negative 55 2805 53 2913

neutral 99 1442 131 1672

336 5578 234

totale sentimentassegnato manualmente

totale sentimentassegnato automaticamente

La matrice di confusione del dataset �tutti� ottenuta tramite 2-folding, le colonnerappresentano i sentiment assegnati automaticamente e le righe i sentimentassegnati manualmente. Le barre indicano le dimensioni relative dei valori.

Figura 5.2:

Page 1

positive negative neutral

positive 39 459 40 538

negative 39 650 26 715

neutral 49 339 6 394

127 1448 72

totale sentimentassegnato manualmente

totale sentimentassegnato automaticamente

La matrice di confusione del dataset E (forum di automobilismo) ottenuta tramite2-folding, le colonne rappresentano i sentiment assegnati automaticamente e lerighe i sentiment assegnati manualmente. Le barre indicano le dimensioni relativedei valori.


5.2.1 Consumo di spazio su disco in modalità distribuita

Hadoop, e quindi BigInsights, o�re diverse serializzazioni delle coppie chiave-valore ricevute e emesse dalle istanze delle funzioni map e reduce dei vari nodi.Il framework sviluppato utilizza un formatter, ossia la componente che si occupadi estrarre le coppie < chiave, valore >dalla sequenza grezza di byte, chiamatoTextInput, che legge i �le riga per riga e fornisce coppie <LongWritable, Text >.La chiave indica la posizione della riga nel �le, a livello di byte, ed è ignorata.Il testo è trasformato in una stringa Java, che a di�erenza dell'oggetto Textè immutabile e maschera il consumo in byte dei diversi caratteri UTF8, cheviene quindi trasformata in un oggetto JSON che incapsula la tupla chiave-valoree�ettivamente usata.

Si ha un overhead dovuto alla descrizione esplicita dei campi key e value, cheè tuttavia molto basso in proporzione alle dimensioni tipiche di un messaggioestratto da un forum. Inoltre, il testo è fortemente comprimibile e BigInsightso�re un codec per la compressione, basato su LZO, proprietario di IBM, moltoperformante e splittabile, ossia in grado di decomprimere un �le a partire da unpunto qualsiasi, quindi fruibile in modalità distribuita accedendo e�cacemente adiverse posizioni di un �le in maniera casuale.

5.2.2 Consumo di memoria di lavoro da parte delle oper-azioni map/reduce locali

Le operazioni di map e reduce su oggetti JSON, in modalità locale, sono eseguitesenza nessun multithreading, per due motivi:

1. Lo scopo della modalità locale è agevolare il debugging, e uno strumentorigidamente sequenziale è molto più semplice da analizzare per l'assenza dirace conditions.

2. L'aspetto più pesante dell'elaborazione sono le operazioni di I/O, con bassalatenza, quindi l'aumento di prestazioni sarebbe risibile.

Se una fase del framework presenta sia una fase di map che una di reduce ènecessario memorizzare i dati intermedi e eseguire lo shu�e. Per non consumarela memoria di lavoro è stata implementata una tecnica molto semplice:

� Si o�re al mapper JSON un sink, che nel caso di BigInsights è un semplicewrapper a quello fornito dalla libreria, mentre in questo caso è una classede�nita dal framework

� Per ogni coppia < key, value > emessa dal mapper JSON come oggettoJSON, si calcola l'espressione hash(key) mod MAX dove MAX è il nu-mero massimo di �le tollerati in una sola cartella (nel nostro caso, con il�lesystem ext4, si può arrivare a 4 miliardi, tuttavia è preferibile tenere il

5.2 Velocità di esecuzione e consumo di memoria 169

numero basso per agevolare l'ispezione manuale) e la si usa come nome del�le temporaneo a cui viene appeso l'oggetto JSON ricevuto.

� Nella fase di reduce, si esaminano uno per uno i �le generati, sfruttandoil fatto che le tuple con la stessa chiave saranno tutte nello stesso �le,eventualmente insieme a altre tuple con la stessa chiave.

� Durante la fase reduce, i valori vengono passati al reducer man mano chevengono letti dal �le, riducendo l'overhead.

� Per maggiore e�cienza, è stata implementato un bu�er che accumula unnumero �sso di coppie emesse dal mapper e le ordina prima di scriverlenei �le temporanei. Questo ordinamento permette di scrivere in manierasequenziale i dati corrispondenti a una stessa chiave, quindi a uno stesso�le, abbattendo i tempi di seeking.

La memoria di lavoro richiesta è dunque corrispondente solo all'oggetto in inpute a quello in output, mentre il resto è salvato al volo. Ovviamente la cache hadimensioni con�gurabili e può essere portata a 0 ottenendo la scrittura immediatadei dati emessi senza consumo di memoria, al costo di una minore velocità.

Nel caso delle fasi di identi�cazione dei luoghi geogra�ci e sentiment analysisè necessario mantenere nella memoria di lavoro, di ogni nodo, l'intero database(o il modello nel caso della sentiment analysis). Come discusso nelle rispettivesezioni, le dimensioni complessive di questi dati sono ben al di sotto di quelledelle memorie moderne.

5.2.3 Importazione nel database

Il tempo per importare i messaggi classi�cati nella corrispondente tabella deldatabase, contenente solo un indice per il campo data, si è mostrato costanterispetto all'aumentare delle dimensioni del dataset. Per classi�care e importarenel database relazionale un dataset da 560000 post sono necessari 15 minuti.

Come discusso nella sezione 3.5.3 al riguardo di MongoDB, è possibile au-mentare la quantità di elementi inseriti nel database per ogni transazione aumen-tando così le prestazioni. La fase del framework che si occupa dell'esportazionetramite JDBC fa proprio questo.

Si è scelta empiricamente una soglia di 200 elementi per transazione osser-vando che, oltre questo valore, non si hanno miglioramenti. L'incremento dellavelocità dovuto a questa modi�ca è di circa il 100%, passando da 1050 a 2001tuple importate al secondo.

Naturalmente, variando l'hardware e il DBMS usato il parametro ottimalecambierà, e andrà determinato empiricamente.

Capitolo 6

Conclusioni

6.1 Estrazione dei contenuti dal web

Lo Scraper implementato ha una velocità di estrazione molto maggiore, an-che di un ordine di grandezza, delle altre soluzioni testate (hhtrack, wget eApache Nutch), è in grado di gestire siti con decine di milioni di pagine usandodell'hardware commodity.

Può esportare i dati direttamente nel formato usato dalle successive fasi dianalisi e nel �lesystem distribuito, e può essere adattato a un sito in pochi minuti,anche nel caso quest'ultimo faccia un forte uso di AJAX o abbia una strutturadelle pagine anomala.

È stata progettata e realizzata un'implementazione fortemente parallela cheutilizza solo la memoria di lavoro per mantenere lo stato dell'analisi di un sito,permettendo di abbinare a ogni singola pagina esaminata un contesto arbitrariodipendente dal contenuto delle pagine esaminate per giungere ad essa, riuscendoa esaminare siti molto grossi anche con una memoria RAM modesta, grazie auna struttura dati probabilistica, il �ltro di Bloom, che è stata implementata etestata per veri�carne le proprietà statistiche.

Con un test di HBase è stato mostrato come quest'ultimo non sia performantein un caso del genere, mentre usando un benchmark in Python è stato messoin evidenza che il programma può scalare �no a esaminare volumi di dati bensuperiori a quelli di qualsiasi sito preso in esame, tra cui erano presenti forumcon archivi di post inviati dagli utenti in un arco temporale di 8 anni.

172 Conclusioni

6.2 Elaborazione di grandi quantità di dati con un

framework basato su BigInsights sviluppato

ad hoc

Dopo aver esaminato le prestazioni e le funzioni di MongoDB è stato sceltoHadoop come strumento per l'elaborazione in batch di dati non strutturati, per lasua capacità di scalare linearmente all'aumento del numero dei nodi nel cluster,con una buona tolleranza ai guasti.

Essendo però il testing delle applicazioni su Hadoop estremamente complesso,così come il concatenamento di più operazioni Map/Reduce è stata sfruttata l'as-trazione propria della de�nizione di queste due fasi per poterle incapsulare inoperazioni eseguite in un solo nodo sul �lesystem locale così come in un clusterHadoop, richiamate da uno script JavaScript che permette una grande �essibil-ità e può essere modi�cato senza eseguire un on eroso redeploy dell'applicazione.De�nendo alcuni operatori Map Reduce generici, chiamati fasi, è stato possibileimplementare un generatore di modelli per la sentiment analysis e un relativoclassi�catore basato sul teorema di Bayes, un identi�catore di nomi di luoghi ge-ogra�ci, un generatore di sintesi (dei �drill up� OLAP) dei dati, un'esportazionedei dati stessi in un database relazionale, il �ltraggio in base a vari criteri, lamanipolazione arbitraria secondo script de�niti dall'utente, la generazione di unostemmer euristico e altre operazioni. Il framework si è mostrato abbastanza�essibile da permettere di implementare l'operazione di K-folding al modelloper la sentiment analysis generando direttamente un report della distribuzionedi valori dell'accuratezza dei risultati utilizzando due parti distinte del modelloscelte casualmente per e�ettuare il training e la validazione.

È stato così possibile esaminare velocemente i diversi aspetti dell'analisi deidati con uno sviluppo agile impossibile con Hadoop, senza perdere la possibilitàdi esportare l'intera applicazione, senza modi�che, su un cluster BigInsights.

6.3 Sentiment Analysis con stemming euristico

In base alle pubblicazioni scienti�che [27, 13, 34, 12] esaminate, il modello naïvedi Bayes è uno dei più accurati nel riconoscere il sentimento dell'autore di untesto, ed è parallelizzabile facilmente, soprattutto usando il framework che èstato sviluppato. Dopo aver esaminato l'unica soluzione che è considerata daglistudi citati come più accurata, la SVM, e aver provato a implementarla usandoil framework Apache Mahout, è stato determinato che non è pratico addestrareun modello di questo tipo in parallelo.

Sono stati esaminati diversi metodi per aumentare l'accuratezza, in parti-colare il vettore dei token presenti in una frase è stato arricchito inserendovi

6.4 Rappresentazione e�cace dei dati 173

anche l'unione di termini vicini, in modo da modellizzare anche strutture comele negazioni, i superlativi e i termini composti.

Per gestire la modi�ca alla morfologia delle parole propria dell'italiano, dell'in-glese e delle lingue agglutinanti, è stato implementato uno stemmer che utilizza isu�ssi più comuni all'interno di un grosso database di 40 milioni di post presi dainternet, analizzato sfruttando le tecniche Big Data, per estrarre le radici delleparole e poter riconoscere correlazioni tra le stesse e i sentimenti da ricercare.

In questo modo è stato possibile estrarre le radici anche nel caso di modi�chemorfologiche che non fanno parte dell'italiano formale (per esempio un classicostemmer basato su regole scritte a mano da un linguista non identi�cherebbele radici comuni di �bello�, �belloooo� e �belloXD� ma solo di termini come�bellissimo�). In alcuni casi lo stemmer aumenta l'accuratezza della classi�-cazione, il framework permette di determinare questo valore al variare del fattoredi aggregazione e dell'utilizzo dello stemming.

6.4 Rappresentazione e�cace dei dati

È stata sviluppata un'applicazione web molto user-friendly che permette all'u-tente di navigare tra i dati estraendo dei messaggi casuali, visualizzando is-togrammi dell'andamento del sentiment in diverse scale temporali, con o senzadrill up e esaminando sia i valori relativi dei sentiment che i volumi dei mes-saggi, nonché visualizzare mappe termiche che danno un colpo d'occhio sulladistribuzione geogra�ca delle citazioni di nomi di luoghi.

La gestione del data cube è molto semplice, permettendo all'utente un �ltrag-gio immediato in base all'ora e alla data, al luogo (indicato sia con i nomi dellelocalità che con rettangoli di coordinate GPS). La base dati per l'analisi OLAPè relazionale ma è implementata in maniera tale da poter essere distribuita confacilità[15], inoltre l'interfaccia stessa fornisce il codice necessario a replicare leoperazioni di slicing direttamente nell'elaborazione distribuita con Map/Reduce,in modo da mantenere la scalabilità necessaria all'elaborazione di grandi quan-tità di dati e contemporaneamente non perdere reattività nella manipolazione deldata cube, permettendo all'utente di esplorare e selezionare i dati con facilità.

6.5 Sviluppi futuri

6.5.1 Estrazione delle pagine web

Lo scraper implementato fa a�damento su un codice fornito dall'utente per es-trarre le componenti dalle pagine (date, nomi utente, messaggi, titoli). Nonos-tante la scrittura di questo codice di solito consista solo nell'esaminare la paginacon strumenti come �rebug per decidere i selettori CSS da usare, potrebbe essereutile implementare uno strumento che stabilisca in base a delle euristiche quali

174 Conclusioni

sono i selettori più appropriati, in modo che l'utente debba solo approvare laselezione e correggerla se necessario.

Inoltre, l'operazione di scraping è intrinsecamente soggetta a forti possibilitàdi errore: un sito può rispondere di punto in bianco in maniera scorretta, al-cune pagine possono essere formattate male, la connessione può interrompersi:è necessario fornire allo scraper un'interfaccia per il monitoraggio che permettaall'utente di scoprire e gestire gli errori velocemente, onde evitare la frustrazionedi un'esecuzione portata avanti per ore senza risultati.

In corso di tesi è stato implementato un altro scraper, basato su un'architet-tura ad eventi e trigger piuttosto che su liste di elementi esaminati e pendenti, chenon è stato descritto per via del suo scarso parallelismo e della mancanza di in-novazioni tecniche implementate, ma potrebbe essere utile per via della maggiorefacilità di monitoraggio.

6.5.2 Sentiment Analysis

Poiché l'accuratezza del motore di sentiment analysis si è mostrata maggiore,prevedibilmente, nel caso di messaggi su argomenti ben circoscritti, potrebbeessere utile sviluppare un classi�catore ad albero, costituito da più modelli perla sentiment analysis relativi a diversi argomenti e registri e un classi�catore perstabilire quale dei modelli utilizzare, oppure quale peso dare a ognuno.

Un'altra estensione possibile del motore per la sentiment analysis è utilizzarela classi�cazione dei messaggi per aggiungere elementi al modello: incremen-tando il dataset di messaggi classi�cati manualmente con i messaggi classi�catiautomaticamente, costruendo il modello e eventualmente ripetendo l'operazione.Questa procedura potrebbe aumentare l'accuratezza, ma è fortemente espostaal biasing. Per mitigare questo rischio, sarebbe necessario usare una parte deldataset per costruire un modello indipendente, da usare a ogni ciclo di espan-sione e ricostruzione del modello per stabilire se l'accuratezza stia e�ettivamenteaumentando.

Gli approcci più simbolici e formali, come le grammatiche e le ontologie, sonostati evitati in favore dei metodi euristici, sia per la mancanza di tempo che per laletteratura scienti�ca che indica una maggiore e�cacia di questi ultimi. Tuttavia,soprattutto nel caso dei messaggi brevi e quindi con una sintassi più semplice,potrebbe risultare pro�cuo a�ancare al modello bayesiano delle grammatiche oaltri strumenti formali.

6.5.3 Analisi OLAP

Lo strumento per l'analisi dei datacube sviluppato, pur fornendo un supporto alleoperazioni essenziali sui dati e un'interfaccia gra�ca semplice e intuitiva, mancadi alcune funzionalità che potrebbero essere utili:

6.5 Sviluppi futuri 175

� Contestualizzazione dei messaggi estratti: di fronte a un messaggio, l'u-tente potrebbe voler sapere in che contesto è stato scritto, quali risposte haavuto e in risposta a che elemento (notizia, messaggio, video su YouTube,etc.) è stato prodotto. L'applicazione dovrebbe permettere di visualizzarequeste informazioni in maniera immediata, per esempio portando l'utentealla pagina da cui è stato estratto il messaggio.

� Esportazione per l'uso in altri strumenti: l'utente potrebbe voler esportare idati in un foglio di calcolo, un �le MATLAB/Octave, un �le CSV o altri. Ilsistema software dovrebbe fornire i datacube e i gra�ci estratti nei formatipiù comuni.

� Correzione del modello: se l'utente visualizza dei messaggi con un sentimenterrato, potrebbe trovare utile segnalare automaticamente l'errore a�nchéil dato sia aggiunto al dataset degli elementi classi�cati manualmente au-mentando l'accuratezza alle successive classi�cazioni.

176 Conclusioni

Bibliogra�a

178 Conclusioni

Bibliogra�a

[1] http://api.mongodb.org/java/current/com/mongodb/gridfs/GridFSInputFile.html.

[2] http://forum.accademiadellacrusca.it/forum_7/interventi/2647.shtml.

[3] http://letitcrash.com/post/26626939256/status-report-of-akka-cluster.

[4] https://en.wikipedia.org/w/index.php?title=ACID&oldid=517270334.

[5] https://lucene.apache.org/core/.

[6] https://wiki.apache.org/cassandra/FAQ#iter_world.

[7] http://www.jcmit.com/memoryprice.htm.

[8] http://www.mongodb.org/display/DOCS/MapReduce.

[9] http://www.tiobe.com/index.php/paperinfo/tpci/Java.html.

[10] Gpfs 5.0-3: Concepts, planning, and installation guide. 2012.

[11] Robert M. French Jon Oberlander Alastair J. Gill, Darren Gergle. Emotionrating from short blog texts. 2008.

[12] Xiaojin Zhu Andrew B. Goldberg. Seeing stars when there aren't many stars:graph-based semi-supervised learning for sentiment categorization. 2006.

[13] Benjamin Snyder; Regina Barzilay. Multiple aspect ranking using the goodgrief algorithm. 2007.

[14] Richard J Bolton and David J Hand. Statistical fraud detection: A review.Statistical Science, pages 235�249, 2002.

[15] Ceryen Tan Samuel R. Madden Christopher Yang, Christine Yen. Os-prey: Implementing mapreduce-style fault tolerance in a shared-nothingdistributed database.

http://api.mongodb.org/java/current/com/mongodb/gridfs/GridFSInputFile.html

http://api.mongodb.org/java/current/com/mongodb/gridfs/GridFSInputFile.html

http://forum.accademiadellacrusca.it/forum_7/interventi/2647.shtml

http://forum.accademiadellacrusca.it/forum_7/interventi/2647.shtml

http://letitcrash.com/post/26626939256/status-report-of-akka-cluster

http://letitcrash.com/post/26626939256/status-report-of-akka-cluster

https://en.wikipedia.org/w/index.php?title=ACID&oldid=517270334

https://en.wikipedia.org/w/index.php?title=ACID&oldid=517270334

https://lucene.apache.org/core/

https://wiki.apache.org/cassandra/FAQ#iter_world

http://www.jcmit.com/memoryprice.htm

http://www.mongodb.org/display/DOCS/MapReduce

http://www.tiobe.com/index.php/paperinfo/tpci/Java.html

180 BIBLIOGRAFIA

[16] Hamish Cunningham, Diana Maynard, Kalina Bontcheva, and ValentinTablan. GATE: A Framework and Graphical Development Environment forRobust NLP Tools and Applications. In Proceedings of the 40th AnniversaryMeeting of the Association for Computational Linguistics (ACL'02), 2002.

[17] L. Dolamic and J. Savoy. When stopword lists make the di�erence. Journalof the American Society for Information Science and Technology, 61(1):200�203, 2009.

[18] Je�rey Dean e Sanjay Ghemawat. Mapreduce: Simpli�ed data process-ing on large clusters. Sixth Symposium on Operating System Design andImplementation, 2004.

[19] ROBERT FORTNER. http://robertfortner.posterous.com/

the-unrecognized-death-of-speech-recognition.

[20] Owen O �Malley from Yahoo! Terabyte sort on apache hadoop. 2008.

[21] Maarten de Rijke Gilad Mishne. Capturing global mood levels using blogposts. 2006.

[22] Chris Harrison. Faster progress bars: Manipulating perceived duration withvisual augmentations.

[23] D.L. Ho�man and T.P. Novak. The impact of online product reviewcharacteristics on consumer preferences, 2013.

[24] Riccardo Tasso Jacopo Farina and David Laniado. Automatically assigningwikipedia articles to macro-categories. page 2, 2011.

[25] Vishwanath Kashi Venkatesh and Nachiappan Nagappan. Characterizingcloud computing hardware reliability. page 3, 2010.

[26] R.T.W. Lo, B. He, and I. Ounis. Automatically building a stopword list foran information retrieval system. Proc. of DIR, 5, 2005.

[27] Georgios Paltoglou Di Cai Mike Thelwall, Kevan Buckley. Sentimentstrength detection in short informal text. 2010.

[28] Gordon E. Moore. Cramming more components onto integrated circuits.Electronics Magazine, 1965.

[29] Seth Gilbert Nancy Lynch. Brewer's conjecture and the feasibility of consis-tent, available, partition-tolerant web services. ACM SIGACT News, Volume33, seconda edizione, pages 51�59, 2002.

http://robertfortner.posterous.com/the-unrecognized-death-of-speech-recognition

http://robertfortner.posterous.com/the-unrecognized-death-of-speech-recognition

BIBLIOGRAFIA 181

[30] Tetsuya Nasukawa and Jeonghee Yi. Sentiment analysis: capturing favor-ability using natural language processing. In Proceedings of the 2nd inter-national conference on Knowledge capture, K-CAP '03, pages 70�77, NewYork, NY, USA, 2003. ACM.

[31] OpenO�ce.org. Microsoft compound document format. http://sc.

openoffice.org/compdocfileformat.pdf, 2006.

[32] Bo Pang and Lillian Lee. Seeing stars: Exploiting class relationships forsentiment categorization with respect to rating scales. In Proceedings ofACL, pages 115�124, 2005.

[33] Bo Pang, Lillian Lee, and Shivakumar Vaithyanathan. Thumbs up? sen-timent classi�cation using machine learning techniques. pages 79�86,2002.

[34] Ana GarcÃa-Serrano Rodrigo Agerri. Q-wordnet: Extracting polarity fromwordnet senses. 2010.

[35] Valitutti Strapparava. Wordnet-a�ect: an a�ective extension of wordnet.2004.

[36] Jie Tang, Jimeng Sun, Chi Wang, and Zi Yang. Social in�uence analysis inlarge-scale networks. In Proceedings of the 15th ACM SIGKDD internationalconference on Knowledge discovery and data mining, pages 807�816. ACM,2009.

[37] Peter Turney. Thumbs up or thumbs down? semantic orientation applied tounsupervised classi�cation of reviews. 2002.

[38] Autori vari. Xhtml�1.0 the extensible hypertext markup language. 2000-2002.

http://sc.openoffice.org/compdocfileformat.pdf

http://sc.openoffice.org/compdocfileformat.pdf

Appendice A - errori e problemi

riscontrati

La possibilità di riscontrare anomalie e errori nel comportamento degli strumentiutilizzati, o della scarsità della documentazione, potrebbe non sembrare un prob-lema rilevante dal punto di vista dei risultati. Eppure, una funzione di un sistemasoftware che non è applicabile come desiderato per via di un difetto è assimilabilea una funzione totalmente assente, qualora il difetto sia tale da impedirne l'usoe�cace.

In altri casi, la mancanza di documentazione relativa all'uso di un'appli-cazione, soprattutto quando accompagnata da una intricata logica della stessa,potrebbe renderne l'uso così complesso e costoso da fare lievitare i costi dell'interasoluzione.

Pertanto, in questa appendice vengono segnalati i maggiori errori e problemiriscontrati nell'uso dei sistemi software citati, o viceversa i casi più notevoli difunzionamento lineare e ben documentato.

Lucene

L'installazione di Lucene si è dimostrata banale, essenzialmente è un �le jar cheviene integrato direttamente nelle applicazioni Java. La fondazione Apache for-nisce una guida introduttiva che mostra i concetti di base, al termine della qualesi possiedono le basi teoriche per capire e contestualizzare le singole interfacce egli strumenti messi a disposizione dalla libreria e documentati individualmente.

Nonostante esistano correntemente due versioni di largo utilizzo, la 3 e la 4,nettamente diverse e incompatibili tra loro, è possibile trovare documentazioneper entrambe e quasi sempre viene indicata la versione di riferimento. Luceneinoltre presenta dei meccanismi per indicare le versioni anche nel codice, fornendouna buona retrocompatibilità e segnalando gli errori chiaramente qualora sianocausati da due versioni diverse dell'applicazione.

184 BIBLIOGRAFIA

UIMA

UIMA presenta allo stato attuale una carenza di documentazione. L'architetturaè piuttosto complessa dal punto di vista concettuale, oltre che tecnico, e una voltacompresi i concetti di base, come il CAS, è di�cile determinare quale sia la loroimplementazione pratica.

La poca documentazione esistente è frammentata sia in diverse sezioni del sitodel progetto che in pagine di documentazione di altri siti, come quello dell'IDE1

Eclipse e della fondazione Apache.Inoltre, la creazione degli annotatori ne richiede una corposa descrizione in

XML, che viene poi abbinata all'e�ettivo codice dell'annotatore tramite uno plu-gin2 di Eclipse, che richiede a sua volta dei plugin usati internamente e unaversione speci�ca del programma, la 3.5. Al momento pare che non esista unmodo di eseguire la stessa operazione senza l'IDE.

MongoDB

6.5.3.1 Test di MongoDB

Per le sue caratteristiche, MongoDB si pone come una possibile alternativa allostack di soluzioni Hadoop, quindi è stato testato con un'operazione di prova perdeterminarne le capacità.

L'operazione consiste nell'indicizzazione e nel successivo recupero di infor-mazioni da un dump di en.wiktionary3. Il dump, scaricabile direttamente dalsito della fondazione Wikimedia4, è un �le XML dalle dimensioni di 2.8 GB checontiene 3.1 milioni di articoli e molte pagine di discussione o ausiliarie. Ognivoce rappresenta una parola che può avere diversi signi�cati in più lingue ed èdescritta testualmente e con dei template. I template sono dei blocchi di codice inlinguaggio MediaWiki che de�niscono dei contenuti frequenti adattati alle singolepagine con dei parametri. Ad esempio alla pagina links è presente il template{{plural of|link}} che indica che questa parola è un plurale e genera il testo �1.Plural form of link.�.

Poiché questo �le è relativamente grosso, non strutturato (anche se è un �leXML, la struttura interna de�nisce le singole pagine e dei metadati molto generici,non il loro contenuto) e richiederà elaborazioni non note a priori, è un buon casod'uso per un utilizzo in ambito Big Data.

1Integrated Development Environment, un programma in grado di gestire e integrare più fasidello sviluppo di un'applicazione

2Estensione di un programma prodotta generalmente da terze parti3https://en.wiktionary.org/wiki/Wiktionary:Main_Page4http://dumps.wikimedia.org/backup-index.html

https://en.wiktionary.org/wiki/Wiktionary:Main_Page

http://dumps.wikimedia.org/backup-index.html

BIBLIOGRAFIA 185

Installazione e con�gurazione L'installazione di MongoDB si rivela estrema-mente semplice e user friendly: su CentOS basta aggiungere il repository di 10gene poi installare i pacchetti con il comando yum, che manterrà gli aggiornamentie permetterà di disinstallarlo correttamente come qualsiasi altro pacchetto. Peraltri sistemi i cui gestori di pacchetti non sono supportati o per Windows esistonodegli installer speci�ci o delle versioni standalone che sono eseguite direttamentesenza installazione.

L'avvio e la con�gurazione dell'esecuzione automatica di Mongo consistono indue chiari comandi indicati nella procedura passo a passo 5, e in circa un quartod'ora il database è pronto e fornisce, out of the box, il �lesystem GridFS, la possi-bilità di e�ettuare lo sharding e una CLI. Sono disponibili delle shell gra�che siaweb che standalone, ma l'installazione di una interfaccia web si mostra parados-salmente più laboriosa dell'installazione del database stesso per via delle dipen-denze (è necessario installare Apache con PHP oppure Django) mentre un'appli-cazione Java chiamata Umongo si mostra molto semplice e funzionale ma ancheinstabile, infatti nelle prime prove si è bloccata tentando di mostrare i risultatidelle query più grossi. Utilizzo quindi la shell di base che è ben documentata.

Importazione del �le XML Bisogna quindi inserire il contenuto del �le XMLin una collezione, ed emerge un primo problema, ossia l'assenza di soluzioni diETL o importazione per MongoDB, a parte l'esportazione e l'importazione inJSON puro principalmente a scopo di backup o trasferimento tra istanze, mentreper Hadoop esistono Flume che permette di importare da altri database e la CLIche permette di importare intere cartelle dal �lesystem locale a HDFS. Esiste peròil comando mongo�les che gestisce GridFS e permette, con l'opzione put, di cari-care un �le. Applicandolo però si ottiene solo il messaggio connected to: 127.0.0.1e dopo qualche minuto un errore che indica che lo spazio è esaurito:

Thu Oct 25 14 : 31 : 14 User Asse r t i on :16428 : Error s t o r i n g GridFS chunk f o r f i l e : enwikt ionary .

xml ,e r r o r : Can ' t take a wr i t e l ock whi l e out o f d i sk space

In realtà lo spazio su disco è presente, e provando a caricare �le di pochiKB ottengo lo stesso errore. Una ricerca su internet mostra che esistono deicomandi come mongod −−repair per ripristinare il database in caso di anomaliedel genere, ma senza e�etto. Riavviando il database l'errore non si ripresenta macomunque non è possibile caricare il �le perché manca lo spazio, infatti MongoDBtenta di allocare nuovi �le vuoti per prepararsi in anticipo all'inserimento rapidodi nuovi dati, quindi richiede molto più spazio di quello necessario a memorizzareil �le in sé.

5http://docs.mongodb.org/manual/tutorial/install-mongodb-on-redhat-centos-or-fedora-linux/

http://docs.mongodb.org/manual/tutorial/install-mongodb-on-redhat-centos-or-fedora-linux/

186 BIBLIOGRAFIA

Installando Mongo su un altro computer con maggiore capienza sono riuscitoa caricare tutto il �le.

Bisogna dunque processarne il contenuto usando le query di MongoDB, possi-bilmente la MapReduce, ma non esistono metodi chiari per accedere ai �le mem-orizzati in GridFS dalle query, infatti dalla shell sono visibili solo la collezionetest.�les che contiene solo un documento con i metadati del �le appena caricato, etest.chunk, che è vuota. Le API Java permettono di leggere i �le e ottenere un In-putStream, che può essere gestito tramite un parser SAX, che è un parser a eventie quindi capace di gestire documenti di dimensioni arbitrarie che sarebbero impos-sibili da manipolare con un parser DOM, per interpretare il codice XML e quindiinserire, per ogni pagina, un documento a sé nella collezione wiktionaryArticlescreata ad hoc.

La scrittura del programma in Java risulta estremamente semplice, infat-ti le API di Mongo sono molto ben documentate e intuitive, e in meno di 20minuti partendo da zero il programma è scritto e sta inserendo i documenti neldatabase. Intanto, usando la shell di Mongo veri�co che sia possibile accedere aldatabase e controllo la presenza dei documenti già inseriti nella collection e condb.wiktionaryArticles.count() veri�co la quantità di articoli inseriti. Il tempo perl'importazione del �le XML è di circa due ore per 5 milioni di documenti6, ossiaun throughput di 815KB/s se si considera che anche il �le in ingresso è estrattodal database. Non è una prestazione notevole, anche se in questa fase non sonostati fatti confronti con altre tecnologie. Come vedremo più avanti, HBase sidimostra ancora più lento in caso di forte concorrenza qualora non sia possibileapplicare lock a grana �ne.

Una possibile strategia per migliorare i risultati è non inserire i documenti unoalla volta ma a blocchi, accumulandoli temporaneamente in un array e inserendoliinsieme al suo riempimento. Questa strategia è molto comune, perché permettedi diminuire l'overhead causato dal locking, dall'apertura di una transazione (chein Mongo però non esiste) e dalla scrittura e�ettiva su disco.

Dunque, il programma viene eseguito più volte nella stessa macchina, can-cellando il contenuto del database ogni volta, veri�cando come varia il tempo diesecuzione in base alla dimensione del blocco.

I risultati sono indicati in tabella 3.1 e la rappresentazione gra�ca (Figura3.2) rende evidente come un valore ottimale per questo caso sia 1000 elementi,e la variazione massima sia 6351−4843

4843= 31%. È interessante osservare come le

prestazioni calino se si sceglie un valore troppo alto: se con un valore troppo bassosi subisce l'overhead per le operazioni legate al commit, per un valore troppo altoprobabilmente entrano in azione dei meccanismi di caching o di scrittura su discodei dati in attesa (si consideri che un documento può occupare diversi KB), manon è stato possibile trovare spiegazioni del fenomeno.

6La cifra di 3.1 milioni di articoli si riferisce alle pagine di contenuto e�ettivo, ma il dumpcontiene anche pagine di discussione, pagine interne al progetto e pagine utente.

BIBLIOGRAFIA 187

BigInsights e Hadoop

BigInsights è un software progettato per essere usato da sviluppatori già com-petenti nello sviluppo di applicazioni con la tecnologia Hadoop, al punto chela documentazione della piattaforma non analizza questo aspetto. La descrizionedella procedura di installazione è chiara e semplice, mentre le informazioni relativeai singoli strumenti o�erti sono frammentate ed è di�cile avere una panoramicadelle funzionalità.

6.5.4 Strumenti o�erti e procedura di installazione

Il vantaggio più evidente di BigInsights è la possibilità di installare un intero stackdi soluzioni usando un solo programma per l'installazione con una con�gurazioneminima.

Assumendo di avere un sistema Linux con una JVM operativa, l'installazionedi Hadoop di per sé richiede solo di scaricare e decomprimere il �le del program-ma, modi�care un �le XML per indicare la modalità di esecuzione e gli eventualiindirizzi egli altri nodi, e in alcune distribuzioni più recenti è disponibile diret-tamente nei repository (nonostante sia raccomandabile scaricare manualmente losnapshot più recente).

I problemi si riscontrano quando si cerca di installare lo stack, che prevede,in ordine:

1. ZooKeeper

2. Oozie

3. HBase

4. JAQL

5. Hive

6. Flume

a cui si aggiungono altri strumenti proprietari di IBM come Streams, la consoleWeb basata su WebSphere e gli strumenti per la visualizzazione di BigSheets.

L'installazione di Oozie è una procedura abbastanza complicata, in particolareper l'interfaccia web che richiede addirittura l'installazione a parte di un serverTomcat e delle librerie ExtJS. Oozie è, secondo il sito7 �tested with 0.20.205. Butcompatible with Hadoop 0.20.x and 1.0.0�. Il problema dell'incompatibilità fraversioni è costante nella con�gurazione dello stack. Per esempio, la breve guidaall'installazione di Oozie indica di eseguire lo script oozie-setup.sh che però non

7https://oozie.apache.org/docs/3.1.3-incubating/DG_QuickStart.html

https://oozie.apache.org/docs/3.1.3-incubating/DG_QuickStart.html

188 BIBLIOGRAFIA

risulta presente nell'archivio; provando a eseguire la build tramite Maven, pas-saggio non indicato esplicitamente ma probabilmente necessario data la presenzadel �le pom.xml e considerando l'uso intensivo di questo programma da partedella ASF, con continui problemi di dipendenze irrisolte, ho ottenuto un erroredovuto, forse, al proxy aziendale:

[ERROR] Error r e s o l v i n g ve r s i on f o r p lug in ' org . codehaus .mojo : f indbugs−maven−plugin ' from the r e p o s i t o r i e s [l o c a l (/home/ har i / .m2/ r epo s i t o r y ) , r e p o s i t o r y . c loudera .com ( https : // r epo s i t o r y . c l oudera . com/ a r t i f a c t o r y /ext−r e l e a s e−l o c a l ) , c e n t r a l ( http :// repo . maven . apache . org /maven2 ) ] : Plugin not found in any p lug in r epo s i t o r y −>[ Help 1 ]

Maven non usa le impostazioni del proxy fornite dal sistema operativo e usateda quasi tutti gli altri programmi; richiede invece, secondo la documentazione,di modi�care un �le xml che però non esiste nel sistema. Creandolo e mod-i�candolo all'occorrenza comunque il problema è rimasto. Addirittura, il �ledi con�gurazione di esempio riportato nella documentazione è errato e è statonecessario eliminarne delle parti per impostare il proxy.

Esistono due versioni mainstream di Maven, la 2 e la 3, incompatibili tradi loro; non è in genere indicato nelle guide all'installazione quale delle due va-da usata. Nel caso dell'errore mostrato, il problema pare noto (http://jira.codehaus.org/browse/MFINDBUGS-126) da circa due anni ma stranamente ir-risolto nel �le pom.xml fornito con Oozie. Modi�cando tale �le per gestire l'er-rore, comunque ho ottenuto un altro errore di cui non ho trovato riscontri sulweb.

JAQL è più user-friendly, avendo una logica di installazione simile ad Hadoop:si decomprime il �le, si imposta la variabile JAQL_HOME per puntare allo stessoe si esegue la shell jaql in $JAQL_HOME/bin/jaqlshell.

Tale shell utilizzerà i valori delle variabili d'ambiente JAVA_HOME eHADOOP_HOMEper eseguire le operazioni in modalità distribuita. Purtroppo anche JAQL pre-senta problemi di compatibilità con le versioni, infatti non supporta Hadoop 1.1e tantomeno Hadoop 2.0 che come anticipato o�re un �lesystem distribuito senzasingle point of failure e altri notevoli miglioramenti, e sarebbe molto interessante.

Anche con Hadoop 1.0, comunque, si ottengono degli errori dovuti alla man-canza di alcune librerie per il logging, dipendenza non indicata nella guida al-l'installazione. L'aggiunta delle librerie al classpath Java, per renderle visibili alcontesto di esecuzione, non è triviale poiché JAQL a sua volta viene eseguito dauno script bash che compone al volo il comando con cui chiamare la JVM, checomunque contiene le righe

# add user−de f ined j a r s to c l a s s p a t hJAQLSHELL_CLASSPATH=""

http://jira.codehaus.org/browse/MFINDBUGS-126

http://jira.codehaus.org/browse/MFINDBUGS-126

BIBLIOGRAFIA 189

per aggiungerlo.

L'installazione di HBase non ha dato errori, ed è stato possibile vedere unashell di HBase in pochi minuti. Purtroppo, il primo tentativo di creare una tabellaè fallito con l'errore

13/02/05 12 : 37 : 23 ERROR c l i e n t .HConnectionManager$HConnectionImplementation : Check thevalue con f i gu r ed in ' zookeeper . znode . parent ' . There

could be a mismatch with the one con f i gu r ed in themaster .

che è causato da ZooKeeper, il quale sta venendo eseguito in modalità singlenode ma cerca comunque gli altri nodi, nonostante i �le di con�gurazione, generatiin base alla guida, non ne facciano menzione e al precedente lancio di ZooKeeperquesto non abbia riportato errori.

Cercando su internet ho trovato dei comandi che permettono di ricaricare lacon�gurazione di ZooKeeper e HBase, e dopo averli eseguiti ottengo un nuovoerrore, un'eccezione interna a HBase con uno stack di oltre 100 righe, che nonriesce a eseguire del codice JRuby, senza riscontri né soluzioni individuabili sulweb.

Quelli riportati sono solo dei piccoli esempi della quantità di problemi, errori,anomalie e crash incontrati nei tentativi di installare i programmi aggiuntivi aHadoop.

Poiché il problema dell'incompatibilità tra le versioni dei diversi programmi èmolto sentito, la fondazione Apache stessa ha avviato un progetto chiamato Big-Top8, che mira a compilare, installare e testare ciclicamente e automaticamentevarie combinazioni delle versioni dei vari software. Non è comunque chiaro qualisiano i risultati. Il progetto fornisce anche delle immagini di macchine virtualicomplete contenenti, almeno in parte, lo stack. Non è stato possibile determinareilIl contenuto e�ettivo delle immagini, e al momento questo aspetto del progettoè riportato come �disabled�.

Dopo aver scaricato e montato l'immagine, il sistema operativo si presentacome CentOS 6.3, nonostante la descrizione riportasse Fedora 16 9, e richiededelle credenziali che non sono riportate e non è stato possibile recuperare.

Mondando l'immagine virtuale come disco di un altro sistema e usando ilcomando chroot e quindi passwd si è tolta la password, e si è visto che l'immaginedella macchina virtuale contiene semplicemente hadoop, senza, per quanto è statopossibile esaminarla, altri software dello stack.

8https://bigtop.apache.org/9http: // bigtop01. cloudera. org: 8080/ job/ Bigtop-VM-matrix/ BR= trunk,KIND=

virtualbox,label= fedora16/

https://bigtop.apache.org/

http://bigtop01.cloudera.org:8080/job/Bigtop-VM-matrix/BR=trunk,KIND=virtualbox,label=fedora16/

http://bigtop01.cloudera.org:8080/job/Bigtop-VM-matrix/BR=trunk,KIND=virtualbox,label=fedora16/

190 BIBLIOGRAFIA

6.5.5 Gestione della piattaforma

Una volta installato BigInsights, la sua gestione avviene principalmente in duemodi: la console web e il plug-in di Eclipse.

Il plug-in di Eclipse comunica con BigInsights tramite l'interfaccia REST, chepermette di eseguire il caricamento, il deploy e il monitoraggio delle applicazioni,nonché la manipolazione del contenuto di HDFS. Oltre a questa interfaccia èpossibile accedere alle shell di Hadoop, HBase, HIVE e JAQL da linea di comando,usando SSH.

L'interfaccia è piuttosto user-friendly, tuttavia presenta alcune piccole stranezze.Il plugin di Eclipse genera di tanto in tanto degli errori non de�niti nel moduloXPCOM, accompagnati da un codice numerico poco indicativo. Aggiornando ilcomponente dalla versione 1.4 alla 2.0, uscita nel corso dello sviluppo, gli errorisono diminuiti signi�cativamente, anche se non del tutto.

La console fa un uso intenso di AJAX, e questo rende di�cile rilevare glierrori: se per esempiosi cerca di eliminare un �le già inesistente, perché elimi-nato concorrentemente da un'altra istanza della console o da un'applicazione inesecuzione, non si ottengono messaggi d'errore ma la pagina rimane in attesa dirisposte dal server per un certo tempo prima di generare un messaggio d'errore.

Allo stesso modo, in caso di errore di una componente, spesso è di�cile rilevarenon solo il problema ma anche il fatto che esista.

Per esempio, durante lo sviluppo è capitato che fosse caricata un'applicazionesenza una libreria. Lanciando tale applicazione in esecuzione dall'interfaccia webnon si ottenevano messaggi d'errore espliciti, ma l'indicazione �running applica-tion�, anziché durare pochi secondi come al solito prima di ottenere lo stato delleoperazioni, rimaneva �ssa richiedendo il riavvio dell'intera piattaforma.

I log di errore dell'applicazione non venivano generati, segno che l'errore eraprecedente all'esecuzione.

Dopo vari tentativi è stato trovato il log di Oozie, separato dai log dell'ap-plicazione, che segnalava un'eccezione. Tale eccezione causava la chiusura diOozie rendendo quindi impossibile mandare in esecuzione altre applicazioni senzariavviare completamente la piattaforma.

Framework Play

Al momento esistono due release principali di Play, la 1 e la 2. La versione 2.1 è diprossima uscita. Una prova della versione 2.0 ha mostrato come il framework siae�ettivamente molto facile da installare e con�gurare, ma provando a sviluppareun'applicazione di prova sono emersi tre problemi:

1. I messaggi di errore sono totalmente incomprensibili. Come osservato prece-dentemente, questo è un problema intrinseco di Scala e del suo metodo dicompilazione, probabilmente destinato a cambiare in futuro.

BIBLIOGRAFIA 191

2. Si veri�cano dei bug, che secondo lo stack delle eccezioni sono interni alframework e quindi non correggibili facilmente da parte mia, vista la comp-lessità del framework che fa un intenso uso del multithreading e degli attoridi Scala

3. Estendere il programma è laborioso, perché il meccanismo di deploy tramiteSBT rende poco chiaro come aggiungere delle librerie senza che venganoperse in fase di aggiornamento.

Inoltre, il parallelismo e la facilità di deploy non sono requisiti primari dell'appli-cazione, quindi gli inconvenienti derivanti dall'uso di SBT e del multithreadingnon sono bilanciati dai vantaggi.

Il fatto che gli errori siano ingestibili rende un azzardo usare il framework,perché si potrebbero veri�care in una fase avanzata dello sviluppo, bloccandolo.

In questo momento, la prima versione di Play è ancora molto utilizzata, men-tre lo sviluppo si sta concentrando sulla seconda, quindi in un caso si ha unframework stabile ma destinato all'obsolescenza in brevi tempi, e nell'altro unframework al momento piuttosto instabile.

Apache Mahout

Apache Mahout è un progetto molto giovane e in fase di rapido sviluppo, chemira a fornire il supporto per numerosi algoritmi di Machine Learning in ambitodistribuito, integrandosi con Hadoop. Tuttavia testandolo sono sorti numerosiproblemi pratici:

� L'installazione è molto laboriosa, anche se in teoria l'utilizzo di Maven10

la dovrebbe rendere automatica. Il framework occupa più di 100 MB, pervia delle numerose dipendenze tra cui Lucene e innumerevoli librerie spessodi�cili da reperire o i cui repository sono spesso o�ine. Pur riuscendoin�ne a installarlo, il suo deploy su BigInsights (o su un server in generale)rimane un'incognita.

� Il programma è estremamente complicato, ogni funzione richiede numerosiparametri e i formati di input e output sono propri di Mahout, senza che cisiano, a quanto è stato possibile osservare, degli helpers per la loro gestione.

� La documentazione è pressoché inesistente. La JavaDoc è molto scarnae assume una conoscenza approfondita da parte dello sviluppatore sia deidettagli algebrici delle tecniche adottate che degli aspetti implementativi.Esiste una wiki che però si limita a segnalare l'esistenza di certe funzioni

10Uno strumento di build, ossia un programma che automatizza lo scaricamento e lacon�gurazione delle dipendenze di un programma e la sua compilazione

192 BIBLIOGRAFIA

senza spiegarne l'utilizzo né fornire degli esempi. Un libro, Mahout in ac-tion11, mostra l'utilizzo di alcune tecniche, ma tra queste non c'è la SVM.Inoltre, il libro è basato sulla versione 0.5 del framework, mentre quellacorrente è la 0.7, e provando a eseguire degli snippet si è visto che non sonocompatibili.

� I codici di esempio, come un recommender system per i �lm basato suldataset Movielens, hanno mostrato di essere poco stabili, fallendo spessol'esecuzione e fornendo errori (stack trace) incomprensibili.

Quindi Mahout, pur essendo potenzialmente molto interessante, è un progettopiuttosto immaturo e non è stato usato.

Mozilla Rhino

Data la natura del progetto, ossia un compilatore che trasforma del codice JavaScriptin bytecode per la JVM che viene eseguito in applicazioni Java facendo un largouso delle tecniche di introspezione e re�ection, è ragionevole aspettarsi delle dif-�coltà di gestione in caso di errori nell'esecuzione del codice, poiché potrebbeessere di�cile abbinare un errore che si manifesta in fase di esecuzione del codicecompilato al codice sorgente che contiene e�ettivamente l'errore.

Invece, Rhino riesce a ricostruire uno stack delle eccezioni estremamentechiaro, che riporta una descrizione chiara dell'errore qualora sia un errore disintassi in fase di parsing del codice JavaScript o l'eccezione Java e il numerodella riga del sorgente originale nel caso l'eccezione avvenga in fase di esecuzione.

A Rhino viene abbinata una shell JavaScript REPL12 che permette di esplo-rare il funzionamento del linguaggio in maniera interattiva e molto rapida.

L'unica di�coltà nel suo utilizzo è causata dai diversi tipi di dati usati daJava e da Rhino, caratteristica comunque ben descritta nella documentazione.

11Mahout in ActionSean Owen, Robin Anil, Ted Dunning, and Ellen Friedman416 pages ISBN 978193518268912Read Evaluate Print Loop, ossia le istruzioni vengono eseguite e l'output mostrato all'utente

man mano che esse vengono digitate, permettendo una programmazione interattiva

Appendice B - Codici sorgenti

6.6 WordCount.java

package org . myorg ;

import java . i o . IOException ;import java . u t i l . * ;

import org . apache . hadoop . f s . Path ;import org . apache . hadoop . conf . * ;import org . apache . hadoop . i o . * ;import org . apache . hadoop . mapreduce . * ;import org . apache . hadoop . mapreduce . l i b . input .

Fi leInputFormat ;import org . apache . hadoop . mapreduce . l i b . input .

TextInputFormat ;import org . apache . hadoop . mapreduce . l i b . output .

FileOutputFormat ;import org . apache . hadoop . mapreduce . l i b . output .

TextOutputFormat ;

public class WordCount {

public stat ic class Map extends Mapper<LongWritable , Text, Text , IntWritable> {private f ina l stat ic IntWritab le one = new IntWritab le

(1 ) ;private Text word = new Text ( ) ;

public void map( LongWritable key , Text value , Contextcontext ) throws IOException , Inter ruptedExcept ion {St r ing l i n e = value . t oS t r i ng ( ) ;S t r ingToken ize r t ok en i z e r = new Str ingToken ize r (

l i n e ) ;

194 BIBLIOGRAFIA

while ( t ok en i z e r . hasMoreTokens ( ) ) {word . s e t ( t ok en i z e r . nextToken ( ) ) ;context . wr i t e (word , one ) ;

}}

}

public stat ic class Reduce extends Reducer<Text ,IntWritable , Text , IntWritable> {

public void reduce (Text key , I t e r ab l e <IntWritable>values , Context context )throws IOException , Inter ruptedExcept ion {int sum = 0 ;for ( IntWritab le va l : va lue s ) {

sum += val . get ( ) ;}context . wr i t e ( key , new IntWritab le (sum) ) ;

}}

public stat ic void main ( St r ing [ ] a rgs ) throws Exception {Conf igurat ion conf = new Conf igurat ion ( ) ;

Job job = new Job ( conf , "wordcount" ) ;

job . setOutputKeyClass ( Text . class ) ;job . setOutputValueClass ( IntWritab le . class ) ;

job . setMapperClass (Map. class ) ;job . setReducerClass (Reduce . class ) ;

job . setInputFormatClass ( TextInputFormat . class ) ;job . setOutputFormatClass (TextOutputFormat . class ) ;

Fi leInputFormat . addInputPath ( job , new Path ( args [ 0 ] ) ) ;FileOutputFormat . setOutputPath ( job , new Path ( args [ 1 ] ) )

;

job . waitForCompletion ( true ) ;}

}

6.7 WordCount con Pig Latin 195

6.7 WordCount con Pig Latin

i nput_l ine s = LOAD '/tmp/my−copy−of−a l l−pages−on−i n t e rne t 'AS ( l i n e : chararray ) ;

−− s i e s t raggono l e r i ghe e l e s i i n s e r i s c e in uncon t en i t o r e g e s t i t o d i re t tamente da Pig

−− poi s i o t t i e n e un e l enco d i pa ro l e " appiattendo " l er i ghe

words = FOREACH input_l ine s GENERATE FLATTEN(TOKENIZE( l i n e) ) AS word ;

−− s i e l iminano g l i spaz if i l t e r ed_words = FILTER words BY word MATCHES '\\w+ ';−− s i raggruppano l e pa ro l e d i s t i n t e come s i fa rebbe in

SQLword_groups = GROUP f i l t e r ed_words BY word ;−− s i determinano l e d imens ion i d i ogni gruppoword_count = FOREACH word_groups GENERATE COUNT(

f i l t e r ed_words ) AS count , group AS word ;−− s i ordinano l e pa ro l e in base a l l a f r equenzaordered_word_count = ORDER word_count BY count DESC;STORE ordered_word_count INTO '/tmp/number−of−words−on−

i n t e rne t ' ;

6.8 WordCount in Jaql

// importiamo una UDF per e f f e t t u a r e l o s p l i t t i n g , checomunque s i può f a r e usando l e e s p r e s s i o n i r e g o l a r i

s p l i tA r r = bu i l t i n ("com . acme . ex t en s i on s . expr .Sp l i t I t e rExp r$De s c r i p t o r ") ;

$ text = read ( hdfs (" messaggi . j s on ") ) ;//un messaggio ha l a s t r u t t u r a {" utente " : nomeutente , "

contenuto " : t e s t o }$text −> expand sp l i tA r r ( $ . contenuto , " ")−> group by $word = $

in to { $word , num: count ( $ ) } ;

POLITECNICO DI MILANO - politesi.polimi.it · di dati da trattare e visualizzare è così grande da...

Documents

Transcript of POLITECNICO DI MILANO - politesi.polimi.it · di dati da trattare e visualizzare è così grande da...