Embed Size (px)
Citation preview
Scuola Politecnica e delle Scienze di BaseCorso di Laurea in Ingegneria Informatica
Elaborato finale in Intelligenza Artificiale
Analisi di social network e progettazione di un tool di apprendimento per l'individuazione delle “association rules” in file di log
Anno Accademico 2016/2017
Candidato:
Salvatore Regalbuto
matr. N46001375
A tute le persone che non smetono mai di credere nel'innovazione.
Indice
Indice..................................................................................................................................................IIIIntroduzione..........................................................................................................................................4
Capitolo 1: Stato dell'arte delle tecniche di analisi di social network................................................6 1.1 Sviluppo, avanzamenti, prospettive.........................................................................................6 1.2 Comunità e strutture gerarchiche nelle reti sociali dinamiche.................................................81.3 Analisi sulla somiglianza delle keyword degli utenti dei social networks............................10
1.4 Classificazione degli utenti dei social networks....................................................................13 1.5 Social media e comunicazione politica..................................................................................16
Capitolo 2: Tecniche di analisi dei dati su flussi di rete.....................................................................202.1 ARFF Reader............................................................................................................................222.2 Data Manipulation....................................................................................................................24
2.2.1 Column Auto Type cast.....................................................................................................252.2.2 Sorter..................................................................................................................................262.2.3 Column Filter…................................................................................................................ 272.2.4 Row Filter...........................................................................….…......................................29
Capitolo 3: Ricerca delle regole di associazione................................................................................313.1 Elaborazioni preliminari: Recursive Loop...............................................................................31
3.1.1 Ramificazione Superiore....................................................................................................32 3.1.2 Ramificazione Inferiore.....................................................................................................34
3.1.3 Risultati ottenuti dal loop...................................................................................................35 3.2 Acquisizione delle regole di associazione: Association Rule Learner.....................................36 3.2.1 Creazione Transition Values..............................................................................................37 3.2.2 Association Rules...............................................................................................................39Capitolo 4: Risultati sperimentali.......................................................................................................42 4.1 Post-Processing.......................................................................................................................42 4.2 Analisi dei risultati..................................................................................................................44
Conclusioni.........................................................................................................................................45Bibliografia.........................................................................................................................................46
Introduzione
I file di log vengono prodotti da un elevatissimo numero di applicazioni, in diversi
contesti.
All'intero di questi file vengono registrate in maniera sequenziale e cronologica tutte le
operazioni che un utente, un amministratore o una macchina compie durante la sua
sessione di lavoro; tali informazioni sono contenute sottoforma di dati grezzi.
Molte volte risulta importante effettuare delle analisi al fine di estrarre informazioni dai
dati contenuti all'interno di un file di log,
le tecniche più diffuse per estrarre informazioni sono quelle di “data mining”.
Il data mining è un processo essenziale in cui si applicano metodi intelligenti per estrarre
modelli di dati (data pattern). Con questo processo si arriva alla scoperta di interessanti
pattern e alla conoscenza ottenuta da grandi quantità di dati. Le fonti (data sources)
possono includere basi di dati, le data warehouses, il Web, altre repository di informazioni
o anche dati che vengono trasmessi al sistema dinamicamente . [1]
Un concetto correlato al data mining è quello di apprendimento automatico (Machine
Learning); infatti, l'identificazione di pattern può paragonarsi all'apprendimento, da parte
del sistema di data mining, di una relazione causale precedentemente ignota, cosa che
trova applicazione in ambiti come quello degli algoritmi euristici e dell'intelligenza
artificiale. Tuttavia, occorre notare che il processo di data mining è sempre sottoposto al
rischio di rivelare relazioni causali che poi si rivelano inesistenti. L'estrazione dei dati vera
e propria giunge al termine di un processo che comporta numerose fasi: si individuano le
fonti di dati; si crea un unico set di dati aggregati; si effettua una pre-elaborazione (data
cleaning, analisi esplorative, selezione, ecc.); si estraggono i dati con l'algoritmo scelto; si
interpretano e valutano i pattern; l'ultimo passaggio va dai pattern alla nuova conoscenza
così acquisita. [2]
4
Questo elaborato è suddiviso in due parti: Nella prima parte descriveremo come si sono
evolute nel tempo le tecniche di analisi di dati ottenuti dai social network. Nella seconda
parte analizzeremo un file di log utilizzando un tool in grado di restituire diverse regole di
associazione in base agli eventi considerati.
5
Capitolo 1: Stato dell'arte delle tecniche di analisi di social
network
In questo capitolo faremo dei brevi cenni riguardo lo sviluppo delle analisi delle reti
sociali.
1.1 Sviluppo, avanzamenti, prospettive
Il pensiero strutturale di un social network ha radici profonde nella tradizione sociologica,
solo nel 1930 il pensiero di rete emerse come un approccio distinto alla struttura sociale.
In questo periodo i teorici sociali tedeschi costruirono una “formal sociology” nella quale
loro indagavano sulle configurazioni delle relazioni sociali prodotte attraverso l'intreccio
di incontri sociali. I fautori principali di questa idea erano Alfred Vierkandt e Leopold von
Wiese; essi adottarono una terminologia di punti, linee e relazioni per andare a descrivere
le relazioni sociali. Intorno al 1936 I due ricercatori Lewin e Moreno effettuarono
importanti indagini sul “campo” o lo “spazio” delle relazioni sociali e delle sue
caratteristiche all'interno della rete. In particolare è stato Moreno che ha dato al suo
approccio il nome di “Sociometria” e ha introdotto l'idea di rappresentare strutture sociali
come reti di diagrammi (sociogrammi) composte da punti e linee. La sociometria divenne
il campo più studiato per effettuare ricerche sull'educazione e sulla psicologia sociale,
dando vita all'approccio chiamato “group dynamics”. Una forte crescita sul “network
thinking” ci fu quando altri due ricercatori Warner e Mayo collaborarono insieme in
un'indagine sulle strutture delle comunità presenti nelle città e nei paesi americani. Essi
focalizzarono la loro attenzione sulle strutture delle relazioni di gruppo e iniziarono a
progettare dei “network diagrams” per rappresentarle. Quando uscì il loro rapporto sulla
ricerca, circa un decennio dopo il suo inizio, venne saldamente stabilità l'idea di vedere
gruppi sociali come network of relations. Nel 1963, lo studioso Harrison White iniziò a
sperimentare l'uso dell'algebra per rappresentare le strutture di parentela, e nel 1976 riuscì
6
insieme ad altri colleghi a sviluppare metodi basati sull'analisi di matrici per studiare le
posizioni sociali. In questi stessi anni, Levine sperimentò metodi di scaling
multidimensionale per studiare il potere delle multinazionali, mentre altri ricercatori
estesero i metodi sociometrici per svolgere indagini sull'aborto e l'occupazione.
Fino a poco tempo fa l'approccio predominante nell'analisi delle reti sociali è stato quello
matematico basato sulla teoria dei grafi. Questa teoria ci permette di studiare reti di tutti i
tipi. Nell'analisi delle reti sociali individui e gruppi sono rappresentati da punti e le loro
relazioni sociali da linee alle quali può essere associata una direzione per rappresentare il
flusso di influenza e un valore per rappresentare la forza della relazione. In particolare
quando i dati di rete sono rappresentati in forma matriciale la teoria dei grafi può agire
direttamente sulle matrici senza aver bisogno di costruire una rappresentazione visiva dei
dati, questo è un grande vantaggio per dataset di grandi dimensioni. In tempi più recenti i
vari approcci usati per l'analisi di reti sociali sono stati implementati all'interno di parti di
software, come ad esempio UCINET (che nasce proprio come implementazione della
teoria dei grafi) e PAJEK (che viene utilizzato per trattare grandi quantità di dati
utilizzando metodi visivi di rappresentazione).
Negli ultimi tempi è cambiato anche il modo di analizzare le features delle reti sociali,
infatti solo negli ultimi anni si è passato dal concentrarsi sulle caratteriste statiche delle
reti sociali, al concentrarsi sui processi dinamici coinvolti nei cambiamenti nel corso del
tempo. Procedendo in questa direzione sono stati ottenuti progressi dervanti dall'uso di
modelli che raffigurano i modi in cui il comportamento dei singoli agenti emerge nelle
trasformazioni globali della struttura della rete. Questi modelli vengono denominati
modelli computazionali basati su agenti, gli agenti (che possono essere individui o
gruppi) vengono visti come entità “rule-following” le cui decisioni, prese per agire in un
modo o in un altro, sono consequenziali per la rete globale in virtù della loro
concatenazione con le conseguenze delle azioni di altri. Pertanto, la conoscenza delle
norme secondo le quali gli agenti agiscono può essere utilizzata per prevedere ampi
modelli di cambiamenti in rete. [3]
7
1.2 Comunità e strutture gerarchiche nelle reti sociali dinamiche
Come detto nel paragrafo precedente, l'individuazione delle strutture della comunità nelle
reti sociali ha richiamato molta attenzione nel contesto della sociologia e delle scienze
comportamentali. Le reti sociali hanno una natura dinamica poiché cambiano
continuamente con il passare del tempo ed inoltre possono presentare una struttura
gerarchica guidata da individui che giocano ruoli importanti all'interno di una società,
come i manager e coloro che hanno potere decisionale. Si può dire che un social network è
un insieme di persone connesse da relazioni sociali, come l'amicizia o collaborazioni
lavorative. L'analisi visiva di una rete sociale è di fondamentale importanza, in quanto la
visualizzazione delle strutture comunitarie presenti nei social networks e l'individuazione
di persone che giocano ruoli importanti all'interno di una rete possono rivelarci
informazioni interessanti, in particolare sfruttando l'evoluzione temporale delle relazioni.
Le reti sociali possono presentare delle dinamiche temporali in diversi modi. Ad esempio
una persona potrebbe cambiare la sua appartenenza con un'azienda unendosi ad un'impresa
diversa e sviluppando nuovi legami sociali con questo nuovo ambiente. Inoltre le relazioni
possono rappresentare eventi ed associazioni che sono importanti ad un certo punto della
vita, come una nuova opportunità di lavoro o la fondazione di una nuova società. In questo
caso la dimensione temporale associata a questi eventi gioca un ruolo chiave per
l'acquisizione di importanti informazioni.
Una recente applicazione sulle analisi delle reti sociali riguarda lo studio della lotta al
terrorismo. Studiare le reti sociali di potenziali terroristi ci può aiutare a scoprire la
struttura organizzativa delle reti terroristiche, a prevedere atti terroristici attraverso
l'individuazione degli eventi e la possibilità di rivelare le identità delle menti più
importanti che stanno dietro le attività criminali.
Nel 2007 venne introdotto un tool denominato C-Group, utilizzato per l'analisi temporale
di una rete sociale. Questo tool si concentra sull'analisi di un paio di individui piuttosto
che sull'intera struttura della rete; come approccio funziona bene per tracciare l'evoluzione
dei rapporti tra individui, ma non acquisisce l'evoluzione delle strutture comunitarie
dell'intera rete sociale. Nello stesso periodo, altri due studiosi Sarkar e Moore
8
presentarono un metodo per la modellazione delle relazioni che cambiano nel tempo.
L'idea è quella di sviluppare una conoscenza dei dati storici e prevedere le interazioni
future. Questo modello può essere usato per studiare i comportamento delle singole
relazioni ma richiede un adattamento per modellare il comportamento di un gruppo di
persone. Questi sistemi appena descritti funzionano bene per sfruttare le dimensioni
temporali di una rete dinamica concentrandosi sui cambiamenti e le transitività degli
individui o delle loro relazioni.
Osserviamo adesso un sistema di analisi delle reti sociali dinamiche proposto da F. Gilbert
ed altri studiosi. Definiamo una rete sociale dinamica come un grafo dinamico G = (V,E)
dove V rappresenti un insieme di nodi (persone) ed E rappresenta un insieme di linee
(relazioni), ogni linea “e” appartenente all'insieme E ha un attributo raffigurante un
intervallo di tempo (0,T]. Quindi Il grafico G[t1,t2 ] rappresenta i nodi del grafo con solo le
relazioni presenti nell'intervallo [t1,t2]. L'idea principale si basa su un framework, la
figura 1.1 mostra le quattro fasi del framework sul quale si appoggia il sistema.
Fig.1.1
La prima fase converte il grafo dinamico in un insieme di grafi statici, dove ad ogni grafo
9
statico corrisponde un intervallo temporale.
La seconda fase raggruppa ogni singolo grafo separatamente usando un algoritmo di
clustering di sovrapposizione per produrre i Fuzzy Clusters. Questa fase ci permette di
identificare le comunità nella rete.
La terza fase rileva grandi cambiamenti strutturali nella rete confrontando i clustering
ottenuti su ogni coppia di successivi grafi statici. Una bassa somiglianza indica grandi
cambiamenti durante il periodo corrispondente alla coppia, mentre un'alta somiglianza
corrisponde a periodi stabili dove la struttura topologica della rete non subisce alcuna
modifica sostanziale. Perciò, una volta ottenuta la matrice di similarità dai clustering,
possiamo decomporre i cambiamenti temporali in ingresso alla rete in periodi di alta
attività e in comunità di “consenso” durante periodi stabili.
L'ultima fase consiste nel trovare una gerarchia di ruoli o influenze nelle comunità di
consenso filtrate nella fase precedente. Possiamo definire un gerarchia di influenze come
un albero, dove l'altezza di un nodo rappresenta l'influenza che ha sull'intera rete.[4]
1.3 Analisi sulla somiglianza delle keyword degli utenti dei social networks
Un profilo utente in un social network online è caratterizzato dalle proprie “user entries”.
Queste voci vengono definite come le keyword dell'utente.
Il famoso esperimento condotto da Travers e Miligram sul problema del “piccolo mondo”,
ha cercato di accertare se le persone nella società fossero tra loro collegate attraverso
piccole catene. L'esperimento consisteva nel fare inviare da alcune persone delle lettere ad
amici contenenti il nome di una persona target che si pensava potesse essere già
conosciuta dal destinatario. I risultati hanno mostrato che le persone sono in grado di
trovare altri individui anche molto lontani abbastanza rapidamente e la lunghezza del
percorso che connette un determinata coppia di individui è molto piccola. Queste
conclusioni molto interessanti portano a chiedersi come gli individui sono collegati tra di
loro nonostante vivono in località geografiche diverse. I social networks online (OSNs) ci
aiutano a studiare questi problemi usando dati ricchi di informazioni presenti sugli utenti.
Infatti un tipico profilo utente in un OSN è caratterizzato da varie keyword come:
10
locazione, città natale, attività, interessi ecc. Per esempio su Facebook le persone
stringono relazioni di amicizia quando esse scoprono profili con keyword simili alle
proprie.
Nei primi anni 2000 sono stati sviluppati diversi modelli matematici per mostrare come gli
utenti interagiscono tra di loro e stabiliscono collegamenti per costruire una rete sociale.
Un esempio è dato dal modello reticolare sviluppato da Kleinberg nel 2000, che si basa
sulla distanza geografica tra gli utenti. Questo modello definisce un modello di rete basato
sulla propensione degli utenti a stringere molte amicizie a corto raggio e pochi contatti a
lungo raggio. Sulla base di ciò, sono stati implementati algoritmi decentralizzati con lo
scopo di dimostrare che gli utenti hanno un'alta probabilità di cercare altri utenti su brevi
percorsi. Più recentemente sono stati anche presentati nuovi modelli matematici per
promuovere l'algoritmo di ricerca decentralizzato che consente di fare ricerche anche
quando gli utenti non sono consapevoli della loro e delle altre posizioni nella rete.
La tendenza degli individui di associarsi e creare legami con altri simili (Homophily) ha
costituito un ruolo importante nello studio delle reti sociali. I sociologi hanno cercato di
studiare questo fenomeno considerando caratteristiche diverse come sesso, razza, etnia
ecc. È stato osservato che lo scambio di informazioni tra gli utenti avviene solo quando
essi condividono un percorso sociale, keyword comuni e appartenenze comunitarie.
Un lavoro pubblicato nel 2005 da Liben-Nowell ha dimostrato che un terzo delle amicizie
su di un social network sono indipendenti dalla geografia. Questa conclusione ci porta a
domandarci sul perché persone che si trovano in luoghi completamente diversi stringono
amicizia e quali sono le caratteristiche che hanno in comune. Per rispondere a queste
domande dobbiamo analizzare i modelli di utilizzo delle keyword, prendiamo come
esempio il social network Facebook. Considerando il campo degli interessi dell'utente
abbiamo una lista di attività alle quali è appassionato o argomenti ai quali è interessato. Ad
esempio un analisi dei dati mostra che una larga fetta di utenti elenca la musica tra i propri
interessi, vedi fig. 1.2.
11
Fig. 1.2
La tabella riportata in fig. 1.2 contiene le prime dieci parole chiave utilizzate più
frequentemente, questo significa che per una media di 6 keyword per profilo utente, un
utente ha un'alta probabilità di avere una di queste keyword.
Descriviamo adesso uno dei modelli più importanti per categorizzare le keyword, il forest
model. Questo modello, ci aiuta a definire la struttura di dati per utilizzare le relazioni
sottostanti tra le keyword ed è in grado di fare una chiara distinzione tra le keyword
collegate e non collegate. Le keyword si dicono connesse quando sono semanticamente
collegate, ad esempio, quando condividono lo stesso significato. Consideriamo, ad
esempio, le keyword 'football' e 'soccer', esse sono collegate poiché rappresentano
entrambe un tipo di sport. In particolare entrambe possono ancora essere collegate con la
keyword 'sport' a causa delle relazioni tra i loro significati. In questo modo grazie alle
relazioni tra le keyword possiamo abbinare i profili utenti e analizzare le somiglianze tra
questi ultimi, gli effetti del fenomeno dell'Omofilia, e come si sono stabili i collegamenti
di amicizia.
Una volta che si è stabilita una relazione tra due parole chiave, il requisito fondamentale
per un modello è che bisogna mantenere separate le keyword non correlate. Questo
significa che mentre 'football' e 'soccer' sono relazionate attraverso il modello, parole
come 'soccer' e 'equine' devono essere mantenute separatamente. Descriviamo il modello:
ogni keyword è vista come nodo, i nodi sono connessi quando esistono relazioni tra le
keyword. Questi nodi sono organizzati in ordine gerarchico in modo che quando una
12
keyword è derivata da un'altra keyword, la gerarchia aiuta nel definire la relazione tra le
keyword. La gerarchia, quindi, offre la possibilità di rilevare distanze e dissomiglianze tra
le keyword e impedisce l'omogeneità tra i nodi che può derivare dall'uso di una struttura di
dati piatta. Pertanto, le gerarchie costruite per definire le relazione tra le parole chiave
portano alla definizione di alberi, inoltre per mantenere le keyword, non correlate tra di
loro, separate l'una dall'altra si utilizzano alberi multipli. In ogni albero è contenuto un set
di keyword che sono collegate tra di loro all'interno della struttura ma estranee a qualsiasi
altra keyword contenuta in altre strutture di alberi. Un esempio di Forest Model composto
da due alberi è mostrato in fig. 1.3. [5]
Fig. 1.3
1.4 Classificazione degli utenti dei social networks
In questo paragrafo considereremo come social network di riferimento Twitter.
L'analisi dei social network può essere suddivisa in due gruppi, analisi qualitativa e analisi
quantitativa. Un esempio di analisi qualitativa è dato dai primi lavori svolti da Berkowitz
(1982) e Scott (1992), i loro studi si basavano sui modelli di relazioni tra le persone, gli
stati le organizzazioni ecc.
Un esempio di analisi quantitativa invece è il lavoro svolto da Marsden e Campbell nel
1984. Essi applicarono diverse tecniche per misurare le forze dei legami all'interno di un
social network, in particolare per ottenere queste misure considerarono due aspetti distinti
della forza di un legame: Il tempo trascorso in un rapporto e la profondità del rapporto. I
risultati delle loro ricerche mostrarono che la vicinanza di un rapporto o l'intensità è il
miglior indicatore di forza.
Come abbiamo visto le analisi dei social network si basano principalmente sui legami, ma
13
questi legami vengono instaurati dagli utenti ed in particolare all'interno dei social
networks gli utenti possono essere visti come attori, dove ogni attore svolge un proprio
ruolo all'interno della comunità. Questi attori possono essere classificati in: leader, lurker,
close associate e spammer.
Leader: coloro che iniziano a twittare ma non seguono nessuno, sebbene potrebbero
avere molti followers.
Lurker: coloro che sono generalmente inattivi ma occasionalmente seguono
qualche tweet.
Spammer: coloro che sono twitter indesiderati, chiamati anche twammers.
Close associates: questa categoria include amici, parenti, colleghi ecc.
Esistono due metodi per classificare i differenti attori all'interno di un social network: Il
primo si basa sull'approccio teorico del fuzzy-set per valutare la forza dei legami nella
rete, il suo nome è Contex-dependent; il secondo metodo invece si basa sulla
classificazione degli attori attraverso l'abbinamento di diversi modelli di tweet, tale
metodo è denominato Context-independent.
Il metodo Contex-dependent si utilizza quando quando si hanno a disposizione grosse
quantità di dati relativi a tweet creati dagli utenti. In Twitter le persone possono seguire
altri utenti o essere seguite a loro volta, in particolare nel gergo di Twitter abbiamo due
tipologie di individui: i “Follower” e i “Followees”. Le relazioni tra gruppi di utenti
possono essere monitorate attraverso i tweet. All'interno di questo social (e generalmente
in tutti) è possibile stimare la forza di una relazione studiando le statistiche dei messaggi
scambiati tra follower-followees. In generale possiamo dire che migliore è la
comunicazione reciproca, maggiore è il legame (relazione) di forza.
Questo metodo segue un processo diviso in due fasi. Nella prima fase si stima la forza dei
legami all'interno della rete e si eliminano un grande numero di attori con forti relazioni
sociali perchè sono sicuramente classificati nel gruppo dei close associates. Nella seconda
fase, si esegue una classificazione lineare dei quattro tipi di attore sopra citati, usando il
numero dei tweet e il rapporto tra follower-followees come feature che vengono utilizzate
14
per considerare solo gli utenti con una relazione di forza debole. In figura 1.4 è mostrato
un social network rappresentato come un grafo con relazioni ponderate.
Fig. 1.4
Il metodo Context-independent viene utilizzato quando non ci sono abbastanza
informazioni riguardanti il social network da analizzare. Questo approccio riceve il suo
supporto da dati empirici riguardanti le nature distinte dei modelli di tweet collezionati da
diverse tipologie di utenti. In fig. 1.5 sono rappresentati tre modelli di tweet registrati in
un arco di 10 giorni, rispettivamente appartenenti a tre tipologie di attori diversi.
Fig. 1.5
15
Questi modelli ci indicano in che modo e quante volte uno spammer o un close associate
o un leader pubblicano tweet. Con questo approccio siamo in grado di andare a classificare
gli attori della rete abbinando modelli di tweet sconosciuti con i prototipi (o campioni) di
differenti classi. Quindi in definitiva possiamo dire che questo metodo si avvale di
classificazioni tradizionali e generici modelli di tweet per distinguere gli attori in
situazioni dove la disponibilità di informazioni (riguardanti ogni singolo attore) è limitata.
In conclusione di questo capitolo riportiamo dati di risultati interessanti ottenuti attraverso
esperimenti svolti sugli utenti di twitter. Gli spammer sono seguiti da moltissime persone
me ne seguono altrettante altre, in particolare questi account generano in media più di
10.000 tweets ogni 10 giorni ed hanno un rapporto follower-followees di circa 1.5 a 1.
I leader possono distinguersi dagli altri in base al loro alto rate di tweeting, un grande
numero di followers, ma un basso numero di followees, inoltre il loro rapporto follower-
followees è al di sotto di 1. I close associates si contraddistinguono dalla loro forte
connettività con i loro followers, un moderato numero di tweets (circa 1000 al giorno), e
un basso rapporto di follower-followees (inferiore a 3). Infine i lurkers sono una rara
classe di utenti che seguono molte persone ma raramente postano o rispondono ai tweet.
[6]
1.5 Social media e comunicazione politica
Negli ultimi anni, i social media stanno avendo un grande impatto sul dibattito pubblico e
sulla comunicazione all'interno della società, infatti hanno mostrato una rapida crescita del
numero degli utenti e sono stati oggetto di analisi scientifiche, basti pensare che Facebook
conta più di 1 miliardo di utenti in tutto il mondo. In particolare, i social media sono
sempre più utilizzati nel contesto politico.
Questo ci fa capire che l'applicazione di questi mezzi ha cambiato completamente il modo
di divulgare le informazioni.
16
I social media sono definiti come “un gruppo di applicazioni internet-based che si basano
sulle fondamenta ideologiche e tecnologiche del Web 2.0 che consentono la creazione e lo
scambio di contenuti generati dagli utenti”. Recentemente i social media come i siti di
social network (SNS), weblogs, microblogging e le wiki, giocano un ruolo sempre più
importante nel plasmare la comunicazione politica negli Stati Uniti e in tutto il resto del
mondo. Infatti, ad esempio, per quanto riguarda i microblog (in particolare Twitter) , molti
studi hanno dimostrato che la maggior parte dei membri del congresso degli Stati Uniti
utilizzano Twitter come mezzo di auto-promozione, condividendo all'interno della rete
informazioni come link di nuovi articoli riguardanti se stessi e le loro attività quotidiane.
Per quanto riguarda invece gli SNS, come ad esempio Facebook, analizzando i contenuti
di pubblico dominio si può notare come proprio Facebook è diventato un metodo sempre
più popolare per studiare le questioni socio-politiche. Infatti i contenuti pubblici, come ad
esempio i post i bacheca o i commenti, permettono alle persone di esprimere le proprie
opinioni e i propri sentimenti riguardo una determinata tematica, consentendo allo stesso
tempo a scienziati sociali e politici di effettuare le loro analisi su temi politici.
I social media offrono una connessione tra i social networks, canali di informazione
personali e i mass media. I dati di questi mezzi, relativi ai contenuti generati dagli utenti
sui blog, microblog, SNS, forum e siti di condivisione multimediale (come YouTube) ,
rappresentano molte opportunità e sfide per i produttori e consumatori di informazioni.
Recenti studi hanno dimostrato un bisogno emergente di istituzioni politiche per sfruttare
le risorse dei social media allo scopo di migliorare i servizi e la comunicazione tra i
cittadini e gli elettori.
Descriviamo adesso un framework utilizzato nel contesto politico per effettuare analisi sui
social media. In fig. 1.6 è riportato un esempio di applicazione di tale strumento.
17
Fig. 1.6
L'esempio riporta una comunicazione politica e le relative analisi sui social media. Da un
punto di vista pratico, il framework potrebbe servire come guida per lo sviluppo di un set
di strumenti volti a collezionare, archiviare, monitorare, analizzare e sintetizzare i
contenuti generati dagli utenti, politicamente rilevanti, attraverso i social media per le
istituzioni politiche. Questo framework è composto da due parti principali: Il tracciamento
e monitoraggio dei dati, e l'analisi dei dati. Vengono considerati i tre tipi di social media
più importanti: microblog, SNS, weblog.
Per effettuare il tracciamento e il monitoraggio dei dati bisogna prima determinare le fonti
dei dati. Per quanto riguarda Twitter i dati che devono essere tracciati e monitorati sono in
forma di “tweet” pubblici il cui accesso può essere facilmente ottenuto. Per Facebook il
tipo più importante di dati è rappresentato dal contenuto in “bacheca” che include gli
“aggiornamenti di stato” e i corrispondenti commenti.
Per quanto riguarda il tracciamento dei dati sia Facebook che Twitter offrono delle API
apposite per il data tracking. Ci sono diversi approcci di data tracking per un'istituzione
politica, la scelta dipende dalle intenzioni di quest'ultima. Vediamo qualche approccio:
Self-involved: Questo approccio è applicabile, ad esempio, quando individui o parti
politiche vogliono conoscere come le persone parlano di loro nei social media. In
questo caso i politici possono avere tutte le raccolte di tweet che contengono il loro
nome sia come keyword che come hashtag.
Keyword/topic-based: Gli attori politici sono solitamente molto interessati al
feedback o opinioni degli utenti dei social media riguardo determinati temi politici.
Questo approccio è ammissibile quando i tweet o i blog o i post contengono
keyword relative al topic che deve essere monitorato.
18
Actor-based: Questo approccio può essere impiegato per monitorare i tweet, i post
in bacheca, commenti sui blog effettuati da utenti influenti che dovrebbero essere
identificati in anticipo.
Random/Exploratory: Vengono selezionati in modo casuale uno o più insiemi di
dati (tweet o post di Facebook o di blog) da analizzare per diversi periodi di tempo.
URL-based: Viene utilizzato per monitorare il contenuto dietro collegamenti
ipertestuali condivisi su Twitter, Facebook o sui blog.
Per quanto riguarda l'analisi dei dati troviamo anche qui diversi approcci:
Topic/issue/trend-based approach: Per i politici e i partiti è importante monitorare
temi e problematiche politiche, poiché, ad esempio, i problemi potrebbero
contenere potenziali conflitti che possono portare a delle vere e proprie crisi.
Opinion/sentiment-based approach: Questo approccio sta diventando sempre più
importante in ambito politico, poiché permette di farsi un'idea sui sentimenti
prevalenti (emozioni positive o negative) o sulle opinioni espresse da altri su se
stessi come persona o organizzazione, nonché su alcuni tempi politici.
Structural approach: Questo approccio permette alle istituzioni politiche di
identificare utenti influenti o opinionisti leader, in particolare quelli che sono
ideologicamente o politicamente contrari a loro. Monitorando questi utenti, gli
attori politici potrebbero essere in grado di avere una certa influenza sulle opinioni
di questi cercando di fare qualche tipo di intervento per aprire un dialogo diretto
con loro. [7]
In conclusione di questo paragrafo possiamo sicuramente affermare che i social media
sono diventati nel corso degli anni un importante canale politico di comunicazione.
19
Capitolo 2: Tecniche di analisi dei dati su flussi di rete
In questo capitolo riportiamo un tool, realizzato utilizzando la piattaforma Knime, che può
essere adoperato per l'analisi dei file di log mediante tecniche di data mining e association
rule learning.
Inizialmente, è stato analizzato il traffico di rete attraverso un network intrusion detection
system (NIDS) software. Questi tipi di software, analizzando un traffico di rete 'grezzo'
(nel nostro caso il file di log) sono in grado di rilevare anomalie nei flussi o un insieme di
possibili eventi dannosi attraverso alcune regole di detection. In seguito all'analisi vengono
prodotti molti record che contengono le descrizioni dei possibili eventi dannosi. Questi
record vengono memorizzati all'interno di un database in modo tale da essere estrapolati
più facilmente per future analisi.
In questo progetto, analizzeremo un dataset molto particolare, il suo nome è “KDD Cup
99”. Facciamo una breve introduzione su tale file:
Il dataset KDD Cup 99 fu creato analizzando porzioni tcpdump del set di dati di
valutazione restituito dal “1998 DARPA Intrusion Detection System”(IDS), creato dal
Lincoln Lab sotto contratto della DARPA. Dal momento che non si può conoscere
l'intenzione (maligna o benigna) di ogni connessione in rete del mondo reale ( se
potessimo non avremmo bisogno di fare ricerche nel rilevamento delle intrusioni), i dati
artificiali sono stati realizzati usando una rete chiusa, alcuni generatori di traffico di reti
proprietaria, e attacchi “hand-injected”. Tutto ciò era destinato a simulare il traffico in una
base US Air Force. Nel corso degli anni si sono sollevate molte critiche riguardanti la
veridicità di tale dataset, ma tuttora questo set viene utilizzato dai ricercatori IDS per
mancanza di meglio.[8]
Questo dataset contiene al suo interno un numero elevato di feature, riportiamo di seguito
tre tabelle contenenti le feature di maggior rilievo con le rispettive descrizioni. [9]
20
Fig. 1.0
il nostro scopo è quello di andare a determinare delle regole di associazione, del tipo
causa-effetto, considerando le tipologie di intrusione rilevate all'interno della rete.
Nei capitoli successivi verrano illustrate le fasi di progettazione di questo tool di analisi.
Per poter comprendere al meglio lo schema generale del tool descriviamo brevemente la
piattaforma Knime.
Knime ha una struttura modulare , dove gli operatori (in questo caso i nodi) effettuano
azioni indipendenti per poi essere collegati tra di loro con lo scopo di creare la pipeline
desiderata.
21
Obiettivo fondamentale di questo tool è quello di andare ad analizzare un file contenente
una serie di eventi (potenzialmente dannosi), processarlo attraverso i vari nodi che
eseguono il data mining, e poi darlo in pasto ad un nodo definito come “Association Rule
Learner Node”, il quale produrrà in uscita un file contenente le “association rules” degli
eventi. Grazie a questo processo possiamo confrontare diverse regole di associazione che
vengono prodotte sulla base di file diversi. In questo modo potremmo anche apprendere
come variano nel tempo, o nel contesto, tali regole.
Lo schema generale del tool, riportato nella figura 2.1, può essere rappresentato come una
serie di meta-nodi, i quali verranno trattati approfonditamente nei paragrafi successivi.
Ogni meta-nodo al suo interno contiene più nodi, per ogni nodo descriveremo gli input, le
configurazioni per la manipolazione dei dati e gli output che produrranno.
Fig.2.1
Vediamo subito com'è stata effettuata la manipolazione dei dati presentando il nodo
“ARFF Reader” e il meta-nodo “DataManipulation”.
2.1 ARFF Reader
Il File Reader, rappresentato in fig. 2.2 , è un nodo che può essere usato per leggere dati in
formato ARFF da un un indirizzo URL.
22
Fig. 2.2
Nel nostro caso il file che il nodo riceve in ingresso è di tipo ARFF (Attribute Relationship
File Format), il quale rappresenta un formato per un file di testo . Questa tipologia di file
viene utilizzata per memorizzare dati all'interno di database ed effettuare l'analisi di questi
ultimi attraverso software per l'apprendimento automatico (Weka). In questo file i campi
vengono strutturati all'interno di una tabella relazionale definendo tutti gli attributi e i
valori che possono assumere.[10]
In uscita a tale nodo abbiamo una tabella contenente ben 494021 righe e 42 feature, vedi
fig. 2.3. Alla luce di ciò dobbiamo cercare di ridurre il numero delle righe e colonne della
tabella, mantenendo un'alta molteplicità dei valori degli eventi di intrusione associati ad
ogni riga, altrimenti perdiamo il significato della nostra analisi. Questo processo di
alleggerimento della tabella è stato eseguito attraverso il meta-nodo “'DataManipulation'”.
Analizziamolo nel dettaglio.
23
Fig. 2.3
2.2 Data Manipulation
Il DataManipulation è un meta-nodo che è stato creato con lo scopo di manipolare i dati
contenuti nella tabella prodotta dal File Reader, vedi fig. 2.4.
. Fig. 2.4
Questo meta-nodo è composto da più nodi disposti in serie, raffigurati in fig. 2.5,
analizziamoli uno ad uno.
24
Fig. 2.5
2.2.1 Column Auto Type Cast
Questo nodo determina il tipo specifico degli elementi appartenenti ad ogni singola
colonna contenuta nella tabella posta in ingresso. Attraverso questo processo tutti gli
elementi degli attributi delle colonne vengono tipizzati in maniera automatica (int, string
ecc). Nel nostro caso, è stato effettuato il casting di alcuni elementi che l'ARFF Reader
non è riuscito a determinare. Nella sua configurazione, riportata in figura 2.6, si può
notare che sono stati inclusi tutti gli attributi delle colonne della tabella posta in ingresso, i
quali saranno convertiti, ove possibile. Nel campo “Choose a date format” invece è stato
impostato il pattern “yyyy-MM-dd HH:mm:ss”.
Fig. 2.6
25
Questo nodo presenta due porte in uscita:
1. La porta 0 produce una tabella uguale a quella di ingresso ma con gli attributi tipizzati.
2. La porta 1 restituisce informazioni riguardo il tipo di casting scelto (Fig. 2.7).
Fig. 2.7
2.2.2 Sorter
Questo nodo svolge un ruolo chiave ai fini della nostra analisi in quanto ordina le righe in
base ai nostri criteri. Nella configurazione possono essere selezionate le colonne in base ai
dati che devono essere ordinati e all'ordine con il quale devono essere mostrati.
In input riceve la tabella prodotta dalla porta 0 del nodo precedente e in base alla
configurazione scelta restituisce la tabella ordinata. La configurazione è visibile in fig. 2.8
Fig. 2.8
26
Come si può osservare è stato impostato un ordinamento, in base all'attributo “count”, di
tipo ascendente. Quindi, in uscita avremo tutti i record ordinati in base al numero delle
connessioni eseguite negli ultimi due secondi sullo stesso host.
Alla fine di questo processo otteniamo una tabella sulla quale è possibile effettuare
un'analisi empirica concentrandosi sugli eventi che si susseguono. Questa osservazione è
di fondamentale importanza per poter impostare correttamente il prossimo nodo.
2.2.3 Column Filter
Questo nodo compie operazioni di filtraggio sulle colonne della tabella di input, in
particolare è consentito tener fuori determinate colonne, in base al nome dell'attributo, e
includerne altre che saranno passate alla tabella di output. La scelta di
inclusione/esclusione delle colonne è stata presa in seguito ad un'osservazione empirica
effettuata sulle feature del dataset, fig. 2.9.
Fig. 2.9
L'osservazione empirica è stata svolta attraverso tre fasi importanti:
1. Focalizzazione del problema: lo scopo della nostra analisi è quello di andare a
27
determinare le regole di associazione studiando la sequenza delle transizioni
all'interno del nostro data set.
2. Osservazione degli eventi che si susseguono all'interno della tabella: gli eventi più
importanti sono riportati come valori dell'attributo “Class”, tra i più frequenti
troviamo eventi di tipo Smurf, Normal, Neptune, Satan, Teardrop e ipsweep.
Poiché a noi interessa analizzare le regole di associazione dobbiamo considerare
successioni di record che contengono eventi per lo più diversi tra di loro.
3. Le cause che scaturiscono tali eventi: La maggior parte degli eventi malevoli
vengono generati effettuando un numero elevatissimo di connessioni in breve
tempo. All'interno della nostra tabella abbiamo 2 feature che ci possono dare un
grande aiuto per comprendere quando determinati eventi avvengono con frequenza
maggiore. La prima feature è “srv_count”, la quale ci riporta il numero di
connessioni effettuate sullo stesso servizio negli ultimi due secondi. Questi valori
sono molto utili in quanto ci permettono di vedere con che frequenza si presenta un
evento. La seconda feature è “count”, la quale ci riporta il numero di connessioni
effettuate sullo stesso host negli ultimi due secondi della sessione corrente. Essendo
il range di due secondi molto breve, si nota facilmente che la maggior parte delle
volte che il valore “count” è alto si verifica un attacco sulla rete, ed è proprio grazie
all'ordinamento effettuato tramite il “Sorter” che è stato possibile notare tale cosa.
Le conclusioni che si possono trarre alla fine di questa osservazione sono che
all'aumentare delle connessioni effettuate sullo stesso host, in un intervallo compreso da
uno a due secondi, aumenta la probabilità di incorrere in eventi malevoli relativi a diversi
tipi di attacchi DoS (denial of service), che ricordiamo tendono a far esaurire le risorse di
un sistema (es. web server) che offre servizi ai client. In particolare gli attacchi che si
ripetono più spesso sono: Smurf, Neptune, tearDrop, satan. Quindi possiamo filtrare la
tabella considerando i due attributi “srv_count” e “count” che elaborati insieme possono
darci informazioni molto importanti sul come si verificano tali eventi.
28
Sulla luce di queste considerazioni possiamo scartare molti attributi che non servono ai
fini del nostro studio. Nel capitolo successivo invece verrà illustrato come sono state
filtrate le righe del data set.
2.2.4 Row Filter
Questo nodo consente di filtrare le righe secondo determinati criteri. Si possono includere
o escludere: determinati intervalli di righe (stabiliti dall'indice della riga iniziale e quello
della riga finale), righe con specifici identificativi, e righe con un certo valore di attributo,
relativo ad una colonna. Come si evince dalla figura 2.5 sono stati posti in serie due Row
Filter, i quali hanno il compito di filtrare opportunamente la nostra tabella per creare una
grande molteplicità di classi di eventi.
Il primo nodo riceve in ingresso una tabella con tutti i record ordinati in base ai valori
dell'attributo “count”. Nella configurazione, rappresentata in fig. 2.10, è stato settato come
criterio di filtro “Include row by attribute value”, come valore corrispondente di colonna
“srv_count”, e infine come criterio di controllo è stato impostato un intervallo di test
avente limite inferiore pari a 25 e limite superiore pari a 250 . In questo modo vengono
filtrati tutti i record aventi un numero di connessioni (ricordiamo che sono connessioni
effettuate sullo stesso servizio negli ultimi due secondi) compreso tra 25 e 250. Così
facendo siamo sicuri di filtrare sia eventi benevoli che malevoli.
Fig. 2.10
29
Il secondo nodo invece riceve in input una nuova tabella contenente gli eventi che si
ripetono più spesso. Adesso, poiché ci sono ancora molte sequenze di eventi uguali che si
ripetono (come ad esempio gli eventi “Normal”), andiamo a sfoltire ancora di più la nostra
tabella utilizzando lo stesso criterio di filtro del precedente nodo ma prendendo come
colonna di riferimento “count” e come estremi di intervallo di controllo [50,215]. In
questo modo avendo assunto come limite inferiore 50 evitiamo di avere troppi eventi
“Normal”, mentre avendo predisposto come limite superiore 215 evitiamo di avere troppi
eventi “Smurf”.
L'output di questa serie di Row Filter, coincidente con l'uscita del meta-nodo (vedi fig.
2.11), ci restituisce finalmente una tabella di riferimento pronta per essere analizzata.
Fig. 2.11
30
Capitolo 3: Ricerca delle regole di associazione
Nella seconda parte del nostro elaborato descriveremo il processo che porta alla scoperta
delle Association Rules. Partiremo dall'elaborazione dei dati che viene effettuata sul meta-
nodo 'RecursiveLoop' fino ad arrivare all'output finale generato dalla porta 0 del nodo
cardine del nostro tool, l'Association Rule Learner.
3.1 Elaborazioni preliminari: Recursive Loop
Fig. 3.1
All'interno di questo meta-nodo, fig. 3.1, viene processata la tabella prodotta dal “Data
Manipulation” per poterla rendere compatibile con l'Association Rule Learner. Per
elaborare correttamente il nostro data set abbiamo bisogno di manipolare i dati per un
numero finito di volte N. Questo procedimento ricorsivo è possibile riprodurlo in Knime
grazie a due nodi che lavorano in coppia:
Il Recursive loop Start che ha il compito di introdurre la tabella di dati all'interno
della struttura ricorsiva. A partire dal secondo ciclo emetterà i dati della tabella
ricevuta dal nodo Recursive loop End.
Il Recursive loop End, il quale riporta la tabella processata di nuovo al Recursive
Loop Start, questo procedimento si ripete fino al ciclo N. In particolare questo nodo
presenta due porte in input: i dati passati alla porta 0 vengono collezionati e
31
trasmessi in uscita, mentre quelli passati alla porta 1 vengono restituiti al nodo
Recursive Loop Start per procedere con la prossima iterazione.
Fig. 3.2
Osservando la fig. 3.2, possiamo notare che l'output del primo nodo crea due ramificazioni
dando cosi una configurazione parallela all'intera struttura del meta-nodo. Andiamo ad
analizzare nel dettaglio la ramificazione superiore e quella inferiore.
3.1.1 Ramificazione Superiore
Sul ramo superiore sono posti in serie tre nodi: Row Filter, Column Filter, Transpose.
Analizziamoli singolarmente:
Il primo nodo è il Row Filter che come descritto in precedenza ci consente di filtrare le
righe a nostro piacimento. In questo caso è stato selezionato come criterio di filtro
“Include Rows by Number”, vedi fig. 3.3, ragion per cui consideriamo solo un intervallo
di righe specifico.
É stato configurato un intervallo il cui range va dalla riga 1 alla riga 18. Questa scelta è
stata motivata in seguito ad un'attenta osservazione eseguita sul data-set.
32
Fig. 3.3
Ad ogni iterazione, in uscita viene prodotta una finestra contenente solo i record di nostro
interesse, vedi fig. 3.4. Analizziamo adesso come viene trattato questo output dal nodo
successivo.
Fig. 3.4 (Esempio di output dopo l'ultimo ciclo)
Il secondo nodo è il Column Filter, il quale riceve in ingresso la tabella prodotta dal nodo
precedente ed esegue un filtraggio sulle colonne, escludendo tutte le colonne eccetto
quella riferita all'attributo “Class”. In questo modo abbiamo trasformato la tabella di 18
elementi in una colonna contenente solo i nomi degli eventi. Quindi in uscita avremo solo
una colonna riportata in fig. 3.5.
33
Fig. 3.5 (Esempio di output dopo l'ultimo ciclo)
L'ultimo nodo della ramificazione superiore è il Transpose. Questo nodo traspone l'intera
tabella d'ingresso scambiando di posizione le righe con le colonne. I nuovi nomi delle
colonne sono forniti dai vecchi identificativi delle righe mentre i nuovi nomi delle righe
sono ottenuti dai vecchi attributi delle colonne. Il tipo della colonna resta il medesimo e
viene applicato a tutti gli elementi in una riga. Nel nostro caso quindi avremo in uscita la
trasposta della matrice applicata in ingresso, fig. 3.6, dove l'identificativo della riga
corrisponde all'attributo “class”.
Fig. 3.6 (Esempio di output dopo l'ultimo ciclo)
3.1.2 Ramificazione Inferiore
Il ramo inferiore è composto da un unico nodo, il Row Filter. Tale nodo prende in ingresso
la tabella di dati uscente dal Recursive Loop Start e la filtra in modo tale da eliminare la
prima riga. Quindi, nella configurazione, come criterio di filtraggio è stato impostato
'Exclude rows by number', settando i parametri “First row number” e “Last row number”
34
a 1, vedi fig. 3.7. In questo modo ad ogni iterazione viene eliminata la prima riga dalla
tabella, dando quest'ultima in input al Recursive Loop End sulla porta 1 dove, come
abbiamo spiegato in precedenza, vengono raccolti i dati da passare di nuovo all'inizio del
prossimo ciclo. In particolare è stato scelto di eliminare una sola riga alla volta in modo
tale da garantire la molteplicità tra gli eventi ed evitare di creare sequenze di eventi uguali
tra di loro.
Fig. 3.7
3.1.3 Risultati ottenuti dal loop
Al termine di questo loop in uscita dal meta-nodo avremo una tabella, fig. 3.8, formata da
N righe e 18 colonne, dove gli elementi di ogni riga sono il risultato di ogni ciclo. Nel
nostro progetto N = 2046, questa scelta viene motivata dalla seguente osservazione: Si
sono voluti raccogliere 18 eventi ad ogni iterazione ed eliminare di volta in volta la prima
riga della tabella. Sapendo che il numero totale delle righe della tabella posta in input al
Loop Start è 2064, allora il numero totale di cicli si otterrà da una semplice sottrazione:
N = 2064 – 18 = 2048.
Ad ogni ciclo la tabella si incrementa di 18 elementi nel seguente modo: Al primo ciclo
vengono collezionati i primi 18 eventi, che vanno dall'indice 0 all''indice 17, al secondo
35
invece vengono aggiunti gli eventi che vanno dall'indice 1 al 18 e così via.
In questo modo possiamo analizzare tutte le relazioni possibili che ci sono tra un evento e i
18 avvenimenti precedenti e successivi. Infine ogni riga rappresenta una singola
transizione.
Fig. 3.8
3.2 Acquisizione delle regole di associazione: Association Rule Learner
Fig. 3.9
All'interno di questo meta-nodo, fig. 3.9 , viene processata la tabella prodotta dal
“Preliminary Processing” con lo scopo di ottenere le association rules relative agli eventi
associati. In figura 3.10 possiamo osservare la configurazione di tale meta-nodo, in
particolare troviamo quattro nodi posti in serie: Create Collection Column, Column Filter,
Association Rule Learner (Borgelt), Column Filter. Analizziamo il funzionamento di
questi nodi.
36
Fig. 3.10
3.2.1 Creazione Transition Values
Il nodo Association Rule Learner per poter funzionare correttamente necessita di ricevere
in ingresso una tabella contenente un'unica lista di transizioni, quindi dobbiamo preparare
la nostra tabella in modo tale da renderla compatibile con tale nodo. I nodi incaricati per
questo lavoro sono il Create Collection Column e il Column Filter.
Il Create Collection Column aggrega più colonne in una nuova colonna separata, il cui tipo
dipende dagli elementi collezionati. Nel nostro caso tale nodo prende in ingresso la tabella
prodotta dal meta-nodo Preliminary Processing, visibile in fig. 3.8, aggrega tutti i valori di
ogni singola riga e crea una nuova colonna definita ''TransitionValues'' contenente tutte le
transizioni relative ad ogni singola riga. Quindi in uscita avremo un nuovo set di dati,
rappresentato in fig. 3.11, contenente una colonna aggiuntiva che va ad associare ad ogni
riga la propria transizione.
37
Fig. 3.11
Il Column Filter invece non fa altro che andare ad escludere tutte le colonne tranne
''TransitionValues''. In questo modo abbiamo ottenuto una tabella composta da un unico
attributo contenente come valori le transizioni relative agli eventi del nostro dataset, vedi
fig. 3.12.
Fig. 3.12
38
3.2.2 Association Rules
Grazie alla tabella ottenuta in figura 3.12, siamo adesso in grado di definire delle regole di
associazione attraverso il nodo cardine del nostro tool, l'Association Rule Learner
(Borgelt).
Questo nodo restituisce delle regolarità in base alle transizioni considerate in ingresso, per
far ciò utilizza un algoritmo chiamato ''Aprirori''. Facciamo un breve accenno su tale
algoritmo. L'algoritmo Apriori, implementato da Christian Borgelt nel 1993, ha lo scopo
di ricercare regole di associazione all'interno di dataset. Esempio molto banale ma
altrettanto esaustivo per la comprensione di un'association rule è «se un cliente compra
del vino e del pane, spesso comprerà anche del formaggio». [11] Quindi esprime
un'associazione tra una collezione di oggetti, che possono essere, ad esempio, prodotti di
un supermercato, servizi offerti da società o come nel nostro caso sequenze di eventi
avvenuti all'interno di una rete.
La configurazione del nodo, visibile in fig. 3.13, è stata fatta settando in maniera
opportuna i seguenti campi:
Item Column: Bisogna selezionare la colonna che contiene il set di oggetti da
elaborare. Nel nostro caso tale colonna è ''TransitionValues'.
Minimum set size: Rappresenta la minima grandezza del set. É stato settato a 2, in
questo modo il nodo riporterà in uscita almeno una coppia di elementi in cui uno
dei due implica l'altro. Quindi abbiamo garantito che nella tabella di output per
ogni riga avremo un conseguente e almeno un valore antecedente.
Minimum support: Indica in quante transizione è presente la regola in uscita, è stato
settato al 20. Quindi ogni regola che otteniamo in uscita deve essere presente
almeno nel 20% delle transizioni.
Minimum rule confidence: Rappresenta la minima confidenza di una regola di
associazione, ovvero quante volte è presente l'implicazione:
Evento X Antecedente → Evento Y Conseguente (es. [Neptune,Smurf.] → satan).
Si considerano solo le transizioni in cui appaiono X e Y. É stato settato al 20%.
39
Fig. 3.13
In uscita, vedi fig. 3.14, avremo una tabella contenente le association rules, con altrettanti
attributi relativi a tali associazioni.
Fig. 3.14
Poichè molti parametri non sono rilevanti ai fini della nostra analisi, è stato applicato in
uscita a questo nodo un Column Filter. Quest'ultimo nodo seleziona solo gli attributi più
rilevanti: Consequent, Antecedent, RuleConfidence%,RelativeBodySetSupport%. L'uscita
finale del meta-nodo è rappresentata in fig. 3.15.
40
Fig. 3.15
41
Capitolo 4: Risultati sperimentali
In questo capitolo descriveremo la fase di post-processing, analizzando I risultati ottenuti
dopo l'esecuzione del tool. In figura 4.1 è rappresentata la serie di nodi che costituisce il
meta-nodo “PostProcessing”: Split Collection Column, Table to PDF.
Fig. 4.1
3.1 Post-Processing
In fase di post-processing è stata elaborata la tabella riportata in fig. 3.15 con lo scopo di
creare un file PDF contenente i risultati ottenuti dal nostro tool.
Il nodo ''Split Collection Column'' effettua l'operazione inversa del nodo ''Create
Collection Column'' utilizzato precedentemente. Quindi divide una colonna contenente un
insieme di valori nelle sue sottocomponenti. Nel nostro caso andiamo a separare i valori
che compongono ogni singola cella della colonna ''Antecedent'' ponendoli in colonne
differenti. Otteniamo in uscita una tabella avente un numero di righe uguale alla tabella di
input e un numero di colonne uguale al massimo numero degli eventi compresi nella
colonna Antecedent. In particolare se una riga contiene più elementi rispetto a quanto
previsto, gli elementi restanti vengono ignorati. Se contiene meno elementi del previsto le
colonne vengono riempite con i missing values. Nel nostro caso abbiamo ottenuto una
tabella con 7 colonne, 4 delle quali ottenute dalla separazione dei valori.
Infine la tabella in uscita da tale nodo è stata salvata su di un file in formato PDF
attraverso l'ultimo nodo del nostro tool ''Table to PDF''.
42
I risultati salvati sul file PDF sono visibili in figura 4.2.
Fig. 4.2
43
4.2 Analisi dei risultati
Come riportato in fig. 4.2, abbiamo ottenuto un file PDF contenente tutte le possibili
regole di associazione tra gli eventi del nostro dataset. Ogni singolo evento dell'attributo
“Consequent” rappresenta un'implicazione data dalla serie degli eventi riportati nelle
successive colonne “Split Value X”. Consideriamo ad esempio il primo evento riportato
in tabella, l'attacco “satan.”. Questo attacco si verificherà il 21.2% delle volte se si
manifestano in successione gli eventi: neptune, smurf, teardrop, normal; in particolare
questa implicazione di “causa→effetto” è presente nel 22.1% dell'intero dataset.
Cosa molto interessante è che sono state individuate poche regole di associazione
all'interno del nostro dataset, nonostante fosse di dimensioni elevate. Questo ci porta a
pensare che la maggior parte degli attacchi DoS avvengono in maniera totalmente
arbitraria senza generare sempre gli stessi effetti, e senza seguire quindi una sequenza
prefissata di eventi. Gli unici parametri che ci aiutano a capire quando si verificano più
spesso determinati attacchi sono, come citato nel primo capitolo, Il “count” e il
“srv_count”. Infatti, ad esempio all'aumentare delle richieste di connessione effettuate
sullo stesso host in un range di due secondi aumentano in maniera esponenziale gli
attacchi di tipo smurf.
44
Conclusioni
Questo elaborato è stato realizzato con lo scopo di comprendere l'importanza dell'analisi
dei dati all'interno della nostra società.
Com'è stato visto nel primo capitolo i dati prodotti dai social network sono di rilevante
importanza in quanto ci forniscono informazioni sulle relazioni sociali instaurate tra
individui diversi appartenenti alla stessa rete. Abbiamo compreso che le reti sociali hanno
una natura dinamica poiché cambiano continuamente con il passare del tempo ed inoltre
possono presentare una struttura gerarchica guidata da individui che giocano ruoli
importanti all'interno di una società; in particolare abbiamo compreso l'importanza dell'uso
dei grafi per la rappresentazione di tali strutture. Di rilevante importanza abbiamo visto
essere anche la classificazione degli utenti dei social network e le loro keyword che ci
aiutano a comprendere la natura delle relazioni che si creano tra gli individui di una stessa
rete. Da non trascurare, poi, la potenza dei social media, che ormai vengono utilizzati da
tutte le istituzioni politiche per poter comunicare in maniera diretta ed efficace con la
società.
Nella seconda parte dell'elaborato abbiamo esaminato la progettazione e il funzionamento
di un tool di analisi, utilizzando un file di log contenente al suo interno diversi attacchi in
rete di tipo DoS. Abbiamo sfruttato le funzionalita di Knime relative alle tecniche di data
mining e association rule learning per ottenere le regole di associazione relative agli eventi
contenuti nel file di log. Questo tool quindi è in grado di analizzare i dati posti in ingresso
e produrre in uscita qualsiasi tipo di regolarità. Pertanto, è possibile utilizzare tale
strumento per diverse applicazioni future, come osservare dataset inerenti ai social
network, e quindi in ambito sociologico.
45
Bibliografia
[1] Data Mining: Concepts and Techniques, Jiawei han,Micheline Kamber, JianPei
[2] Wikipedia, https://it.wikipedia.org/wiki/Data_mining , 10 gennaio 2017
[3] Scott, J. SOCNET (2011) 1: 21. doi:10.1007/s13278-010-0012-6 – 6 october 2010
[4] Frèdèric Gilbert • Paolo Simonetto • Faraz Zaidi • Fabien Jourdan • Romain
Bourqui, Communities and hierarchical structures in dynamic social networks:
analysis and visualization,DOI 10.1007/s13278-010-0002-8 – 5 october 2010
[5] Prantik Bhattacharyya • Ankush Garg • Shyhtsun Felix Wu, Analysis of user
keyword similarity in online social networks, 6 october 2010, DOI 10.1007/s13278-
010-0006-4
[ 6 ] Mohamed Fazeen • Ram Dantu • Parthasarathy Guturu, Identification of
leaders, lurkers, associates and spammers in a social network: context-dependent
and context-independent approaches, 15 February 2011, DOI 10.1007/s13278-
011-0017-9
[7] Stefan Stieglitz • Linh Dang-Xuan, Social media and political communication: a
social media analytics framework, 25 August 2012 , DOI 10.1007/s13278-012-
0079-3
[8] http://www.kdnuggets.com/news/2007/n18/4i.html ,15 Sep 2007
[9] DERUVED FEATURES, https://kdd.ics.uci.edu/databases/kddcup99/task.html, 15
Sep 2007
[10] Wikipedia, https://it.wikipedia.org/wiki/ARFF, 2014
[11] Christian Borgelt, Apriori, Find Frequent Item Sets And Association Rules With
Apriori Algorithm, http://www.borgelt.net/doc/apriori/apriori.html, 2002-2016
46
