SlideShare une entreprise Scribd logo
1  sur  111
Télécharger pour lire hors ligne
Università degli Studi del Sannio
Dipartimento di Ingegneria
Corso di Laurea in Ingegneria Informatica
Tesi di Laurea
Big Data processing:
un sistema scalabile per la
Sentiment Analysis
Luglio 2014
Relatore
Prof. Eugenio Zimeo
Correlatore
Dott. Guido Anzuoni
Candidato
Francesco Cardinale
Matr. 195001566
A chi insegue un sogno nella vita
ai tenaci, ai testardi, agli ostinati
a chi cade e si rialza
a chi ci prova sempre e a chi non molla mai.
Perché loro sono quelli che guardano avanti
quelli che sperimentano sempre
quelli che credono nel futuro e non smettono mai di sognare.
Quelli che si sentiranno vecchi
solo quando i rimpianti saranno superiori ai sogni.
Quando si giunge ad un traguardo così importante nella vita, bisogna voltarsi indietro ed avere il
coraggio, o forse il buon senso, di ammettere che: sulla strada dei gradi traguardi non si è mai soli.
Mi guardo indietro: salite, sorrisi, amici. Guardo avanti: nuove salite, altri sorrisi, gli stessi amici.
Molte sono le persone a cui devo molto e da cui ho appreso tanto. A loro vanno tutta la mia
gratitudine ed ammirazione.
Dedico questo lavoro principalmente alla mia famiglia, in particolare ai miei genitori, per tutti i
sacrifici che hanno fatto per darmi la possibilità di realizzare i miei sogni. Ai miei nonni, per la
loro fiducia riposta in me. A mio fratello e alla mia sorellina, sempre disponibili a regalarmi un
sorriso. A loro vanno tutta la mia stima, il mio rispetto e la mia riconoscenza.
Agli amici di sempre, quelli su cui si può sempre contare, quelli a cui basta un semplice sguardo.
Capisci l’importanza di averli quando pensi ai momenti più belli della tua vita e li vedi al tuo
fianco.
A tutti i fantastici ragazzi di ITD Solutions, ai loro consigli e ai loro sorrisi. Da ognuno di loro
ho appreso qualcosa, un qualcosa che custodirò gelosamente. Mi hanno accolto come se facessi da
sempre parte dell’azienda. In particolare, ringrazio la Dott.sa C. Ruocco e il Dott. L. Ristoratore
che, come fratelli maggiori mi hanno insegnato tanto, anche dal punto di vista umano.
Al Dott. G. Anzuoni che mi ha dato la possibilità di entrare a far parte di questo gruppo. Mi ha
dato più di quanto possa immaginare, mi ha dato un modello a cui aspirare. Grazie e lui ho
scoperto questo affascinante mondo di Hadoop e della Sentiment Analysis.
Al Prof. E. Zimeo, sempre disponibile nel dispensare consigli e soluzioni, a qualsiasi ora. Grazie
a lui ho avuto la possibilità di vivere questa splendida esperienza e di venire a conoscenza di
questo nuovo mondo.
Francesco Cardinale
Indice
Indice
Indice delle Figure .................................................................................................... vi
Indice delle Tabelle.................................................................................................. vii
Sommario................................................................................................................ viii
Introduzione ..............................................................................................................ix
Capitolo 1 – MapReduce............................................................................................ 1
1.1 Introduzione........................................................................................................................1
1.1.1 Panoramica................................................................................................................2
1.1.2 Confronto tra RDBMS e MapReduce.................................................................2
1.2 Fondamenti di Hadoop MapReduce..........................................................................3
1.2.1 Rapida terminologia...............................................................................................4
1.2.2 Flusso di dati..............................................................................................................5
1.3 Modello di programmazione........................................................................................6
1.3.1 Tipi e formato dei dati............................................................................................6
1.3.2 Esempio.......................................................................................................................7
1.4 Per Big Data servono “Big ideas” .................................................................................8
1.4.1 I guasti sono frequenti...........................................................................................8
1.4.2 Elaborazione sequenziale dei dati, non casuale ...........................................9
1.4.3 Concentrare l’elaborazione sui dati...................................................................9
1.4.4 Semplice scalabilità.............................................................................................. 10
1.4.5 Parallelizzazione implicita..................................................................................10
1.4.6 Architettura Scale-out.........................................................................................10
1.5 Quando usare MapReduce? ........................................................................................11
Capitolo 2 – Apache Hadoop .................................................................................. 12
2.1 Panoramica........................................................................................................................13
2.1.1 Origini del progetto e diffusione attuale......................................................15
2.1.2 Senza Hadoop?...................................................................................................... 15
2.1.3 Caratteristiche salienti ........................................................................................16
2.2 HDFS.....................................................................................................................................16
2.2.1 NameNode e DataNode .....................................................................................17
iii
Indice
2.2.2 Blocchi e replicazione.......................................................................................... 19
2.3 Hadoop MapReduce ......................................................................................................20
2.3.1 Java MapReduce ................................................................................................... 21
2.3.2 Esecuzione di un job MapReduce...................................................................23
2.3.3 Shuffle e Sort.......................................................................................................... 25
2.4 Hadoop Streaming..........................................................................................................26
2.5 YARN.....................................................................................................................................27
2.6 ZooKeeper..........................................................................................................................29
2.7 Pig..........................................................................................................................................30
2.8 Hive.......................................................................................................................................31
2.8.1 Il modello dati........................................................................................................ 33
2.8.2 Creazione di tabelle ............................................................................................. 34
2.8.3 SerDe......................................................................................................................... 34
2.8.4 Funzioni definite dall’utente.............................................................................35
2.9 HBase....................................................................................................................................36
2.10 Flume ...................................................................................................................................38
2.11 Oozie ....................................................................................................................................40
Capitolo 3 – Sentiment Analysis............................................................................. 42
3.1 Il Web ai tempi del Social Media................................................................................42
3.1.1 Applicazioni della sentiment analysis ...........................................................43
3.1.2 Un case study: La campagna presidenziale di Obama .............................44
3.2 Complessità della Sentiment Analysis.....................................................................44
3.2.1 Modalità di analisi................................................................................................. 45
3.2.2 Il vocabolario e i relativi problemi...................................................................46
3.2.3 I problemi dell’elaborazione del linguaggio naturale .............................47
3.2.4 Il problema dello spam.......................................................................................47
3.3 Definizione del problema.............................................................................................47
3.3.1 Task basilari della Sentiment Analysis...........................................................48
3.3.2 Definizione formale di opinione......................................................................48
3.4 Classificazione di un documento ..............................................................................49
3.4.1 Supervised Learning............................................................................................ 50
3.4.2 Unsupervised Learning.......................................................................................51
3.4.3 Limiti della classificazione per documento .................................................52
3.5 Classificazione a livello di frase ..................................................................................52
3.6 Espansione del vocabolario.........................................................................................53
iv
Indice
3.7 Classificazione dei singoli aspetti..............................................................................54
3.7.1 Estrazione degli aspetti ......................................................................................54
3.7.2 Classificazione della polarità.............................................................................55
Capitolo 4 – Sistema per la Sentiment Analysis.................................................... 57
4.1 Panoramica del sistema sviluppato..........................................................................57
4.2 Twitter..................................................................................................................................58
4.2.1 Twitter API............................................................................................................... 59
4.2.2 Formato dei dati.................................................................................................... 60
4.2.3 Perché Twitter?...................................................................................................... 61
4.3 Acquisizione e memorizzazione dei tweet............................................................62
4.3.1 Source....................................................................................................................... 62
4.3.2 Configurazione dell’Agent.................................................................................63
4.3.3 Channel.................................................................................................................... 64
4.3.4 Sink ............................................................................................................................ 64
4.4 Analisi dei dati ..................................................................................................................65
4.4.1 Interpretazione dei dati......................................................................................65
4.4.2 Determinazione del Sentiment........................................................................67
4.4.3 Tabella di output................................................................................................... 74
4.5 Automatizzazione del Sistema...................................................................................74
4.6 Accuratezza del Sistema...............................................................................................75
4.7 Analisi dei risultati...........................................................................................................77
4.7.1 Intervalli temporali............................................................................................... 78
4.7.2 Geolocalizzazione del sentiment ....................................................................82
Capitolo 5 – Conclusioni e sviluppi futuri.............................................................. 84
Appendice A – Cloudera.......................................................................................... 86
Appendice B – Classificazione bayesiana .............................................................. 88
B.1 Classificatore Naïve Bayes............................................................................................88
B.2 Classificatori Naïve Bayes in Weka ............................................................................89
B.2.1 Multinomial Naïve Bayes....................................................................................89
B.2.2 Naïve Bayes............................................................................................................. 90
Appendice C – Pentaho ........................................................................................... 91
Bibliografia e Sitografia.......................................................................................... 92
v
Indice delle Figure
Indice delle Figure
Figura 1.1 – Vista semplificata dell’architettura di MapReduce................................ 4
Figura 1.2 – Flusso dei dati in un job MapReduce ................................................... 5
Figura 1.3 – Esempio WordCount: passi di un job MapReduce ............................... 8
Figura 2.1 – Architettura di Hadoop......................................................................14
Figura 2.2 – Architettura di HDFS.........................................................................18
Figura 2.3 – Come Hadoop esegue un job MapReduce...........................................23
Figura 2.4 – Operazioni di Shuffle e Sort in MapReduce.........................................25
Figura 2.5 - Architettura di YARN .........................................................................28
Figura 2.6 – Architettura di Hive ...........................................................................32
Figura 2.7 – Struttura di HBase..............................................................................38
Figura 2.8 – Architettura di Flume.........................................................................39
Figura 4.1 – Architettura del sistema per la Sentiment Analysis...............................58
Figura 4.2 – Architettura del sistema di acquisizione dei tweet................................62
Figura 4.3 – Distribuzione percentuale delle polarità..............................................78
Figura 4.4 – Trend del sentiment su intervallo temporale di 24 ore .........................79
Figura 4.5 – Trend del sentiment su scala oraria in relazione alla prima partita........80
Figura 4.6 – Trend del sentiment su scala oraria in relazione alla seconda partita. ...81
Figura 4.7 – Trend del sentiment su scala oraria in relazione alla terza partita. ........82
Figura 4.8 – Distribuzione dei tweet positivi per ogni regione. ................................83
vi
Indice delle Tabelle
Indice delle Tabelle
Tabella 1.1 – Confronto tra RDBMS tradizionali e MapReduce ............................... 3
Tabella 2.1 – Funzionalità delle componenti dell’ecosistema Hadoop.....................14
Tabella 2.2 – Formati di input di MapReduce ........................................................22
Tabella 2.3 – Formati di output di MapReduce......................................................22
Tabella 2.4 – Confronto tra RDBMS e Hive ...........................................................31
Tabella 4.1 – Parole chiave del mondo Twitter.......................................................59
Tabella 4.2 – Matrice di Confusione del sistema.....................................................76
Tabella 4.3 – Dati relativi alle tre partite dell'Italia nel Mondiale 2014 ....................79
vii
Sommario
Sommario
“Per natura, all'opinione piace opinare.”
– Platone
I social media sono i luoghi virtuali dove si concretizzano le comunicazioni
interpersonali, dove le opinioni prendono forma e si diffondono. Mentre il passaparola
tradizionale è difficile da misurare, le discussioni online sono normalmente visibili e
persistenti e dunque possono essere ascoltate, comprese ed analizzate, sia al fine di
individuare trend emergenti che per progettare efficaci azioni di comunicazione,
pubbliche relazioni e marketing, così come per esaminare gli umori degli utenti.
La progressiva diffusione dei social network, sia generalisti (quali Twitter, Facebook o
Google+) che specializzati (ad esempio le comunità professionali di LinkedIn), ha reso
disponibile una massiccia e inedita quantità di dati, utilizzabile in tempo reale. Questi
dati custodiscono una visione d’insieme sull’atteggiamento – meglio conosciuto come
sentiment – degli utenti verso un prodotto, un servizio, un’azienda o una singola
persona.
Il sentiment è quindi il pensiero espresso dagli utenti attraverso i mezzi di
comunicazione attualmente disponibili nel Web. L'analisi del sentiment – meglio
conosciuta come Sentiment Analysis – è l'insieme delle operazioni con le quali si
ascolta il web per rilevare le opinioni, gli umori, i punti di vista degli utenti.
Con un approccio basato sulla combinazione di un dizionario dei termini e di un
classificatore automatico, si è realizzato un sistema, intrinsecamente scalabile,
affidabile e automatizzato, grazie all’utilizzo degli strumenti messi a disposizione da
Hadoop, per la determinazione del sentiment degli italiani, sulla base delle loro
opinioni espresse su Twitter durante tutto l’arco temporale che ha visto protagonista,
nel bene e nel male, la Nazionale Italiana nel Mondiale di calcio brasiliano del 2014.
I risultati finali, riportati graficamente tramite Pentaho, consentono di ottenere una
visione degli umori e delle emozioni degli italiani sia sulla base di un intervallo
temporale variabile, la cui unità minima di tempo è definita su una singola ora, che
sulla base di una mappa geografica dell’Italia per ottenere un grafico geolocalizzato.
viii
Introduzione
Introduzione
“Al pari di Google, tutta una serie di social media, come Facebook, Twitter, LinkedIn,
Foursquare e altri, siedono letteralmente su una montagna di informazioni datizzate che,
una volta analizzate, faranno luce sulle dinamiche sociali a tutti i livelli, dall’individuo
alla società nel suo complesso”
– Viktor Mayer-Schönberger e Kenneth Cukier
iviamo nell’era dei dati, o meglio dei Big Data1
! In un’era in cui l’analisi di grandi
moli di dati destrutturati diventa fondamentale, non solo per gli aspetti
puramente commerciali e civili, in quanto i dati possono essere d'ausilio anche alla
singola persona fisica, i social network diventano un bacino insostituibile di
reperimento di informazioni, aprendo innumerevoli opportunità per le aziende.
La quantità di informazioni digitali che si generano ogni giorno sta assumendo
proporzioni colossali, dal segnale GPS dei telefonini alle strisciate di bancomat e carte
di credito, dai Tweet alle chiacchere su Facebook. Non si entra più in Internet, ci
viviamo dentro.
Fino al 2003 tutti gli strumenti connessi alla rete hanno prodotto 5 miliardi di
gigabytes, nel 2010 erano già diventati 80 miliardi, oggi tale quantità viene raggiunta
in due giorni. All’origine si tratta di semplici numeri, pura matematica, poi, quando
vengono accorpati, letti e interpretati, diventano informazioni. Se elaborati e
contestualizzati si trasformano in conoscenza.
Gestire ed elaborare queste grandi quantità di dati risulta però complesso. Il diminuire
dei costi di memorizzazione, e quindi le dimensioni delle memorie di massa, non è
andato di pari passo con le possibilità di accedervi. Ad esempio, nel 1990 un tipico
disco2
aveva la capacità di 1370 MB abbinato ad una velocità di trasferimento di
4,5 MB/s, rendendo possibile leggere l'intero contenuto in circa 5 minuti. Al giorno
d'oggi, dopo più di 20 anni, dischi di capacità intorno al terabyte sono la norma: la
capacità è aumentata di un fattore 1000. Le velocità di trasferimento attuali sono
1 Big data indica i dati prodotti in grande quantità, con notevole rapidità e nei formati più diversi, la cui
elaborazione richiede strumenti differenti da quelli convenzionali, in tutte le fasi del processo:
dall'acquisizione, alla gestione e all’archiviazione passando per condivisione, analisi e visualizzazione.
2 Le specifiche si riferiscono al modello Seagate ST-41600n.
V
ix
Introduzione
invece aumentate solo di un fattore 25 e si assestano nell'ordine dei
100 MB/s, rendendo quindi necessarie più di due ore e mezzo per accedere all'intero
contenuto del disco.
In molti contesti è emersa la necessità di svolgere elaborazioni di grandi quantità di
dati. Agli albori dello sviluppo della rete Internet, e anche per alcuni decenni a seguire,
non ci si ponevano queste problematiche proprio perché i mezzi fisici, i computer, non
avevano una grande diffusione presso privati e quindi nella casa – o addirittura nelle
tasche – di ogni cittadino del mondo economicamente sviluppato. Oggi invece la
situazione si è ribaltata e sempre più persone sono in grado di essere loro stessi dei
creatori di informazioni oppure collaborano alla creazione delle stesse e in più possono
occuparsi della loro promozione e condivisione.
Nella realtà contemporanea c’è quindi una grande mole di informazioni disponibili e
in costante aumento, alla quale gli utenti accedono e contribuiscono a mantenere in
vita e far sviluppare. Ciò anche grazie a strumenti hardware e software di grande
diffusione come macchine fotografiche digitali e programmi di fotoritocco,
smartphone, piattaforme di facile utilizzo per la gestione di blog, ecc. Si tratta di
informazioni e messaggi che una volta generati possono essere modificati e diffusi in
rete da chiunque.
Nell’economia della rete è informazione tutto ciò che questa è in grado di generare e
può essere provato come tale: non solo la semplice notizia, ma anche il fatto che una
persona che reputa interessante un video, un’immagine, una notizia, un post, e così
via, e decida di condividerlo sulla propria bacheca di Facebook e lì aggiungere un
commento per innescare un confronto con gli amici, anche attraverso l’utilizzo di
ulteriori strumenti di comunicazione (ad esempio, pubblicando l’articolo in un tweet).
È comprensibile quindi come il concetto di informazione assuma una forte dimensione
pubblica e collettiva, secondo i canoni propri di Internet. Ed è evidente che quando si
parla di informazione non si può riduttivamente intendere solo ciò che l’utente ricerca,
ma anche qualsiasi altra azione egli faccia in rete. Quali parole usa per interrogare un
motore di ricerca, quanto resta in un pagina, se usa i link, se clicca sulla pubblicità,
quale pubblicità, se condivide un contenuto, se carica video su Youtube, quali video
vede, e in generale tutto ciò che decide di condividere.
Inoltre, la gran mole di dati che produciamo non trae origini solo dalla rete Internet,
comunemente nota. Oggi oltre che attraverso i PC e i classici mezzi di comunicazione,
l’informazione viene generata e propagata anche da una moltitudine di piccoli
x
Introduzione
dispositivi che supportano, quotidianamente, le nostre attività: navigatori satellitari,
telecamere, sensori urbani, telepass, ecc.
Le aziende si trovano ad affrontare la sfida posta da questa sempre crescente mole di
dati che devono essere catturati, archiviati e utilizzati ai fini di una successiva
elaborazione, sia per scopi di business che per produrre nuova conoscenza. L’ulteriore
sfida è posta dalla natura stessa di questi dati che sta cambiando, arricchendosi sempre
più di dati di provenienza varia. I dati non strutturati costituiscono ora una parte molto
consistente della totalità delle informazioni disponibili e le aziende stanno rapidamente
valutando tecnologie che permettano di analizzarli per ottenerne un vantaggio
competitivo.
Per molti, i dati non strutturati rappresentano una potente risorsa ancora tutta da
scoprire e sfruttare, una risorsa capace di fornire una conoscenza più approfondita su
clienti ed operazioni che può quindi trasformarsi in un vantaggio competitivo. Ma
questi dati non possono essere facilmente gestiti con database relazionali tradizionali
o con strumenti di business intelligence, concepiti per gestire solo dati strutturati.
Il problema viene ulteriormente complicato dalla rapidità con cui crescono volume e
velocità dei dati strutturati e non strutturati, il che costringe le aziende a cercare modi
nuovi per acquisire, organizzare, gestire e analizzare questi dati.
L’insieme di questi elementi ha portato allo sviluppo di nuovi modelli di elaborazione
distribuita e di tecnologie analitiche quali Hadoop, NoSQL3
e altre adatte a gestire i
dati non strutturati nella loro forma originaria. Queste tecnologie permettono alle
aziende di studiare soluzioni per diventare più efficienti, ridurre il TCO4
(Total Cost
of Ownership) e migliorare la flessibilità dell’infrastruttura IT di supporto.
Naturalmente, sarebbe anche tecnicamente possibile convertire i dati non strutturati
in una forma strutturata e poi utilizzare sistemi di gestione di database relazionali per
manipolarli. Il processo di conversione, tuttavia, richiede una considerevole quantità
di tempo, incrementando i costi e ritardando il raggiungimento del risultato finale.
È evidente, quindi, che per trattare questa grande mole di dati ci sia bisogno di un
approccio infrastrutturale ad hoc, più efficiente in termini di costi. In molte situazioni,
la piattaforma più idonea è basata sulla presenza di tante commodity server di
3 Il termine NoSQL identifica tutti quei database che si discostano dalle regole che caratterizzano i
database relazioni (RDBMS). Essi sono spessi utilizzati per immagazzinare grandi quantità di dati e
sono altamente scalabili. Si consiglia di visitare il sito http://nosql-database.org/, che si pone come
guida di riferimento del movimento NoSQL, per ulteriori approfondimenti in merito.
4 Total Cost of Ownership (TCO), in italiano costo totale di proprietà o costo totale di possesso, è un
approccio utilizzato per calcolare tutti i costi del ciclo di vita di un’apparecchiatura informatica IT,
per l’acquisto, l’installazione, la gestione, la manutenzione e il suo smantellamento.
xi
Introduzione
dimensioni più piccole, anziché di piattaforme di classe enterprise, e le risorse di
storage vengono gestite localmente, a livello di singolo server, anziché essere
centralizzate e condivise. Questo approccio distribuito, infatti, presenta numerosi
vantaggi. Per esempio, garantisce flessibilità in termini di costi grazie alla potenzialità
di rapida scalabilità orizzontale che consente di introdurre anche migliaia di server di
fascia bassa, anziché dover effettuare un costoso aggiornamento di server enterprise e
apparecchiature di storage. E per quanto riguarda le performance, il modello
“shared-nothing”, in cui appunto ciascun nodo dispone di risorse a esso dedicate,
elimina la necessità di incanalare i dati attraverso un numero limitato di dischi
condivisi, eliminando il rischio di potenziali colli di bottiglia che potrebbero incidere
significativamente sulle performance in caso di ingenti quantità di dati da elaborare.
Tra i numerosi metodi emersi in questi anni per analizzare i Big Data, quello che
presenta le suddette caratteristiche è senza dubbio MapReduce e in particolare la sua
implementazione open source che ha riscosso maggiore successo, anche per numero
di installazioni, Hadoop.
Panoramica su Hadoop
Hadoop è un framework open source, affidabile e scalabile, finalizzato all’analisi,
all'archiviazione e all'elaborazione distribuita di grandi quantità di dati strutturati e
non strutturati. Permette alle applicazioni di lavorare con migliaia di nodi e petabyte
di dati. Fornisce un filesystem distribuito (HDFS) in grado di memorizzare i dati su
migliaia di server, e un modo per eseguire computazioni (detti job Map/Reduce)
distribuite su tali macchine, in prossimità dei dati.
Hadoop è un progetto Apache di alto livello, e Yahoo! rappresenta il più grande
contributore, e ne fa fortemente uso. Hadoop è usato anche da: Ebay, Facebook, IBM,
ImageShack, Linkedin, Spotify, The New York Times, Twitter, e tanti altri.
Fondamentalmente si tratta di una tecnologia in grado di distribuire i carichi di lavoro
tra più computer (partizionando opportunamente il dataset), al fine di suddividere
l’analisi dei dati in più task paralleli per produrre i risultati in maniera più rapida.
Sempre più organizzazioni si rendono conto della necessità di disporre di una nuova
piattaforma sviluppata sulla base di tecnologie come Hadoop che, oltre a ospitare i
flussi di dati correnti, sia i grado di assorbire i nuovi flussi di dati che, inevitabilmente,
arriveranno sulla scia del successo iniziale del progetto. Una tale piattaforma facilita
notevolmente le attività di utilizzo, analisi e sperimentazione dei flussi di dati
xii
Introduzione
eterogenei (strutturati e non strutturati), adeguandosi perfettamente al concetto dei
Big Data.
Panoramica sulla Sentiment Analysis
La Sentiment Analysis si propone di analizzare le opinioni espresse dagli utenti sui
social media relativamente a prodotti e servizi e alle loro caratteristiche. Trae origine
dalla Natural Language Processing (ovvero, l’analisi del linguaggio naturale), dalla
linguistica computazionale5
e dal social media analytics, la disciplina che studia e
analizza i dati sociali, e trova applicazione in svariati settori che vanno da quello
turistico, alla military intelligence6
, alle strategie di real-time marketing7
basati su
contenuti sociali. Alcuni esempi sono il monitoraggio e l’analisi dei fenomeni sociali,
l’analisi delle opinioni riferite a un particolare prodotto o un determinato servizio della
pubblica amministrazione, o ancora l’analisi delle intenzioni di voto, come è stato fatto
negli Stati Uniti durante il confronto elettorale tra i due candidati Obama e Romney8
.
Attraverso le reti sociali, gli utenti possono comunicare condividendo informazioni
legate ai propri interessi e attività, ed esprimere opinioni riguardanti il proprio stile di
vita, le proprie necessità e desideri. Le scelte dei consumatori sono sempre più
influenzate dai pareri espressi sui social media attraverso il passaparola sul web – word
of mouth – e il feedback degli utenti a prescindere dal bene di consumo, dal prodotto
o dal servizio.
Le recenti analisi di mercato evidenziano la tendenza dei consumatori a utilizzare i
social media per la prenotazione di un albergo, per l’acquisto di beni, cellulari,
automobili, per decidere che film vedere o ancora relativamente a temi di politica e
attualità. I contenuti, generati dagli utenti sotto forma di recensioni di prodotti e/o
opinioni su blog, forum, gruppi di discussione e social network crescono rapidamente
e si stanno rivelando una risorsa di considerevole importanza. Le opinioni sono lette e
seguite dalla gente comune, dalle compagnie e dalle imprese, ma accedervi sta
gradualmente diventando sempre più complesso a causa della crescita del numero delle
5 La linguistica computazionale si concentra sullo sviluppo di formalismi descrittivi del funzionamento
del linguaggio naturale, tali che si possano trasformare in programmi eseguibili dai computer.
I problemi che affronta la linguistica computazionale consistono nel trovare una mediazione fra un
oggetto di studio in costante evoluzione (il linguaggio umano) e le capacità di comprensione della
macchina, limitate a quanto può essere descritto tramite regole formali.
6 La military intelligence si occupa della raccolta, analisi e distribuzione di informazioni rilevanti per le
operazioni militari.
7 La real-time marketing si occupa di determinare “in tempo reale” un approccio adeguato o ottimale
per un determinato cliente in un determinato momento e/o luogo.
8 Per approfondimenti si veda il Paragrafo 3.1.2.
xiii
Introduzione
conversazioni virtuali. L’abilità di ascoltare le opinioni e la disponibilità di programmi
in grado di processarle in modo automatico rappresentano elementi sempre più
apprezzati, specialmente dalle grandi organizzazioni che sfruttano l’opinione del
consumatore per ricavarne informazioni utili per le proprie decisioni e per la
definizione di scelte di strategia aziendale e di marketing.
Mentre la prima generazione di prodotti dedicati alla social media analytics forniva
strumenti in grado di contare citazioni di brand, marchi o prodotti, attualmente si
stanno diffondendo strumenti più efficienti in grado di effettuare un monitoraggio più
accurato delle informazioni riferite ai prodotti e servizi di interesse. Analogamente per
quanto riguarda l’analisi dei contenuti esistono diversi strumenti in grado di lavorare
sui testi attraverso approcci statistici o linguistici. I primi basati su funzioni che
operano in base alla frequenza dei termini e i secondi basati su risorse linguistiche che
permettono l’analisi sintattica e semantica dei contenuti. Entrambi gli approcci sono
utilizzati nella Sentiment Analysis ma con evidenti differenze di comportamento e di
dettaglio di analisi.
Attualmente il principale obiettivo della ricerca nell’ambito della Sentiment Analysis è
quello di spostare la frontiera, passando dalla semplice valutazione della polarità delle
opinioni espresse ad una in cui le opinioni sono analizzate in modo sempre più
dettagliato, al fine di coglierne le correlazioni, legarle al contesto e possibilmente
geo-referenziarle. A tal proposito, le attuali ricerche prevedono lo sviluppo di algoritmi
e applicazioni basati su un approccio linguistico del tipo Natural Language Processing.
In particolare, possono essere individuate come fasi principali lo sviluppo di risorse
linguistiche, la classificazione basata sullo stato emotivo espresso nelle opinioni e la
sommarizzazione dei risultati ottenuti, che consiste nell’aggregazione e
rappresentazione dei risultati elaborati.
La preparazione dei dati in un sistema di Sentiment Analysis coinvolge l’utilizzo di
diverse risorse linguistiche. L’insieme delle attività coinvolte nell’analisi sintattica e
semantica dei testi sono processi basati su WordNet9
, che rappresenta la risorsa
linguistica più ampiamente diffusa nell’ambito della NLP e sviluppata presso
l’Università di Princeton, oppure MultiWordNet10
per lingue diverse dall’inglese.
La classificazione del sentiment contempla lo sviluppo di algoritmi e di applicazioni
basati su diversi approcci, mediante un dizionario dei termini, tecniche di machine
learning o metodologie tipiche della NLP. L’elaborazione dei testi include fasi
9 Sito web: http://wordnet.princeton.edu/.
10 Sito web: http://multiwordnet.fbk.eu/english/home.php.
xiv
Introduzione
successive di analisi dei dati: si spazia dall’analisi sintattica, che determina la struttura
grammaticale di un testo attraverso l’identificazione delle parti del discorso11
, in
inglese part-of-speech (POS), all’analisi semantica che assegna il significato più
probabile alle POS per risolvere automaticamente l’ambiguità intrinseca nei termini e
permette di estrarre il significato espresso nel testo. Se si è interessati ai testi che
parlano di “calcio”, è necessario selezionare il significato preciso di tale parola. Se
l’interessa riguarda l’attività sportiva, si vogliono selezionare tutti i testi in cui una
parola è presente proprio con questa accezione, e quindi escludere automaticamente,
attraverso la tecnica della disambiguazione che considera il contesto in cui le parole
sono inserite, tutti i risultati che riportano il termine calcio con altri significati
(elemento chimico, comune in provincia di Bergamo, componente di una pistola, ecc.).
L’utilizzo della risorsa linguistica è necessario anche nelle fasi successive per correlare
le opinioni espresse dagli utenti alle considerazioni sui prodotti o servizi su cui si
esprime un’opinione. L’attività di estrazione delle feature (caratteristiche o aspetti),
anche nota come features o aspects extraction, fa parte dell’opinion extraction e
prevede l’identificazione degli aspetti relativi al prodotto o servizio a cui le opinioni
sono riferite. Per esempio, se si parla di un hotel alcune delle sue caratteristiche
possono essere: camera, stanza da bagno, letto, prezzi, piscina, ristorante, igiene, ecc.
L’analisi delle opinioni viene riferita alle caratteristiche e complessivamente al
prodotto o al servizio da esse descritto.
Al fine di riferire correttamente le opinioni alle caratteristiche è necessario poi, isolare
le frasi aventi valore soggettivo, che esprimono cioè una opinione. Le frasi contenute
nelle opinioni sono infatti distinte in frasi oggettive e frasi soggettive. Queste ultime
esprimono stati mentali ed emozioni quali valutazioni, sensazioni, sentimenti, ecc.
Una frase soggettiva esprime ad esempio un apprezzamento: “la camera era molto
accogliente”, mentre una frase oggettiva descrive semplicemente un fatto: “sono
andato in vacanza con un’amica, in camera doppia”.
Isolare tali frasi, attraverso un sistema di classificazione, consente di ridurre il
“rumore” causato dalla presenza di affermazioni e valutazioni non pertinenti e di
impostare la fase di sommarizzazione, durante la quale si aggregano i risultati elaborati
precedentemente, limitatamente alle frasi esprimenti giudizi sulle caratteristiche
identificate secondo schemi e grafici di facile lettura.
11 La grammatica italiana distingue tradizionalmente le seguenti parti del discorso: sostantivo, verbo,
aggettivo, articolo, avverbio, preposizione, numerali, pronome, interiezione.
xv
Introduzione
Obiettivo del lavoro di Tesi
In questo lavoro di Tesi si intende creare un sistema per la Sentiment Analysis, che sia
efficiente, affidabile e scalabile, tramite l’utilizzo delle funzionalità offerte da Hadoop
e dalle relative componenti.
Il lavoro svolto prevede attività che caratterizzano varie fasi della Sentiment Analysis.
Nella prima fase si procede all’estrazione dei dati da una sorgente che in questo lavoro
è rappresentata dal Social Network Twitter. Sulla base di un insieme di parole chiave
sono prelevati tramite un estrattore, quale Flume (una componente di Hadoop), i tweet
riferiti ad un argomento prestabilito, quale la Nazionale Italiana di Calcio.
Una volta estratti e memorizzati i dati su HDFS, si procede alla classificazione del
sentiment. In questo lavoro si procederà sia sulla base di un classificatore automatico
che sulla base di un dizionario dei termini, dove a ciascun termine viene associato un
valore numerico che ne specifica la polarità positiva o negativa del sentiment. Per la
fase di classificazione è possibile sfruttare le potenzialità di Hive, una componente di
Hadoop che permette di utilizzare un linguaggio simile a SQL, e di integrarlo con
funzioni definite dall’utente (UDF), e allo stesso tempo, convertendo automaticamente
le query in elaborazioni MapReduce, ne assicura la scalabilità.
I dati prodotti possono essere poi elaborati e presentati secondo diverse dimensioni,
utilizzando tool di business intelligence come Pentaho, in modo da ottenere grafici e
report relativi al sentiment, sia in riferimento ad un determinato intervallo temporale,
che ad una particolare area geografica.
Ai fini del lavoro di tesi si prevede anche di automatizzare tutte le operazioni,
sfruttando orchestratori/scheduler come Oozie di Hadoop.
Struttura della Tesi
Nel Capitolo 1 viene presentata una panoramica riguardante il paradigma MapReduce,
su cui si basa indirettamente l’intero sistema, sia dal punto di vista concettuale, sia
analizzandone le principali funzionalità implementate in Hadoop. Nel Capitolo 2 viene
descritto il framework Hadoop, e tutte le relative componenti più importanti. Nel
Capitolo 3 sono presentati i diversi approcci, e quindi lo stato dell’arte, nel campo della
Sentiment Analysis. Nel Capitolo 4 viene presentato il sistema sviluppato per la
Sentiment Analysis, i risultati ottenuti in termini di accuratezza e i report relativi alle
analisi effettuate. Nel Capitolo 5 sono descritti gli sviluppi futuri, relativi sia
all’aumento delle performance che al miglioramento dell’accuratezza del sistema.
xvi
Capitolo 1 MapReduce
MapReduce
“MapReduce è un modello di programmazione e una relativa implementazione per
elaborare e generare insiemi di dati di grandi dimensioni. […] I programmi che adottano
questo stile funzionale vengono automaticamente gestiti in una logica parallela ed eseguiti
su cluster di macchine a tecnologia commodity. Il sistema run time si occupa nel dettaglio
del partizionamento dei dati di input, pianificando l’esecuzione del programma attraverso
una serie di macchine, gestendone gli eventuali guasti e la comunicazione che ha luogo tra
esse. Tutto questo permette a programmatori senza alcuna esperienza in sistemi paralleli e
distribuiti di utilizzare con molta semplicità le risorse di un grande sistema distribuito.”
– Jeffrey Dean e Sanjay Ghemawat
apReduce è un framework1
software brevettato e introdotto da Google per
supportare la computazione distribuita di grandi quantità di dati su cluster2
di computer, in modalità batch3
.
MapReduce lavora secondo il principio divide et impera. Un problema complesso, che
utilizza una gran mole di dati, è suddiviso, assieme ai dati stessi, in piccole parti
processate in modo autonomo e, una volta che ciascuna parte del problema è stata
calcolata, i vari risultati parziali sono “ridotti” a un unico risultato finale.
1.1 Introduzione
MapReduce permette di processare, in modalità batch, query ad hoc riguardanti
l’intero insieme di dati, o una buona porzione di esso, per poi produrre un risultato in
1 Un framework è una struttura di supporto su cui un software può essere organizzato e progettato. Un
framework, in generale, include software di supporto, librerie, un linguaggio per gli script e altri
software che possono aiutare a mettere insieme le varie componenti di un progetto.
2 Un cluster è un insieme di computer connessi tramite una rete telematica.
3 Tutta la sequenza di operazioni e dati necessari per svolgere un particolare compito vengono preparati
in anticipo e memorizzati su un adeguato supporto creando una procedura. La procedura viene poi
eseguita dal sistema come un blocco unico, cioè senza che sia necessario, o possibile, un intervento
umano prima che sia terminata.
CAPITOLO 1
M
1
Capitolo 1 MapReduce
un tempo ragionevolmente breve. Il termine MapReduce viene utilizzato sia per
indicare il modello computazionale, sia il framework concettuale necessario, sia le
specifiche implementazioni.
1.1.1 Panoramica
Un anno dopo la pubblicazione di un documento nel quale si descriveva l’architettura
del filesystem distribuito4
utilizzato da Google, detto GFS (Google File System)5
, nel
2004 Google rilascia un altro documento che introduce MapReduce6
al mondo. Le
forti esigenze di parallelizzazione hanno portato l’azienda a creare un’astrazione che
potesse accelerare lo sviluppo di applicazioni parallele, relegando i dettagli relativi alla
parallelizzazione, gestione dei guasti e distribuzione dei dati ad una libreria.
MapReduce è un framework utile alla creazione di applicazioni in grado di elaborare
grandi quantità di dati in parallelo, basato sul concetto di programmazione funzionale.
L’implementazione classica del calcolo parallelo è basata sulla programmazione
multithreading, che prevede la suddivisione del lavoro in più parti distinte, i thread,
condividendo la memoria ed altre risorse. La programmazione multithreading presenta
una certa complessità proprio nel coordinare l’accesso alle risorse condivise. Nella
programmazione funzionale, invece, la condivisione dei dati è eliminata, e con essa,
anche i relativi problemi di coordinazione. I dati sono invece passati tra le funzioni
come parametri o valori di ritorno.
1.1.2 Confronto tra RDBMS e MapReduce
MapReduce è davvero essenziale? Oppure è possibile utilizzare database distribuiti su
più dischi per effettuare delle analisi batch su larga scala?
I Big Data sono disponibili in enormi volumi, si presentano con formati destrutturati e
caratteristiche eterogenee e, spesso, sono prodotti con estrema velocità. Volume,
variabilità e velocità sono dunque le caratteristiche che li identificano.
Velocità. Il Seek time è il tempo necessario per spostare la testina del disco sopra la
traccia desiderata, per leggere o scrivere una particolare porzione del disco. Esso
sostanzialmente caratterizza il tempo di accesso al disco, dato che il tempo di
4 Il termine file system indica, informalmente, un modello con il quale i file sono posizionati e organizzati
su un supporto di archiviazione. Un file system distribuito è un particolare file system che permette
la memorizzazioni di file e risorse in dispositivi di archiviazione distribuiti in una rete informatica.
5 Si veda http://research.google.com/archive/gfs.html.
6 Si veda http://research.google.com/archive/mapreduce.html.
2
Capitolo 1 MapReduce
trasferimento di un blocco di bit è relativamente più basso. Per cui, risulta molto
più conveniente limitare quanto più possibile il seek time, evitando di accedere di
volta in volta a diverse porzioni del disco. E questo è ciò che avviene con
MapReduce, che esprime tutte le sue qualità quando si tratta di analizzare l’intero
dataset in modo sequenziale, a differenza dei database relazionali, utili soprattutto
per aggiornamenti di piccole porzioni di dati.
Variabilità. La caratteristica della variabilità, che si traduce nella mancanza di una
struttura ben definita, rende difficile la rappresentazione di tali dati in un sistema
relazionale, che preferisce operare su dati strutturati, organizzati in schemi
predefiniti. MapReduce, invece, è in grado di lavorare su qualsiasi formato di dati,
essendo progettato per interpretare i dati.
Volume. Per quanto riguarda il volume dei dati, MapReduce presenta un modello
quasi linearmente scalabile. Idealmente, la velocità di elaborazione è direttamente
proporzionale al numero dei nodi del cluster e inversamente proporzionale alle
dimensioni dei dati da analizzare. Per cui, raddoppiando il numero dei nodi,
raddoppia la velocità. Raddoppiando le dimensioni del dataset, si dimezza la
velocità di elaborazione. E questo non sempre è vero per i database relazionali.
Tabella 1.1 – Confronto tra RDBMS tradizionali e MapReduce
RDBMS Tradizionale MapReduce
Dimensione dei dati Gigabyte Petabyte
Accesso Interattivo e Batch Batch
Aggiornamenti Scritto e Letto più volte Scritto una volta, letto più volte
Struttura Schema statico Schema dinamico
Integrità Alta Bassa
Scalabilità Non lineare Lineare
1.2 Fondamenti di Hadoop MapReduce
Il framework MapReduce è anche una componente centrale dell’ecosistema Hadoop,
che sarà trattato in dettaglio nel prossimo capitolo. Per ora è sufficiente sapere che
Hadoop è una piattaforma software open source, affidabile e scalabile, finalizzata al
calcolo distribuito, cioè al calcolo che avviene su un sistema di computer indipendenti,
ma collegati tra loro in rete. Il nucleo centrale di Hadoop è essenzialmente costituito
dal framework MapReduce e da HDFS, un file system distribuito che fornisce
3
Capitolo 1 MapReduce
un’efficace modalità di accesso ai dati. HDFS garantisce che i dati siano ridondanti nel
cluster rendendo le operazioni sui dati stessi immuni da un eventuale guasto o
malfunzionamento di un nodo. HDFS, inoltre, accetta dati in qualsiasi formato,
strutturato, semistrutturato o non strutturato.
1.2.1 Rapida terminologia
Prima di immergersi nelle funzionalità di MapReduce, è necessario esplicitare il
significato dei termini che lo caratterizzano.
Un job è un’unità di lavoro destinata all’esecuzione, sottoposta dal client Hadoop. Si
compone dei dati di input, un programma MapReduce, informazioni di
configurazione. Hadoop esegue il job dividendolo in task, che sono di due tipi: map
task e reduce task.
A livello architetturale, MapReduce presenta due tipi di nodi, in una struttura
master/slave, che controllano il processo di esecuzione di un job: un JobTracker e
diversi TaskTracker. Il JobTracker si occupa della gestione delle risorse (CPU e
Memoria) e del ciclo di vita del job MapReduce. Inoltre, coordina tutti i job eseguiti
sul sistema, schedulando i task che devono essere eseguiti sui TaskTracker. I
TaskTracker, che girano sui singoli nodi, eseguono i task sotto la direzione del
JobTracker, e inviano di tanto in tanto dei report sullo stato del processo ai JobTracker.
Figura 1.1 – Vista semplificata dell’architettura di MapReduce
4
Capitolo 1 MapReduce
1.2.2 Flusso di dati
L’input di un job MapReduce è diviso da Hadoop in blocchi di dimensione fissa, detti
split. Successivamente, Hadoop crea un map task per ogni split, che esegue la
particolare funzione map definita dall’utente per ogni record nello split.
In generale, è consigliabile avere degli split sufficientemente piccoli per avere un carico
di lavoro bilanciato tra i diversi nodi, anche se la dimensione non deve essere inferiore
ad una certa soglia, altrimenti l'overhead per gestirli diventa più rilevante del tempo
totale per eseguire l'operazione vera e propria. Generalmente, la migliore scelta è quella
di avere la dimensione di uno split corrispondente alla grandezza di un blocco HDFS.
Nel processo di map i dati in input sono letti da HDFS, mentre i dati di output sono
scritti sul filesystem locale in quanto si tratta di risultati parziali che dovranno essere
rielaborati in seguito dai reducer per produrre l’output finale. Invece l’output finale
prodotto dai reducer è normalmente archiviato su HDFS per garantire l’affidabilità.
Nella Figura 1.2 è rappresentato il flusso di dati in un job MapReduce, con multipli
map task e reduce task. Le caselle tratteggiate indicano i nodi, le frecce tratteggiate
denotano i trasferimenti di dati in uno stesso nodo, mentre le altre frecce evidenziano
i trasferimenti di dati tra nodi diversi.
Figura 1.2 – Flusso dei dati in un job MapReduce
I map task partizionano gli output, creando una partizione per ogni reduce task. In
ogni partizione potrebbero esserci diverse chiavi (e relativi valori), ma i record per ogni
specifica chiave, relativi ad uno specifico split in input, sono tutti in una singola
partizione. In ogni partizione è eseguito un ordinamento – fase sort – per chiave. Una
5
Capitolo 1 MapReduce
volta terminata la fase di map, i TaskTracker notificano al JobTracker il
completamento del loro lavoro e, a questo punto, i dati di input sono stati trasformati
in una lista di coppie chiave/valore.
Successivamente le partizioni sono copiate nei nodi dove risiedono i reducer e il
JobTracker può attivare la fase di reduce, nella quale i TaskTracker aggregano – fase
merge – i risultati dei mapper, conservando l’ordinamento per chiave. Le fasi di sort e
merge, implicite e gestite dal sistema, costituiscono congiuntamente la fase di shuffle.
Infine, i TaskTracker eseguono la funzione reduce al fine di produrre l’output, salvato
in un file diverso per ciascun TaskTracker. La fase reduce, per ogni chiave, elabora i
valori a essa associati e crea, come output, una o più coppie chiave/valore.
È anche possibile definire una funzione combiner, che si posiziona nel flusso di lavoro
tra i mapper e i reducer. In pratica svolge lo stesso lavoro dei reducer, ma limitatamente
ad un singolo nodo. L’utilizzo di combiner consente di ridurre notevolmente il traffico
di rete, poiché l’attività di aggregazione è svolta prima di inviare i dati ad altri nodi.
Inoltre, il processo di esecuzione può anche essere più articolato rispetto a quello
proposto, poiché è possibile che si susseguano più fasi MapReduce: l’output di un job
diventa l’input del job successivo, finché non si giunge al risultato finale. La
concatenazione di più job si rende necessaria per la soluzione di problemi complessi.
1.3 Modello di programmazione
MapReduce presenta un semplice modello di elaborazione dati: la computazione
riceve in ingresso un insieme di coppie chiave/valore e produce in uscita un insieme di
coppie chiave/valore. Lo sviluppatore dovrà solo farsi carico di esprimere la
computazione attraverso due funzioni: map e reduce.
1.3.1 Tipi e formato dei dati
La funzione map riceve in input una coppia chiave/valore e produce una lista di coppie
chiave/valore intermedie:
map: (k1, v1)  list(k2, v2)
La funzione map è applicata in parallelo ad ogni coppia dell’insieme dei dati in ingresso.
Essa produce una lista di coppia per ogni chiamata. Successivamente, il framework
MapReduce si occupa di raggruppare tutti i valori intermedi associati alla stessa chiave
6
Capitolo 1 MapReduce
intermedia, creando quindi una lista di valori per ogni chiave e trasferisce il tutto alla
funzione reduce.
La funzione reduce riceve in input la chiave intermedia e, per ognuna di essa, una lista
corrispondente di valori, generando in uscita una lista di coppie chiave/valore:
reduce: (k2, list(v2))  list(k3, v3)
I tipi di dato delle chiavi e dei valori, il formato di input – che determina la modalità di
lettura dei dati e ciò che è passato alla funzione map come chiave e valore – e il formato
di output sono definiti dallo sviluppatore.
In generale, i tipi di dato in ingresso (k1 e v1) alla funzione map sono differenti da quelli
in uscita (k2 e v2). Tuttavia, i tipi di dato in ingresso alla funzione reduce devono
coincidere con quelli in uscita dalla funzione map, e quelli in uscita dalla funzione
reduce potrebbero essere ancora differenti (k3 e v3).
1.3.2 Esempio
Il WordCount è un classico esempio utilizzato per descrivere il funzionamento di
MapReduce. L’obiettivo è quello di contare il numero di occorrenze di ogni parola
all’interno di una collezione di documenti. L’input della funzione map è una coppia
chiave/valore, dove la chiave rappresenta il nome del documento e il valore il testo del
documento, mentre l’output della funzione reduce è una lista di coppie chiave/valore,
che rappresentano la parola e il relativo numero di occorrenze.
Ecco lo pseudocodice delle due funzioni Map e Reduce per l’esempio in questione:
function map(String key, String value):
// key: nome del documento
// value: testo del documento
for each word w in value:
emit (w, 1)
function reduce(String key, Iterator values):
// key: una parola
// values: una lista di valori
sum = 0
for each v in values:
sum += ParseInt(v)
emit (key, sum)
La funzione map suddivide il testo del documento nelle parole che lo compongono e
associa il valore 1 a ciascuna parola, creando così le coppie (“parola”, 1) da restituire
7
Capitolo 1 MapReduce
in output. La funzione reduce somma il contenuto della lista di valori – in questo caso
tutti ‘1’ – che sono associati alla chiave.
Si suppone, per esempio, di avere due file costituiti l’uno dalla frase “Efficienza
significa fare le cose nel modo giusto” e l’altro dalla frase “Efficacia significa fare le
cose giuste”. Nella Figura 1.3 sono rappresentati i vari step del job MapReduce.
Figura 1.3 – Esempio WordCount: passi di un job MapReduce
1.4 Per Big Data servono “Big ideas”
Appositamente sviluppato per affrontare carichi di lavoro su larga scala, MapReduce
presenta delle caratteristiche che non sono del tutto innovative. Tuttavia, la genialità
degli ingegneri di Google non è stata solo nel riuscire ad implementare le potenzialità
di queste grandi idee, ma anche nel concatenarle tra loro in un modo molto efficiente.
1.4.1 I guasti sono frequenti
I guasti non sono un’eccezione, sono la norma. In cluster di medie/grandi dimensioni,
la probabilità che qualche nodo sia irraggiungibile è molto alta, sia per guasti
hardware, sia per guasti di connettività o semplicemente per manutenzione. A maggior
ragione questo risulta vero utilizzando macchine di classe server low-end. Affinché
possa essere efficace, un servizio di calcolo distribuito non può prescindere dalla
gestione dei guasti. In particolare, occorre fare in modo che questi non impattino sulla
8
Capitolo 1 MapReduce
qualità del servizio. Nel caso di computazioni batch, mentre un ritardo limitato può
essere ammissibile, sicuramente non lo è la corruzione o la perdita dei dati.
Nella filosofia di MapReduce, l’irraggiungibilità di un numero limitato di nodi prima
della fase di esecuzione è facilmente sopportabile a livello di calcolo, grazie
all’astrazione tra algoritmo e piattaforma. Lo stesso vale per la disponibilità dei dati:
l’irraggiungibilità di specifici nodi può essere superata aggiungendo delle repliche
dislocate dei dati a livello di filesystem distribuito.
Nel caso si verifichi un guasto durante l’esecuzione di un calcolo, il sistema deve essere
in grado di portarlo ugualmente a compimento. La strategia suggerita in questo caso è
la riesecuzione: nel caso un nodo diventi irraggiungibile, le parti di calcolo assegnate a
quel nodo (nella forma di esecuzioni di chiamate alle funzioni map o reduce) vengono
riassegnate ad altri nodi.
1.4.2 Elaborazione sequenziale dei dati, non casuale
MapReduce è stato concepito per elaborare, in modalità batch, enormi quantità di dati
che risiedono necessariamente nei dischi, essendo troppo grandi da tenere in memoria.
Come già detto nel Paragrafo 1.1.2, il seek time costituisce il limite maggiore quando
si tenta di accedere al disco in maniera random. Di conseguenza, MapReduce tenta di
evitare il più possibile l’accesso casuale, preferendo l’accesso ai dati in modo
sequenziale. Trattandosi di computazioni batch, l’idea di MapReduce è quella di
favorire il throughput7
a scapito della latenza8
, sfruttando la banda aggregata dei dischi
di un cluster.
1.4.3 Concentrare l’elaborazione sui dati
In alcuni sistemi di calcolo ad alte prestazioni è comune disporre di supercomputer
dove vi è una distinzione tra nodi di calcolo e nodi di memorizzazione, collegati da
interconnessioni ad elevato throughput. In tali sistemi, l’elaborazione di enormi moli
di dati può portare ad un inevitabile collo di bottiglia, costituito dalle interconnessioni.
In MapReduce, invece, ciascun nodo svolge entrambi le funzioni, sia di
memorizzazione e sia di calcolo. Questo permette di ridurre notevolmente la quantità
di dati trasferiti da un nodo all’altro, eseguendo la funzione map direttamente sul nodo
dove risiedono i dati di input, sfruttando in questo modo il principio di località dei
7 Il throughput indica il numero di operazioni processate per unità di tempo.
8 La latenza è il tempo richiesto da una singola operazione per essere processata dall’inizio alla fine.
9
Capitolo 1 MapReduce
dati. Ovviamente ciò è possibile in cooperazione con il filesystem distribuito,
responsabile della gestione dei dati sui quali opera MapReduce.
1.4.4 Semplice scalabilità
Un algoritmo ideale in grado di elaborare grandi quantità di dati deve essere
linearmente scalabile, sia in riferimento ai dati da elaborare, sia in riferimento alle
risorse hardware a disposizione. Se un algoritmo richiedesse 1 ora per elaborare un
particolare insieme di dati su una singola macchina, allora in un cluster di 100
macchine lo stesso algoritmo su un insieme di dati 100 volte maggiore idealmente
dovrebbe richiedere lo stesso tempo, ossia 1 ora.
Uno degli aspetti di maggior rilievo di MapReduce è proprio il fatto di riuscire ad
avvicinarsi il più possibile a tale caratteristica di scalabilità lineare.
1.4.5 Parallelizzazione implicita
È noto come lo sviluppo di applicazioni parallele sia un compito alquanto complesso,
in quanto le problematiche relative a fenomeni quali deadlocks e race conditions sono
intrinsecamente difficili da individuare, isolare e risolvere. Sebbene esistano molte
tecniche e design patterns che possono parzialmente sopperire a questa difficoltà, la
programmazione distribuita e parallela rimane una sfida non semplice da affrontare.
MapReduce si fa carico di gestire queste problematiche, in questo modo il
programmatore potrà concentrarsi solo sulla progettazione delle due funzioni map e
reduce, la cui esecuzione parallela è garantita dal framework MapReduce.
1.4.6 Architettura Scale-out
La scalabilità indica la capacità di un sistema di evolvere in potenza, aggiungendo o
sostituendo un componente. Il concetto dietro alla scalabilità orizzontale – approccio
scaling out – è quello di usare hardware commodity, ossia facile da reperire e dal costo
limitato. A differenza della scalabilità verticale – approccio scaling up – in cui si
installano server sempre più potenti, nel caso di quella orizzontale si possono
aumentare le performance del sistema aumentando il numero di server di classe media,
suddividendo le risorse in tanti piccoli nodi low-end interconnessi fra di loro.
L’obiettivo è quello di poter creare un cluster di nodi che per potenza di calcolo,
throughput e scalabilità offra maggiori garanzie di un sistema tradizionale ma a costi
più ridotti. Una tale architettura è anche definita shared-nothing, poiché ciascun nodo
10
Capitolo 1 MapReduce
dispone di risorse a esso dedicate, suddividendo l’esecuzione di un’operazione in più
task paralleli e indipendenti.
MapReduce è stato concepito per sfruttare questo tipo di architettura, favorendo la
località dei dati, per minimizzare quanto più possibile onerosi trasferimenti di dati tra
diversi nodi della rete. Il programma, infatti, viene suddiviso in task in base a dove
sono localizzati i dati. Viene data priorità all’esecuzione dei map task sulla stessa
macchina su cui risiedono fisicamente i dati, o almeno nello stesso rack.
1.5 Quando usare MapReduce?
I programmi MapReduce non hanno la garanzia di essere veloci. Il maggiore beneficio
di questo modello di programmazione è quello di distribuire le operazioni in modo
ottimale sull’hardware a disposizione, cosicché il programmatore possa concentrarsi
solo sui requisiti funzionali e quindi nella scrittura del codice riguardante le funzioni
map e reduce. Tuttavia, tener conto della funzione di partizione e della quantità di dati
scritta dalla funzione map potrebbe avere un grande impatto sulle prestazioni.
Funzionalità aggiuntive, come la funzione combiner, possono inoltre contribuire a
ridurre la quantità di dati scritti sul disco e trasmessi da un nodo all’altro sulla rete.
Nel progettare un algoritmo MapReduce, il programmatore dovrà scegliere un buon
compromesso tra velocità di computazione e overhead dovuto alle comunicazioni,
dato che molte implementazioni MapReduce sono progettare per registrare tutte le
comunicazioni sul file system per favorire il successivo recupero dai guasti.
Per i processi che terminano velocemente, e per quelli dove la quantità di dati è
relativamente piccola, tale da essere contenuta nella memoria principale di una singola
macchina o di un piccolo cluster, l’utilizzo del framework MapReduce generalmente
non è efficace: dal momento che il framework è progettato per facilitare il ripristino in
caso di guasti di un nodo qualsiasi durante la computazione, esso scrive i risultati
intermedi sul file system distribuito. Tale meccanismo di ripristino risulta costoso, e
paga solo quando la computazione coinvolge molti computer e calcoli elaborati – una
computazione che termina in pochi secondi può solo essere riavviata in caso di errore;
la probabilità che si verifichi almeno un guasto aumenta rapidamente con la
dimensione del cluster. Per tali problemi, le implementazioni mantengono tutti i dati
in memoria e semplicemente riavviano la computazione in caso di guasto di un nodo,
oppure – quando la dimensione dei dati è abbastanza piccola – soluzioni non
distribuite risultano spesso più veloci di un sistema MapReduce.
11
Capitolo 2 Hadoop
Apache Hadoop
“Al tempo dei pionieri questi usavano i buoi per trainare i carichi pesanti, e quando un
bue non riusciva a tirare un tronco essi non tentavano di allevare buoi più grossi. Noi non
dobbiamo provare a costruire computer più grandi, ma sistemi di più computer”
– Grace Hopper
adoop è una piattaforma software open source, affidabile e scalabile, finalizzata
al calcolo distribuito, cioè al calcolo che avviene su un sistema di computer
indipendenti, ma collegati tra loro in rete; permette alle applicazioni di lavorare con
migliaia di nodi e petabyte di dati.
Apache Hadoop consente di archiviare e analizzare i dati e costituisce il modo per
creare valore dai cosiddetti Big Data. Tutti sanno che i dati sono in crescita
esponenziale. Cosa non è così chiaro è il modo di sbloccare il valore che detengono.
Hadoop è la risposta. Sviluppato da Doug Cutting di Cloudera, Hadoop è un
framework che consente di distribuire l'elaborazione parallela di grandi quantità di dati
su hardware commodity, relativamente poco costoso.
Hadoop è in grado di gestire tutti i tipi di dati provenienti da sistemi diversi: strutturati,
non strutturati, file di log, immagini, file audio, documenti, comunicazioni e-mail,
tutto quello che si può pensare. Anche quando i diversi tipi di dati sono stati
memorizzati in sistemi non correlati, è possibile scaricare il tutto in un cluster Hadoop
prima ancora di sapere come si potrebbe trarne vantaggio in futuro.
Con Hadoop i dati non sono mai troppo grandi. In un mondo in cui le persone, le
imprese e le macchine creano dati continuativamente, la capacità di Hadoop di
crescere praticamente senza limiti permette di sbloccarne il potenziale valore.
Una curiosità: il nome Hadoop proviene da un elefante giallo di peluche del figlio di
Doug Cutting, il quale lo ha scelto perché è semplice da scrivere e pronunciare, privo
di significato e non usato altrove.
CAPITOLO 2
H
12
Capitolo 2 Hadoop
2.1 Panoramica
La crescita impressionante dei dati osservata negli ultimi anni, e destinata a proseguire
nel futuro, ha fatto nascere molti progetti indirizzati a trovare delle soluzioni il più
possibile semplici ed economiche sia per archiviare tali informazioni, sia per eseguire
delle elaborazioni su moli di dati fino a poco tempo fa impensabili. Poiché la gran parte
delle informazioni oggi generate è di tipo non strutturato, è in questa direzione che
molti dei progetti si sono mossi e tra questi anche Hadoop.
Hadoop nasce come progetto per l’analisi distribuita di grandi insiemi di dati
attraverso un semplice modello di programmazione. L’architettura, realizzata in Java,
permette di poter scalare da pochi server fino a migliaia di sistemi: ogni server
contribuisce con le proprie risorse di calcolo e la propria capacità di memorizzare i
dati, e quindi aggiungendo server, chiamati anche nodi, è possibile far crescere un
sistema Hadoop in modo quasi lineare.
L’alta affidabilità, e dunque la protezione dei dati, viene realizzata non basandosi sulle
caratteristiche hardware dei server, bensì a livello software: sono le librerie di Hadoop
che si occupano di identificare se e quali componenti presentino un
malfunzionamento, intervenendo per ripristinare le operazioni, ad esempio creando
una nuova copia dei dati contenuti in un server. È evidente che nella scala dei petabyte
le soluzioni di backup tradizionali non sono utilizzabili, quindi è proprio la
distribuzione dei dati su diversi nodi la chiave per salvaguardare le informazioni anche
di fronte ad un guasto di uno dei nodi.
Le componenti costituenti il nucleo centrale di Hadoop sono:
 Hadoop common. Uno strato di software comune che fornisce funzioni di
supporto agli altri moduli.
 HDFS. Il file system distribuito che fornisce un’efficace modalità di accesso ai
dati. Garantisce ridondanza e affidabilità. Accetta dati in qualsiasi formato.
 YARN. Un framework che consente di creare applicazioni o infrastrutture per il
calcolo distribuito. Si occupa della gestione delle risorse del cluster.
 MapReduce. Il sistema di elaborazione parallela dei dati (basato su YARN a
partire della versioni 0.23.X e 2.X.X di Hadoop).
Al nucleo centrale, “sopra” HDFS e MapReduce, si aggiungono altri moduli che fanno
parte dell’ecosistema, estendendone le funzionalità. La Figura 2.1 mostra l’insieme
13
Capitolo 2 Hadoop
delle componenti dell’ecosistema Hadoop e nella Tabella 2.1 sono elencate in breve le
relative funzionalità.
Figura 2.1 – Architettura di Hadoop
Tabella 2.1 – Funzionalità delle componenti dell’ecosistema Hadoop
Componente Descrizione
HDFS Hadoop Distributed File System. Garantisce l’accesso ai dati in un qualsiasi nodo del cluster Hadoop. Accetta
dati in un qualsiasiformato, strutturato o non strutturato.
YARN Sistemadigestionedellerisorsedelcluster,checonsentedicreareapplicazionioinfrastruttureperilcalcolo
distribuito.
MapReduce Piattaformasoftwareperlacreazionediapplicazionicheprocessanograndimolididatiinparallelosucluster
di molti nodi.
Hive Sistema di data warehousing costruito su Hadoop, che consente di aggregare dati, eseguire query e
analizzare grandi dataset. Hive utilizza il linguaggio HiveQL, simile sintatticamente a SQL.
R (connettori) R è un software statistico in grado di utilizzare Hadoop attraverso i plug-in (connettori) RHive e RHadoop.
Pig Libreria che semplifica la creazione di job di trasformazione dei dati. Pig, con il suo linguaggio chiamato Pig
Latin, consente di scrivere sequenze di operazioni di trasformazione in maniera piuttosto semplice, che Pig
stesso converte in job MapReduce.
Mahout Libreria di Machine Learning e Data Mining
HBase È un database column oriented, distribuito e scalabile, che si basa su HDFS.
Oozie Strumento di gestione del workflow delle operazioni.
Zookeeper Strumento di coordinamento e sincronizzazione delle risorse per applicazioni distribuite.
Flume Sistema per la movimentazione di grandi quantità di dati da fonti di diverso tipo verso HDFS (o altre
destinazioni). Presenta un’architettura semplice e flessibile basata sullo streaming di flussi di dati.
Sqoop Libreria per il trasferimento di dati tra database relazionali e Hadoop.
Ambari Strumenti di monitoraggio e amministrazione del cluster Hadoop.
14
Capitolo 2 Hadoop
2.1.1 Origini del progetto e diffusione attuale
Hadoop nasce per sopperire a un problema di scalabilità di Nutch1
, un crawler2
open
source. Doug Cutting e Michael J. Caffarella hanno lavorato su un embrione di
Hadoop a partire dal 2004, anno in cui furono pubblicati documenti tecnici riguardanti
Google File System e Google MapReduce, tecnologie da cui Hadoop ha attinto.
Inizialmente si trattava di un componente di Nutch, in grado di migliorarne la
scalabilità e le prestazioni. Nel 2008 nasce la prima release come progetto open source
indipendente di Apache, realizzata anche grazie all’assunzione da parte di Yahoo! di
Cutting, al quale fu messo a disposizione un team di sviluppo.
Hadoop è ormai riconosciuto come una delle più promettenti soluzioni
general-purpose per i Big Data, capace di memorizzare grandi quantità di dati e fornire
una semplice ma potente piattaforma di analisi: numerose distribuzioni di Hadoop
sono oggi messe a disposizione da aziende storiche dell’IT quali EMC, IBM e
Microsoft, oltre che da realtà specializzate sulle tecnologie Hadoop quali Cloudera.
Ebay, Facebook, LinkedIn, Twitter e AOL sono solo alcune tra le più importanti realtà
che attualmente fanno uso di Hadoop3
.
2.1.2 Senza Hadoop?
Prima dell’affermazione di Hadoop, le elaborazioni su grandi quantitativi di dati erano
realizzate esclusivamente da sistemi di High Performance Computing4
(HPC) e Grid
Computing5
, tramite l’utilizzo di API quali, per esempio, Message Passing Interface
(MPI), un protocollo di comunicazione tra nodi appartenenti a un cluster di computer
che eseguono un programma parallelo sviluppato per sistemi a memoria distribuita.
Gli HPC suddividono il lavoro su molti computer in cluster, che utilizzano un file
system condiviso, cioè un insieme di dischi raggiungibili da tutti i nodi del cluster. Se
l’attività è processor-intensive, il sistema funziona bene, ma qualora occorresse
1 Nutch è un progetto finalizzato alla costruzione di un motore di ricerca open source. È basato su
Lucene, una libreria di ricerca e di indicizzazione che inizialmente non conteneva un crawler,
mancanza poi sopperita da Nutch.
2 I crawler, detti anche spider o robot, sono componenti dei motori di ricerca che analizzano i contenuti
di una rete (o di un database) in un modo metodico e automatizzato, recuperando i contenuti delle
pagine e fornendoli al motore di ricerca per l’indicizzazione.
3 Al link http://wiki.apache.org/hadoop/PoweredBy sono indicati i maggiori utilizzatori di Hadoop.
4 Il termine High Performance Computing si riferisce alle tecnologie utilizzate da computer cluster per
creare dei sistemi di elaborazione in grado di fornire delle prestazioni molto elevate, ricorrendo
tipicamente al calcolo parallelo.
5 I Grid Computing sono un’infrastruttura di calcolo distribuito, utilizzati per l’elaborazione di grandi
quantità di dati, mediante l’uso di una vasta quantità di risorse.
15
Capitolo 2 Hadoop
accedere a grandi moli di dati, le performance non sarebbero ottimali a causa di
problemi di rete: l’accesso di tutti i nodi del cluster alla risorsa di storage condivisa
costringerebbe i nodi stessi ad attendere l’arrivo dei dati. Inoltre le MPI sono librerie
di basso livello, piuttosto complesse.
Al contrario, Hadoop con HDFS e MapReduce offre librerie di alto livello, più semplici
da utilizzare. Inoltre la ripartizione dei dati direttamente sui nodi di calcolo permette
di minimizzare i tempi di accesso, poiché i dati sono immediatamente disponibili alle
procedure, senza onerosi trasferimenti di rete.
2.1.3 Caratteristiche salienti
Hadoop è un sistema altamente affidabile: esso gestisce gli eventuali problemi del
sistema a livello applicativo, invece di sfruttare sistemi hardware di alta disponibilità.
Hadoop, infatti, è pensato per sfruttare cluster di commodity hardware, che può essere
frequentemente soggetto a problemi e che non prevede meccanismi di fail-over6
.
Un’altra importante caratteristica di Hadoop è la scalabilità, che è realizzabile
semplicemente aggiungendo nodi al cluster. Ciò concorre a limitare i costi rispetto ad
una soluzione basata su database tradizionale, dove spesso la scalabilità si realizza
sostituendo l’hardware esistente con macchine più potenti ed estremamente costose.
Hadoop nasce per la gestione di calcoli ed elaborazioni su grandi moli di dati, caricati
nel sistema e utilizzati, in lettura, da una o più procedure. Tale utilizzo è nettamente
all’opposto rispetto a un database relazionale OLTP7
(Online Transaction Processing),
nel quale le singole transazioni interessano soltanto pochi record. L’utilizzo di Hadoop
in tali scenari non sarebbe efficiente e non avrebbe senso, poiché si tratta di attività
gestite in modo ottimale dagli RDBMS.
2.2 HDFS
HDFS (Hadoop Distributed File System)8
è un file system distribuito appositamente
progettato per poter utilizzare commodity hardware, dato che è altamente
fault-tolerant. HDFS è in grado di gestire un numero elevatissimo di file, anche di
6 Il meccanismo di fail-over implica il monitoraggio continuo del sistema, e consente di far fronte a
malfunzionamenti che si verificano su un nodo, spostandone le attività su altri nodi.
7 Un database OLTP presenta un modello dati fortemente normalizzato per favorire non tanto le letture
e l’analisi di grandi quantità di record, quanto le attività transazionali, quali inserimenti, cancellazioni
e modifiche di porzioni di dati.
8 Al link http://goo.gl/kCnIht è possibile trovare vignette autoesplicative sul funzionamento di HDFS.
16
Capitolo 2 Hadoop
dimensioni ragguardevoli (dell’ordine dei gigabyte o terabyte), attraverso la
realizzazione di cluster che possono contenere migliaia di nodi.
L’utilizzo di hardware a buon mercato e la possibilità di configurare cluster con
moltissimi elementi comportano una certa probabilità di avere guasti frequenti che
possono rendere indisponibili uno o più nodi. Per questo la capacità di identificare
problemi e di effettuare operazioni di recovery automatiche è una delle caratteristiche
principali del file system di Hadoop.
Rispetto ai file system general purpose (come NFS9
o CIFS10
), HDFS è costruito
attorno all’idea di un utilizzo dei dati in modalità write-once, read-many. Questo
ovviamente non significa che i dati non possano essere modificati, ma indica un
approccio differente all’utilizzo dei dati stessi: come è tipico del mondo Big Data, non
ci si aspetta di accedere in modo chirurgico ad un singolo file o ad una porzione di
questo, ma piuttosto è previsto che le analisi operino su una gran parte dei dati
memorizzati (se non tutti). HDFS, infatti, supporta solo un limitato insieme di
operazioni sui file, quali letture, scritture, eliminazioni ma non aggiornamenti e, per di
più, non fornisce un meccanismo di caching locale dei dati. L’overhead dovuto al
caching, su grandi insiemi di dati, diventa talmente rilevante che la rilettura dei dati
dalla sorgente è la soluzione migliore dal punto di vista della prestazioni.
HDFS, inoltre, è stato pensato per operazioni che attraversino una porzione
importante dei dati disponibili, con un focus sulla scalabilità di questo percorso di
accesso: profili di accesso ai dati sensibili alla latenza (qualche millisecondo) non sono
adatti ad essere ospitati in HDFS. Per cui, HDFS non è la soluzione migliore in caso di
applicazioni che richiedano un accesso ai dati in tempi molto ridotti, dato che il
throughput è ottimizzato a spese della latenza.
2.2.1 NameNode e DataNode
HDFS presenta i file organizzati in una struttura gerarchica di directory, come qualsiasi
altro file system. Come mostrato nella Figura 2.2, i file sono organizzati come sequenze
di blocchi della stessa dimensione, memorizzati nel cluster Hadoop. Un file può essere
costituito da diversi blocchi, che sono memorizzati su differenti DataNode, ossia
applicazioni che girano sugli altri nodi del cluster, generalmente una per nodo, e
9 Network File System. Consente ai computer di utilizzare la rete per accedere agli hard disk remoti
come fossero dischi locali.
10 Common Internet File System. Permette un accesso unificato e parallelo ai file remoti presenti su
diversi sistemi operativi.
17
Capitolo 2 Hadoop
gestiscono fisicamente lo storage di ciascun nodo. In pratica eseguono le operazioni di
lettura e scrittura richieste dai client e gestiscono fisicamente la creazione,
cancellazione o replica dei blocchi di dati.
Figura 2.2 – Architettura di HDFS
Il DataNode memorizza ogni blocco di dati HDFS in un file separato sul proprio
filesystem locale, senza nessuna conoscenza circa i file stessi. Per migliorare il
throughput, il DataNode non crea tutti i file nella stessa directory, ma utilizza delle
euristiche per determinare il numero ottimale di file per directory, e crea sottodirectory
in modo appropriato.
Uno dei requisiti per un tale filesystem strutturato a blocchi è la capacità di
memorizzare, gestire ed accedere ai metadati11
del file in modo affidabile e veloce.
Diversamente dagli stessi file HDFS, il cui accesso è regolato dal paradigma write-once
e read-many, la struttura dei metadati può essere modificata da un numero
considerevole di client in modo concorrente. È fondamentale che tali informazioni
siano sempre sincronizzate. A tal proposito, HDFS si avvale di un’applicazione che gira
sul server principale, ossia il NameNode, che memorizza i metadati per il filesystem.
Questo significa che HDFS presenta un’architettura master/slave. Un singolo
NameNode gestisce il namespace, ovvero l’elenco dei nomi dei file e dei blocchi e
regola l’accesso ai file da parte dei client. L’esistenza di un singolo master nel cluster
semplifica notevolmente l’architettura del sistema.
Dato che la quantità di metadati per file è relativamente limitata, il NameNode
memorizza tutti questi dati nella memoria principale, permettendo in tal modo un
11 I metadati sono informazioni che descrivono caratteristiche e proprietà dei file e dei blocchi.
18
Capitolo 2 Hadoop
accesso random molto veloce. Poiché la memoria è progettata per essere compatta, un
NameNode con 4 GB di RAM è in grado di supportare un gran numero di file e
directory.
Inoltre, la memoria dei metadati è anche persistente. L’intero namespace del filesystem
è contenuto in un file chiamato FsImage memorizzato nel filesystem locale del
NameNode. Il NameNode utilizza anche un log dei cambiamenti avvenuti al
namespace a partire dall’ultima volta in cui il file FsImage è stato aggiornato. Tali
cambiamenti sono registrati in un file detto EditLog. Quando il NameNode parte,
unisce questi due file in modo da produrre uno snapshot12
dell’ultima situazione. A
questo punto il file FsImage è sovrascritto con lo snapshot.
L’approccio master/slave di HDFS semplifica l’architettura, ma comporta
inevitabilmente un’importante criticità: un problema al NameNode implicherebbe
l’indisponibilità dell’intero cluster. Per attenuare questo problema è stato
implementato il Secondary NameNode, detto anche CheckPoint Node.
Il Secondary NameNode non è un nodo di backup, non si fa carico delle funzioni del
NameNode. Si occupa, invece, di scaricare periodicamente il file FsImage e il log dei
cambiamenti dal NameNode, di unirli in un unico snapshot, che è poi restituito al
NameNode e potrebbe essere utilizzato in caso di problemi su quest’ultimo. La sua
copia però non è aggiornata. Per questo, recentemente è stato introdotto anche il
Backup Node, che mantiene una copia read-only del NameNode, sincronizzata in
tempo reale.
Inoltre, a partire dalle versioni di Hadoop marcate come 2.X.X, due diversi server sono
configurati come NameNode: uno di essi è attivo, mentre l’altro è in standby, pronto
a subentrare in caso di problemi al primo nodo.
2.2.2 Blocchi e replicazione
Affinché la memoria necessaria al NameNode rimanga gestibile, la dimensione di
default di un blocco HDFS è 64 MB (o 128 MB), molto più grande rispetto alla
dimensione dei blocchi di un tipico filesystem, che comunemente si assesta su pochi
kilobyte. Tali dimensioni, inoltre, permettono che grandi quantità di dati siano
memorizzate sequenzialmente sul disco, minimizzando in tal modo il seek time per
consentire letture veloci in streaming.
12 Uno snapshot rappresenta un’istantanea dello stato di un oggetto o del sistema in un particolare
momento.
19
Capitolo 2 Hadoop
Per assicurare l’alta disponibilità, HDFS replica ogni blocco su un certo numero di
nodi – tre, per default. Tali repliche sono utilizzate sia per garantire l’accesso a tutti i
dati anche in presenza di problemi ad uno o più nodi, sia per migliorare il recupero dei
dati. In HDFS, infatti, per le richieste di lettura dati, sono scelti i nodi più vicini al client
che effettua la lettura. In presenza di dati ridondanti è in tal modo più semplice
soddisfare questo requisito.
Una strategia di replica consiste nel copiare un blocco su altri DataNode, appartenenti
a rack13
diversi. In tal modo si minimizzano i rischi legati ai guasti (sia del rack, sia dei
nodi), si massimizzano le performance di lettura, poiché può essere utilizzata la banda
di rete di rack differenti, ma si appesantiscono le scritture, dato che occorre spostare
dati su diversi rack.
Tipicamente, la banda di rete, e conseguentemente le performance della rete, tra
macchine nello stesso rack è maggiore della banda di rete tra macchine in rack
differenti. Per questo motivo, è possibile migliorare le performance relative al
trasferimento dati utilizzando un numero di rack minore del numero di repliche. Per
esempio, quando il fattore di replicazione è tre, due repliche sono posizionate su un
rack, e la terza su un rack differente. In questo modo si ottiene un incremento delle
performance relative alla scritture delle diverse repliche.
Per minimizzare il consumo di banda globale e la latenza di lettura, HDFS tenta di
soddisfare una richiesta di lettura dalla replica più vicina, meglio se dallo stesso rack.
2.3 Hadoop MapReduce
Il motore di elaborazione fondamentale di un sistema Hadoop è MapReduce. Fornisce
tutte le funzionalità necessarie per partizionare i Big Data in blocchi gestibili, elaborare
i dati in parallelo su cluster distribuiti, e quindi rendere i dati disponibili all’utente o
pronti per ulteriori elaborazioni. E fa tutto questo lavoro in un ambiente altamente
resiliente14
e tollerante ai guasti.
Con MapReduce e Hadoop, i calcoli sono eseguiti sul nodo in cui sono presenti i dati.
Inoltre, lavorando in tandem con HDFS, MapReduce assicura che la memorizzazione
e l’elaborazione dei dati coesistano sullo stesso nodo fisico nel cluster, limitando
13 I rack sono strutture simili ad armadi che ospitano apparati di rete, quali server, switch, router, ecc.
14 Il termine resilienza indica la capacità di un sistema di adattarsi alle condizioni d'uso e di resistere
all'usura in modo da garantire la disponibilità dei servizi erogati. Tali obiettivi si possono raggiungere
mediante tecniche di ridondanza o distribuendo un'applicazione su più calcolatori in modo da
assorbire i carichi elaborativi.
20
Capitolo 2 Hadoop
notevolmente i colli di bottiglia tradizionali, quali la larghezza di banda di rete, dovuti
a trasferimenti di grosse quantità di dati.
Per cui, MapReduce combina computazione parallela, distribuita e sequenziale,
mescolando semplicità, potenza e scalabilità in un unico cocktail.
Numerosi problemi pratici – come analisi dei log, ordinamento dei dati, analisi dei
grafi, calcoli matematici complessi, operazioni del mondo relazionale, creazione di
inverted index15
, e tantissimi altri – sono stati risolti utilizzando MapReduce.
2.3.1 Java MapReduce
La scrittura di un programma MapReduce comporta fondamentalmente la creazione
di una funzione map, una funzione reduce, e del codice addizionale per eseguire il job.
La funzione map è rappresentata dalla classe Mapper, che dichiara un metodo astratto
map(). La classe Mapper è di tipo generico, con quattro tipi formali di parametri che
specificano i tipi della chiave di input, del valore di input, della chiave di output e del
valore di output della funzione map.
I tipi dato delle chiavi e dei valori sono oggetti che implementano una specifica
interfaccia chiamata Writable, che consente ad Hadoop di scrivere (e leggere) i dati su
(o da) file e sono ottimizzati per la serializzazione16
di rete. Alcuni tipi di dato tra i più
comuni sono Text, IntWritable, LongWritable, FloatWritable, BooleanWritable,
ByteWritable, ArrayWritable e così via.
Il metodo map() fornisce un’istanza di Context, destinata a contenere l’output della
funzione map, ossia una collezione di chiavi e valori.
La funzione reduce è similmente definita utilizzando la classe Reducer. In modo del
tutto simile a quanto accade per la funzione map, anche questa classe ha un metodo,
chiamato reduce(), che svolge il lavoro. Anche in questo caso si hanno quattro
parametri formali che specificano input e output della funzione reduce. I tipi di input
della funzione reduce devono combaciare con i tipi di output della funzione map.
15 Gli inverted index sono strutture dati che memorizzano un mapping tra il contenuto – come parole o
numeri – e la relativa locazione in un documento o un insieme di documenti. Sono utilizzati
soprattutto per agevolare la ricerca full-text e sono componenti centrali di un tipico motore di ricerca.
16 La serializzazione è un processo per salvare un oggetto in un supporto di memorizzazione lineare (ad
esempio, un file o un'area di memoria), o per trasmetterlo su una connessione di rete. La
serializzazione può essere in forma binaria o può utilizzare codifiche testuali (ad esempio il formato
XML) direttamente leggibili dagli esseri umani. Lo scopo della serializzazione è di trasmettere l'intero
stato dell'oggetto in modo che esso possa essere successivamente ricreato nello stesso identico stato
dal processo inverso, chiamato deserializzazione.
21
Capitolo 2 Hadoop
Alla funzione reduce giungono, quindi, le coppie chiave/valore già ordinate e separate
in partizioni, attraverso un processo chiamato shuffling, che assegna un certo
intervallo di chiavi a ciascun nodo reducer.
La classe Mapper e la classe Reducer non sono sufficienti alla definizione di un
programma MapReduce. Occorre infatti creare un’ulteriore classe, chiamata Driver,
che ha il compito di inizializzare il job, passare i parametri di input, definire dove
posizionare l’output, e altre configurazioni opzionali. Tale classe imposta il nome del
job, le classi che costituiscono i tipi di dati per le chiavi e i valori di output, la classe
Mapper, la classe Reducer, la classe Combiner (di cui si è parlato nel Paragrafo 1.2.2) e i
formati dell’input e dell’output. Inoltre, il driver imposta i percorsi di input e di output,
ricevuti come parametri, ed è possibile configurare il numero di mapper e reducer.
Il compito finale del driver, una volta impostate tutte le necessarie configurazione, è
quello di lanciare il job MapReduce. Ciò avviene attraverso una singola chiamata al
metodo submit() su un oggetto Job, oppure è possibile chiamare il metodo
waitForCompletion() che ritorna un valore booleano indicante il successo o il
fallimento del job.
Il formato di input determina la modalità di lettura dei dati e ciò che è passato al
mapper come chiave e valore. La tabella 2.2 riassume i formati di input.
Tabella 2.2 – Formati di input di MapReduce
Nome formato Descrizione Chiave Valore
TextInputFormat È il formato di default e
determina la lettura di intere
righe da un file.
La chiave è l’offset della riga. Il valore è l’intera riga.
KeyValueInputFormat Suddivide le righe lette in
chiavi e valori.
La chiave è ciò che si trova a
partire dall’inizio della riga
fino al primo carattere Tab.
Il valore è il resto della riga.
SequenceFileInputFormat Formato binario di Hadoop. Definita dall’utente. Definito dall’utente.
Nella tabella 2.3 sono invece riassunti i formati di output.
Tabella 2.3 – Formati di output di MapReduce
Nome formato Descrizione
TextOutputFormat È il formato di default. Genera righe nel formato chiave valore, separati dal carattere Tab.
KeyValueOutputFormat Nongeneraalcunoutput.Èutilizzatoquandolosviluppatorecrea,direttamentenellafunzione
reduce, il proprio output.
SequenceFileOutputFormat Formato binario di Hadoop, utilizzatoper passare dati tra job MapReduce.
22
Capitolo 2 Hadoop
2.3.2 Esecuzione di un job MapReduce
Come detto nel Paragrafo precedente, è possibile eseguire un job MapReduce
attraverso una singola chiamata al metodo submit() su un oggetto Job. Dietro a questa
semplice chiamata si nasconde una grande quantità di elaborazione.
La figura 2.3 illustra i passi di esecuzione di un job MapReduce. Al livello più alto, ci
sono quattro entità indipendenti:
 Il client, che sottopone il job MapReduce.
 Il JobTracker, che coordina l’esecuzione del job.
 Il TaskTracker, che esegue i task nei quali è stato splittato il job.
 Il Filesystem distribuito (normalmente HDFS), che è usato per la condivisione dei
file del job tra le diverse entità.
Figura 2.3 – Come Hadoop esegue un job MapReduce
Il metodo submit() sul Job crea un’istanza interna JobSubmmitter e chiama
submitJobInternal() su esso (step 1 in Figura 2.3). Il JobSubmmitter interroga il
JobTracker per ottenere un nuovo job ID (step 2). Inoltre, copia le risorse necessarie
23
Capitolo 2 Hadoop
all’esecuzione del job sul filesystem del JobTracker, incluso il file JAR del job, il file di
configurazione e gli input split che calcola (step 3). Infine, avvisa il JobTracker che il
job è pronto per l’esecuzione (step 4).
Quando il JobTracker viene informato che il job è pronto, esso lo pone in una coda
interna da dove il job scheduler lo raccoglie e lo inizializza. L’inizializzazione implica
la creazione di un oggetto che rappresenta il job, in cui vengono incapsulati i relativi
task e informazioni per tenere traccia dello stato e dei progressi dei task (step 5).
Per creare una lista di task da eseguire, il job scheduler recupera dal filesystem
condiviso gli input split calcolati dal client (step 6). Successivamente crea un map task
per ogni split. Il numero dei reduce task da creare è invece determinato dalla proprietà
mapred.reduce.tasks definita nel Job.
I TaskTracker eseguono un semplice loop con cui periodicamente interrogano il
JobTracker. Queste periodiche interrogazioni permettono anche al JobTracker di
sapere che il TaskTracker è “vivo” e attivo. Un TaskTracker potrebbe inoltre informare
il JobTracker di essere pronto per l’esecuzione di un nuovo task e, in tal caso, il
JobTracker gli alloca il nuovo task, comunicandoglielo attraverso lo stesso flusso di
comunicazione (step 7).
Al momento della scelta del nuovo task da eseguire, se si tratta di un reduce task il
JobTracker sceglie semplicemente il prossimo nella lista. Se si tratta di un map task,
tuttavia, il JobTracker tiene conto della locazione di rete del TaskTracker, scegliendo
un task il cui input split sia quanto più vicino possibile al nodo TaskTracker.
Una volta che è stato assegnato il task al TaskTracker, il prossimo passo è quello di
eseguire tale task. Per prima cosa, il TaskTracker copia dal filesystem condiviso al
filesystem locale tutte le risorse necessarie all’esecuzione del job, come il JAR del job e
qualsiasi altro file essenziale (step 8). Successivamente, crea una directory di lavoro
locale per il task, e estrae il contenuto del JAR in tale directory. Dopodiché crea un
istanza di TaskRunner per eseguire il task.
TaskRunner lancia una nuova Java Virtual Machine (step 9) per eseguire ogni task (step
10), cosicché qualsiasi bug nelle funzioni map e reduce definite dall’utente non
influiscano sul TaskTracker (causando un blocco o un crash, per esempio).
Infine, quando il JobTracker riceve una notifica che l’ultimo task per il job è stato
completato, cambia lo stato per il job in “successful”. Di conseguenza, quando il Job
verifica lo stato, apprende che il job è stato completato con successo, e quindi stampa
un messaggio per informare l’utente.
24
Capitolo 2 Hadoop
2.3.3 Shuffle e Sort
MapReduce assicura che l’input di ogni reducer sia ordinato per chiave. Il processo
con cui il sistema esegue l’ordinamento – e trasferisce gli output del map ai reducer
come input – è detto shuffle. La fase di shuffle costituisce sostanzialmente il cuore di
MapReduce.
L’output della funzione map non viene semplicemente scritto su disco. Il processo è
più complicato, e si avvale di scritture temporanee in memoria e preordinamenti per
ragioni di efficienza. La Figura 2.4 mostra ciò che avviene.
Figura 2.4 – Operazioni di Shuffle e Sort in MapReduce
Ogni map task ha un buffer di memoria circolare in cui scrive gli output. Quando il
buffer raggiunge un certo valore di soglia predefinito, un thread in background
comincerà a riversarne il contenuto sul disco.
Prima di scrivere sul disco, il thread divide i dati in un numero di partizioni
corrispondente al numero di reducer, a cui successivamente saranno inviate. In ogni
partizione, il thread in background esegue un ordinamento per chiave, e se è stata
impostata una funzione combiner, essa sarà eseguita sull’output ottenuto in seguito
all’ordinamento. L’esecuzione della funzione combiner permette di rendere l’output
più compatto, in modo tale che ci siano meno dati da scrivere sul disco locale e da
trasferire successivamente ai reducer.
Ogni qual volta il buffer di memoria raggiunge il valore di soglia, viene generato un
nuovo spill file, cosicché dopo che il map task ha scritto il suo ultimo record di output
potrebbero esserci diversi spill file, opportunamente partizionati e ordinati. Tali spill
file sono uniti – operazione di merge – per formare il file di output finale, che sarà
ordinato per partizioni, dove ogni partizione sarà ordinata per chiave.
25
Capitolo 2 Hadoop
Prodotto il file finale, ogni partizione sarà inviata ad un diverso reducer. Dato che ogni
map task potrebbe produrre gli output in tempi differenti, i reduce task iniziano a
copiare – fase copy – i loro output non appena sono completati. Ogni reduce task ha
un certo numero di thread addetti alla copia cosicché possano prelevare – fetch – gli
output dei mapper in parallelo.
Se gli output del map sono sufficientemente piccoli, saranno copiati in memoria,
altrimenti sul disco. Se il buffer di memoria raggiunge una certa grandezza di soglia,
oppure un numero preimpostato di map output, essi sono uniti e riversati sul disco.
Anche in questo caso, una funzione combiner, se specificata, potrebbe ridurre la
quantità di dati scritti su disco.
Quando tutti gli output del map sono stati copiati, avviene la fase sort, in cui vengono
uniti – merge – gli output del map, mantenendo il loro ordinamento. Successivamente,
durante la fase reduce, si ha un’ultima unione dei segmenti provenienti sia dal disco
che dalla memoria.
Durante la fase reduce, la funzione reduce è invocata per ogni chiave nell’output
ordinato. L’output di questa fase è scritto direttamente sul filesystem di output,
tipicamente HDFS. Nel caso di HDFS, dato che il nodo TaskTracker sta anche
eseguendo un DataNode, la prima replica sarà scritta sul disco locale.
2.4 Hadoop Streaming
Hadoop Streaming è una utility grazie alla quale è possibile utilizzare programmi
eseguibili oppure script come mapper e reducer. Con Hadoop MapReduce è necessario
implementare delle classi Java – principalmente tre: mapper, reducer e driver – con
alcune caratteristiche sostanzialmente predefinite17
. Con Hadoop Streaming, invece, è
sufficiente creare due programmi in grado di leggere dallo standard input e scrivere
sullo standard output. Il programma può essere scritto in un qualsiasi linguaggio di
programmazione ed è compito dell’utility la creazione del job MapReduce, la sua
esecuzione e il relativo monitoraggio.
Le righe lette dall’input sono suddivise tra chiave e valore con il seguente criterio: i
caratteri fino al primo Tab sono considerati chiave, mentre il resto della riga è il valore.
Se non esiste un carattere Tab, la riga è considerata tutta come chiave, e il valore sarà
nullo. Ovviamente è possibile specificare un altro separatore di campi attraverso alcuni
17 Per approfondimenti sulle caratteristiche di un programma MapReduce in Java si consiglia di visitare
la documentazione al link seguente: http://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html
26
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis
Big Data processing: un sistema scalabile per la Sentiment Analysis

Contenu connexe

Big Data processing: un sistema scalabile per la Sentiment Analysis

  • 1. Università degli Studi del Sannio Dipartimento di Ingegneria Corso di Laurea in Ingegneria Informatica Tesi di Laurea Big Data processing: un sistema scalabile per la Sentiment Analysis Luglio 2014 Relatore Prof. Eugenio Zimeo Correlatore Dott. Guido Anzuoni Candidato Francesco Cardinale Matr. 195001566
  • 2. A chi insegue un sogno nella vita ai tenaci, ai testardi, agli ostinati a chi cade e si rialza a chi ci prova sempre e a chi non molla mai. Perché loro sono quelli che guardano avanti quelli che sperimentano sempre quelli che credono nel futuro e non smettono mai di sognare. Quelli che si sentiranno vecchi solo quando i rimpianti saranno superiori ai sogni.
  • 3. Quando si giunge ad un traguardo così importante nella vita, bisogna voltarsi indietro ed avere il coraggio, o forse il buon senso, di ammettere che: sulla strada dei gradi traguardi non si è mai soli. Mi guardo indietro: salite, sorrisi, amici. Guardo avanti: nuove salite, altri sorrisi, gli stessi amici. Molte sono le persone a cui devo molto e da cui ho appreso tanto. A loro vanno tutta la mia gratitudine ed ammirazione. Dedico questo lavoro principalmente alla mia famiglia, in particolare ai miei genitori, per tutti i sacrifici che hanno fatto per darmi la possibilità di realizzare i miei sogni. Ai miei nonni, per la loro fiducia riposta in me. A mio fratello e alla mia sorellina, sempre disponibili a regalarmi un sorriso. A loro vanno tutta la mia stima, il mio rispetto e la mia riconoscenza. Agli amici di sempre, quelli su cui si può sempre contare, quelli a cui basta un semplice sguardo. Capisci l’importanza di averli quando pensi ai momenti più belli della tua vita e li vedi al tuo fianco. A tutti i fantastici ragazzi di ITD Solutions, ai loro consigli e ai loro sorrisi. Da ognuno di loro ho appreso qualcosa, un qualcosa che custodirò gelosamente. Mi hanno accolto come se facessi da sempre parte dell’azienda. In particolare, ringrazio la Dott.sa C. Ruocco e il Dott. L. Ristoratore che, come fratelli maggiori mi hanno insegnato tanto, anche dal punto di vista umano. Al Dott. G. Anzuoni che mi ha dato la possibilità di entrare a far parte di questo gruppo. Mi ha dato più di quanto possa immaginare, mi ha dato un modello a cui aspirare. Grazie e lui ho scoperto questo affascinante mondo di Hadoop e della Sentiment Analysis. Al Prof. E. Zimeo, sempre disponibile nel dispensare consigli e soluzioni, a qualsiasi ora. Grazie a lui ho avuto la possibilità di vivere questa splendida esperienza e di venire a conoscenza di questo nuovo mondo. Francesco Cardinale
  • 4. Indice Indice Indice delle Figure .................................................................................................... vi Indice delle Tabelle.................................................................................................. vii Sommario................................................................................................................ viii Introduzione ..............................................................................................................ix Capitolo 1 – MapReduce............................................................................................ 1 1.1 Introduzione........................................................................................................................1 1.1.1 Panoramica................................................................................................................2 1.1.2 Confronto tra RDBMS e MapReduce.................................................................2 1.2 Fondamenti di Hadoop MapReduce..........................................................................3 1.2.1 Rapida terminologia...............................................................................................4 1.2.2 Flusso di dati..............................................................................................................5 1.3 Modello di programmazione........................................................................................6 1.3.1 Tipi e formato dei dati............................................................................................6 1.3.2 Esempio.......................................................................................................................7 1.4 Per Big Data servono “Big ideas” .................................................................................8 1.4.1 I guasti sono frequenti...........................................................................................8 1.4.2 Elaborazione sequenziale dei dati, non casuale ...........................................9 1.4.3 Concentrare l’elaborazione sui dati...................................................................9 1.4.4 Semplice scalabilità.............................................................................................. 10 1.4.5 Parallelizzazione implicita..................................................................................10 1.4.6 Architettura Scale-out.........................................................................................10 1.5 Quando usare MapReduce? ........................................................................................11 Capitolo 2 – Apache Hadoop .................................................................................. 12 2.1 Panoramica........................................................................................................................13 2.1.1 Origini del progetto e diffusione attuale......................................................15 2.1.2 Senza Hadoop?...................................................................................................... 15 2.1.3 Caratteristiche salienti ........................................................................................16 2.2 HDFS.....................................................................................................................................16 2.2.1 NameNode e DataNode .....................................................................................17 iii
  • 5. Indice 2.2.2 Blocchi e replicazione.......................................................................................... 19 2.3 Hadoop MapReduce ......................................................................................................20 2.3.1 Java MapReduce ................................................................................................... 21 2.3.2 Esecuzione di un job MapReduce...................................................................23 2.3.3 Shuffle e Sort.......................................................................................................... 25 2.4 Hadoop Streaming..........................................................................................................26 2.5 YARN.....................................................................................................................................27 2.6 ZooKeeper..........................................................................................................................29 2.7 Pig..........................................................................................................................................30 2.8 Hive.......................................................................................................................................31 2.8.1 Il modello dati........................................................................................................ 33 2.8.2 Creazione di tabelle ............................................................................................. 34 2.8.3 SerDe......................................................................................................................... 34 2.8.4 Funzioni definite dall’utente.............................................................................35 2.9 HBase....................................................................................................................................36 2.10 Flume ...................................................................................................................................38 2.11 Oozie ....................................................................................................................................40 Capitolo 3 – Sentiment Analysis............................................................................. 42 3.1 Il Web ai tempi del Social Media................................................................................42 3.1.1 Applicazioni della sentiment analysis ...........................................................43 3.1.2 Un case study: La campagna presidenziale di Obama .............................44 3.2 Complessità della Sentiment Analysis.....................................................................44 3.2.1 Modalità di analisi................................................................................................. 45 3.2.2 Il vocabolario e i relativi problemi...................................................................46 3.2.3 I problemi dell’elaborazione del linguaggio naturale .............................47 3.2.4 Il problema dello spam.......................................................................................47 3.3 Definizione del problema.............................................................................................47 3.3.1 Task basilari della Sentiment Analysis...........................................................48 3.3.2 Definizione formale di opinione......................................................................48 3.4 Classificazione di un documento ..............................................................................49 3.4.1 Supervised Learning............................................................................................ 50 3.4.2 Unsupervised Learning.......................................................................................51 3.4.3 Limiti della classificazione per documento .................................................52 3.5 Classificazione a livello di frase ..................................................................................52 3.6 Espansione del vocabolario.........................................................................................53 iv
  • 6. Indice 3.7 Classificazione dei singoli aspetti..............................................................................54 3.7.1 Estrazione degli aspetti ......................................................................................54 3.7.2 Classificazione della polarità.............................................................................55 Capitolo 4 – Sistema per la Sentiment Analysis.................................................... 57 4.1 Panoramica del sistema sviluppato..........................................................................57 4.2 Twitter..................................................................................................................................58 4.2.1 Twitter API............................................................................................................... 59 4.2.2 Formato dei dati.................................................................................................... 60 4.2.3 Perché Twitter?...................................................................................................... 61 4.3 Acquisizione e memorizzazione dei tweet............................................................62 4.3.1 Source....................................................................................................................... 62 4.3.2 Configurazione dell’Agent.................................................................................63 4.3.3 Channel.................................................................................................................... 64 4.3.4 Sink ............................................................................................................................ 64 4.4 Analisi dei dati ..................................................................................................................65 4.4.1 Interpretazione dei dati......................................................................................65 4.4.2 Determinazione del Sentiment........................................................................67 4.4.3 Tabella di output................................................................................................... 74 4.5 Automatizzazione del Sistema...................................................................................74 4.6 Accuratezza del Sistema...............................................................................................75 4.7 Analisi dei risultati...........................................................................................................77 4.7.1 Intervalli temporali............................................................................................... 78 4.7.2 Geolocalizzazione del sentiment ....................................................................82 Capitolo 5 – Conclusioni e sviluppi futuri.............................................................. 84 Appendice A – Cloudera.......................................................................................... 86 Appendice B – Classificazione bayesiana .............................................................. 88 B.1 Classificatore Naïve Bayes............................................................................................88 B.2 Classificatori Naïve Bayes in Weka ............................................................................89 B.2.1 Multinomial Naïve Bayes....................................................................................89 B.2.2 Naïve Bayes............................................................................................................. 90 Appendice C – Pentaho ........................................................................................... 91 Bibliografia e Sitografia.......................................................................................... 92 v
  • 7. Indice delle Figure Indice delle Figure Figura 1.1 – Vista semplificata dell’architettura di MapReduce................................ 4 Figura 1.2 – Flusso dei dati in un job MapReduce ................................................... 5 Figura 1.3 – Esempio WordCount: passi di un job MapReduce ............................... 8 Figura 2.1 – Architettura di Hadoop......................................................................14 Figura 2.2 – Architettura di HDFS.........................................................................18 Figura 2.3 – Come Hadoop esegue un job MapReduce...........................................23 Figura 2.4 – Operazioni di Shuffle e Sort in MapReduce.........................................25 Figura 2.5 - Architettura di YARN .........................................................................28 Figura 2.6 – Architettura di Hive ...........................................................................32 Figura 2.7 – Struttura di HBase..............................................................................38 Figura 2.8 – Architettura di Flume.........................................................................39 Figura 4.1 – Architettura del sistema per la Sentiment Analysis...............................58 Figura 4.2 – Architettura del sistema di acquisizione dei tweet................................62 Figura 4.3 – Distribuzione percentuale delle polarità..............................................78 Figura 4.4 – Trend del sentiment su intervallo temporale di 24 ore .........................79 Figura 4.5 – Trend del sentiment su scala oraria in relazione alla prima partita........80 Figura 4.6 – Trend del sentiment su scala oraria in relazione alla seconda partita. ...81 Figura 4.7 – Trend del sentiment su scala oraria in relazione alla terza partita. ........82 Figura 4.8 – Distribuzione dei tweet positivi per ogni regione. ................................83 vi
  • 8. Indice delle Tabelle Indice delle Tabelle Tabella 1.1 – Confronto tra RDBMS tradizionali e MapReduce ............................... 3 Tabella 2.1 – Funzionalità delle componenti dell’ecosistema Hadoop.....................14 Tabella 2.2 – Formati di input di MapReduce ........................................................22 Tabella 2.3 – Formati di output di MapReduce......................................................22 Tabella 2.4 – Confronto tra RDBMS e Hive ...........................................................31 Tabella 4.1 – Parole chiave del mondo Twitter.......................................................59 Tabella 4.2 – Matrice di Confusione del sistema.....................................................76 Tabella 4.3 – Dati relativi alle tre partite dell'Italia nel Mondiale 2014 ....................79 vii
  • 9. Sommario Sommario “Per natura, all'opinione piace opinare.” – Platone I social media sono i luoghi virtuali dove si concretizzano le comunicazioni interpersonali, dove le opinioni prendono forma e si diffondono. Mentre il passaparola tradizionale è difficile da misurare, le discussioni online sono normalmente visibili e persistenti e dunque possono essere ascoltate, comprese ed analizzate, sia al fine di individuare trend emergenti che per progettare efficaci azioni di comunicazione, pubbliche relazioni e marketing, così come per esaminare gli umori degli utenti. La progressiva diffusione dei social network, sia generalisti (quali Twitter, Facebook o Google+) che specializzati (ad esempio le comunità professionali di LinkedIn), ha reso disponibile una massiccia e inedita quantità di dati, utilizzabile in tempo reale. Questi dati custodiscono una visione d’insieme sull’atteggiamento – meglio conosciuto come sentiment – degli utenti verso un prodotto, un servizio, un’azienda o una singola persona. Il sentiment è quindi il pensiero espresso dagli utenti attraverso i mezzi di comunicazione attualmente disponibili nel Web. L'analisi del sentiment – meglio conosciuta come Sentiment Analysis – è l'insieme delle operazioni con le quali si ascolta il web per rilevare le opinioni, gli umori, i punti di vista degli utenti. Con un approccio basato sulla combinazione di un dizionario dei termini e di un classificatore automatico, si è realizzato un sistema, intrinsecamente scalabile, affidabile e automatizzato, grazie all’utilizzo degli strumenti messi a disposizione da Hadoop, per la determinazione del sentiment degli italiani, sulla base delle loro opinioni espresse su Twitter durante tutto l’arco temporale che ha visto protagonista, nel bene e nel male, la Nazionale Italiana nel Mondiale di calcio brasiliano del 2014. I risultati finali, riportati graficamente tramite Pentaho, consentono di ottenere una visione degli umori e delle emozioni degli italiani sia sulla base di un intervallo temporale variabile, la cui unità minima di tempo è definita su una singola ora, che sulla base di una mappa geografica dell’Italia per ottenere un grafico geolocalizzato. viii
  • 10. Introduzione Introduzione “Al pari di Google, tutta una serie di social media, come Facebook, Twitter, LinkedIn, Foursquare e altri, siedono letteralmente su una montagna di informazioni datizzate che, una volta analizzate, faranno luce sulle dinamiche sociali a tutti i livelli, dall’individuo alla società nel suo complesso” – Viktor Mayer-Schönberger e Kenneth Cukier iviamo nell’era dei dati, o meglio dei Big Data1 ! In un’era in cui l’analisi di grandi moli di dati destrutturati diventa fondamentale, non solo per gli aspetti puramente commerciali e civili, in quanto i dati possono essere d'ausilio anche alla singola persona fisica, i social network diventano un bacino insostituibile di reperimento di informazioni, aprendo innumerevoli opportunità per le aziende. La quantità di informazioni digitali che si generano ogni giorno sta assumendo proporzioni colossali, dal segnale GPS dei telefonini alle strisciate di bancomat e carte di credito, dai Tweet alle chiacchere su Facebook. Non si entra più in Internet, ci viviamo dentro. Fino al 2003 tutti gli strumenti connessi alla rete hanno prodotto 5 miliardi di gigabytes, nel 2010 erano già diventati 80 miliardi, oggi tale quantità viene raggiunta in due giorni. All’origine si tratta di semplici numeri, pura matematica, poi, quando vengono accorpati, letti e interpretati, diventano informazioni. Se elaborati e contestualizzati si trasformano in conoscenza. Gestire ed elaborare queste grandi quantità di dati risulta però complesso. Il diminuire dei costi di memorizzazione, e quindi le dimensioni delle memorie di massa, non è andato di pari passo con le possibilità di accedervi. Ad esempio, nel 1990 un tipico disco2 aveva la capacità di 1370 MB abbinato ad una velocità di trasferimento di 4,5 MB/s, rendendo possibile leggere l'intero contenuto in circa 5 minuti. Al giorno d'oggi, dopo più di 20 anni, dischi di capacità intorno al terabyte sono la norma: la capacità è aumentata di un fattore 1000. Le velocità di trasferimento attuali sono 1 Big data indica i dati prodotti in grande quantità, con notevole rapidità e nei formati più diversi, la cui elaborazione richiede strumenti differenti da quelli convenzionali, in tutte le fasi del processo: dall'acquisizione, alla gestione e all’archiviazione passando per condivisione, analisi e visualizzazione. 2 Le specifiche si riferiscono al modello Seagate ST-41600n. V ix
  • 11. Introduzione invece aumentate solo di un fattore 25 e si assestano nell'ordine dei 100 MB/s, rendendo quindi necessarie più di due ore e mezzo per accedere all'intero contenuto del disco. In molti contesti è emersa la necessità di svolgere elaborazioni di grandi quantità di dati. Agli albori dello sviluppo della rete Internet, e anche per alcuni decenni a seguire, non ci si ponevano queste problematiche proprio perché i mezzi fisici, i computer, non avevano una grande diffusione presso privati e quindi nella casa – o addirittura nelle tasche – di ogni cittadino del mondo economicamente sviluppato. Oggi invece la situazione si è ribaltata e sempre più persone sono in grado di essere loro stessi dei creatori di informazioni oppure collaborano alla creazione delle stesse e in più possono occuparsi della loro promozione e condivisione. Nella realtà contemporanea c’è quindi una grande mole di informazioni disponibili e in costante aumento, alla quale gli utenti accedono e contribuiscono a mantenere in vita e far sviluppare. Ciò anche grazie a strumenti hardware e software di grande diffusione come macchine fotografiche digitali e programmi di fotoritocco, smartphone, piattaforme di facile utilizzo per la gestione di blog, ecc. Si tratta di informazioni e messaggi che una volta generati possono essere modificati e diffusi in rete da chiunque. Nell’economia della rete è informazione tutto ciò che questa è in grado di generare e può essere provato come tale: non solo la semplice notizia, ma anche il fatto che una persona che reputa interessante un video, un’immagine, una notizia, un post, e così via, e decida di condividerlo sulla propria bacheca di Facebook e lì aggiungere un commento per innescare un confronto con gli amici, anche attraverso l’utilizzo di ulteriori strumenti di comunicazione (ad esempio, pubblicando l’articolo in un tweet). È comprensibile quindi come il concetto di informazione assuma una forte dimensione pubblica e collettiva, secondo i canoni propri di Internet. Ed è evidente che quando si parla di informazione non si può riduttivamente intendere solo ciò che l’utente ricerca, ma anche qualsiasi altra azione egli faccia in rete. Quali parole usa per interrogare un motore di ricerca, quanto resta in un pagina, se usa i link, se clicca sulla pubblicità, quale pubblicità, se condivide un contenuto, se carica video su Youtube, quali video vede, e in generale tutto ciò che decide di condividere. Inoltre, la gran mole di dati che produciamo non trae origini solo dalla rete Internet, comunemente nota. Oggi oltre che attraverso i PC e i classici mezzi di comunicazione, l’informazione viene generata e propagata anche da una moltitudine di piccoli x
  • 12. Introduzione dispositivi che supportano, quotidianamente, le nostre attività: navigatori satellitari, telecamere, sensori urbani, telepass, ecc. Le aziende si trovano ad affrontare la sfida posta da questa sempre crescente mole di dati che devono essere catturati, archiviati e utilizzati ai fini di una successiva elaborazione, sia per scopi di business che per produrre nuova conoscenza. L’ulteriore sfida è posta dalla natura stessa di questi dati che sta cambiando, arricchendosi sempre più di dati di provenienza varia. I dati non strutturati costituiscono ora una parte molto consistente della totalità delle informazioni disponibili e le aziende stanno rapidamente valutando tecnologie che permettano di analizzarli per ottenerne un vantaggio competitivo. Per molti, i dati non strutturati rappresentano una potente risorsa ancora tutta da scoprire e sfruttare, una risorsa capace di fornire una conoscenza più approfondita su clienti ed operazioni che può quindi trasformarsi in un vantaggio competitivo. Ma questi dati non possono essere facilmente gestiti con database relazionali tradizionali o con strumenti di business intelligence, concepiti per gestire solo dati strutturati. Il problema viene ulteriormente complicato dalla rapidità con cui crescono volume e velocità dei dati strutturati e non strutturati, il che costringe le aziende a cercare modi nuovi per acquisire, organizzare, gestire e analizzare questi dati. L’insieme di questi elementi ha portato allo sviluppo di nuovi modelli di elaborazione distribuita e di tecnologie analitiche quali Hadoop, NoSQL3 e altre adatte a gestire i dati non strutturati nella loro forma originaria. Queste tecnologie permettono alle aziende di studiare soluzioni per diventare più efficienti, ridurre il TCO4 (Total Cost of Ownership) e migliorare la flessibilità dell’infrastruttura IT di supporto. Naturalmente, sarebbe anche tecnicamente possibile convertire i dati non strutturati in una forma strutturata e poi utilizzare sistemi di gestione di database relazionali per manipolarli. Il processo di conversione, tuttavia, richiede una considerevole quantità di tempo, incrementando i costi e ritardando il raggiungimento del risultato finale. È evidente, quindi, che per trattare questa grande mole di dati ci sia bisogno di un approccio infrastrutturale ad hoc, più efficiente in termini di costi. In molte situazioni, la piattaforma più idonea è basata sulla presenza di tante commodity server di 3 Il termine NoSQL identifica tutti quei database che si discostano dalle regole che caratterizzano i database relazioni (RDBMS). Essi sono spessi utilizzati per immagazzinare grandi quantità di dati e sono altamente scalabili. Si consiglia di visitare il sito http://nosql-database.org/, che si pone come guida di riferimento del movimento NoSQL, per ulteriori approfondimenti in merito. 4 Total Cost of Ownership (TCO), in italiano costo totale di proprietà o costo totale di possesso, è un approccio utilizzato per calcolare tutti i costi del ciclo di vita di un’apparecchiatura informatica IT, per l’acquisto, l’installazione, la gestione, la manutenzione e il suo smantellamento. xi
  • 13. Introduzione dimensioni più piccole, anziché di piattaforme di classe enterprise, e le risorse di storage vengono gestite localmente, a livello di singolo server, anziché essere centralizzate e condivise. Questo approccio distribuito, infatti, presenta numerosi vantaggi. Per esempio, garantisce flessibilità in termini di costi grazie alla potenzialità di rapida scalabilità orizzontale che consente di introdurre anche migliaia di server di fascia bassa, anziché dover effettuare un costoso aggiornamento di server enterprise e apparecchiature di storage. E per quanto riguarda le performance, il modello “shared-nothing”, in cui appunto ciascun nodo dispone di risorse a esso dedicate, elimina la necessità di incanalare i dati attraverso un numero limitato di dischi condivisi, eliminando il rischio di potenziali colli di bottiglia che potrebbero incidere significativamente sulle performance in caso di ingenti quantità di dati da elaborare. Tra i numerosi metodi emersi in questi anni per analizzare i Big Data, quello che presenta le suddette caratteristiche è senza dubbio MapReduce e in particolare la sua implementazione open source che ha riscosso maggiore successo, anche per numero di installazioni, Hadoop. Panoramica su Hadoop Hadoop è un framework open source, affidabile e scalabile, finalizzato all’analisi, all'archiviazione e all'elaborazione distribuita di grandi quantità di dati strutturati e non strutturati. Permette alle applicazioni di lavorare con migliaia di nodi e petabyte di dati. Fornisce un filesystem distribuito (HDFS) in grado di memorizzare i dati su migliaia di server, e un modo per eseguire computazioni (detti job Map/Reduce) distribuite su tali macchine, in prossimità dei dati. Hadoop è un progetto Apache di alto livello, e Yahoo! rappresenta il più grande contributore, e ne fa fortemente uso. Hadoop è usato anche da: Ebay, Facebook, IBM, ImageShack, Linkedin, Spotify, The New York Times, Twitter, e tanti altri. Fondamentalmente si tratta di una tecnologia in grado di distribuire i carichi di lavoro tra più computer (partizionando opportunamente il dataset), al fine di suddividere l’analisi dei dati in più task paralleli per produrre i risultati in maniera più rapida. Sempre più organizzazioni si rendono conto della necessità di disporre di una nuova piattaforma sviluppata sulla base di tecnologie come Hadoop che, oltre a ospitare i flussi di dati correnti, sia i grado di assorbire i nuovi flussi di dati che, inevitabilmente, arriveranno sulla scia del successo iniziale del progetto. Una tale piattaforma facilita notevolmente le attività di utilizzo, analisi e sperimentazione dei flussi di dati xii
  • 14. Introduzione eterogenei (strutturati e non strutturati), adeguandosi perfettamente al concetto dei Big Data. Panoramica sulla Sentiment Analysis La Sentiment Analysis si propone di analizzare le opinioni espresse dagli utenti sui social media relativamente a prodotti e servizi e alle loro caratteristiche. Trae origine dalla Natural Language Processing (ovvero, l’analisi del linguaggio naturale), dalla linguistica computazionale5 e dal social media analytics, la disciplina che studia e analizza i dati sociali, e trova applicazione in svariati settori che vanno da quello turistico, alla military intelligence6 , alle strategie di real-time marketing7 basati su contenuti sociali. Alcuni esempi sono il monitoraggio e l’analisi dei fenomeni sociali, l’analisi delle opinioni riferite a un particolare prodotto o un determinato servizio della pubblica amministrazione, o ancora l’analisi delle intenzioni di voto, come è stato fatto negli Stati Uniti durante il confronto elettorale tra i due candidati Obama e Romney8 . Attraverso le reti sociali, gli utenti possono comunicare condividendo informazioni legate ai propri interessi e attività, ed esprimere opinioni riguardanti il proprio stile di vita, le proprie necessità e desideri. Le scelte dei consumatori sono sempre più influenzate dai pareri espressi sui social media attraverso il passaparola sul web – word of mouth – e il feedback degli utenti a prescindere dal bene di consumo, dal prodotto o dal servizio. Le recenti analisi di mercato evidenziano la tendenza dei consumatori a utilizzare i social media per la prenotazione di un albergo, per l’acquisto di beni, cellulari, automobili, per decidere che film vedere o ancora relativamente a temi di politica e attualità. I contenuti, generati dagli utenti sotto forma di recensioni di prodotti e/o opinioni su blog, forum, gruppi di discussione e social network crescono rapidamente e si stanno rivelando una risorsa di considerevole importanza. Le opinioni sono lette e seguite dalla gente comune, dalle compagnie e dalle imprese, ma accedervi sta gradualmente diventando sempre più complesso a causa della crescita del numero delle 5 La linguistica computazionale si concentra sullo sviluppo di formalismi descrittivi del funzionamento del linguaggio naturale, tali che si possano trasformare in programmi eseguibili dai computer. I problemi che affronta la linguistica computazionale consistono nel trovare una mediazione fra un oggetto di studio in costante evoluzione (il linguaggio umano) e le capacità di comprensione della macchina, limitate a quanto può essere descritto tramite regole formali. 6 La military intelligence si occupa della raccolta, analisi e distribuzione di informazioni rilevanti per le operazioni militari. 7 La real-time marketing si occupa di determinare “in tempo reale” un approccio adeguato o ottimale per un determinato cliente in un determinato momento e/o luogo. 8 Per approfondimenti si veda il Paragrafo 3.1.2. xiii
  • 15. Introduzione conversazioni virtuali. L’abilità di ascoltare le opinioni e la disponibilità di programmi in grado di processarle in modo automatico rappresentano elementi sempre più apprezzati, specialmente dalle grandi organizzazioni che sfruttano l’opinione del consumatore per ricavarne informazioni utili per le proprie decisioni e per la definizione di scelte di strategia aziendale e di marketing. Mentre la prima generazione di prodotti dedicati alla social media analytics forniva strumenti in grado di contare citazioni di brand, marchi o prodotti, attualmente si stanno diffondendo strumenti più efficienti in grado di effettuare un monitoraggio più accurato delle informazioni riferite ai prodotti e servizi di interesse. Analogamente per quanto riguarda l’analisi dei contenuti esistono diversi strumenti in grado di lavorare sui testi attraverso approcci statistici o linguistici. I primi basati su funzioni che operano in base alla frequenza dei termini e i secondi basati su risorse linguistiche che permettono l’analisi sintattica e semantica dei contenuti. Entrambi gli approcci sono utilizzati nella Sentiment Analysis ma con evidenti differenze di comportamento e di dettaglio di analisi. Attualmente il principale obiettivo della ricerca nell’ambito della Sentiment Analysis è quello di spostare la frontiera, passando dalla semplice valutazione della polarità delle opinioni espresse ad una in cui le opinioni sono analizzate in modo sempre più dettagliato, al fine di coglierne le correlazioni, legarle al contesto e possibilmente geo-referenziarle. A tal proposito, le attuali ricerche prevedono lo sviluppo di algoritmi e applicazioni basati su un approccio linguistico del tipo Natural Language Processing. In particolare, possono essere individuate come fasi principali lo sviluppo di risorse linguistiche, la classificazione basata sullo stato emotivo espresso nelle opinioni e la sommarizzazione dei risultati ottenuti, che consiste nell’aggregazione e rappresentazione dei risultati elaborati. La preparazione dei dati in un sistema di Sentiment Analysis coinvolge l’utilizzo di diverse risorse linguistiche. L’insieme delle attività coinvolte nell’analisi sintattica e semantica dei testi sono processi basati su WordNet9 , che rappresenta la risorsa linguistica più ampiamente diffusa nell’ambito della NLP e sviluppata presso l’Università di Princeton, oppure MultiWordNet10 per lingue diverse dall’inglese. La classificazione del sentiment contempla lo sviluppo di algoritmi e di applicazioni basati su diversi approcci, mediante un dizionario dei termini, tecniche di machine learning o metodologie tipiche della NLP. L’elaborazione dei testi include fasi 9 Sito web: http://wordnet.princeton.edu/. 10 Sito web: http://multiwordnet.fbk.eu/english/home.php. xiv
  • 16. Introduzione successive di analisi dei dati: si spazia dall’analisi sintattica, che determina la struttura grammaticale di un testo attraverso l’identificazione delle parti del discorso11 , in inglese part-of-speech (POS), all’analisi semantica che assegna il significato più probabile alle POS per risolvere automaticamente l’ambiguità intrinseca nei termini e permette di estrarre il significato espresso nel testo. Se si è interessati ai testi che parlano di “calcio”, è necessario selezionare il significato preciso di tale parola. Se l’interessa riguarda l’attività sportiva, si vogliono selezionare tutti i testi in cui una parola è presente proprio con questa accezione, e quindi escludere automaticamente, attraverso la tecnica della disambiguazione che considera il contesto in cui le parole sono inserite, tutti i risultati che riportano il termine calcio con altri significati (elemento chimico, comune in provincia di Bergamo, componente di una pistola, ecc.). L’utilizzo della risorsa linguistica è necessario anche nelle fasi successive per correlare le opinioni espresse dagli utenti alle considerazioni sui prodotti o servizi su cui si esprime un’opinione. L’attività di estrazione delle feature (caratteristiche o aspetti), anche nota come features o aspects extraction, fa parte dell’opinion extraction e prevede l’identificazione degli aspetti relativi al prodotto o servizio a cui le opinioni sono riferite. Per esempio, se si parla di un hotel alcune delle sue caratteristiche possono essere: camera, stanza da bagno, letto, prezzi, piscina, ristorante, igiene, ecc. L’analisi delle opinioni viene riferita alle caratteristiche e complessivamente al prodotto o al servizio da esse descritto. Al fine di riferire correttamente le opinioni alle caratteristiche è necessario poi, isolare le frasi aventi valore soggettivo, che esprimono cioè una opinione. Le frasi contenute nelle opinioni sono infatti distinte in frasi oggettive e frasi soggettive. Queste ultime esprimono stati mentali ed emozioni quali valutazioni, sensazioni, sentimenti, ecc. Una frase soggettiva esprime ad esempio un apprezzamento: “la camera era molto accogliente”, mentre una frase oggettiva descrive semplicemente un fatto: “sono andato in vacanza con un’amica, in camera doppia”. Isolare tali frasi, attraverso un sistema di classificazione, consente di ridurre il “rumore” causato dalla presenza di affermazioni e valutazioni non pertinenti e di impostare la fase di sommarizzazione, durante la quale si aggregano i risultati elaborati precedentemente, limitatamente alle frasi esprimenti giudizi sulle caratteristiche identificate secondo schemi e grafici di facile lettura. 11 La grammatica italiana distingue tradizionalmente le seguenti parti del discorso: sostantivo, verbo, aggettivo, articolo, avverbio, preposizione, numerali, pronome, interiezione. xv
  • 17. Introduzione Obiettivo del lavoro di Tesi In questo lavoro di Tesi si intende creare un sistema per la Sentiment Analysis, che sia efficiente, affidabile e scalabile, tramite l’utilizzo delle funzionalità offerte da Hadoop e dalle relative componenti. Il lavoro svolto prevede attività che caratterizzano varie fasi della Sentiment Analysis. Nella prima fase si procede all’estrazione dei dati da una sorgente che in questo lavoro è rappresentata dal Social Network Twitter. Sulla base di un insieme di parole chiave sono prelevati tramite un estrattore, quale Flume (una componente di Hadoop), i tweet riferiti ad un argomento prestabilito, quale la Nazionale Italiana di Calcio. Una volta estratti e memorizzati i dati su HDFS, si procede alla classificazione del sentiment. In questo lavoro si procederà sia sulla base di un classificatore automatico che sulla base di un dizionario dei termini, dove a ciascun termine viene associato un valore numerico che ne specifica la polarità positiva o negativa del sentiment. Per la fase di classificazione è possibile sfruttare le potenzialità di Hive, una componente di Hadoop che permette di utilizzare un linguaggio simile a SQL, e di integrarlo con funzioni definite dall’utente (UDF), e allo stesso tempo, convertendo automaticamente le query in elaborazioni MapReduce, ne assicura la scalabilità. I dati prodotti possono essere poi elaborati e presentati secondo diverse dimensioni, utilizzando tool di business intelligence come Pentaho, in modo da ottenere grafici e report relativi al sentiment, sia in riferimento ad un determinato intervallo temporale, che ad una particolare area geografica. Ai fini del lavoro di tesi si prevede anche di automatizzare tutte le operazioni, sfruttando orchestratori/scheduler come Oozie di Hadoop. Struttura della Tesi Nel Capitolo 1 viene presentata una panoramica riguardante il paradigma MapReduce, su cui si basa indirettamente l’intero sistema, sia dal punto di vista concettuale, sia analizzandone le principali funzionalità implementate in Hadoop. Nel Capitolo 2 viene descritto il framework Hadoop, e tutte le relative componenti più importanti. Nel Capitolo 3 sono presentati i diversi approcci, e quindi lo stato dell’arte, nel campo della Sentiment Analysis. Nel Capitolo 4 viene presentato il sistema sviluppato per la Sentiment Analysis, i risultati ottenuti in termini di accuratezza e i report relativi alle analisi effettuate. Nel Capitolo 5 sono descritti gli sviluppi futuri, relativi sia all’aumento delle performance che al miglioramento dell’accuratezza del sistema. xvi
  • 18. Capitolo 1 MapReduce MapReduce “MapReduce è un modello di programmazione e una relativa implementazione per elaborare e generare insiemi di dati di grandi dimensioni. […] I programmi che adottano questo stile funzionale vengono automaticamente gestiti in una logica parallela ed eseguiti su cluster di macchine a tecnologia commodity. Il sistema run time si occupa nel dettaglio del partizionamento dei dati di input, pianificando l’esecuzione del programma attraverso una serie di macchine, gestendone gli eventuali guasti e la comunicazione che ha luogo tra esse. Tutto questo permette a programmatori senza alcuna esperienza in sistemi paralleli e distribuiti di utilizzare con molta semplicità le risorse di un grande sistema distribuito.” – Jeffrey Dean e Sanjay Ghemawat apReduce è un framework1 software brevettato e introdotto da Google per supportare la computazione distribuita di grandi quantità di dati su cluster2 di computer, in modalità batch3 . MapReduce lavora secondo il principio divide et impera. Un problema complesso, che utilizza una gran mole di dati, è suddiviso, assieme ai dati stessi, in piccole parti processate in modo autonomo e, una volta che ciascuna parte del problema è stata calcolata, i vari risultati parziali sono “ridotti” a un unico risultato finale. 1.1 Introduzione MapReduce permette di processare, in modalità batch, query ad hoc riguardanti l’intero insieme di dati, o una buona porzione di esso, per poi produrre un risultato in 1 Un framework è una struttura di supporto su cui un software può essere organizzato e progettato. Un framework, in generale, include software di supporto, librerie, un linguaggio per gli script e altri software che possono aiutare a mettere insieme le varie componenti di un progetto. 2 Un cluster è un insieme di computer connessi tramite una rete telematica. 3 Tutta la sequenza di operazioni e dati necessari per svolgere un particolare compito vengono preparati in anticipo e memorizzati su un adeguato supporto creando una procedura. La procedura viene poi eseguita dal sistema come un blocco unico, cioè senza che sia necessario, o possibile, un intervento umano prima che sia terminata. CAPITOLO 1 M 1
  • 19. Capitolo 1 MapReduce un tempo ragionevolmente breve. Il termine MapReduce viene utilizzato sia per indicare il modello computazionale, sia il framework concettuale necessario, sia le specifiche implementazioni. 1.1.1 Panoramica Un anno dopo la pubblicazione di un documento nel quale si descriveva l’architettura del filesystem distribuito4 utilizzato da Google, detto GFS (Google File System)5 , nel 2004 Google rilascia un altro documento che introduce MapReduce6 al mondo. Le forti esigenze di parallelizzazione hanno portato l’azienda a creare un’astrazione che potesse accelerare lo sviluppo di applicazioni parallele, relegando i dettagli relativi alla parallelizzazione, gestione dei guasti e distribuzione dei dati ad una libreria. MapReduce è un framework utile alla creazione di applicazioni in grado di elaborare grandi quantità di dati in parallelo, basato sul concetto di programmazione funzionale. L’implementazione classica del calcolo parallelo è basata sulla programmazione multithreading, che prevede la suddivisione del lavoro in più parti distinte, i thread, condividendo la memoria ed altre risorse. La programmazione multithreading presenta una certa complessità proprio nel coordinare l’accesso alle risorse condivise. Nella programmazione funzionale, invece, la condivisione dei dati è eliminata, e con essa, anche i relativi problemi di coordinazione. I dati sono invece passati tra le funzioni come parametri o valori di ritorno. 1.1.2 Confronto tra RDBMS e MapReduce MapReduce è davvero essenziale? Oppure è possibile utilizzare database distribuiti su più dischi per effettuare delle analisi batch su larga scala? I Big Data sono disponibili in enormi volumi, si presentano con formati destrutturati e caratteristiche eterogenee e, spesso, sono prodotti con estrema velocità. Volume, variabilità e velocità sono dunque le caratteristiche che li identificano. Velocità. Il Seek time è il tempo necessario per spostare la testina del disco sopra la traccia desiderata, per leggere o scrivere una particolare porzione del disco. Esso sostanzialmente caratterizza il tempo di accesso al disco, dato che il tempo di 4 Il termine file system indica, informalmente, un modello con il quale i file sono posizionati e organizzati su un supporto di archiviazione. Un file system distribuito è un particolare file system che permette la memorizzazioni di file e risorse in dispositivi di archiviazione distribuiti in una rete informatica. 5 Si veda http://research.google.com/archive/gfs.html. 6 Si veda http://research.google.com/archive/mapreduce.html. 2
  • 20. Capitolo 1 MapReduce trasferimento di un blocco di bit è relativamente più basso. Per cui, risulta molto più conveniente limitare quanto più possibile il seek time, evitando di accedere di volta in volta a diverse porzioni del disco. E questo è ciò che avviene con MapReduce, che esprime tutte le sue qualità quando si tratta di analizzare l’intero dataset in modo sequenziale, a differenza dei database relazionali, utili soprattutto per aggiornamenti di piccole porzioni di dati. Variabilità. La caratteristica della variabilità, che si traduce nella mancanza di una struttura ben definita, rende difficile la rappresentazione di tali dati in un sistema relazionale, che preferisce operare su dati strutturati, organizzati in schemi predefiniti. MapReduce, invece, è in grado di lavorare su qualsiasi formato di dati, essendo progettato per interpretare i dati. Volume. Per quanto riguarda il volume dei dati, MapReduce presenta un modello quasi linearmente scalabile. Idealmente, la velocità di elaborazione è direttamente proporzionale al numero dei nodi del cluster e inversamente proporzionale alle dimensioni dei dati da analizzare. Per cui, raddoppiando il numero dei nodi, raddoppia la velocità. Raddoppiando le dimensioni del dataset, si dimezza la velocità di elaborazione. E questo non sempre è vero per i database relazionali. Tabella 1.1 – Confronto tra RDBMS tradizionali e MapReduce RDBMS Tradizionale MapReduce Dimensione dei dati Gigabyte Petabyte Accesso Interattivo e Batch Batch Aggiornamenti Scritto e Letto più volte Scritto una volta, letto più volte Struttura Schema statico Schema dinamico Integrità Alta Bassa Scalabilità Non lineare Lineare 1.2 Fondamenti di Hadoop MapReduce Il framework MapReduce è anche una componente centrale dell’ecosistema Hadoop, che sarà trattato in dettaglio nel prossimo capitolo. Per ora è sufficiente sapere che Hadoop è una piattaforma software open source, affidabile e scalabile, finalizzata al calcolo distribuito, cioè al calcolo che avviene su un sistema di computer indipendenti, ma collegati tra loro in rete. Il nucleo centrale di Hadoop è essenzialmente costituito dal framework MapReduce e da HDFS, un file system distribuito che fornisce 3
  • 21. Capitolo 1 MapReduce un’efficace modalità di accesso ai dati. HDFS garantisce che i dati siano ridondanti nel cluster rendendo le operazioni sui dati stessi immuni da un eventuale guasto o malfunzionamento di un nodo. HDFS, inoltre, accetta dati in qualsiasi formato, strutturato, semistrutturato o non strutturato. 1.2.1 Rapida terminologia Prima di immergersi nelle funzionalità di MapReduce, è necessario esplicitare il significato dei termini che lo caratterizzano. Un job è un’unità di lavoro destinata all’esecuzione, sottoposta dal client Hadoop. Si compone dei dati di input, un programma MapReduce, informazioni di configurazione. Hadoop esegue il job dividendolo in task, che sono di due tipi: map task e reduce task. A livello architetturale, MapReduce presenta due tipi di nodi, in una struttura master/slave, che controllano il processo di esecuzione di un job: un JobTracker e diversi TaskTracker. Il JobTracker si occupa della gestione delle risorse (CPU e Memoria) e del ciclo di vita del job MapReduce. Inoltre, coordina tutti i job eseguiti sul sistema, schedulando i task che devono essere eseguiti sui TaskTracker. I TaskTracker, che girano sui singoli nodi, eseguono i task sotto la direzione del JobTracker, e inviano di tanto in tanto dei report sullo stato del processo ai JobTracker. Figura 1.1 – Vista semplificata dell’architettura di MapReduce 4
  • 22. Capitolo 1 MapReduce 1.2.2 Flusso di dati L’input di un job MapReduce è diviso da Hadoop in blocchi di dimensione fissa, detti split. Successivamente, Hadoop crea un map task per ogni split, che esegue la particolare funzione map definita dall’utente per ogni record nello split. In generale, è consigliabile avere degli split sufficientemente piccoli per avere un carico di lavoro bilanciato tra i diversi nodi, anche se la dimensione non deve essere inferiore ad una certa soglia, altrimenti l'overhead per gestirli diventa più rilevante del tempo totale per eseguire l'operazione vera e propria. Generalmente, la migliore scelta è quella di avere la dimensione di uno split corrispondente alla grandezza di un blocco HDFS. Nel processo di map i dati in input sono letti da HDFS, mentre i dati di output sono scritti sul filesystem locale in quanto si tratta di risultati parziali che dovranno essere rielaborati in seguito dai reducer per produrre l’output finale. Invece l’output finale prodotto dai reducer è normalmente archiviato su HDFS per garantire l’affidabilità. Nella Figura 1.2 è rappresentato il flusso di dati in un job MapReduce, con multipli map task e reduce task. Le caselle tratteggiate indicano i nodi, le frecce tratteggiate denotano i trasferimenti di dati in uno stesso nodo, mentre le altre frecce evidenziano i trasferimenti di dati tra nodi diversi. Figura 1.2 – Flusso dei dati in un job MapReduce I map task partizionano gli output, creando una partizione per ogni reduce task. In ogni partizione potrebbero esserci diverse chiavi (e relativi valori), ma i record per ogni specifica chiave, relativi ad uno specifico split in input, sono tutti in una singola partizione. In ogni partizione è eseguito un ordinamento – fase sort – per chiave. Una 5
  • 23. Capitolo 1 MapReduce volta terminata la fase di map, i TaskTracker notificano al JobTracker il completamento del loro lavoro e, a questo punto, i dati di input sono stati trasformati in una lista di coppie chiave/valore. Successivamente le partizioni sono copiate nei nodi dove risiedono i reducer e il JobTracker può attivare la fase di reduce, nella quale i TaskTracker aggregano – fase merge – i risultati dei mapper, conservando l’ordinamento per chiave. Le fasi di sort e merge, implicite e gestite dal sistema, costituiscono congiuntamente la fase di shuffle. Infine, i TaskTracker eseguono la funzione reduce al fine di produrre l’output, salvato in un file diverso per ciascun TaskTracker. La fase reduce, per ogni chiave, elabora i valori a essa associati e crea, come output, una o più coppie chiave/valore. È anche possibile definire una funzione combiner, che si posiziona nel flusso di lavoro tra i mapper e i reducer. In pratica svolge lo stesso lavoro dei reducer, ma limitatamente ad un singolo nodo. L’utilizzo di combiner consente di ridurre notevolmente il traffico di rete, poiché l’attività di aggregazione è svolta prima di inviare i dati ad altri nodi. Inoltre, il processo di esecuzione può anche essere più articolato rispetto a quello proposto, poiché è possibile che si susseguano più fasi MapReduce: l’output di un job diventa l’input del job successivo, finché non si giunge al risultato finale. La concatenazione di più job si rende necessaria per la soluzione di problemi complessi. 1.3 Modello di programmazione MapReduce presenta un semplice modello di elaborazione dati: la computazione riceve in ingresso un insieme di coppie chiave/valore e produce in uscita un insieme di coppie chiave/valore. Lo sviluppatore dovrà solo farsi carico di esprimere la computazione attraverso due funzioni: map e reduce. 1.3.1 Tipi e formato dei dati La funzione map riceve in input una coppia chiave/valore e produce una lista di coppie chiave/valore intermedie: map: (k1, v1)  list(k2, v2) La funzione map è applicata in parallelo ad ogni coppia dell’insieme dei dati in ingresso. Essa produce una lista di coppia per ogni chiamata. Successivamente, il framework MapReduce si occupa di raggruppare tutti i valori intermedi associati alla stessa chiave 6
  • 24. Capitolo 1 MapReduce intermedia, creando quindi una lista di valori per ogni chiave e trasferisce il tutto alla funzione reduce. La funzione reduce riceve in input la chiave intermedia e, per ognuna di essa, una lista corrispondente di valori, generando in uscita una lista di coppie chiave/valore: reduce: (k2, list(v2))  list(k3, v3) I tipi di dato delle chiavi e dei valori, il formato di input – che determina la modalità di lettura dei dati e ciò che è passato alla funzione map come chiave e valore – e il formato di output sono definiti dallo sviluppatore. In generale, i tipi di dato in ingresso (k1 e v1) alla funzione map sono differenti da quelli in uscita (k2 e v2). Tuttavia, i tipi di dato in ingresso alla funzione reduce devono coincidere con quelli in uscita dalla funzione map, e quelli in uscita dalla funzione reduce potrebbero essere ancora differenti (k3 e v3). 1.3.2 Esempio Il WordCount è un classico esempio utilizzato per descrivere il funzionamento di MapReduce. L’obiettivo è quello di contare il numero di occorrenze di ogni parola all’interno di una collezione di documenti. L’input della funzione map è una coppia chiave/valore, dove la chiave rappresenta il nome del documento e il valore il testo del documento, mentre l’output della funzione reduce è una lista di coppie chiave/valore, che rappresentano la parola e il relativo numero di occorrenze. Ecco lo pseudocodice delle due funzioni Map e Reduce per l’esempio in questione: function map(String key, String value): // key: nome del documento // value: testo del documento for each word w in value: emit (w, 1) function reduce(String key, Iterator values): // key: una parola // values: una lista di valori sum = 0 for each v in values: sum += ParseInt(v) emit (key, sum) La funzione map suddivide il testo del documento nelle parole che lo compongono e associa il valore 1 a ciascuna parola, creando così le coppie (“parola”, 1) da restituire 7
  • 25. Capitolo 1 MapReduce in output. La funzione reduce somma il contenuto della lista di valori – in questo caso tutti ‘1’ – che sono associati alla chiave. Si suppone, per esempio, di avere due file costituiti l’uno dalla frase “Efficienza significa fare le cose nel modo giusto” e l’altro dalla frase “Efficacia significa fare le cose giuste”. Nella Figura 1.3 sono rappresentati i vari step del job MapReduce. Figura 1.3 – Esempio WordCount: passi di un job MapReduce 1.4 Per Big Data servono “Big ideas” Appositamente sviluppato per affrontare carichi di lavoro su larga scala, MapReduce presenta delle caratteristiche che non sono del tutto innovative. Tuttavia, la genialità degli ingegneri di Google non è stata solo nel riuscire ad implementare le potenzialità di queste grandi idee, ma anche nel concatenarle tra loro in un modo molto efficiente. 1.4.1 I guasti sono frequenti I guasti non sono un’eccezione, sono la norma. In cluster di medie/grandi dimensioni, la probabilità che qualche nodo sia irraggiungibile è molto alta, sia per guasti hardware, sia per guasti di connettività o semplicemente per manutenzione. A maggior ragione questo risulta vero utilizzando macchine di classe server low-end. Affinché possa essere efficace, un servizio di calcolo distribuito non può prescindere dalla gestione dei guasti. In particolare, occorre fare in modo che questi non impattino sulla 8
  • 26. Capitolo 1 MapReduce qualità del servizio. Nel caso di computazioni batch, mentre un ritardo limitato può essere ammissibile, sicuramente non lo è la corruzione o la perdita dei dati. Nella filosofia di MapReduce, l’irraggiungibilità di un numero limitato di nodi prima della fase di esecuzione è facilmente sopportabile a livello di calcolo, grazie all’astrazione tra algoritmo e piattaforma. Lo stesso vale per la disponibilità dei dati: l’irraggiungibilità di specifici nodi può essere superata aggiungendo delle repliche dislocate dei dati a livello di filesystem distribuito. Nel caso si verifichi un guasto durante l’esecuzione di un calcolo, il sistema deve essere in grado di portarlo ugualmente a compimento. La strategia suggerita in questo caso è la riesecuzione: nel caso un nodo diventi irraggiungibile, le parti di calcolo assegnate a quel nodo (nella forma di esecuzioni di chiamate alle funzioni map o reduce) vengono riassegnate ad altri nodi. 1.4.2 Elaborazione sequenziale dei dati, non casuale MapReduce è stato concepito per elaborare, in modalità batch, enormi quantità di dati che risiedono necessariamente nei dischi, essendo troppo grandi da tenere in memoria. Come già detto nel Paragrafo 1.1.2, il seek time costituisce il limite maggiore quando si tenta di accedere al disco in maniera random. Di conseguenza, MapReduce tenta di evitare il più possibile l’accesso casuale, preferendo l’accesso ai dati in modo sequenziale. Trattandosi di computazioni batch, l’idea di MapReduce è quella di favorire il throughput7 a scapito della latenza8 , sfruttando la banda aggregata dei dischi di un cluster. 1.4.3 Concentrare l’elaborazione sui dati In alcuni sistemi di calcolo ad alte prestazioni è comune disporre di supercomputer dove vi è una distinzione tra nodi di calcolo e nodi di memorizzazione, collegati da interconnessioni ad elevato throughput. In tali sistemi, l’elaborazione di enormi moli di dati può portare ad un inevitabile collo di bottiglia, costituito dalle interconnessioni. In MapReduce, invece, ciascun nodo svolge entrambi le funzioni, sia di memorizzazione e sia di calcolo. Questo permette di ridurre notevolmente la quantità di dati trasferiti da un nodo all’altro, eseguendo la funzione map direttamente sul nodo dove risiedono i dati di input, sfruttando in questo modo il principio di località dei 7 Il throughput indica il numero di operazioni processate per unità di tempo. 8 La latenza è il tempo richiesto da una singola operazione per essere processata dall’inizio alla fine. 9
  • 27. Capitolo 1 MapReduce dati. Ovviamente ciò è possibile in cooperazione con il filesystem distribuito, responsabile della gestione dei dati sui quali opera MapReduce. 1.4.4 Semplice scalabilità Un algoritmo ideale in grado di elaborare grandi quantità di dati deve essere linearmente scalabile, sia in riferimento ai dati da elaborare, sia in riferimento alle risorse hardware a disposizione. Se un algoritmo richiedesse 1 ora per elaborare un particolare insieme di dati su una singola macchina, allora in un cluster di 100 macchine lo stesso algoritmo su un insieme di dati 100 volte maggiore idealmente dovrebbe richiedere lo stesso tempo, ossia 1 ora. Uno degli aspetti di maggior rilievo di MapReduce è proprio il fatto di riuscire ad avvicinarsi il più possibile a tale caratteristica di scalabilità lineare. 1.4.5 Parallelizzazione implicita È noto come lo sviluppo di applicazioni parallele sia un compito alquanto complesso, in quanto le problematiche relative a fenomeni quali deadlocks e race conditions sono intrinsecamente difficili da individuare, isolare e risolvere. Sebbene esistano molte tecniche e design patterns che possono parzialmente sopperire a questa difficoltà, la programmazione distribuita e parallela rimane una sfida non semplice da affrontare. MapReduce si fa carico di gestire queste problematiche, in questo modo il programmatore potrà concentrarsi solo sulla progettazione delle due funzioni map e reduce, la cui esecuzione parallela è garantita dal framework MapReduce. 1.4.6 Architettura Scale-out La scalabilità indica la capacità di un sistema di evolvere in potenza, aggiungendo o sostituendo un componente. Il concetto dietro alla scalabilità orizzontale – approccio scaling out – è quello di usare hardware commodity, ossia facile da reperire e dal costo limitato. A differenza della scalabilità verticale – approccio scaling up – in cui si installano server sempre più potenti, nel caso di quella orizzontale si possono aumentare le performance del sistema aumentando il numero di server di classe media, suddividendo le risorse in tanti piccoli nodi low-end interconnessi fra di loro. L’obiettivo è quello di poter creare un cluster di nodi che per potenza di calcolo, throughput e scalabilità offra maggiori garanzie di un sistema tradizionale ma a costi più ridotti. Una tale architettura è anche definita shared-nothing, poiché ciascun nodo 10
  • 28. Capitolo 1 MapReduce dispone di risorse a esso dedicate, suddividendo l’esecuzione di un’operazione in più task paralleli e indipendenti. MapReduce è stato concepito per sfruttare questo tipo di architettura, favorendo la località dei dati, per minimizzare quanto più possibile onerosi trasferimenti di dati tra diversi nodi della rete. Il programma, infatti, viene suddiviso in task in base a dove sono localizzati i dati. Viene data priorità all’esecuzione dei map task sulla stessa macchina su cui risiedono fisicamente i dati, o almeno nello stesso rack. 1.5 Quando usare MapReduce? I programmi MapReduce non hanno la garanzia di essere veloci. Il maggiore beneficio di questo modello di programmazione è quello di distribuire le operazioni in modo ottimale sull’hardware a disposizione, cosicché il programmatore possa concentrarsi solo sui requisiti funzionali e quindi nella scrittura del codice riguardante le funzioni map e reduce. Tuttavia, tener conto della funzione di partizione e della quantità di dati scritta dalla funzione map potrebbe avere un grande impatto sulle prestazioni. Funzionalità aggiuntive, come la funzione combiner, possono inoltre contribuire a ridurre la quantità di dati scritti sul disco e trasmessi da un nodo all’altro sulla rete. Nel progettare un algoritmo MapReduce, il programmatore dovrà scegliere un buon compromesso tra velocità di computazione e overhead dovuto alle comunicazioni, dato che molte implementazioni MapReduce sono progettare per registrare tutte le comunicazioni sul file system per favorire il successivo recupero dai guasti. Per i processi che terminano velocemente, e per quelli dove la quantità di dati è relativamente piccola, tale da essere contenuta nella memoria principale di una singola macchina o di un piccolo cluster, l’utilizzo del framework MapReduce generalmente non è efficace: dal momento che il framework è progettato per facilitare il ripristino in caso di guasti di un nodo qualsiasi durante la computazione, esso scrive i risultati intermedi sul file system distribuito. Tale meccanismo di ripristino risulta costoso, e paga solo quando la computazione coinvolge molti computer e calcoli elaborati – una computazione che termina in pochi secondi può solo essere riavviata in caso di errore; la probabilità che si verifichi almeno un guasto aumenta rapidamente con la dimensione del cluster. Per tali problemi, le implementazioni mantengono tutti i dati in memoria e semplicemente riavviano la computazione in caso di guasto di un nodo, oppure – quando la dimensione dei dati è abbastanza piccola – soluzioni non distribuite risultano spesso più veloci di un sistema MapReduce. 11
  • 29. Capitolo 2 Hadoop Apache Hadoop “Al tempo dei pionieri questi usavano i buoi per trainare i carichi pesanti, e quando un bue non riusciva a tirare un tronco essi non tentavano di allevare buoi più grossi. Noi non dobbiamo provare a costruire computer più grandi, ma sistemi di più computer” – Grace Hopper adoop è una piattaforma software open source, affidabile e scalabile, finalizzata al calcolo distribuito, cioè al calcolo che avviene su un sistema di computer indipendenti, ma collegati tra loro in rete; permette alle applicazioni di lavorare con migliaia di nodi e petabyte di dati. Apache Hadoop consente di archiviare e analizzare i dati e costituisce il modo per creare valore dai cosiddetti Big Data. Tutti sanno che i dati sono in crescita esponenziale. Cosa non è così chiaro è il modo di sbloccare il valore che detengono. Hadoop è la risposta. Sviluppato da Doug Cutting di Cloudera, Hadoop è un framework che consente di distribuire l'elaborazione parallela di grandi quantità di dati su hardware commodity, relativamente poco costoso. Hadoop è in grado di gestire tutti i tipi di dati provenienti da sistemi diversi: strutturati, non strutturati, file di log, immagini, file audio, documenti, comunicazioni e-mail, tutto quello che si può pensare. Anche quando i diversi tipi di dati sono stati memorizzati in sistemi non correlati, è possibile scaricare il tutto in un cluster Hadoop prima ancora di sapere come si potrebbe trarne vantaggio in futuro. Con Hadoop i dati non sono mai troppo grandi. In un mondo in cui le persone, le imprese e le macchine creano dati continuativamente, la capacità di Hadoop di crescere praticamente senza limiti permette di sbloccarne il potenziale valore. Una curiosità: il nome Hadoop proviene da un elefante giallo di peluche del figlio di Doug Cutting, il quale lo ha scelto perché è semplice da scrivere e pronunciare, privo di significato e non usato altrove. CAPITOLO 2 H 12
  • 30. Capitolo 2 Hadoop 2.1 Panoramica La crescita impressionante dei dati osservata negli ultimi anni, e destinata a proseguire nel futuro, ha fatto nascere molti progetti indirizzati a trovare delle soluzioni il più possibile semplici ed economiche sia per archiviare tali informazioni, sia per eseguire delle elaborazioni su moli di dati fino a poco tempo fa impensabili. Poiché la gran parte delle informazioni oggi generate è di tipo non strutturato, è in questa direzione che molti dei progetti si sono mossi e tra questi anche Hadoop. Hadoop nasce come progetto per l’analisi distribuita di grandi insiemi di dati attraverso un semplice modello di programmazione. L’architettura, realizzata in Java, permette di poter scalare da pochi server fino a migliaia di sistemi: ogni server contribuisce con le proprie risorse di calcolo e la propria capacità di memorizzare i dati, e quindi aggiungendo server, chiamati anche nodi, è possibile far crescere un sistema Hadoop in modo quasi lineare. L’alta affidabilità, e dunque la protezione dei dati, viene realizzata non basandosi sulle caratteristiche hardware dei server, bensì a livello software: sono le librerie di Hadoop che si occupano di identificare se e quali componenti presentino un malfunzionamento, intervenendo per ripristinare le operazioni, ad esempio creando una nuova copia dei dati contenuti in un server. È evidente che nella scala dei petabyte le soluzioni di backup tradizionali non sono utilizzabili, quindi è proprio la distribuzione dei dati su diversi nodi la chiave per salvaguardare le informazioni anche di fronte ad un guasto di uno dei nodi. Le componenti costituenti il nucleo centrale di Hadoop sono:  Hadoop common. Uno strato di software comune che fornisce funzioni di supporto agli altri moduli.  HDFS. Il file system distribuito che fornisce un’efficace modalità di accesso ai dati. Garantisce ridondanza e affidabilità. Accetta dati in qualsiasi formato.  YARN. Un framework che consente di creare applicazioni o infrastrutture per il calcolo distribuito. Si occupa della gestione delle risorse del cluster.  MapReduce. Il sistema di elaborazione parallela dei dati (basato su YARN a partire della versioni 0.23.X e 2.X.X di Hadoop). Al nucleo centrale, “sopra” HDFS e MapReduce, si aggiungono altri moduli che fanno parte dell’ecosistema, estendendone le funzionalità. La Figura 2.1 mostra l’insieme 13
  • 31. Capitolo 2 Hadoop delle componenti dell’ecosistema Hadoop e nella Tabella 2.1 sono elencate in breve le relative funzionalità. Figura 2.1 – Architettura di Hadoop Tabella 2.1 – Funzionalità delle componenti dell’ecosistema Hadoop Componente Descrizione HDFS Hadoop Distributed File System. Garantisce l’accesso ai dati in un qualsiasi nodo del cluster Hadoop. Accetta dati in un qualsiasiformato, strutturato o non strutturato. YARN Sistemadigestionedellerisorsedelcluster,checonsentedicreareapplicazionioinfrastruttureperilcalcolo distribuito. MapReduce Piattaformasoftwareperlacreazionediapplicazionicheprocessanograndimolididatiinparallelosucluster di molti nodi. Hive Sistema di data warehousing costruito su Hadoop, che consente di aggregare dati, eseguire query e analizzare grandi dataset. Hive utilizza il linguaggio HiveQL, simile sintatticamente a SQL. R (connettori) R è un software statistico in grado di utilizzare Hadoop attraverso i plug-in (connettori) RHive e RHadoop. Pig Libreria che semplifica la creazione di job di trasformazione dei dati. Pig, con il suo linguaggio chiamato Pig Latin, consente di scrivere sequenze di operazioni di trasformazione in maniera piuttosto semplice, che Pig stesso converte in job MapReduce. Mahout Libreria di Machine Learning e Data Mining HBase È un database column oriented, distribuito e scalabile, che si basa su HDFS. Oozie Strumento di gestione del workflow delle operazioni. Zookeeper Strumento di coordinamento e sincronizzazione delle risorse per applicazioni distribuite. Flume Sistema per la movimentazione di grandi quantità di dati da fonti di diverso tipo verso HDFS (o altre destinazioni). Presenta un’architettura semplice e flessibile basata sullo streaming di flussi di dati. Sqoop Libreria per il trasferimento di dati tra database relazionali e Hadoop. Ambari Strumenti di monitoraggio e amministrazione del cluster Hadoop. 14
  • 32. Capitolo 2 Hadoop 2.1.1 Origini del progetto e diffusione attuale Hadoop nasce per sopperire a un problema di scalabilità di Nutch1 , un crawler2 open source. Doug Cutting e Michael J. Caffarella hanno lavorato su un embrione di Hadoop a partire dal 2004, anno in cui furono pubblicati documenti tecnici riguardanti Google File System e Google MapReduce, tecnologie da cui Hadoop ha attinto. Inizialmente si trattava di un componente di Nutch, in grado di migliorarne la scalabilità e le prestazioni. Nel 2008 nasce la prima release come progetto open source indipendente di Apache, realizzata anche grazie all’assunzione da parte di Yahoo! di Cutting, al quale fu messo a disposizione un team di sviluppo. Hadoop è ormai riconosciuto come una delle più promettenti soluzioni general-purpose per i Big Data, capace di memorizzare grandi quantità di dati e fornire una semplice ma potente piattaforma di analisi: numerose distribuzioni di Hadoop sono oggi messe a disposizione da aziende storiche dell’IT quali EMC, IBM e Microsoft, oltre che da realtà specializzate sulle tecnologie Hadoop quali Cloudera. Ebay, Facebook, LinkedIn, Twitter e AOL sono solo alcune tra le più importanti realtà che attualmente fanno uso di Hadoop3 . 2.1.2 Senza Hadoop? Prima dell’affermazione di Hadoop, le elaborazioni su grandi quantitativi di dati erano realizzate esclusivamente da sistemi di High Performance Computing4 (HPC) e Grid Computing5 , tramite l’utilizzo di API quali, per esempio, Message Passing Interface (MPI), un protocollo di comunicazione tra nodi appartenenti a un cluster di computer che eseguono un programma parallelo sviluppato per sistemi a memoria distribuita. Gli HPC suddividono il lavoro su molti computer in cluster, che utilizzano un file system condiviso, cioè un insieme di dischi raggiungibili da tutti i nodi del cluster. Se l’attività è processor-intensive, il sistema funziona bene, ma qualora occorresse 1 Nutch è un progetto finalizzato alla costruzione di un motore di ricerca open source. È basato su Lucene, una libreria di ricerca e di indicizzazione che inizialmente non conteneva un crawler, mancanza poi sopperita da Nutch. 2 I crawler, detti anche spider o robot, sono componenti dei motori di ricerca che analizzano i contenuti di una rete (o di un database) in un modo metodico e automatizzato, recuperando i contenuti delle pagine e fornendoli al motore di ricerca per l’indicizzazione. 3 Al link http://wiki.apache.org/hadoop/PoweredBy sono indicati i maggiori utilizzatori di Hadoop. 4 Il termine High Performance Computing si riferisce alle tecnologie utilizzate da computer cluster per creare dei sistemi di elaborazione in grado di fornire delle prestazioni molto elevate, ricorrendo tipicamente al calcolo parallelo. 5 I Grid Computing sono un’infrastruttura di calcolo distribuito, utilizzati per l’elaborazione di grandi quantità di dati, mediante l’uso di una vasta quantità di risorse. 15
  • 33. Capitolo 2 Hadoop accedere a grandi moli di dati, le performance non sarebbero ottimali a causa di problemi di rete: l’accesso di tutti i nodi del cluster alla risorsa di storage condivisa costringerebbe i nodi stessi ad attendere l’arrivo dei dati. Inoltre le MPI sono librerie di basso livello, piuttosto complesse. Al contrario, Hadoop con HDFS e MapReduce offre librerie di alto livello, più semplici da utilizzare. Inoltre la ripartizione dei dati direttamente sui nodi di calcolo permette di minimizzare i tempi di accesso, poiché i dati sono immediatamente disponibili alle procedure, senza onerosi trasferimenti di rete. 2.1.3 Caratteristiche salienti Hadoop è un sistema altamente affidabile: esso gestisce gli eventuali problemi del sistema a livello applicativo, invece di sfruttare sistemi hardware di alta disponibilità. Hadoop, infatti, è pensato per sfruttare cluster di commodity hardware, che può essere frequentemente soggetto a problemi e che non prevede meccanismi di fail-over6 . Un’altra importante caratteristica di Hadoop è la scalabilità, che è realizzabile semplicemente aggiungendo nodi al cluster. Ciò concorre a limitare i costi rispetto ad una soluzione basata su database tradizionale, dove spesso la scalabilità si realizza sostituendo l’hardware esistente con macchine più potenti ed estremamente costose. Hadoop nasce per la gestione di calcoli ed elaborazioni su grandi moli di dati, caricati nel sistema e utilizzati, in lettura, da una o più procedure. Tale utilizzo è nettamente all’opposto rispetto a un database relazionale OLTP7 (Online Transaction Processing), nel quale le singole transazioni interessano soltanto pochi record. L’utilizzo di Hadoop in tali scenari non sarebbe efficiente e non avrebbe senso, poiché si tratta di attività gestite in modo ottimale dagli RDBMS. 2.2 HDFS HDFS (Hadoop Distributed File System)8 è un file system distribuito appositamente progettato per poter utilizzare commodity hardware, dato che è altamente fault-tolerant. HDFS è in grado di gestire un numero elevatissimo di file, anche di 6 Il meccanismo di fail-over implica il monitoraggio continuo del sistema, e consente di far fronte a malfunzionamenti che si verificano su un nodo, spostandone le attività su altri nodi. 7 Un database OLTP presenta un modello dati fortemente normalizzato per favorire non tanto le letture e l’analisi di grandi quantità di record, quanto le attività transazionali, quali inserimenti, cancellazioni e modifiche di porzioni di dati. 8 Al link http://goo.gl/kCnIht è possibile trovare vignette autoesplicative sul funzionamento di HDFS. 16
  • 34. Capitolo 2 Hadoop dimensioni ragguardevoli (dell’ordine dei gigabyte o terabyte), attraverso la realizzazione di cluster che possono contenere migliaia di nodi. L’utilizzo di hardware a buon mercato e la possibilità di configurare cluster con moltissimi elementi comportano una certa probabilità di avere guasti frequenti che possono rendere indisponibili uno o più nodi. Per questo la capacità di identificare problemi e di effettuare operazioni di recovery automatiche è una delle caratteristiche principali del file system di Hadoop. Rispetto ai file system general purpose (come NFS9 o CIFS10 ), HDFS è costruito attorno all’idea di un utilizzo dei dati in modalità write-once, read-many. Questo ovviamente non significa che i dati non possano essere modificati, ma indica un approccio differente all’utilizzo dei dati stessi: come è tipico del mondo Big Data, non ci si aspetta di accedere in modo chirurgico ad un singolo file o ad una porzione di questo, ma piuttosto è previsto che le analisi operino su una gran parte dei dati memorizzati (se non tutti). HDFS, infatti, supporta solo un limitato insieme di operazioni sui file, quali letture, scritture, eliminazioni ma non aggiornamenti e, per di più, non fornisce un meccanismo di caching locale dei dati. L’overhead dovuto al caching, su grandi insiemi di dati, diventa talmente rilevante che la rilettura dei dati dalla sorgente è la soluzione migliore dal punto di vista della prestazioni. HDFS, inoltre, è stato pensato per operazioni che attraversino una porzione importante dei dati disponibili, con un focus sulla scalabilità di questo percorso di accesso: profili di accesso ai dati sensibili alla latenza (qualche millisecondo) non sono adatti ad essere ospitati in HDFS. Per cui, HDFS non è la soluzione migliore in caso di applicazioni che richiedano un accesso ai dati in tempi molto ridotti, dato che il throughput è ottimizzato a spese della latenza. 2.2.1 NameNode e DataNode HDFS presenta i file organizzati in una struttura gerarchica di directory, come qualsiasi altro file system. Come mostrato nella Figura 2.2, i file sono organizzati come sequenze di blocchi della stessa dimensione, memorizzati nel cluster Hadoop. Un file può essere costituito da diversi blocchi, che sono memorizzati su differenti DataNode, ossia applicazioni che girano sugli altri nodi del cluster, generalmente una per nodo, e 9 Network File System. Consente ai computer di utilizzare la rete per accedere agli hard disk remoti come fossero dischi locali. 10 Common Internet File System. Permette un accesso unificato e parallelo ai file remoti presenti su diversi sistemi operativi. 17
  • 35. Capitolo 2 Hadoop gestiscono fisicamente lo storage di ciascun nodo. In pratica eseguono le operazioni di lettura e scrittura richieste dai client e gestiscono fisicamente la creazione, cancellazione o replica dei blocchi di dati. Figura 2.2 – Architettura di HDFS Il DataNode memorizza ogni blocco di dati HDFS in un file separato sul proprio filesystem locale, senza nessuna conoscenza circa i file stessi. Per migliorare il throughput, il DataNode non crea tutti i file nella stessa directory, ma utilizza delle euristiche per determinare il numero ottimale di file per directory, e crea sottodirectory in modo appropriato. Uno dei requisiti per un tale filesystem strutturato a blocchi è la capacità di memorizzare, gestire ed accedere ai metadati11 del file in modo affidabile e veloce. Diversamente dagli stessi file HDFS, il cui accesso è regolato dal paradigma write-once e read-many, la struttura dei metadati può essere modificata da un numero considerevole di client in modo concorrente. È fondamentale che tali informazioni siano sempre sincronizzate. A tal proposito, HDFS si avvale di un’applicazione che gira sul server principale, ossia il NameNode, che memorizza i metadati per il filesystem. Questo significa che HDFS presenta un’architettura master/slave. Un singolo NameNode gestisce il namespace, ovvero l’elenco dei nomi dei file e dei blocchi e regola l’accesso ai file da parte dei client. L’esistenza di un singolo master nel cluster semplifica notevolmente l’architettura del sistema. Dato che la quantità di metadati per file è relativamente limitata, il NameNode memorizza tutti questi dati nella memoria principale, permettendo in tal modo un 11 I metadati sono informazioni che descrivono caratteristiche e proprietà dei file e dei blocchi. 18
  • 36. Capitolo 2 Hadoop accesso random molto veloce. Poiché la memoria è progettata per essere compatta, un NameNode con 4 GB di RAM è in grado di supportare un gran numero di file e directory. Inoltre, la memoria dei metadati è anche persistente. L’intero namespace del filesystem è contenuto in un file chiamato FsImage memorizzato nel filesystem locale del NameNode. Il NameNode utilizza anche un log dei cambiamenti avvenuti al namespace a partire dall’ultima volta in cui il file FsImage è stato aggiornato. Tali cambiamenti sono registrati in un file detto EditLog. Quando il NameNode parte, unisce questi due file in modo da produrre uno snapshot12 dell’ultima situazione. A questo punto il file FsImage è sovrascritto con lo snapshot. L’approccio master/slave di HDFS semplifica l’architettura, ma comporta inevitabilmente un’importante criticità: un problema al NameNode implicherebbe l’indisponibilità dell’intero cluster. Per attenuare questo problema è stato implementato il Secondary NameNode, detto anche CheckPoint Node. Il Secondary NameNode non è un nodo di backup, non si fa carico delle funzioni del NameNode. Si occupa, invece, di scaricare periodicamente il file FsImage e il log dei cambiamenti dal NameNode, di unirli in un unico snapshot, che è poi restituito al NameNode e potrebbe essere utilizzato in caso di problemi su quest’ultimo. La sua copia però non è aggiornata. Per questo, recentemente è stato introdotto anche il Backup Node, che mantiene una copia read-only del NameNode, sincronizzata in tempo reale. Inoltre, a partire dalle versioni di Hadoop marcate come 2.X.X, due diversi server sono configurati come NameNode: uno di essi è attivo, mentre l’altro è in standby, pronto a subentrare in caso di problemi al primo nodo. 2.2.2 Blocchi e replicazione Affinché la memoria necessaria al NameNode rimanga gestibile, la dimensione di default di un blocco HDFS è 64 MB (o 128 MB), molto più grande rispetto alla dimensione dei blocchi di un tipico filesystem, che comunemente si assesta su pochi kilobyte. Tali dimensioni, inoltre, permettono che grandi quantità di dati siano memorizzate sequenzialmente sul disco, minimizzando in tal modo il seek time per consentire letture veloci in streaming. 12 Uno snapshot rappresenta un’istantanea dello stato di un oggetto o del sistema in un particolare momento. 19
  • 37. Capitolo 2 Hadoop Per assicurare l’alta disponibilità, HDFS replica ogni blocco su un certo numero di nodi – tre, per default. Tali repliche sono utilizzate sia per garantire l’accesso a tutti i dati anche in presenza di problemi ad uno o più nodi, sia per migliorare il recupero dei dati. In HDFS, infatti, per le richieste di lettura dati, sono scelti i nodi più vicini al client che effettua la lettura. In presenza di dati ridondanti è in tal modo più semplice soddisfare questo requisito. Una strategia di replica consiste nel copiare un blocco su altri DataNode, appartenenti a rack13 diversi. In tal modo si minimizzano i rischi legati ai guasti (sia del rack, sia dei nodi), si massimizzano le performance di lettura, poiché può essere utilizzata la banda di rete di rack differenti, ma si appesantiscono le scritture, dato che occorre spostare dati su diversi rack. Tipicamente, la banda di rete, e conseguentemente le performance della rete, tra macchine nello stesso rack è maggiore della banda di rete tra macchine in rack differenti. Per questo motivo, è possibile migliorare le performance relative al trasferimento dati utilizzando un numero di rack minore del numero di repliche. Per esempio, quando il fattore di replicazione è tre, due repliche sono posizionate su un rack, e la terza su un rack differente. In questo modo si ottiene un incremento delle performance relative alla scritture delle diverse repliche. Per minimizzare il consumo di banda globale e la latenza di lettura, HDFS tenta di soddisfare una richiesta di lettura dalla replica più vicina, meglio se dallo stesso rack. 2.3 Hadoop MapReduce Il motore di elaborazione fondamentale di un sistema Hadoop è MapReduce. Fornisce tutte le funzionalità necessarie per partizionare i Big Data in blocchi gestibili, elaborare i dati in parallelo su cluster distribuiti, e quindi rendere i dati disponibili all’utente o pronti per ulteriori elaborazioni. E fa tutto questo lavoro in un ambiente altamente resiliente14 e tollerante ai guasti. Con MapReduce e Hadoop, i calcoli sono eseguiti sul nodo in cui sono presenti i dati. Inoltre, lavorando in tandem con HDFS, MapReduce assicura che la memorizzazione e l’elaborazione dei dati coesistano sullo stesso nodo fisico nel cluster, limitando 13 I rack sono strutture simili ad armadi che ospitano apparati di rete, quali server, switch, router, ecc. 14 Il termine resilienza indica la capacità di un sistema di adattarsi alle condizioni d'uso e di resistere all'usura in modo da garantire la disponibilità dei servizi erogati. Tali obiettivi si possono raggiungere mediante tecniche di ridondanza o distribuendo un'applicazione su più calcolatori in modo da assorbire i carichi elaborativi. 20
  • 38. Capitolo 2 Hadoop notevolmente i colli di bottiglia tradizionali, quali la larghezza di banda di rete, dovuti a trasferimenti di grosse quantità di dati. Per cui, MapReduce combina computazione parallela, distribuita e sequenziale, mescolando semplicità, potenza e scalabilità in un unico cocktail. Numerosi problemi pratici – come analisi dei log, ordinamento dei dati, analisi dei grafi, calcoli matematici complessi, operazioni del mondo relazionale, creazione di inverted index15 , e tantissimi altri – sono stati risolti utilizzando MapReduce. 2.3.1 Java MapReduce La scrittura di un programma MapReduce comporta fondamentalmente la creazione di una funzione map, una funzione reduce, e del codice addizionale per eseguire il job. La funzione map è rappresentata dalla classe Mapper, che dichiara un metodo astratto map(). La classe Mapper è di tipo generico, con quattro tipi formali di parametri che specificano i tipi della chiave di input, del valore di input, della chiave di output e del valore di output della funzione map. I tipi dato delle chiavi e dei valori sono oggetti che implementano una specifica interfaccia chiamata Writable, che consente ad Hadoop di scrivere (e leggere) i dati su (o da) file e sono ottimizzati per la serializzazione16 di rete. Alcuni tipi di dato tra i più comuni sono Text, IntWritable, LongWritable, FloatWritable, BooleanWritable, ByteWritable, ArrayWritable e così via. Il metodo map() fornisce un’istanza di Context, destinata a contenere l’output della funzione map, ossia una collezione di chiavi e valori. La funzione reduce è similmente definita utilizzando la classe Reducer. In modo del tutto simile a quanto accade per la funzione map, anche questa classe ha un metodo, chiamato reduce(), che svolge il lavoro. Anche in questo caso si hanno quattro parametri formali che specificano input e output della funzione reduce. I tipi di input della funzione reduce devono combaciare con i tipi di output della funzione map. 15 Gli inverted index sono strutture dati che memorizzano un mapping tra il contenuto – come parole o numeri – e la relativa locazione in un documento o un insieme di documenti. Sono utilizzati soprattutto per agevolare la ricerca full-text e sono componenti centrali di un tipico motore di ricerca. 16 La serializzazione è un processo per salvare un oggetto in un supporto di memorizzazione lineare (ad esempio, un file o un'area di memoria), o per trasmetterlo su una connessione di rete. La serializzazione può essere in forma binaria o può utilizzare codifiche testuali (ad esempio il formato XML) direttamente leggibili dagli esseri umani. Lo scopo della serializzazione è di trasmettere l'intero stato dell'oggetto in modo che esso possa essere successivamente ricreato nello stesso identico stato dal processo inverso, chiamato deserializzazione. 21
  • 39. Capitolo 2 Hadoop Alla funzione reduce giungono, quindi, le coppie chiave/valore già ordinate e separate in partizioni, attraverso un processo chiamato shuffling, che assegna un certo intervallo di chiavi a ciascun nodo reducer. La classe Mapper e la classe Reducer non sono sufficienti alla definizione di un programma MapReduce. Occorre infatti creare un’ulteriore classe, chiamata Driver, che ha il compito di inizializzare il job, passare i parametri di input, definire dove posizionare l’output, e altre configurazioni opzionali. Tale classe imposta il nome del job, le classi che costituiscono i tipi di dati per le chiavi e i valori di output, la classe Mapper, la classe Reducer, la classe Combiner (di cui si è parlato nel Paragrafo 1.2.2) e i formati dell’input e dell’output. Inoltre, il driver imposta i percorsi di input e di output, ricevuti come parametri, ed è possibile configurare il numero di mapper e reducer. Il compito finale del driver, una volta impostate tutte le necessarie configurazione, è quello di lanciare il job MapReduce. Ciò avviene attraverso una singola chiamata al metodo submit() su un oggetto Job, oppure è possibile chiamare il metodo waitForCompletion() che ritorna un valore booleano indicante il successo o il fallimento del job. Il formato di input determina la modalità di lettura dei dati e ciò che è passato al mapper come chiave e valore. La tabella 2.2 riassume i formati di input. Tabella 2.2 – Formati di input di MapReduce Nome formato Descrizione Chiave Valore TextInputFormat È il formato di default e determina la lettura di intere righe da un file. La chiave è l’offset della riga. Il valore è l’intera riga. KeyValueInputFormat Suddivide le righe lette in chiavi e valori. La chiave è ciò che si trova a partire dall’inizio della riga fino al primo carattere Tab. Il valore è il resto della riga. SequenceFileInputFormat Formato binario di Hadoop. Definita dall’utente. Definito dall’utente. Nella tabella 2.3 sono invece riassunti i formati di output. Tabella 2.3 – Formati di output di MapReduce Nome formato Descrizione TextOutputFormat È il formato di default. Genera righe nel formato chiave valore, separati dal carattere Tab. KeyValueOutputFormat Nongeneraalcunoutput.Èutilizzatoquandolosviluppatorecrea,direttamentenellafunzione reduce, il proprio output. SequenceFileOutputFormat Formato binario di Hadoop, utilizzatoper passare dati tra job MapReduce. 22
  • 40. Capitolo 2 Hadoop 2.3.2 Esecuzione di un job MapReduce Come detto nel Paragrafo precedente, è possibile eseguire un job MapReduce attraverso una singola chiamata al metodo submit() su un oggetto Job. Dietro a questa semplice chiamata si nasconde una grande quantità di elaborazione. La figura 2.3 illustra i passi di esecuzione di un job MapReduce. Al livello più alto, ci sono quattro entità indipendenti:  Il client, che sottopone il job MapReduce.  Il JobTracker, che coordina l’esecuzione del job.  Il TaskTracker, che esegue i task nei quali è stato splittato il job.  Il Filesystem distribuito (normalmente HDFS), che è usato per la condivisione dei file del job tra le diverse entità. Figura 2.3 – Come Hadoop esegue un job MapReduce Il metodo submit() sul Job crea un’istanza interna JobSubmmitter e chiama submitJobInternal() su esso (step 1 in Figura 2.3). Il JobSubmmitter interroga il JobTracker per ottenere un nuovo job ID (step 2). Inoltre, copia le risorse necessarie 23
  • 41. Capitolo 2 Hadoop all’esecuzione del job sul filesystem del JobTracker, incluso il file JAR del job, il file di configurazione e gli input split che calcola (step 3). Infine, avvisa il JobTracker che il job è pronto per l’esecuzione (step 4). Quando il JobTracker viene informato che il job è pronto, esso lo pone in una coda interna da dove il job scheduler lo raccoglie e lo inizializza. L’inizializzazione implica la creazione di un oggetto che rappresenta il job, in cui vengono incapsulati i relativi task e informazioni per tenere traccia dello stato e dei progressi dei task (step 5). Per creare una lista di task da eseguire, il job scheduler recupera dal filesystem condiviso gli input split calcolati dal client (step 6). Successivamente crea un map task per ogni split. Il numero dei reduce task da creare è invece determinato dalla proprietà mapred.reduce.tasks definita nel Job. I TaskTracker eseguono un semplice loop con cui periodicamente interrogano il JobTracker. Queste periodiche interrogazioni permettono anche al JobTracker di sapere che il TaskTracker è “vivo” e attivo. Un TaskTracker potrebbe inoltre informare il JobTracker di essere pronto per l’esecuzione di un nuovo task e, in tal caso, il JobTracker gli alloca il nuovo task, comunicandoglielo attraverso lo stesso flusso di comunicazione (step 7). Al momento della scelta del nuovo task da eseguire, se si tratta di un reduce task il JobTracker sceglie semplicemente il prossimo nella lista. Se si tratta di un map task, tuttavia, il JobTracker tiene conto della locazione di rete del TaskTracker, scegliendo un task il cui input split sia quanto più vicino possibile al nodo TaskTracker. Una volta che è stato assegnato il task al TaskTracker, il prossimo passo è quello di eseguire tale task. Per prima cosa, il TaskTracker copia dal filesystem condiviso al filesystem locale tutte le risorse necessarie all’esecuzione del job, come il JAR del job e qualsiasi altro file essenziale (step 8). Successivamente, crea una directory di lavoro locale per il task, e estrae il contenuto del JAR in tale directory. Dopodiché crea un istanza di TaskRunner per eseguire il task. TaskRunner lancia una nuova Java Virtual Machine (step 9) per eseguire ogni task (step 10), cosicché qualsiasi bug nelle funzioni map e reduce definite dall’utente non influiscano sul TaskTracker (causando un blocco o un crash, per esempio). Infine, quando il JobTracker riceve una notifica che l’ultimo task per il job è stato completato, cambia lo stato per il job in “successful”. Di conseguenza, quando il Job verifica lo stato, apprende che il job è stato completato con successo, e quindi stampa un messaggio per informare l’utente. 24
  • 42. Capitolo 2 Hadoop 2.3.3 Shuffle e Sort MapReduce assicura che l’input di ogni reducer sia ordinato per chiave. Il processo con cui il sistema esegue l’ordinamento – e trasferisce gli output del map ai reducer come input – è detto shuffle. La fase di shuffle costituisce sostanzialmente il cuore di MapReduce. L’output della funzione map non viene semplicemente scritto su disco. Il processo è più complicato, e si avvale di scritture temporanee in memoria e preordinamenti per ragioni di efficienza. La Figura 2.4 mostra ciò che avviene. Figura 2.4 – Operazioni di Shuffle e Sort in MapReduce Ogni map task ha un buffer di memoria circolare in cui scrive gli output. Quando il buffer raggiunge un certo valore di soglia predefinito, un thread in background comincerà a riversarne il contenuto sul disco. Prima di scrivere sul disco, il thread divide i dati in un numero di partizioni corrispondente al numero di reducer, a cui successivamente saranno inviate. In ogni partizione, il thread in background esegue un ordinamento per chiave, e se è stata impostata una funzione combiner, essa sarà eseguita sull’output ottenuto in seguito all’ordinamento. L’esecuzione della funzione combiner permette di rendere l’output più compatto, in modo tale che ci siano meno dati da scrivere sul disco locale e da trasferire successivamente ai reducer. Ogni qual volta il buffer di memoria raggiunge il valore di soglia, viene generato un nuovo spill file, cosicché dopo che il map task ha scritto il suo ultimo record di output potrebbero esserci diversi spill file, opportunamente partizionati e ordinati. Tali spill file sono uniti – operazione di merge – per formare il file di output finale, che sarà ordinato per partizioni, dove ogni partizione sarà ordinata per chiave. 25
  • 43. Capitolo 2 Hadoop Prodotto il file finale, ogni partizione sarà inviata ad un diverso reducer. Dato che ogni map task potrebbe produrre gli output in tempi differenti, i reduce task iniziano a copiare – fase copy – i loro output non appena sono completati. Ogni reduce task ha un certo numero di thread addetti alla copia cosicché possano prelevare – fetch – gli output dei mapper in parallelo. Se gli output del map sono sufficientemente piccoli, saranno copiati in memoria, altrimenti sul disco. Se il buffer di memoria raggiunge una certa grandezza di soglia, oppure un numero preimpostato di map output, essi sono uniti e riversati sul disco. Anche in questo caso, una funzione combiner, se specificata, potrebbe ridurre la quantità di dati scritti su disco. Quando tutti gli output del map sono stati copiati, avviene la fase sort, in cui vengono uniti – merge – gli output del map, mantenendo il loro ordinamento. Successivamente, durante la fase reduce, si ha un’ultima unione dei segmenti provenienti sia dal disco che dalla memoria. Durante la fase reduce, la funzione reduce è invocata per ogni chiave nell’output ordinato. L’output di questa fase è scritto direttamente sul filesystem di output, tipicamente HDFS. Nel caso di HDFS, dato che il nodo TaskTracker sta anche eseguendo un DataNode, la prima replica sarà scritta sul disco locale. 2.4 Hadoop Streaming Hadoop Streaming è una utility grazie alla quale è possibile utilizzare programmi eseguibili oppure script come mapper e reducer. Con Hadoop MapReduce è necessario implementare delle classi Java – principalmente tre: mapper, reducer e driver – con alcune caratteristiche sostanzialmente predefinite17 . Con Hadoop Streaming, invece, è sufficiente creare due programmi in grado di leggere dallo standard input e scrivere sullo standard output. Il programma può essere scritto in un qualsiasi linguaggio di programmazione ed è compito dell’utility la creazione del job MapReduce, la sua esecuzione e il relativo monitoraggio. Le righe lette dall’input sono suddivise tra chiave e valore con il seguente criterio: i caratteri fino al primo Tab sono considerati chiave, mentre il resto della riga è il valore. Se non esiste un carattere Tab, la riga è considerata tutta come chiave, e il valore sarà nullo. Ovviamente è possibile specificare un altro separatore di campi attraverso alcuni 17 Per approfondimenti sulle caratteristiche di un programma MapReduce in Java si consiglia di visitare la documentazione al link seguente: http://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html 26