Universitatea din Craiova

Facultatea de Automatică, Calculatoare și

Electronică
Școala Doctorală "Constantin Belea"
Domeniul: Calculatoare și Tehnologia
Informației

Algoritmi de calcul distribuit utilizând

tehnica MapReduce

Coordonator ştiinţific:
Prof. univ. dr. Dumitru Dan BURDESCU

Doctorand:
Slabu Florin

1
Cuprins

Cuprins........................................................................................................................................2
Capitolul 1. Introducere..............................................................................................................3
1.1 Big Data............................................................................................................................3
1.2 Cloud computing...............................................................................................................5
1.3 Hadoop - Un framework pentru calcule distribuite..........................................................8
1.4 MapReduce.....................................................................................................................11
Capitolul 2. Algoritmi pentru calculul indexului Jaccard.........................................................14
2.1 Introducere......................................................................................................................14
2.2 Măsura de similitudinea Jaccard.....................................................................................15
2.3 Descrierea algoritmului de calcul...................................................................................17
2.4 Rezultate experimentale..................................................................................................22
2.5 Concluzii....................................................................................................................27
Capitolul 3. Extragerea regulilor de asociere fuzzy folosind tehnica MapReduce...................29
3.1 Introducere.................................................................................................................29
3.2 Concepte de bază........................................................................................................30
3.2.1 Reguli de asociere Fuzzy....................................................................................30
3.2.2 Reguli de asociere fuzzy distribuite....................................................................32
3.3 Algoritmul MapReduce pentru extragerea fuzzy itemseturilor frecvente..................34
3.3.1 Exemplificarea procesului de calcul...................................................................39
3.4 Concluzii....................................................................................................................40
Bibliografie...............................................................................................................................42

2
Capitolul 1. Introducere

1.1 Big Data

Exploatarea seturilor mari de date sau analiza de date mari sunt două subiecte frecvent
întâlnite în ultima decadă. De exemplu, există multe conferințe, prezentări, demo-uri etc. toate
având drept subiect central metode și algoritmi matematici pentru rezolvarea noilor probleme
apărute din analiza cantităţilor mari de date.
Aceste subiecte acoperă procesul de analiză a unor cantități foarte mari de date cu accent
pe metodele de extragere a datelor și de învățare automată. Mulţimile mari de date nu au
apărut din senin în ultimii ani, companiile colectând de ceva vreme datele strategice într-un
fel sau altul: de exemplu companiile farmaceutice au colectat cantități uriașe de informații în
timpul cercetărilor lor, date care sunt disponibile în rețelele private ale acestora prin
intermediul unor depozite locale de date. Camerele de supraveghere, RFID, tot felul de
senzori folosiți în cadrul sistemelor de securitate, toate au produs date care ar putea și sunt
stocate.
Termenul de Big data descrie seturi de date care cresc foarte repede şi devin atât de mari
încât devine nepractică procesarea acestora cu instrumente tradiționale precum sisteme de
gestiune a bazelor de date, sisteme de gestiune a conținutului sau vreun software avansat de
analiză statistică.
Astăzi, în fiecare domeniu, se găsesc cantități foarte mari de date, cum ar fi datele
rezultate din diverse procese precum tranzacțiile de comerț electronic, tranzacțiile bancare sau
tranzacțiile cu cardurile de credit, navigarea pe web concretizată în jurnalele site-urilor web.
Trebuie să menționăm cantitatea uriașă de date (personale) păstrate de către rețelele sociale
precum Facebook1 sau Linkedin2.
Viziunea ca oamenii, în activitatea lor zilnică, să poată inspecta cantități mari de date,
interacționând în mod natural cu interfața grafică a unor aplicații software ce gestionează
sarcinile de prelucrare a datelor, a stimulat entuziasmul utilizatorilor. Aceste instrumente
trebuie să utilizeze capacitatea oamenilor de a răspunde prin inferență la întrebări importante,
fundamentale.
1
http://www.facebook.com/
2
https://www.linkedin.com/
3
 Problema cu aceste date de dimensiuni mari nu este atât complexitatea proceselor
implicate, cât mai degrabă cantitatea de date și rata de colectare a datelor noi.
În prezent, majoritatea companiilor din domeniu trebuie să gestioneze o cantitate
semnificativă de date, pe care trebuie să le prelucreze în timpul activităților lor zilnice.
Primele afaceri, care au fost afectate de creșterea exponențială a datelor au fost motoarele de
căutare precum Yahoo! și Google şi rețelele sociale precum Facebook sau Twitter. De
exemplu, multe date sunt generate regulat pe Facebook: foarte mulţi dintre utilizatorii activi
încarcă o mulțime de imagini și videoclipuri sau partajează conținuturi precum link-uri web,
postări de blog, fotografii, note etc. În 2009 cantitatea de videoclipuri și fotografii încărcate pe
Facebook era de peste 1 miliard în fiecare lună.
Câteva informaţii statistice despre datele generate de Facebook:
 peste 1,79 miliarde de utilizatori activi zilnic în medie, şi peste 2,70 miliarde de
utilizatori activi lunar (iunie 2020)3;
 300 de milioane de utilizatori folosesc Facebook Stories zilnic față de 500 de milioane
care folosesc Instagram Stories în fiecare zi (ianuarie 2019);
 numărul total de conexiuni ale prietenilor pe Facebook a fost de peste 150 de miliarde
(februarie 2013)4;
 numărul total de fotografii încărcate a depășit în septembrie 2013 valoarea de 250 de
miliarde5;
 media fotografiilor încărcate zilnic a fost de peste 350 de milioane (februarie 2013);
 există mai mult de 300 PB de date despre utilizator (noiembrie 2013).
Prelucrarea cantităţilor mari de date nu poate fi efectuată de oameni sau prin instrumentele
existente concepute pentru a prelucra seturi mici de date, deoarece nu mai sunt eficiente în
cazul în care cantitatea de date depășește o anumită limită. Sistemele de gestiune a bazelor de
date clasice sunt utile în special pentru date de tip structurat, în timp ce big data nu înseamnă
doar date structurate, cât și semi-structurate sau date nestructurate. Cantitatea de date
nestructurate este într-o creștere mai rapidă decât cantitatea de date structurate, aproximativ
80% din date publice dovedindu-se a fi date nestructurate.
În anul 2012, în articolul "The Digital Universe in 2020: Big Data, Bigger Digital
Shadows, and Biggest Growth in the Far East" 6 estima că „din 2005 până în 2020, universul
digital va crește cu un factor de 300, de la 130 de exabytes la 40.000 de exabytes sau 40 de

3
https://zephoria.com/top-15-valuable-facebook-statistics/
4
https://expandedramblings.com/index.php/by-the-numbers-17-amazing-facebook-stats/
5
https://www.omnicoreagency.com/facebook-statistics/
6
https://www.cs.princeton.edu/courses/archive/spring13/cos598C/idc-the-digital-universe-in-2020.pdf
4
trilioane de gigabiti. De acum până în 2020, universul digital se va dubla aproximativ la
fiecare doi ani”.
Big data sunt produse de diverse surse :
 EBay folosea în aprilie 2009 două depozite de date, Terradata și Greenplum, primul
având stocată o cantitate de date de peste 6,5 PB şi peste 17 trilioane de înregistrări și
colecta peste 150 de miliarde de înregistrări noi pe zi, rezultând o rată de creştere ce
depăşea 50 TB / zi7.
 În 2008, Google prelucra aproximativ 20 PB de date pe zi.
Necesitatea dezvoltării unor algoritmi specializaţi, ce pot prelucra o cantitate
semnificativă de date, devine mai presantă având în vedere epoca activităţilor intens digitale
în care trăim [7]. Efortul pentru implementarea unor astfel de algoritmi a primit o mână de
ajutor odată cu apariţia tehnologiilor de de cloud computing.
Capacitatea de a stoca, agrega, combina datele și apoi de a folosi rezultatele acestor
prelucrări pentru a efectua o analiză profundă a datelor a devenit acum mai accesibilă, datorită
unor tendințe precum Legea lui Moore pentru procesoare, sau echivalentul acesteia în stocarea
digitală și cloud computing, ce continuă să scadă costurile și să depăşească alte bariere
tehnologice [8].
Deși conceptul de „cloud computing” este vechi, definiția acestui termen datează din
1997, când a fost enuntata pentru prima oară de profesorul Ramnath Chellappa în articolul său
intitulat „Intermediaries in Cloud-Computing: A New Computing Paradigm” [9].

1.2 Cloud computing

Calculul în cloud este, potrivit unui document special publicat sub auspiciile Institutul
Național de Știință și Tehnologie8, "un model care să permită accesul în reţea pretutindeni,
convenabil și la cerere la un grup comun de resurse de calcul configurabile (de exemplu,
rețele, servere, unităţi de stocare, aplicații și servicii) care poate fi furnizat rapid și eliberat
cu un efort minim de gestionare sau interacţiune cu furnizorul de servicii" [2].
O altă definiție poate fi întâlnită într-un document oficial realizat de către un grup de
experţi în cloud computing al Comisiei UE din ianuarie 2010, "The future of Cloud
Computing" [3]:

7
http://www.dbms2.com/2009/04/30/ebays-two-enormous-data-warehouses/
8
NIST http://www.nist.gov/index.html
5
 un „nor” este un mediu de execuție elastic a resurselor care implică mai multe părți
interesate și oferă un serviciu contorizat la mai multe granularități pentru un nivel specific de
calitate (al serviciului)9.
În concluzie, cloud computing-ul poate fi privit ca o nouă abordare în utilizarea serviciilor
IT ce prezintă avantajul accesării acestora cu costuri mai mici și fiind mult mai simplu de
utilizat, menținând în același timp un nivel ridicat de scalabilitate și fiabilitate. În figura 1 este
prezentată arhitectura cloud computing din punct de vedere logic10.

Figura 1 Arhitectura cloud computing

Din punctul de vedere al unui client, cel mai bun comportament al unui serviciu este un
serviciu de cloud computing ce oferă acces la resurse (hardware și software), sub impresia că
sunt nelimitate. Aceasta necesită alocarea și managementul automat al resurselor pentru a
prelucra eficient toate cererile. O soluție care se scalează bine pentru această problemă, este
virtualizarea. De asemenea, virtualizarea are avantaje certe din punct de vedere al securităţii.
La rularea mai multor mașini virtuale într-un mediu de tip cloud, procesoarele, memoria
principală, plăcile de rețea și hard disk-urile trebuie să fie partajate de maşinile virtuale
lansate pe același server fizic. Deși procesoarele și memoria principală pot fi partajate,
blocajele apar la nivelul operaţiilor de I/O de rețea și disc. Îmbunătățirea virtualizărilor
întreruperilor și a canalelor de I/O se poate face cu ajutorul inginerilor proiectanţi de hardware
şi a programatorilor ce lucrează la dezvoltarea sistemelor de operare.
Principalele modele de implementare pentru sistemele de cloud sunt:
9
a 'cloud' is an elastic execution environment of resources involving multiple stakeholders and providing a
metered service at multiple granularities for a specified level of quality (of service).
10
http://en.wikipedia.org/wiki/Cloud_computing
6
  Public cloud - în acest model de implementare, resursele cloud sunt puse la dispoziția
publicului larg;
 Community cloud - cloud-ul este operat de o comunitate care permite organizațiilor
membre să partajeze infrastructura. Organizațiile membre au în comun aceleași
interese, obiective, obiective.
 Cloud hibrid - este un model intermediar de la public cloud la private cloud;
 Private cloud - serviciul este disponibil numai pentru o singură entitate, fiind dezvoltat
și întreținut de același actor.
Infrastructura cloud se bazează pe trei modele de servicii:
 Infrastructura ca serviciu (IaaS) - furnizorii de cloud oferă infrastructura pentru
utilizatorii de cloud, de obicei ca mașină virtuală [3] (de exemplu Amazon S311, SQL
Azure12, Amazon EC213);
 Platforma ca serviciu (PaaS) - furnizorii de cloud oferă utilizatorilor de cloud o
întreagă platformă de dezvoltare şi mai mult, compusă din sistem de operare, mediu de
programare, bază de date, server web (de exemplu Google App Engine14, Windows
Azure15);
 Software as a Service (SaaS) - furnizorii de cloud oferă implementări pentru diferite
aplicații software destinate utilizatorilor de cloud (de exemplu Google Docs16,
Microsoft Office 36517).
Unii cercetători susțin [1] că deşi preţul serviciului pay-as-you-go este mai mare decât
costul de amortizare al unui server într-o anumită perioadă de timp, beneficiile sunt oferite
prin transferul riscului (supra-aprovizionare sau subprovizionare) și proprietatea elasticității
serviciului.
Supra-aprovizionarea apare atunci când operatorii de servicii estimează o anumită
încărcare (un factor de utilizare a resurselor) pentru o perioadă de timp și, din anumite motive,
cum ar fi cererea sezonieră, resursele rămân subutilizate şi astfel apare pierderea unei sume de
bani - suma de bani cheltuită pentru închirierea resurselor care au fost parțial utilizate.
Subprovizionarea se caracterizează printr-o saturație a resurselor ca urmare a exploziei
cererii din cauza unor evenimente externe. În astfel de situații, resursele nu sunt în măsură să
îndeplinească solicitările utilizatorilor, concretizate în refuzul cererilor unor utilizatori care,

11
http://aws.amazon.com/s3/
12
https://azure.microsoft.com/en-us/services/sql-database/
13
https://aws.amazon.com/ec2/
14
https://cloud.google.com/appengine/docs
15
https://azure.microsoft.com/en-us/
16
https://docs.google.com/
17
http://www.microsoft.com/office365/
7
cu o mare probabilitate, nu vor mai reveni. Este dificil de evaluat pierderile produse prin
excesul de utilizatori refuzaţi, deoarece nu putem şti cu o anumită precizie numărul de
utilizatori care nu vor abandona serviciul.
Elasticitatea este proprietatea de a adăuga sau elimina o cantitate mare de resurse
hardware sau software, chiar și la un nivel fin.
În concluzie, caracteristicile care fac cloud computing atât de atractiv sunt utilizarea pe
termen scurt, fără costuri ridicate și capacitatea infinită la cerere [1].
Printre diferite tipuri de virtualizare, o mașină virtuală găzduită este instalată ca o
aplicație, software-ul de virtualizare fiind executat de către sistemul de operare existent. Acest
sistem de operare este responsabil pentru furnizarea către software-ului de virtualizare a
driverelor pentru dispozitive și servicii la nivel low.
Serverul VMware GSX prezintă o arhitectură găzduită (hosted architecture) iar serverul
VMware ESX prezintă o arhitectură supervizată (hypervisor architecture) [4], [5].
Serverul VMware ESX furnizează un strat intermediar virtual între hardware și mașinile
virtuale în timp ce serverul WMware GSX oferă un strat virtual între sistemul de operare
gazdă și mașinile virtuale.
Serverul ESX rulează direct pe serverul gazdă fără a avea nevoie de un sistem de operare
terț, avand propriul kernel, numit vmkernel, ce poseda o arhitectura de microkernel.
Stratul virtual introdus de serverul ESX abstractizeaza hardware-ul sistemului într-un grup
de resurse logice ce pot fi alocate masinilor virtuale. Performanțele de calcul ale masinilor
virtuale ce rulează pe serverul ESX sunt superioare celor care rulează sub serverul GSX.

1.3 Hadoop - Un framework pentru calcule distribuite

Apache Hadoop este un proiect Apache Software Foundation, care constă din mai multe
sub-proiecte, oferind un cadru pentru dezvoltarea aplicațiilor distribuite. Este unul dintre cele
mai populare framework-uri open-source care oferă un API Java, şi care poate fi utilizat
pentru a dezvolta aplicații bazate pe paradigma MapReduce.
Framework-ul Hadoop ascunde detaliile procesării job-urilor, lăsând dezvoltatorilor
libertatea de a se concentra asupra logicii aplicațiilor. Hadoop are câteva trăsături
caracteristice:
1. accesibil - poate fi rulat pe clustere mari sau în servicii de cloud computing;
2. robust - a fost proiectat pentru a rula pe orice hardware obişnuit în producţie, un
aspect major avut în vedere în timpul dezvoltării sale fiind toleranța la defecțiunile și
blocările frecvente ale hardware-ului;

8
 3. scalabil - scalează cu ușurință pentru procesarea unor cantități crescute de date prin
adăugarea la cluster, în mod transparent, a unor noduri noi;
4. simplu - permite dezvoltatorilor să scrie într-un timp scurt cod specific.
Hadoop prezintă un domeniu destul de mare de aplicații specifice. Câteva exemple includ
aplicațiile de comerț electronic online pentru furnizarea de recomandări mai bune clienților
interesaţi de anumite produse sau aplicații financiare pentru analiza și evaluarea riscurilor ce
folosesc modele de calcul sofisticate ale căror rezultate nu pot fi stocate într-o bază de date.
Hadoop a câștigat o popularitate foarte mare, companii precum Yahoo! [6], New York
Times, IBM, Facebook, Hulu etc. folosindu-l în activitatea zilnică. Un factor ce a contribuit la
adoptarea sa se referă la faptul că aplicațiile bazate pe Hadoop pot fi executate pe toate
sistemele de operare: Windows, Linux, Unix și Mac OS, chiar dacă Linux este platforma sa
oficială.
Framework-ul de bază Hadoop este compus din următoarele module:
 Hadoop Common - conține biblioteci și utilitare necesare altor module Hadoop.
 Sistemul de fișiere distribuit Hadoop (HDFS) - un sistem de fișiere distribuit ce
pastrează datele pe calculatoare obişnuite, oferind o lățime de bandă agregată foarte
mare pentru întregul cluster.
 Hadoop YARN - o platformă de gestionare a resurselor, adăugată începând cu Hadoop
2.0, responsabilă pentru gestionarea resurselor de calcul din clustere și utilizarea
acestora pentru programarea aplicațiilor utilizatorilor.
 Hadoop MapReduce - un model de programare pentru prelucrarea datelor pe scară
largă.
Framework-ul Hadoop poate fi utilizat într-unul din următoarele moduri:
 Standalone - nu sunt lansaţi daemoni, toate procesele fiind rulate pe o singură mașină
virtuală. Este utilizat pentru dezvoltare, testare și depanare;
 Pseudo-distribuit - daemonii Hadoop rulează pe mașina locală, dar în cadrul unor
mașini virtuale separate, simulând un cluster adevărat. Comunicarea dintre mașini
reprezentată de traficul de rețea nu se efectuează;
 Distribuit - daemonii Hadoop sunt executaţi într-un un cluster.
Hadoop implementează o arhitectură master-slave folosită atât pentru stocarea distribuită
a datelor, cât și pentru calcule distribuite.

9
 Figura 2 Arhitectura Hadoop

Atunci cand rulează pe un cluster complet configurat Hadoop este compus dintr-un set de
daemoni sau module interne executate pe diverse mașini din cadrul clusterului. Aceşti
daemoni au sarcini specifice, unii dintre ei rulând doar pe o singură mașină, alţii având mai
multe instanţe ce rulează pe mai multe mașini (calculatoare). Daemonii Hadoop sunt:
 NameNode - este cel mai important demon. Daemonul NameNode reprezintă
managerul principal al HDFS, coordonând daemoni DataNode pentru efectuarea
operațiunilor de I/O. Acesta este singurul punct critic din cluster, funcţionarea
defectuoasă a acestuia ducând la blocarea clusterului;
 DataNode - fiecare maşină slave din cluster va găzdui un daemon DataNode ce citeşte
și scrie blocuri HDFS din fișierele stocate în sistemul de fișiere local;
 NameNode secundar - SNN - are rolul de a monitoriza starea de sănătate a clusterului
HDFS. Fiecare cluster are un NameNode principal și un NameNode secundar ce
rulează pe mașini separate, principala diferență dintre cei doi daemoni fiind că cel de-
al doilea nu primește în timp real modificările din interiorul HDFS;
 JobTracker - asigură sincronizarea între aplicație și Hadoop. JobTracker stabilește
planul de execuție în concordanță cu fișierele ce vor fi procesate, alocă noduri fiecărui
task și monitorizează toate task-urile aflate în execuţie. Fiecare cluster Hadoop are un
singur daemon JobTracker, care rulează pe un server ca nod principal;
 TaskTracker - este responsabil de executarea sarcinilor atribuite de JobTracker.
Fiecare nod slave are un singur TaskTracker ce poate porni mai multe JVM-uri pentru
a rula în paralel mai multe sarcini.

10
 HDFS este sistemul de stocare utilizat de aplicațiile Hadoop. HDFS decide cum și unde să
replice blocurile de date și să le distribuie între nodurile clusterului acolo unde au loc
calculele; scopul acestor operaţii este acela de a efectua calculele mai rapid și fiabil.
Un exemplu privind arhitectura unui cluster Hadoop este prezentat în figura 3. Pentru un
cluster mic, daemonul Secondary NameNode poate fi găzduit pe un nod slave, în timp ce, pe
un cluster mare, se obişnuieşte să se separe daemonii NameNode și JobTracker pe mașini
diferite. În figura 3, avem un nod master (principal) ce rulează daemonii NameNode și
JobTracker și un nod independent care găzduiește demonul Secondary NameNode, utilizat în
cazul nefuncţionării nodului principal.
Fiecare mașină slave găzduiește doi daemoni, un DataNode și un TaskTracker, cu scopul
de a realiza sarcinile de calcul pe același nod unde sunt stocate şi datele de intrare.

Figura 3 Arhitectura unui cluster Hadoop

1.4 MapReduce
Modelul de programare MapReduce a fost descris pentru prima dată de către cercetătorii
Jeffrey Dean și Sanjay Ghemawat în lucrarea publicată în 2004, intitulată MapReduce:
Simplified Data Processing on Large Clusters [10]. Acest model de programare fusese
proiectat și introdus în producţie de ceva devreme de către cercetătorii de la Google, dar
implementarea sa nu a fost făcută publică. Schema de procesare a datelor a devenit curând
foarte populară, la adoptarea sa pe scară largă contribuind şi framework-ul open-source
Hadoop, apărut în 2005. Un job în cadrul modelului de programare MapReduce împarte
mulţimea datelor de intrare în mai multe blocuri independente de date şi care sunt procesate în
paralel.
Se cuvine să amintim două idei de bază ce pot fi întâlnite în MapReduce:

11
  Există o strategie binecunoscută în informatică pentru rezolvarea problemelor, o
metodă generală pentru elaborarea algoritmilor, denumită divide-et-impera: când
trebuie să rezolvăm o problemă a cărei soluție generală este necunoscută, atunci
problema este descompusă în subprobleme mai mici, aplicăm aceeași strategie pentru
fiecare din acestea și combinăm rezultatele / soluțiile parțiale corespunzătoare fiecărei
subprobleme într-o soluție generală. Procesul de descompunere continuă până când
dimensiunea subproblemei este suficient de mică pentru a fi gestionată individual.
 Metoda generală de calcul se bazează pe două structuri de date, perechea (cheie,
valoare) și lista. Proiectarea algoritmilor MapReduce implică utilizarea perechilor
(cheie, valoare) peste mulţimi de date oarecare.
Conceptele Map și Reduce au fost inspirate din programarea funcțională, Lisp având două
funcții cu semnificație similară, map și fold. Operațiile funcționale au proprietatea de a păstra
structurile de date astfel încât datele originale să rămână nemodificate și să fie create noi
structuri de date.
Funcția map are drept argumente o funcție f și o listă, aplică funcția f fiecărui element al
listei de intrare, rezultând o listă nouă de ieșire.
Funcția fold prezintă un argument suplimentar în comparație cu argumentele funcţiei map:
pe lângă funcția f și lista de intrare, avem un acumulator. Funcția f este aplicată fiecărui
element al listei de intrare, rezultatul este adăugat la acumulatorul anterior obținându-se
valoarea acumulatorului pentru pasul următor.
Detaliile de implementare ale unei abordări divide-et-impera nu sunt aşa de simple, deși
ideea pare a fi foarte simplă,. Există multe elemente particulare de care trebuie să se ocupe un
programator:
 descompunerea problemei și alocarea subproblemelor către workeri;
 sincronizarea între workeri;
 comunicarea rezultatelor parțiale și combinarea acestora pentru a obţine soluții locale;
 gestionarea defecțiunilor software / hardware;
 gestionarea eșecurilor workerilor.
MapReduce a fost proiectat în jurul a două concepte importante, mapper și reducer, în
timp ce comunicarea între procese se realizează pe baza unor liste de perechi de tip cheie-
valoare. Mapper și reducer au fost concepute ca două funcții ce trebuie să fie implementate de
către utilizator cu următoarele semnături:
 ,
 .

12
 O funcţie mapper este creată pentru fiecare operaţie de map și o funcţie reducer este creată
pentru fiecare operaşie reduce. Funcția map se aplică fiecărei perechi de date de intrare
generând o listă de perechi la ieșire, care, la rândul lor, reprezintă
datele de intrare pentru reducer. Între cele două task-uri se efectuează o operație de grupare,
astfel încât datele de ieşire de la primul task ajung la cel de-al doilea task ordonate și grupate
după o cheie. De obicei, un reducer primește date de la mai mulți mapperi, conducând astfel la
un numărul de reduceri mai mic decât numărul de mapperi. Funcția reduce primește o pereche
, unde este o listă ce conține toate valorile intermediare asociate cu aceeași
cheie intermediară , le agregă și produce o listă de perechi . Instanțele map și
reduce sunt distribuite pe mai multe mașini din cluster, pentru a putea fi procesate (rulate) în
paralel. Cheile și valorile pot fi de orice tip, definite sau nu de către utilizator. Există o singură
regulă care se aplică pentru datele de ieșire ale mapperului și pentru datele de intrare ale
reducerului: tipul cheilor și al valorilor din datele de ieşire ale mapperului trebuie să se
potrivească cu tipul cheilor și al valorilor din datele de intrare ale reducerului.
Iată câteva exemple de algoritmi dezvoltați utilizând tehnica MapReduce: pi, distribuited
grep, index inversat, calculul frecvențelor numărului de adrese URL etc. [11], [12], [13], [14].
Pentru a reduce traficul de rețea încărcat de schimbul de date între nodurile mapper și
nodurile reducer implicate în aceeași lucrare MapReduce, se poate introduce un task
combiner. Un combiner poate fi văzut ca un task „mini-reducer”, care funcționează numai pe
datele generate de o mașină

13
Capitolul 2. Algoritmi pentru calculul indexului Jaccard

2.1 Introducere
Un cititor informat poate observa prezența structurilor de date de tip graf aproape peste
tot, începând cu rețelele sociale precum Facebook, MySpace, NetFlix și terminând cu rute de
transport sau arhitectura infrastructurii Internet. Aceste grafuri continuă să crească în
dimensiuni și există o mulțime de date noi pe care oamenii ar dori să le deducă din
numeroasele fațete ale informațiilor stocate în aceste structuri de date.
Grafurile pot avea miliarde de vârfuri și muchii. Graful citarilor, graful afilierilor, graful
de convorbirilor de mesagerie instant, graful apelurilor telefonice fac parte din așa-numita
analiză a rețelelor sociale. În lucrarea [24] este arătat că, în ciuda presupunerii ca aceste
grafuri sunt grafuri rare, densitatea acestora crește în timp.
Dezvoltarea și implementarea unor algoritmi capabili de a prelucra cantități uriașe de date
a devenit mai accesibil datorită cloud-computing [1] și modelului de programare MapReduce
[15], care a permis dezvoltarea unor framework-uri open-source, cum ar fi Apache Hadoop.
Un rol foarte important în evoluția cloud computing îl joacă Amazon, care oferă cea mai
utilizata bibliotecă online din întreaga lume. Această companie a introdus două servicii de
cloud computing, destinate inițial doar pentru utilizarea internă și care, în timp, au devenit
foarte populare în cadrul comunității IT datorită proiectării inteligente, ceea ce a condus la o
utilizare facilă pentru programatori: EC218 - pentru calcule și S3e19 - pentru depozitarea și
gestionarea resurselor.
Aplicațiile MapReduce sunt extrem de largi, fiind întâlnit de exemplu la framework-uri de
calcul distribuit cu aplicații în securitatea sistemelor informatice, cum ar fi detectarea botnet-
ilor şi clasificarea spamului [16] sau detectarea spamului [17]. Autorii ultimei lucrări au
utilizat setul de date WEBSPAM-UK2007 pentru verificarea experimentala a algoritmilor
propusi, set de date pe care l-am utilizat pentru validarea rezultatelor prezentate in acest
capitol.

18
Amazon Elastic Compute Cloud - http://aws.amazon.com/ec2/
19
Amazon Simple Storage Service - http://aws.amazon.com/s3/
14
 În [18] autorii analizează corpusul relațiilor cu utilizatorii al site-ului de știri de tehnologie
Slashdot. Lucrarea explorează, printre alte elemente caracteristice, caracteristicile la nivel de
legătură, cum ar fi distanțe și măsuri de similaritate.
De-a lungul timpului au fost definite și studiate mai multe măsuri de similaritate, Datorită
diverselor studii comparative efectuate, cercetătorii au ajuns să cunoască avantajele și
dezavantajele acestora [13]. Una dintre aceste măsuri, indicele de similaritate Jaccard, are
diverse aplicații [19], [20], [21].
În [22] coeficientul Jaccard a fost ales dintre diferite măsuri de similaritate pentru
evaluarea algoritmului de localizare propus Rank Based Fingerprinting (RBF). Într-o altă
lucrare, Leydesdorff [23] prezintă rezultatele unei comparații empirice a mai multor măsuri de
similaritate directe și indirecte: corelațiile de rang Spearman între puterea de asociere
(denumită afinitatea probabilistică sau indicele de activitate), cosinusul și indicele Jaccard.
Măsurile sunt aplicate unui set de date de intrare mai mic decât cel luat în considerare în acest
capitol, format din frecvențele de co-citare a 24 de autori.
Implementarea prezentată în continuare pentru calculul indicelui de similaritate Jaccard
este inspirată din [19].

2.2 Măsura de similitudinea Jaccard

Din punct de vedere simplu, măsurile de similaritate denotă apropierea dintre două sau
mai multe obiecte. O clasă importantă de măsuri de similaritate este reprezentată de funcţiile
de distanță. Fie A o mulțime de elemente, numit spațiu. Fie o funcție ,
având ca argument o pereche de elemente din , fiind un număr real. A se
numeşte spaţiu metric dacă există o funcție , ce satisface următoarele
patru proprietăţi:
[1] (distanţa dintre două elemente este întotdeauna un număr pozitiv). d este
pozitiv definită.
[2] .
[3] (d este simetrică).
[4] (inegalitatea triunghiului).
O funcție d cu proprietățile de mai sus se numește funcție distanță sau metrică.
Noțiunea de similaritate este foarte flexibilă, existând mai multe funcţii de distanță:
distanța Euclidiană, distanța Jaccard, distanța cosinus, distanța de editare, distanța Tanimoto
etc. [13].
15
 Una dintre cele mai populare metrici utilizate pentru a evalua gradul de similaritate dintre
două seturi de date este indicele Jaccard (sau coeficientul de similaritate Jaccard) definit ca
raportul dintre cardinalul intersecției a două mulţimi și cardinalul reuniunii acelorași două
mulţimi de date

(1)

Indicele de similaritate Jaccard nu este o funcţie distanță și poate fi aplicat la obiecte care
au atribute binare.
Funcția definită ca diferența dintre 1 și indicele Jaccard este o funcţie distanță (metrică)
cunoscută sub numele de distanţă Jaccard. Măsoară gradul de disimilaritate între două
muțimi de date, definite drept complementul coeficientului Jaccard:

(2)

Exemplu [27]:
Să considerăm două site-uri web notate cu A și B. Dorim să evaluăm gradul de
asemănare pentru aceste două site-uri web, influențat de faptul că partajează aceleași link-
uri (către alte site-uri) în paginile lor web. Vom lua în considerare numai numele site-ului
prezent în URL-ul unui link dintr-o pagină web.
Să presupunem că Host1, Host2, Host3, Host4 sunt toate nume de site-uri la care fac
referire linkurile URL din paginile web de pe cele două site-uri web. Tabelul următor
prezintă legăturile enumerate în paginile web de pe site-urile A și B.
Site Host1 Host2 Host3 Host4
A Da Da Da Da
B Nu Da Nu Nu
Tabelul 1 Distribuţia legăturiloe pentru site-urile A şi B

Site-ul A are mulţimea vecinilor iar site-ul B are

mulţimea vecinilor . Atunci

Fie două obiecte, A și B, descrise de n atribute binare. Indicele Jaccard măsoară, în acest
caz, gradul de similaritate între A și B din punctul de vedere al atributelor. Să considerăm
următoarele variabile:
 - numărul total de atribute din A și B având aceleași valori 1;
16
  - numărul total de atribute având valoarea 0 pentru obiectul A și având
valoarea 1 pentru obiectul B;
 - numărul total de atribute având valoarea 1 pentru obiectul A și având
valoarea 0 pentru obiectul B;
 - numărul total de atribute din A și B având aceleași valori 0.
Formula pentru indicele Jaccard (coeficientul de similaritate Jaccard) devine:

(3)

Câteva exemple referitoare la situaţii în care poate fi utilizat coeficientul de similaritate

Jaccard: similaritatea documentelor, cumpărături online, ratingurile filmelor, similaritatea
utilizatorilor din rețelele sociale etc.

2.3 Descrierea algoritmului de calcul

În această secțiune, vom descrie pașii algoritmului de calcul pentru calculul valorii
măsurii de similaritate Jaccard, având ca punct de pornire [19].

Prima parte este reprezentată de calculul indicelui Jaccard între oricare două noduri ale
grafului de intrare. Acest proces poate fi descompus în trei etape:

1. În prima etapă, datele de intrare sunt citite dintr-un fișier: fiecare linie reprezintă o
muchie a grafului descrisă de cele două vârfuri ale sale. Avem următoarele notaţii
speciale: primul nod reprezintă cheia k, în timp ce al doilea nod reprezintă
valoarea v. Functia map a primul job (a se vedea Algoritmul 1) trebuie doar să
analizeze fiecare linie a fișierului de intrare și să emită perechi .
Algoritmul 1 XYMapper
INPUT:
k - id nodului curent
v – informația nodului
1: class Mapper
2: method Map( , )
3: Emit(k, v) // emite actualizări pentru nodul curent
4: end method
5: end class

CountCardinalReducer (a se vedea Algoritmul 2) calculează pentru fiecare

cheie de intrare k cardinalul mulţimii de valori corespunzătoare. Mulțimea L (
17
 ) reprezintă mulţimea de vecini a vârfului de intrare (a cărui valoare
este păstrată de cheia k). Pentru fiecare pereche se emite o nouă pereche
, unde reprezintă un vârf din lista de vecini ai vârfului k și va fi
utilizat în continuare pentru intersecția listelor de vecini ale oricăror două vârfuri ale
grafului.

Algoritmul 2 CountCardinalReducer
INPUT:
k - id nodului curent
L – lista vecinilor nodului k
1: class Reducer
2: method Reduce( , )
3: for all do
4: Emit(k, {v, size(L)})
5: end for
6: end method
7: end class

2. Funcţia map a celui de-al doilea job (a se vedea Algoritmul 3) primește ca date de
intrare valorile calculate de functia reduce a primului job. Pozițiile
vârfurilor în cadrul datelor de intrare sunt interschimbate: functia map va genera o
pereche nouă cheie-valoare de forma unde v este nodul conținut
în partea de valoare procesată de catre functia reduce de la pasul anterior, în timp
ce "valoarea" din această pereche nouă (valoarea ) este compusă din
"cheia" k a perechii de intrare și valoarea cardinalului mulţimii, count.

Algoritmul 3 FromXYToYXMapper
INPUT:
k - id nodului curent
v - un nod din multimea vecinilor nodului curent
count – cardinalul multimii vecinilor nodului
1: class Mapper
2: method Map( , )
3: Emit(v, {k, count})
4: end method
5: end class

18
 Al doua functie reduce (a se vedea Algoritmul 4) primește ca date de intrare un vârf al
grafului drept cheie și o listă de perechi ce conțin noduri și dimensiuni ale unor mulţimi. Un
număr maxim de valori sunt grupate împreună într-un șir de caractere. Pentru fiecare șir de
caractere, fie având dimensiunea maximă, fie cu valorile rămase, funcţia reduce emite o
pereche constând din șirul vid drept cheie, şi șirul construit drept valoare. Cheia nu va fi
folosită în pasul următor.
Algoritmul 4 SplitReducer
INPUT:
k – id-ul nodului curent
L – informatia din lista nodurilor
1: class Reducer
2: method Reduce( , )
3:
4: for all do
5:
6: end for
7:
8:
9: Emit(newKey, newValue)
10: end method
11: end class

3. Ultima sarcină din această parte de procesare calculează indicele Jaccard pentru
fiecare pereche de vârfuri.

Metoda map primește un șir vid drept cheie și un șir de caractere str ca valoare (a se
vedea Algoritmul 5) [27]. Elementele din șirul str sunt extrase și păstrate într-o listă
L. Mai departe, se vor construi toate perechile , din primul element al listei L,
și fiecare alt element al listei L, , . Metoda emite perechi având drept
cheie o pereche de noduri ale grafului și ca valoare, suma cardinalelor
mulțimilor vecine .

Algoritmul 5 CollectAllPairsMapper
INPUT:

19
 k – id-ul nodului curent
str – sir de caractere
1: class Mapper
2: method Map( , )
3:
4: while (str.hasMoreTokens()) do
5: x parse(str.nextToken())
6: c parse(str.nextToken())
7:
8: end while
9:
10: while ( ) do
11:
12: if ( ) then
13: Emit({x, y}, n + m)
14: else
15: Emit({y, x}, n + m)
16: end if
17: end while
18: end method
19: end class
Vom parsa şirul de caractere str, descompunându-l în cuvinte (token-uri). Funcţia
(metoda) hasMoreTokens() întoarce valoarea true dacă şirul str mai are cuvinte
neprocesate. Metoda nextToken() returnează următorul cuvânt din şirul de caractere
str. Metoda parse() transformă un şir de caractere în valoarea numerică asociată.

Ultimul reducer (Algoritmul 6) primește o cheie alcătuită dintr-o pereche de noduri ale
grafului , ale căror liste de vecinătate au intersecția nevidă și o listă de valori,
fiecare valoare reprezentând suma cardinalelor mulțimilor de vecini . Se
calculează cardinalul listei L - această valoare reprezintă cardinalul mulțimii obținute din
intersecția dintre mulţimea vecinilor vârfului u și mulţimea vecinilor vârfului v (numărul
de noduri care sunt vecini atât nodului u cât şi nodului v). Indicele Jaccard al perechii
este raportul dintre cardinalul listei L și diferența dintre suma cardinalelor
mulțimilor de vecini și cardinalul intersecției.
Algoritmul 6 ComputeJaccardReducer
INPUT:
{u, v} – o pereche cu două vârfuri
20
 L - lista cu valorile reprezentând suma cardinalelor
multimilor de vecini
1: class Reducer
2: method Reduce( , )
3:

4: Emit({u, v}, )

5: end method
6: end class

A doua parte este reprezentată de un algoritm ce calculează frecvența valorilor indicelui

Jaccard pentru un graf dat. Algoritmul constă dintr-o singură etapă de procesare MapReduce.
Funcţia map (a se vedea Algoritmul 7) își obține datele din fișierul de intrare, sub formă
de perechi (cheie, valoare), unde fiecare linie din fișierul de intrare este trimisă prin
elementul valoare al perechii și conține valorile corespunzătoare id-urilor a două vârfuri și
valoarea indicelui Jaccard corespunzător lor, u v r. Metoda emite o pereche
unde k reprezintă valoarea indicelui Jaccard asociată perechilor de vârfuri u v, iar
newValue este un șir format din cele două noduri, separate printr-o virgulă.

Algoritmul 7 NodesToJaccardMapper
INPUT:
k - cheia
txt - textul de intrare
1: class Mapper
2: method Map( , )
3: u parse(txt.nextToken())
4: v parse(txt.nextToken())
5: r parse(txt.nextToken())
6: Emit(r, u + ”,” + v)
7: end method
8: end class

Functia reducer (a se vedea Algoritmul 8) primește pentru o valoare a cheii k toate

perechile de noduri care au aceeași valoare pentru indicele Jaccard. Numără elementele din
lista de intrare și emite o pereche , unde k conține valoarea indicelui Jaccard și
count reprezintă cardinalul listei de intrare.
21
Algoritmul 8 CountJaccardValuesReducer
INPUT:
k – valoarea indicelui Jaccard
L– lista de siruri de caractere
1: class Reducer
2: method Reduce( , )
3:
4: Emit(k, count)
5: end method
6: end class.

2.4 Rezultate experimentale

Primele experimente au fost efectuate pe un set mare de date numit WEBSPAM-UK2007

[28]. Din acest set de date am folosit fişierul hostgraph, ce reprezintă o colecție foarte
mare de site-uri adnotate ca spam/non-spam, conținând 114,529 de site-uri, numerotarea
nodurilor începând de la 0. Fișierul de intrare pentru implementarea algoritmului MapReduce
conține graful de site-uri, care rezumă linkurile URL către URL prin convertirea tuturor
linkuri-lor dintre pagini web diferite ale aceloraşi două site-uri într-un singur link între cele
două site-uri.
O linie din fișierul de intrare are următorul format:
dest_1:nlinks_1, dest_2:nlinks_2,…, dest_k:nlinks_k
unde dest_i reprezintă site-ul destinație, iar nlinks_i reprezintă numărul de legături
pagină la pagină dintre site-ul curent având id-ul egal cu numărul de linie şi site-ul dest_i.
Când un site nu are nicio legătură către un alt site, linia sa corespunzătoare este goală.
Am procesat fişierul specificat pentru a obține un nou fișier care să conțină listele de
adiacență ale nodurilor din graful site-urilor. Fiecare linie din fișierul original este parsată
obţinând ca rezultat o secvenţă de linii noi, fiecare având o structură de forma [site
curent - fiecare site de pe linia initială].

Indicele
Node1 Node2
Jaccard
100012 100002 0.016528925
100021 100002 0.002851711

22
 100024 100012 0.023121387
100024 100021 0.018365473
100059 100007 0.1
100059 100012 0.006264462
100061 100024 0.012987013
100062 100010 0.03125
100062 100018 0.045454547
100064 100021 0.001897533
100083 100077 0.33333334
100088 100010 0.03448276
100107 100104 0.25
100110 100007 0.1
100110 100012 0.008264462
100110 100092 0.030303031

Tabelul 2. Valorile indicelui Jaccard pentru un eșantion de perechi de noduri din graful Webspam-
Uk2007.

Aplicația a fost rulată pe un cluster virtual, format din șase mașini virtuale. Mașina
principală a găzduit daemoni pentru NameNode, Secondary NameNode și JobTracker, în timp
ce daemoni DataNode și TaskTracker au rulat pe celelalte cinci mașini din cluster (slaves).
Fiecare mașină virtuală avea 1 GB RAM, un procesor dual corel de 1.99 GHz și un
hard disk cu o capacitate de 25 GB. Mașinile virtuale au fost lansate și gestionate folosind
VMWareESX 5.020. Versiunea Hadoop instalată pe aceste mașini a fost Hadoop 0.18.0 [25],
[26].
Mărimea fișierului de intrare pentru aplicație a fost de 16 MB, în timp ce dimensiunea
fișierului rezultat a fost de peste 2 GB. Câteva linii din fișierul de ieșire sunt listate în tabelul
2.
Histograma indicelui Jaccard este reprezentată în figura 4 [26], unde se poate vedea că
majoritatea nodurilor din graful considerat au coeficientul de similaritate Jaccard inclus în
intervalul [0.0, 0.1). Acest interval conține peste 70000000 de valori ale indicilor, astfel
majoritatea nodurilor din graful nostru sunt complet diferite (din punct de vedere al
asemănării). În ceea ce privește nodurile identice din punct de vedere al similitudinii, există
mai mult de 150000 de indici având valoarea 1, în timp ce peste 50000 sunt aproape identici,
având valoarea coeficientul Jaccard aparţinând intervalului [0.9, 1.0). Pentru a examina
în continuare intervalul [0.0, 0.1), a fost împărțit în intervale mai mici, rezultatele fiind
afișate în figura 5 [27].

20
http://www.vmware.com/products/esxi-and-esx/
23
 Figura 4. Histograma indicelui Jaccard pentru setul de date WEBSPAM-UK2007

Figura 5. Distribuția valorilor indicelui Jaccard pe intervalul [0.0, 0.3) pentru setul de date
WEBSPAM – UK2007

Din această figură, se poate observa că cele mai multe site-uri din setul de date ales au una
sau două legături comune pentru fiecare 100 de site-uri adiacente. Distribuția indicelui
Jaccard este foarte eterogenă din cauza setului de date ales. Valori mai mici sunt obținute în
functie de numărul de site-uri care au valori ale coeficientului de similaritate Jaccard de la
0.13-0.14 (pentru site-urile care au 13-14 legături comune la fiecare 100 de vecini).

24
 Al doilea test a fost efectuat pe un alt set de date, Slashdot, care a fost colectat în februarie
200921. Slashdot este un site de știri referitoare la tehnologie 22, care oferă o caracteristică
Slashdot ZOO ce permite utilizatorilor să se eticheteze reciproc ca prieteni sau dușmani.
Graful corespunzător conține legături de tip prieten / dușman între utilizatorii Slashdot.
Fișierul ce conține setul de date are pe fiecare linie o pereche de noduri, separate printr-un
spațiu, cu structura . Setul de date conține 82168 noduri și 948464 de muchii
[29].
Histograma corespunzătoare secvenței de valori calculate pentru indicele Jaccard
poate fi văzută în figura 6. Rezultatele sunt similar cu cele obținute din primul set de date,
majoritatea perechilor de noduri din graf având valorile indicelui Jaccard apartinand
intervalului [0.0, 0.1).

Figura 6. Distribuția valorilor indicelui Jaccard pentru graful Slashdot.

În mod similar, pentru a face o analiza mai atentă asupra distribuției valorilor,
intervalul [0.0, 0.3) a fost împărțit în intervale mai mici iar figura 7 prezintă histograma
pentru acest interval [26].
Ca o concluzie, graful Slashdot are multe perechi de noduri cu valorile
corespunzătoare ale indicelui Jaccard aparținând intervalului [0.0, 0.1), ceea ce
înseamnă că majoritatea nodurilor sale sunt foarte diferite din punctul de vedere al funcției de
similaritate folosit[. Valorile de frecvență mai mici ale histogramei sunt situate în intervalele

21
http://snap.stanford.edu/data/soc-Slashdot0902.html
22
https://slashdot.org/
25
[0.24, 0.25) și [0.29, 0.3) (pentru prietenii care au între 24 - 25 și 29-30 legături
comune la fiecare 100 de vecini). Câteva valori ale setului de date sunt listate în tabelul 3.

Figura 7. Distribuția valorilor indicelui Jaccard peste intervalul [0,0, 0,3) pentru setul de date
Slashdot.

Indicele
Node1 Node2
Jaccard
100012 100002 0.016528925
100021 100002 0.002851711
100024 100012 0.023121387
100024 100021 0.018365473
100059 100007 0.1
100059 100012 0.006264462
100061 100024 0.012987013
100062 100010 0.03125
100062 100018 0.045454547
100064 100021 0.001897533
100083 100077 0.33333334
100088 100010 0.03448276
100107 100104 0.25
100110 100007 0.1
100110 100012 0.008264462
100110 100092 0.030303031

Tabelul 3. Valorile indicelui Jaccard pentru cateva exemple de perechi de noduri din graful Slashdot.

26
 2.5 Concluzii
În ceea ce privește mulţimea de date WEBSPAM-UK2007, să luăm în considerare două
site-uri diferite și . Să notăm cu A mulțimea de site-uri vecine cu (site-uri care au
cel puțin o pagină web indicată de către un link conţinut de o pagină web din ) și B
mulțimea de site-uri vecine cu . Indicele Jaccard pentru și reprezintă reprezintă
măsura suprapunerii mulțimilor A și B. Cu alte cuvinte, această valoare reprezintă numărul de
site-uri vecine simultan cu cele două site-uri și raportat la numărul total de site-uri
care sunt vecine cu cel puţin unul dintre cele două site-uri considerate.
Dacă două site-uri și au indicele Jaccard ≈ 1, atunci:
1) putem concluziona că gradul lor de hub este similar luând în considerare doar numărul
de site-uri la care se referă (considerăm noțiunea de hub așa cum a fost introdusă pentru
algoritmul HITS [30]);
2) ar putea fi o măsură bună pentru clasificarea site-urilor ca fiind spam / non-spam (dacă
un site a fost deja clasificat ca fiind spam, atunci toate site-urile care au indicele Jaccard ≈ 1,
sunt candidați buni pentru aceeași etichetare);
3) cele două site-uri sunt conectate din punct de vedere semantic (dacă au în comun o
mulțime de site-uri învecinate, atunci informațiile pe care le găzduiesc sunt similare).
Pe de altă parte, un indice Jaccard ≈ 0 înseamnă că cele două site-uri au mai puține
trăsături caracteristice comune din punct de vedere semantic.
În ceea ce privește setul de date Slashdot, mulţimea vecinilor unui nod u poate fi
interpretată ca un grup de persoane cărora nodul u le este deja familiar. Astfel, indicele
Jaccard este un indicator al nivelul persoanelor cunoscute în mod obișnuit. Dacă o pereche de
persoane au valoarea indicelui Jaccard mai mare de 0,9 atunci înseamnă că există conexiuni
puternice între ele la nivel profesional sau că persoanele respective au interese comune. De
asemenea, un nivel mai mic de 0,1 poate fi văzut ca un indicator al faptului că cele două
persoane au mai puține elemente în comun.
Putem crea un graf nou pe baza indicelui Jaccard, graf având aceeași mulţime de vârfuri,
în timp ce mulţimea de muchii va conține o muchie dacă și numai dacă valoarea
indicelui Jaccard calculată pentru cele două noduri este mai mare decât valoarea unui prag
( , unde de exemplu ).
Pe baza valorilor obținute prin calcularea coeficienților de similaritate Jaccard pentru două
grafuri foarte mari, am analizat conexiunile și influențele pe care anumite noduri le au asupra
altor noduri. Toate testele au fost efectuate pe un cluster distribuit pentru a obține rezultatele
descrise anterior.
27
 Scopul principal a fost dezvoltarea unei aplicații distribuite pentru a calcula una dintre
cele mai populare măsuri de similaritate, coeficientul Jaccard, și utilizarea aplicației pentru
evaluarea gradului de similaritate sau disimilaritate pentru nodurile din grafuri foarte mari.
Am ilustrat modul în care framework-ul Apache Hadoop și modelul de programare
MapReduce pot fi utilizate pentru un volum mare de calcule. Aplicația a fost implementată
într-un cluster Hadoop unde s-au efectuat experimente folosind două seturi de date din lumea
reală, în timp ce rezultatele au fost analizate și interpretate.

28
Capitolul 3. Extragerea regulilor de asociere fuzzy folosind
tehnica MapReduce
.

3.1 Introducere
Tehnicile data mining de analiză a bazelor de date de dimensiuni mari și foarte mari în
vederea descoperirii de cunostiințe noi, utile constituie una din provocarile a numeroși
cercetatori. Datele ce sunt analizate provin din cele mai variate domenii: tranzacții ale
clienților din supermarketuri, tranzacții bancare, înregistrari medicale, observații astronomice,
colecții de documente, log-urile de acces etc [31].
Extragerea regulilor de asociere constituie una dintre cele mai cunoscute tehnici de analiza
din data mining ce permite identificarea de asocieri, corelații între diferite atribute sau obiecte,
patternuri frecvente existente în baze de date tranzacționale.
În acest capitol propunem o extensie a algoritmului Count Distribution pentru extragerea
regulilor de asociere fuzzy dintr-o bază de date distribuită. Algoritmul folosește modelul de
programare MapReduce, care are drept scop distribuirea procesului de extragere pe mai multe
noduri cluster. Distribuirea procesului permite gestionarea bazelor de date foarte mari și
îmbunătățește semnificativ timpul de execuție
În zilele noastre, majoritatea companiilor produc o cantitate semnificativă de date stocate
în baze de date distribuite. În acest caz, majoritatea algoritmilor tradiționali de extragere a
regulilor de asociere devin ineficienți, necesitând o mulțime de resurse pentru a extrage
patternurile frecvente. Tehnologiile de cloud computing ne oferă infrastructura pentru
gestionarea unor astfel de seturi enorme de date. Găsirea regulilor de asociere din baze de date
foarte mari este una dintre cele mai importante sarcini din data mining. Regulile de asociere
descriu relațiile importante între atributele bazei de date.
Algoritmul Apriori [32] este primul algoritm utilizat pentru a gasi regulile de asociere
booleene dintr-o bază de date tranzacțională centralizată. În [33], autorii au propus o extindere
a modelului clasic care acceptă atribute cantitative. Kuok [34] introduce reguli de asociere
fuzzy pentru a gestiona date cantitative și categorice, oferind suportul necesar pentru a utiliza
tipuri de date incerte în algoritmii deja existenți.
În zilele noastre, majoritatea companiilor produc o cantitate considerabilă de date stocate
în baze de date distribuite. Tranzacțiile clienților unui lanț de magazine distribuite pe mai
multe site-uri pot fi considerate un exemplu de astfel de bază de date.

29
 În consecință, sarcina de a extrage modele sau modele interesante din aceste seturi mari de
date distribuite a devenit o provocare. Utilizarea tehnologiilor de cloud computing, oferă
infrastructura necesară pentru a distribui procesul de data mining pe mai multe calculatoare.
În continuare este propus un nou algoritm pentru extragerea regulilor de asociere fuzzy
bazat pe modelul de programare MapReduce, care vizează distribuirea procesului de
extragerea a regulilor de asociere pe mai multe mașini (noduri). Algoritmul împarte baza de
date în mai multe partiții și le distribuie pe mai multe noduri. Pe fiecare nod se efectuează un
proces de minare local care extrage fuzzy itemseturile frecvente local. După aceea, toate fuzzy
itemseturile frecvente local sunt agregate pentru a determina fuzzy itemseturile frecvente
global utilizate la extragerea regulilor de asociere fuzzy puternice.

3.2 Concepte de bază

3.2.1 Reguli de asociere Fuzzy

Prezentăm conceptele de bază legate de extragerea a regulilor de asociere fuzzy, ca în

[34]. Fie DB = { fie o bază de date tranzacțională. Fiecare tranzacție are asociat un

identificator unic TID și se caracterizează printr-un set de atribute categoriale sau cantitative I
={ .

Pentru fiecare atribut , vom considera un set de muțimi fuzzy asociate

. Notăm prin funcția de apartenență asociată mulțimii fuzzy .

Definiție 3.1. Se numește fuzzy itemset (set de articole fuzzy), perechea , unde

, și este un set de mulțimi fuzzy asociate elementelor din . Dacă are k atribute

atunci se numește k-fuzzy itemset.

Tabelul 4 [35] prezintă un exemplu de bază de date cu atribute cantitative,

După cum se poate observa, mulțimea de atribute este .

Considerarăm următoarele muțimi fuzzy asociate atributelor bazei de date:

, și
30
 . În acest caz, următorul tuplul

constituie un fuzzy itemset.

TID Vârsta Venit Greutate

1 25 2000 68
2 31 4000 80
3 40 5000 96
4 50 6000 90
5 60 3000 80
6 58 2000 70

Tabelul 4. Un exemplu de baza de date

Definiție 3.2. O regulă de asociere fuzzy este o implicație având următoarea formă:

, sunt mulțimi fuzzy asociate atributelor din , respectiv . Mai exact,

Notăm această regulă cu . Semnificația intuitivă a regulii de

asociere fuzzy este: „dacă o tranzacție (tuplu) satisface proprietatea

, atunci va satisface proprietatea , de asemenea, cu o probabilitate ridicată”.

Regulile de asociere pot fi evaluate printr-o serie de măsuri de calitate, printre care măsurile
de suport și de confidență sunt esențiale.
Definiție 3.3. Fuzzy suportul fuzzy itemset-ului în se definește astfel:

unde este definite astfel:

31
 iar este un prag minim specificat de utilizator pentru funcția de apartenență. Astfel,

valorile funcțiilor de apartenență mai mici decât acest prag minim sunt ignorate.
Definiție 3.4. Un fuzzy itemset se numește fuzzy itemset frecvent (eng. large

fuzzy itemset) dacă valoarea de fuzzy suportului său este mai mare sau egal cu pragul minim
de suport (minsup).
Definiție 3.5. Fie o regulă de asociere fuzzy. Fuzzy suportul

regulii este definit ca fiind valoarea fuzzy supportului itemsetului :

Fuzzy confidență regulii se definește astfel:

unde .

O regulă de asociere fuzzy este considerată interesantă dacă fuzzy suportul și fuzzy
confidența sunt mai mari sau egale cu un prag minim suport (minsup) și respectiv prag minim
de confidență (minconf). Asftel de reguli se numesc reguli de asociere fuzzy tari sau puternice
(eng. strong fuzzy association rules).
Având date pragul minim de suport pentru funcția de membru , pragul minim de suport

(minsup) și pragul minim de confidență (minconf), problema extragerii secvențiale a regulilor

de asociere fuzzy constă în găsirea tuturor regulilor de asociere fuzzy puternice. Această
problemă poate fi descompusă în două subprobleme. În prima etapă se extrag toate fuzzy
itemseturile frecvente, în timp ce, în a doua etapă, se generează regulile de asociere fuzzy
futernice din fuzzy itemsetuirle frecvente identificate în prima etapă.

3.2.2 Reguli de asociere fuzzy distribuite

Fie o bază de date distribuită pe orizontală pe n site-uri .

Definiția 3.6. [35]Fuzzy suportul global al unui fuzzy itemset dat este definit ca

fuzzy suportul itemsetului în :

iar fuzzy suportul global absolut (eng. global fuzzy support count) este definit ca:

32
 Definiția 3.7. [35] Fuzzy supportul local al unui fuzzy itemset dat pe este

definit ca fuzzy suportul în :

iar fuzzy suportul local absolut (eng. local fuzzy support count) pe este definit ca:

Fie minsup pragul de support minim.

Definiția 3.8. Un fuzzy itemset se numește fuzzy itemset frecvent global (eng.

global large fuzzy itemset) dacă ≥ minsup. Fuzzy itemsetul se numește fuzzy itemset

frecvent local (eng. local large fuzzy itemset) pe site-ul dacă ≥ minsup.

Problema 1 (Extragerea Regulilor de asociere fuzzy distribuite).

Având dată mulțimea de atribute , baza de date distribuită ,

multimile fuzzy asociate cu atributele din I, pragul minim suport (minsup) și pragul minim de
confidență (minconf), să se extragă toate regulile de asociere fuzzy tari din DB.
În mod similar cu cazul centralizat, problema poate fi descompusă și aici în două
subprobleme:
1) găsirea tuturor fuzzy itemseturilor frecvente global.
2) generarea regulilor de asociere fuzzy globale din fuzzy itemseturilor frecvente global,
calculate în prima etapă.
Principala problemă a extragerii regulilor de asociere fuzzy din baza de date distribuită

este prima subproblemă din cele două probleme menționate anterior.

În cele ce urmează, vom nota cu mulțimea tuturor fuzzy itemseturilor frecvente global

din , și cu mulțimea tuturor k-fuzzy itemseturilor frecvente global din .

Cel mai popular algoritm pentru extragerea regulilor de asociere booleene este Apriori
[32]. Acesta extrage itemseturile frecvente din bazele de date tranzacționale folosind o metodă
iterativă care generează k-itemseturi candidate din (k−1) - itemseturile frecvente calculate la
pasul anterior.

33
 Majoritatea algoritmilor pentru extragerea regulilor de asociere fuzzy [36], [37] se
bazează pe algoritmul Apriori [32]. Agrawal propune în [38] trei algoritmi paraleli pentru
extragerea regulilor de asociere booleene: Count Distribution, Data Distribution and
Candidate Distribution.
În [35] s-a propus o extindere a algoritmului Count Distribution, numit Algoritm Fuzzy
Count Distribution, care extrage reguli de asociere fuzzy dintr-o bază de date distribuită
orizontal printr-o rețea Grid.
Cheung introduce algoritmul DMA [39] pentru extragerea regulilor de asociere booleane
din bazele de date distribuită, o îmbunătățire a algoritmului Count Distribution folosind un set
de proprietăți ale itemseturilor frecvente global și local. O extensie a acestui algoritm pentru
extragerea regulilor de asociere fuzzy este prezentată în [40].
În ultimii ani, au fost propuși anumiți algoritmi pentru extragerea regulilor de asociere
booleene bazați pe modelul de programare MapReduce [41], [42], [43], [44], [45], [46].
Acești algoritmi folosesc două tehnici de implementare. Prima abordare folosește o singură
fază (un singur job MapReduce) pentru a genera toate itemseturile frecvente [47]. Deși ușor
de implementat, această clasă de algoritmi este ineficientă datorită timpilor foarte mari de
execuție. A doua abordare utilizează k-faze (k joburi de tip MapReduce) pentru a genera seturi
de articole frecvente [48], [49]. În prima fază a algoritmului, este inițiat un job MapReduce
pentru a determina L1, mulțimea de 1-itemseturi frecvente, apoi în faza a doua, o este pornit
un job de tip MapReduce pentru determinarea lui L2, mulțimea 2-itemseturilor frecvente, etc.
Numărul de faze este egal cu lungimea maximă a itemseturilor frecvente.
În [50] am prezentat o versiune preliminară a unui algoritm pentru extragerea regulilor de
asociere fuzzy pe un cluster Hadoop.

3.3 Algoritmul MapReduce pentru extragerea fuzzy

itemseturilor frecvente

În continuare, vom descrie abordarea noastră [54] pentru a determina fuzzy itemseturile
frecvente global necesare pentru extragerea regulilor de asociere.
Metoda propusă bazată pe modelul MapReduce extinde algoritmul Count Distribution (o
paralelizare a algoritmului Apriori) pentru găsirea unor șabloane booleane frecvente. Modelul
utilizat pentru implementarea acestuia este cel în faze descris anterior.

Astfel, într-o manieră iterativă, ca în algoritmul Apriori, modelul de calcul extrage ,

mulțimea tuturor 1-fuzzy itemseturilor frecvente global. La pasul următor, este utilizată

34
pentru a genera , mulțimea de 2-fuzzy itemseturilor candidate, urmat de calcularea

suportului fuzzy global pentru fiecare fuzzy itemset din . Mulțimea este obținută prin

păstrarea din doar a fuzzy itemseturilor frecvente. Procesul continuă folosind pentru a

obține și așa mai departe. În Figura 8 este prezentat procesul distribuit de extragere ce se

execută într-un cluster Hadoop.

Figura 8. Fuxul pentru extragerea distribuita a fuzzy itemseturilor frecvente cu algoritmul MapReduce

La fiecare pas , nodul principal care coordonează întregul proces de extracție, generează

mulțimea a fuzzy itemseturile globale candidate, pe baza mulțimii a - fuzzy

35
itemseturlor frecvente global folosind funcția FuzzyAprioriGen [40], după care stochează

într-un DistributedCache din sistemul distribuit de fișiere HDFS (faza de generare a

itemseturilor candidate). Mai departe, un job MapReduce este trimis la JobTracker pentru a
începe procesul de extragere a k-fuzzy itemseturilor frecvente global (faza MapReduce).
Algoritmul 9 [54] prezintă clasele care descriu jobul MapReduce pentru procesul de
extragere.
În faza MapReduce, baza de date este împărțită într-un număr de partiții orizontale

, și se distribuie pe multe noduri Hadoop din HDFS (Hadoop Distributed

File System). Fiecare partiție este procesată de către un AprioriMapper, pentru a calcula

suportul local al fuzzy itemseturilor candidate. Când AprioriMapper începe, mulțimea de

candidații se extrage din DistributedCache. După aceasta, citește tranzacțiile din baza de

date și emite ca valoare, o pereche constând din suportul partial absolut și un număr

întreg necesar pentru a calcula numărul de tranzacții. Agregatorul AprioriCombiner realizează

o agregare locală pentru fiecare candidat și emite perechi cu fuzzy suportul local absolut și
număr de tranzacții din . În final, AprioriReducer agregă fuzzy suportul local absolut

pentru a calcula fuzzy suportul global al fuzzy itemseturilor candidate. Fuzzy itemeturile de
ce au fuzzy suportul mai mare decât minsup sunt păstrate în , mulțimea de k-fuzzy

itemseturi frecvente global.

Algoritmul 9 AprioriMapReduceJob [54] – Extrage mulțimea de k-fuzzy itemseturile

frecvente global
1: class APRIORIMAPPER
2: method INITIALIZE()
3: //Se executa o singură dată când mapper-ul începe procesarea

4: ← DistributedCache.get(k)
5: //Preia muțimea de candidați din DistributedCache
6: end method
7: method MAP(i, )
8: for all transaction t ∈ do
9: for all candidate do

10: EMIT( ,pair( )

11: end for
12: end for

36
 13: end method
14: end class

1: class APRIORICOMBINER //Realizează agregarea locală

2: method

3: 0//Reține fuzzy suportul local absolut pentru pe

4: 0 //Reține numărul de tranzacții din

5: for all pair (cfs,cnt)∈ value do

6:

7:
8: end for
9: EMIT( ,pair(
10: end method
11:end class

1: class APRIORIREDUCER
2: method REDUCE

3: ← 0 //Reține fuzzy suportul global absolut pentru

4: ←0 //Reține numărul de tranzacții din

5: for all pair value do

6: ←

7: ← +
8: end for
9: ←

10: if ≥ then
11: //Colectează fuzzy itemseturile frecvente global
12: EMIT
13: end if
14: end method
15:end class

Algoritmul 10 [54] reprezintă o versiune îmbunătățită a algoritmului 1, care vizează

scăderea numărului de mesaje emise în timpul procesului de calcul. În acest caz, se realizează
o agregare locală (sablonul de proiectare in-mapper combiner, [16] [12]) folosind un tablou
37
asociativ care menține suport local absolut parțial al fiecărui fuzzy itemset candidat, în loc să
emită o pereche cheie-valoare pentru fiecare tranzacție din baza de date (a se vedea [50]).

Algoritmul 10 AprioriMapReduceJob –Extrage mulțimea de k-seturi fuzzy mari,

globale, folosind modelul combinat in-mapper [54]

1: class APRIORIMAPPER
2: method INITIALIZE()
3: // Se execută o dată când mapperul începe procesarea
4: // Preia setul de candidați din DistributedCache

5: ← DistributedCache.get(k)

6: 0 //Reține numărul de tranzacții din

7: //Păstreaza numărul suport al fiecarui itemset candidat

8: ← new AssociativeArray
9: end method
10: method MAP
11: for all transaction t ∈ do

12: ← + 1
13: ← //obține toți candidații din t
14: for all candidate do

15:

16: end for

17: end for
18: end method
19: method CLOSE( )
20: //Se execută o singura data când mapper termină procesarea

21: for all fuzzy itemset do

22: EMIT( ,pair(

23: end for
24: end method
25: end class
1: class APRIORIREDUCER
2: // Același reducer ca în implementarea anterioară
3: end class

38
 Pseudocodul pentru procesul de coordonare care va fi rulat pe nodul principal este
prezentat în Algoritmul 11 [54].

Algoritmul 11- AprioriJobsDriver - Coordonează procesul de extragere [54]

INPUT:
– baza de date

- pragul minim de suport

OUTPUT:
- seturi de articole fuzzy globale mari din
1: class DRIVER
2: method RUN( )
3: k ← 0
4: L ← ∅
5: repeat
6: k ← k + 1
7: if k=1 then
8:
9: else
10: ← FuzzyAprioriGen )
11: end if
12: //păstrează candidații în
13: DistributedCache.put
14: AprioriJob ← new AprioriMapReduceJob
15: // Execută MapReduce pentrua calcula
16: AprioriJob.waitToRun()
17: L ← L ∪ Lk
18: until
19: end method
20: end class

3.3.1 Exemplificarea procesului de calcul

Figura 9 [54] ilustrează etapele de execuție ale fazei 1 corespunzătoare procesul de

extragere pentru o bază de date cu șase înregistrări și prag minim suport = 30%. Baza

de date inițială este împărțită în două partiții și , fiecare conținând trei

39
înregistrări. Înainte de a porni jobul MapReduce, mulțimea de fuzzy itemseturi candidate

(care constă din toate 1-fuzzy itemseturile) este generată și stocată în .

După aceea, fiecare partiție a bazei de date este procesată de un . Mapperul

primește din și scanează tranzacțiile bazei de date pentru a calcula

fuzzy suportul local.

De exemplu, suport fuzzy pentru în se calculează astfel:

Pentru fiecare candidat , mapperul emite la ieșire o pereche

unde reprezintă fuzzy suport local calculat pe

și reprezintă . În exemplul nostru, pentru 1-fuzzy itemset candidat

emite la ieșire

În continuare, toate perechile de ieșire ale sunt pregătite și mutate în

nodul unde va fi rulat ( ). Mai precis,

perechile cu aceeași fuzzy itemset cheie sunt grupate într-o listă și formeză inputul pentru
reducer. În exemplul nostru, perechile și

sunt îmbinate rezultând perechea

În cele din urmă, procesul agregă perechile asociate fiecărui fuzzy

itemset cheie și calculează fuzzy suportul global. Pentru inputul

funcția reduce calculează suportul fuzzy global

care este mai mare decât și este emis ca output.

La sfârșitul fazei 1, mulțimea 1- fuzzy itemseturilor frecvente global este

Mulțimea calculată este utilizată pentru a genera mulțimea 2-fuzzy itemseturilor

candidate:

40
care este stocată în și un nou MapReduce Job este pornit să extragă

mulțimea tuturor 2-fuzzy itemseturilor frecvente global (faza 2), care extrage

3.4 Concluzii

În cadrul acestui capitol sunt prezentate două versiuni ale unui algoritm distribuit pentru
extragerea regulilor de asociere fuzzy. Algoritmii sunt proiectați utilizând modelul de
programare MapReduce, folosind ca implementare concretă a acestei paradigme de
programare framework-ul Apache Hadoop. Modelul descris constă în executarea iterativă a
mai multor joburi MapReduce. Am optimizat prima versiune a algoritmului de exploatare prin
folosirea șablonului de proiectare in-mapper care permite reducerea numărul de mesaje
schimbate în cluster și implicit la creșterea generală a performanței.
Principalul avantaj al utilizării modelului de programare MapReduce constă în capacitatea
de a procesa baze de date distribuite foarte mari reducând astfel timpul de procesare. De
asemenea,servicii cloud precum Amazon Elastic MapReduce (EMR) [52] sau Microsoft
Azure [53] oferă API-uri pentru a implementa și a rularea unor astfel de algoritmi.
Deși implementarea este în faza experimentală, suntem siguri ca rezultatul va fi promițator
luând în considerare experimentele efectuate pe alți algoritmi similari apriori pentru
extragerea regulilor de asocierii booleene [49], [51].

41
Figura 9 Execuția algoritmului MapReduce pentru extragerea 1-fuzzy itemseturilor frecvente

42
Bibliografie

[1]M. Armbrust, A. Fox, R. Griffith, A. Joseph, R. Katz, A. Konwinski, G. Lee, D.

Patterson, A. Rabkin, I. Stoica, D. Zaharia, A view of cloud computing, Communication of
the ACM, 53(4), 50–58, 2010.
[2]P. Mell, T. Grance, The NIST Definition of Cloud Computing, National Institute of
Science and Technology, September 2011.
[3]European Commission Expert Group Report, The Future of Cloud Computing, January,
2010. http://ec.europa.eu/information_society/newsroom/cf//document.cfm?doc_id=1175
[4] J. E. Smith, R. Nair, The Architecture of Virtual Machines, Computer, vol. 38, issue 5,
2005, pp. 32-38, http://dx.doi.org/10.1109/MC.2005.173
[5] J. Sugerman, G. Venkitachalam, B.-H. Lim, Virtualizing I/O Devices on VMware
Workstation's Hosted Virtual Machine Monitor, Proceedings of the General Track: 2002
USENIX Annual Technical Conference, 2001, pp. 1-14.
http://dl.acm.org/citation.cfm?id=647055.715774
[6] B. Irving, Big data and the power of Hadoop, Yahoo! Hadoop Summit, 2010.
[7] T. White, Hadoop: The Definitive Guide. Storage and Analysis at Internet Scale, 3rd
Edition, O’Reilly Media / Yahoo Press, 2012.
[8]McKinsey Global Institute. Big data: The next frontier for innovation, competition, and
productivity, 2011.
[9] R. Chellappa, Intermediaries in cloud-computing: A new computing paradigm, in
INFORMS Dallas 1997 Cluster: Electronic Commerce, Dallas, Texas, 1997.
[10] J. Dean, S. Ghemawat, MapReduce: simplified data processing on large clusters. in
Proceedings of the 6th Conference on Symposium on Operating Systems Design &
Implementation (OSDI04), vol. 6, pp. 137–150, 2004.
[11] D. Borthakur, Hadoop architecture and its usage at Facebook,
http://borthakur.com/ftp/hadoopmicrosoft.pdf, 2009.
[12] J. Lin, C. Dyer, Data-intensive text processing with MapReduce, Morgan&Claypool
Publishers, 2010.

43
[13] J. Leskovec, A. Rajaraman and J. D. Ullman, Mining of Massive Datasets, 2nd
edition, Cambridge University Press, 2014.
[14] T. White, Hadoop: The Definitive Guide, 4th edition, O'Reilly Media, 2015.
[15] J. Zhao and J. Pjesivac-Grbovic, MapReduce – The Programming Model and
Practice, Sigmod 2009 Tutorial, 2009.
http://static.googleusercontent.com/media/research.google.com/en//archive/papers/
mapreduce-sigmetrics09-tutorial.pdf
[16] G. Caruana, M. Li, and M. Qi, A MapReduce based parallel SVM for large scale
spam filtering, in 8th International Conference on Fuzzy Systems and Knowledge
Discovery (FSKD), vol. 4, IEEE, pp. 2659-2662, 2011.
[17] W. Indyk, T. Kajdanowicz, P. Kazienko, and S. Plamowski, Web Spam Detection
Using MapReduce Approach to Collective Classification, in International Joint
Conference CISIS/ICEUTE/SOCO Special Sessions, Springer, 189:197-206, 2013.
[18] J. Kunegis, A. Lommatzsch, and C. Bauckhag, The Slashdot Zoo: Mining a Social
Network with Negative Edges, in Procedings of World Wide Web Conference, pp. 741-
750, 2009.
[19] J. Bank, and B. Cole, Calculating the Jaccard Similarity Coefficient with Map Reduce
for Entity Pairs in Wikipedia, 2008.
[20] S. Engen, V. Grøtan, and B.-E. Sæther, Estimating similarity of communities: a
parametric approach to spatio-temporal analysis of species diversity, Ecography, 34:220-
231, 2011.
[21] C. M. Mulqueen, T. A. Stetz, J. M. Beaubien, and B. J. O’Connell, Developing
Dynamic Work Roles Using Jaccard Similarity Indices of Employee Competency Data,
Ergometrika, 2:26-37, 2001.
[22] J. Machaj, R. Pich, and P. Brida, Rank Based Fingerprinting Algorithm for Indoor
Positioning, International Conference on Indoor Positioning and Indoor Navigation
(IPIN), pp. 1-6, 2011.
[23] L. Leydesdorff, On the Normalization and Visualization of Author Co-Citation Data:
Saltons Cosine versus the Jaccard Index, Journal of the American Society for Information
Science and Technology, 59(1): 77-85, 2008.
[24] J. Leskovec, J. Kleinberg, and C. Faloutsos, Graphs over time: Densification laws,
shrinking diameters and possible explanations, in Proceedings of the eleventh ACM

44
SIGKDD International Conference on Knowledge Discovery in Data Mining (KDD’05),
ACM, pp. 177–187, 2005.
[25] M. Cosulschi, M. Gabroveanu, A. Sbircea, Running Hadoop applications in
virtualization environment, Annals of the University of Craiova, Mathematics and
Computer Science Series, 39(2), pp. 322-333, 2012.
[26] M. Cosulschi, M. Gabroveanu, F. Slabu, A. Sbircea, Experiments with computing
similarity coefficient over big data, 2nd Intelligent Data Analysis with Applications in
Information Retrieval and Machine Learning, 2014, in The 5th International Conference
on Information, Intelligence, Systems and Applications (IISA 2014), IEEE, ISBN 978-1-
4799-6171-9, pp. 112-117, 2014.
[27] M. Cosulschi, M. Gabroveanu, F. Slabu, A. Sbircea, Scaling up a distributed
computing of similarity coefficient with MapReduce, Special Issue of the International
Journal of Computer Science & Applications (IJCSA2015), ISSN 0972-9038, vol.12(2),
pp. 81-98, 2015.
[28]“Web Spam Collections”, Crawled by the Laboratory of Web Algorithmics,
University of Milan, http://chato.cl/webspam/datasets/ [Online; accessed 15-June-2020].
[29] J. Leskovec, K. Lang, A. Dasgupta, and M. Mahoney, Community Structure in Large
Networks: Natural Cluster Sizes and the Absence of Large Well-Defined Clusters, Internet
Mathematics, 6(1), pp. 29-123, 2009.
[30] J. Kleinberg, Authoritative sources in a hyperlinked environment, Journal of the
ACM, 46(5), pp. 604-632, 1999.
[31] M. Gabroveanu, Data Mining. Tehnici de Extragere a Regulilor de Asociere.
Algoritmi si Aplicații, Editura SITECH, ISBN 978-606-11-4899-8
[32] R. Agrawal and R. Srikant, “Fast algorithms for mining association rules,” in Proc.
20th Int. Conf. Very Large Data Bases, VLDB, J. B. Bocca, M. Jarke, and C. Zaniolo, Eds.
Morgan Kaufmann, 12–15 1994, pp. 487–499.
[33]——, “Mining quantitative association rules in large relational tables,” in Proceedings
of the 1996 ACM SIGMOD International Conference on Management of Data, H. V.
Jagadish and I. S. Mumick, Eds., Montreal, Quebec, Canada, 4–6 1996, pp. 1–12.
[34] C. M. Kuok, A. W. Fu, and M. H. Wong, “Mining fuzzy association rules in
databases,” SIGMOD Rec., vol. 27, no. 1, pp. 41–46, 1998.
[35] M. Gabroveanu, I. Iancu, M. Cosulschi, and N. Constantinescu, “Towards using Grid
services for mining fuzzy association rules,” in Proceedings of the 1st East European

45
Workshop on Rule-Based Applications - RuleApps 2007. Los Alamitos, CA, USA: IEEE
Computer Society, September 2007, pp. 507–513.
[36]A. Gyenesei, “Mining weighted association rules for fuzzy quantita-tive items,” in
Principles of Data Mining and Knowledge Discovery, 2000, pp. 416–423.
[37] T. P. Hong, C. S. Kuo, S. C. Chi, and S. L. Wang, “Mining fuzzy rules from
quantitative data based on the apriotitid algorithm,” in Proceedings of the 2000 ACM
symposium on Applied computing, 2000, pp. 534–536.
[38] R. Agrawal and J. C. Shafer, “Parallel mining of association rules,” Ieee Trans. On
Knowledge And Data Engineering, vol. 8, pp. 962– 969, 1996.
[39] D. W. Cheung, J. Han, V. Ng, A. W. Fu, and Y. Fu, “A fast distributed algorithm for
mining association rules,” in In 4th International Con-ference on Parallel and Distributed
Information Systems (PDIS ’96). IEEE Computer Society Technical Committee on Data
Engineering, and ACM SIGMOD, 1996, pp. 31–43.
[40] M. Gabroveanu, M. Cosulschi, and N. Constantinescu, “A new ap-proach to mining
fuzzy association rules from distributed databases,” Annals of the University of Bucharest,
Mathematics and Computer Science Series, vol. LIV, pp. 3–16, 2005.
[41] A. Saabith, E. Sundararajan, and A. Bakar, “Parallel implementation of apriori
algorithms on the hadoop-mapreduce platform - an evalu-ation of literature,” Journal of
Theoretical and Applied Information Technology, vol. 85, no. 3, pp. 321–351, 2016.
[42] O. Yahya, O. Hegazy, and E. Ezat, “An efficient implementation of apriori algorithm
based on hadoop-mapreduce model,” International Journal of Reviews in Computing, vol.
12, pp. 59–67, 2012.
[43] Z. Farzanyar and N. Cercone, “Efficient mining of frequent itemsets in social network
data based on mapreduce framework,” in Proceedings of the 2013 IEEE/ACM
International Conference on Advances in Social Networks Analysis and Mining, ser.
ASONAM ’13. New York, NY, USA: ACM, 2013, pp. 1183–1188.
[44]S. Moens, E. Aksehirli, and B. Goethals, “Frequent itemset mining for big data,” in
Big Data, 2013 IEEE International Conference on, Oct 2013, pp. 111–118.
[45] F. Kovcs and J. Ills, “Frequent itemset mining on hadoop,” in Compu-tational
Cybernetics (ICCC), 2013 IEEE 9th International Conference on, July 2013, pp. 241–245.
[46] L. Wang, L. Feng, J. Zhang, and P. Liao, “An efficient algorithm of frequent itemsets
mining based on MapReduce,” Journal of Infor-mation and Computational Science, vol.
11, no. 8, pp. 2809–2816, 2014.

46
[47] L. Li and M. Zhang, “The strategy of mining association rule based on cloud
computing,” in Proceedings of the 2011 International Confer-ence on Business
Computing and Global Informatization, ser. BCGIN ’11. Washington, DC, USA: IEEE
Computer Society, 2011, pp. 475– 478.
[48] N. Li, L. Zeng, Q. He, and Z. Shi, “Parallel implementation of apriori algorithm based
on mapreduce,” in Software Engineering, Artificial Intelligence, Networking and Parallel
Distributed Computing (SNPD), 2012 13th ACIS International Conference on, Aug 2012,
pp. 236–241.
[49] M.-Y. Lin, P.-Y. Lee, and S.-C. Hsueh, “Apriori-based frequent item-set mining
algorithms on mapreduce,” in Proceedings of the 6th International Conference on
Ubiquitous Information Management and Communication, ser. ICUIMC ’12. New York,
NY, USA: ACM, 2012, pp. 76:1–76:8.
[50] M. Gabroveanu, M. Cosulschi, and F. Slabu, “Mapreduce algorithm for distributed
mining fuzzy association rules,” in Procedings of Joint International Conference of
Doctoral and Post-Doctoral Researchers, Volume 2: Post-Doctoral research within
Engineering and Exact Sciences, September 2014, pp. 197–208.
[51] S. Singh, R. Garg, and P. K. Mishra, “Performance analysis of apriori algorithm with
different data structures on hadoop cluster,” International Journal of Computer
Applications, vol. 128, no. 9, pp. 45–51, 2015.
[52]https://azure.microsoft.com/
[53]https://aws.amazon.com/elasticmapreduce
[54] M. Gabroveanu, M. Cosulschi, Florin. Slabu: Mining fuzzy association rules using
MapReduce technique August 2016 DOI: 10.1109/INISTA.2016.7571866 Conference:
2016 International Symposium on INnovations in Intelligent SysTems and Applications
(INISTA2016)
https://ieeexplore.ieee.org/abstract/document/7571866

47