TEZĂ DE DOCTORAT - aspc.cs.upt.roaspc.cs.upt.ro/~calin/research/pater.pdf · universitatea...

UNIVERSITATEA „POLITEHNICA” TIMIŞOARA

FACULTATEA DE AUTOMATICĂ ŞI CALCULATOARE

Ing. ALEXANDRINA MIRELA PATER

TEZĂ DE DOCTORAT

Conducător ştiinţific:

Prof. Univ. Dr. Ing. IONEL JIAN

TIMIŞOARA -2006-

2

ING. ALEXANDRINA MIRELA PATER

CONTRIBUŢII LA DEZVOLTAREA ALGORTIMILOR DE EXTRAGERE A DATELOR DIN BAZELE DE

DATE MULTI-NIVEL

Conducător ştiinţific:

Prof. Univ. Dr. Ing. IONEL JIAN

3

CUPRINS

1. INTRODUCERE ..................................................................................................... 13

1.2. Descoperirea cunoştinţelor şi Data Mining ........................................................... 13

1.3. Model Data Mining ................................................................................................. 17

1.4. Cerinţele şi provocările extragerii de date .............................................................20

1.5. Extragerea de date privită din perspectiva bazelor de date ................................ 22

2. TEHNICI DE EXTRAGERE DE DATE (DATA MINING) .............................. 26

2.1. Noţiuni de bază ........................................................................................................ 26

2.2. Clasificarea şi regresia ............................................................................................ 27

2.2.1. Clasificarea bazată pe arbori de decizie ............................................................... 28

2.2.1.1.Definiţie .................................................................................................................. 28

2.2.1.2.Inducţia arborelui de decizie .................................................................................. 30

2.2.1.3.Extragerea regulilor din arbore ............................................................................. 32

2.2.1.4.Algoritmi de decizie ................................................................................................ 33

2.2.1.5.Avantajele şi dezavantajele arborilor de decizie ................................................... 35

2.2.2. Reţele neuronale .................................................................................................... 36

2.2.2.1.Avantaje şi dezavantaje ale reţelelor neuronale .................................................... 38

2.2.3. Algoritmul celor mai apropiaţi k vecini (k-nearest neighbors) ........................... 39

2.2.3.1.Avantaje şi dezavantaje ale algoritmului k-NN ...................................................... 40

2.3. Gruparea .................................................................................................................. 41

2.3.1. Algoritmi bazaţi pe măsuri de similaritate ............................................................ 43

2.3.2. Algoritmi cu reţele neuronale ............................................................................... 46

2.3.2.1.Avantaje şi dezavantaje ale metodei SOM ............................................................. 48

2.4. Alte tehnici Data Mining ......................................................................................... 48

2.5. Concluzii ................................................................................................................... 48

3. DESCOPERIREA REGULILOR DE ASOCIERE ............................................. 50

3.1. Definiţii şi terminologie ........................................................................................... 50

3.2. Descoperirea seturilor frecvente de articole (large itemsets) .............................. 55

3.3. Algoritmi pentru descoperirea regulilor de asociere ........................................... 58

3.3.1. Definirea problemei ............................................................................................... 59

3.3.2. Algoritmul APRIORI ............................................................................................. 60

3.3.2.1.Funcţia AprioriGen ................................................................................................ 61

3.3.2.2.Funcţia Subset ........................................................................................................ 62

4

3.3.2.3.Avantaje şi dezavantaje ale algoritmului APRIORI ............................................... 63

3.3.3. Algoritmul SAMPLING (de eşantionare) ............................................................. 63

3.3.3.1.Exemplu de aplicare ............................................................................................... 66

3.3.3.2.Avantaje şi dezavantaje ale algoritmului SAMPLING ........................................... 67

3.3.4. Algoritmul PARTITIONING (de partiţionare) .................................................... 68

3.3.4.1.Exemplu de aplicare ............................................................................................... 69

3.3.4.2.Avantaje şi dezavantaje ale algoritmului PARTITIONING ................................... 70

3.4. Studiu comparativ de performanţă ....................................................................... 70

3.5. Concluzii ................................................................................................................... 75

4. DESCOPERIREA REGULILOR DE ASOCIERE FOLOSIND

EXTRAGEREA TIPARELOR FRECVENTE .................................................... 76

4.1. Introducere ............................................................................................................... 76

4.2. Proiectarea şi construirea arborelui tiparelor frecvente (FP-Tree) ................... 79

4.2.1. Definirea problemei ............................................................................................... 79

4.2.2. Construirea arborelui FP-Tree ............................................................................. 81

4.3. Metoga FP-Growth de extragere a tiparelor frecvente folosind arborele

FP-Tree ..................................................................................................................... 85

4.4. Algoritmul AFOPT (Ascending Frequency Ordered Prefix Tree) ..................... 94

4.4.1. Prezentarea problemei ........................................................................................... 94

4.4.2. Algoritmul AFOPT ................................................................................................ 96

4.5. Studiu comparativ de performanţă ..................................................................... 101

4.6. Concluzii ................................................................................................................. 103

5. DESCOPERIREA REGULILOR DE ASOCIERE

GENERALIZATE (MULTI_NIVEL) ................................................................. 104

5.1. Definiţii şi terminologie ......................................................................................... 104

5.2. Algoritmi de extragere a regulilor de asociere multi-nivel ................................ 109

5.2.1. Algoritmul ADAPTIVE APRIORI .......................................................................109

5.2.1.1.Avantajele algoritmului ........................................................................................ 113

5.2.2. Algoritmul ML_T2L1 .......................................................................................... 113

5.2.2.1.Exemplu de utilizare ............................................................................................. 115

5.2.2.2.Avantajele algoritmului ........................................................................................ 119

5.2.2.3.Dezavantajele algoritmului .................................................................................. 119

5.2.3. Algoritmul ADA-FP ............................................................................................ 120

5.2.3.1.Descrierea algoritmului ....................................................................................... 122

5

5.2.4. Studiu comparativ de performanţă ..................................................................... 126

5.2.4.1.Avantajele ADA-FP faţă de ML_T2L1 ................................................................. 126

5.2.4.2.Avantajele ADA-FP faţă de ADAPTIVE APRIORI .............................................. 127

5.3. Concluzii ................................................................................................................. 128

6. ALGORITMI DE EXTRAGERE A DATELOR DIN BAZE DE DATE

MULTI-NIVEL ..................................................................................................... 129

6.1. Algoritmul Depth First Multi-Level APRIORI (DFMLA) ................................ 132

6.1.1. Prezentarea algoritmului (DFMLA1) ................................................................. 132

6.1.2. Versiune optimizată (DFMLA2) ......................................................................... 139


6.1.3.1.Avantaje ................................................................................................................ 139

6.1.3.2.Dezavantaje ...........................................................................................................141

6.2. Algoritmul MULTI-LEVEL FP-Growth (MLFP-Growth) .............................. 142

6.2.1. Prezentarea algoritmului MLFP-Growth ........................................................... 143

6.2.1.1.Metoda I: Obţinerea arborelui FP-Tree şi apoi aplicarea algoritmului

FP-Growth direct pe nivelul conceptual k (MLFP-Growth I) ............................. 145

6.2.1.2.Metoda II: Obţinerea arborelui FP-Tree pentru nivelul k din arborele

nivelului l (l>k) (MLFP-Growth II) .................................................................... 147


6.2.2.1.Avantaje ................................................................................................................ 151

6.2.2.2.Dezavantaje .......................................................................................................... 152

6.3. Algoritmul Multi-Level AFOPT (ML-AFOPT) ................................................. 153

6.3.1. Prezentarea algoritmului ..................................................................................... 154


6.3.2.1.Avantaje ................................................................................................................ 160

6.3.2.2.Dezavantaje .......................................................................................................... 162

6.4. Algoritmul ML-ADA-AFOPT .............................................................................. 163

6.4.1. Prezentarea algoritmului ..................................................................................... 163


6.5. Concluzii ................................................................................................................. 172

7. CONCLUZII ŞI CONTRIBUŢII PERSONALE ................................................174

7.1. Contribuţii personale ............................................................................................ 175

7.2. Concluzii finale ...................................................................................................... 178

Bibliografie ...................................................................................................................... 187

6

GLOSAR

DM - Extragerea datelor (Data Mining) KDD - Descoperirea de cunoştinţe din baze de date (Knowledge

Discovery in Databases) FP-Tree - Arborele tiparelor frecvente (Frequent Pattern Tree) FP-Growth - Extragerea tiparelor frecvente folosind FP-Tree prin creşterea

fragmentelor de tipare AFOPT - Arborele tiparelor frecvente sortate în ordine crescătoare a

frecvenţei de apariţie (Ascending Frequency Ordered Prefix-Tree) DBMS - Sisteme de gestiune a bazelor de date (DataBase Management

Systems) MLDB - Baze de date multi-nivel (Multi-Level DataBase)

7

Lista de figuri

Fig. 1.1-1. Etapele procesului de KDD (conform Fayyad et al. din 1996) ........................ 14

Fig. 1.2-1. Model al procesului Data Minnig (conform Rainsford din 1993) .................... 18

Fig. 2.2-1. Set de date de antrenare .................................................................................... 28

Fig. 2.2-2. Exemplu de arbore de decizie ........................................................................... 29

Fig. 2.2-3. Arborele de decizie pentru „cumpărătorii de calculatoare” .............................. 31

Fig. 2.2-4. Exemplu de reţea neuronală cu 6 noduri .......................................................... 37

Fig. 2.2-5. Nod al reţelei neuronale .................................................................................... 38

Fig. 2.2-6. Clasificarea folosind 3-NN ............................................................................... 39

Fig. 2.2-7. Exemplu de clasificare k-NN ............................................................................ 40

Fig. 2.3-1. Clasificarea algoritmilor de grupare ................................................................. 43

Fig. 3.3-1. Algoritmul APRIORI ........................................................................................ 61

Fig. 3.3-2. Funcţia AprioriGen ........................................................................................... 62

Fig. 3.3-3. Graniţa negativă ................................................................................................ 64

Fig. 3.3-4. Algoritmul SAMPLING .................................................................................... 66

Fig. 3.3-5. Algoritmul PARTITIONING ............................................................................. 69

Fig. 3.3-6. Exemplu de aplicare a algoritmului PARTITIONING ...................................... 69

Fig. 3.4-1. Scalabilitatea raportată la suport pentru o baza de date D1 40K ...................... 72

Fig. 3.4-2. Scalabilitatea raportată la număr de tranzacţii (25% suport) ............................ 73

Fig. 3.4-3. Scalabilitatea APRIORI raportată la tranzacţii/suport ...................................... 74

Fig. 4.2-1. Construirea arborelui FP-Tree pentru Exemplul 1 ........................................... 82

Fig. 4.2-2. Algoritmul de construire a arborelui FP-Tree .................................................. 83

Fig. 4.3-1. Arborele FP-Tree condiţional construit pentru m ............................................ 88

Fig. 4.3-2. Algoritmul FP-Growth ..................................................................................... 92

Fig. 4.4-1. Arborele spaţiului de căutare ............................................................................ 95

Fig. 4.4-2. Arborele AFOPT ............................................................................................... 97

Fig. 4.4-3. Parcurgerea subarborelui c ............................................................................... 98

Fig. 4.4-4. Reunirea fiilor nodului c cu nodurile fraţi ale lui c .......................................... 99

Fig. 4.4-5. Algoritmul AFOPT ......................................................................................... 100

Fig. 4.4-6. Studiu comparativ între algoritmul FP-Growth şi algoritmul AFOPT ........... 103

Fig. 5.1-1. Exemplu de ierarhie taxonomică simplă ......................................................... 105

Fig. 5.1-2. Exemplu de ierarhie taxonomică multiplă ...................................................... 106

8

Fig. 5.1-3. Exemplu de extragere de reguli de asociere multi-nivel ................................ 108

Fig. 5.2-1. Baza de date exemplu ..................................................................................... 111

Fig. 5.2-2. Arborele schemei de enumerare T marcat cu Sminsup/Pminsup .................... 112

Fig. 5.2-3. Algoritmul ML_T2L1 ...................................................................................... 115

Fig. 5.2-4. Arborele ierarhiei conceptuale ........................................................................ 116

Fig. 5.2-5. Procedura ADA-FP-Growth ............................................................................ 125

Fig. 6.1-1. Baza de date ierarhică multi-nivel .................................................................. 134

Fig. 6.1-2. Moştenirea unei reguli .................................................................................... 138

Fig. 6.1-3. Funcţia recursivă pentru verificarea descendenţilor ....................................... 138

Fig. 6.1-4. Comparaţie Multi-level APRIORI cu DFMLA1 .............................................. 140

Fig. 6.1-5. Comparaţie DFMLA1 cu DFMLA2 ................................................................ 141

Fig. 6.2-1. Comparaţie ML_T2L1 cu FP-Growth ............................................................ 143

Fig. 6.2-2. Baza de date ierarhică multi-nivel .................................................................. 144

Fig. 6.2-3. Arborele FP-Tree al celui de-al 2-lea nivel conceptual .................................. 146

Fig. 6.2-4. Crearea tabelei antet pentru nivelul k ............................................................. 147

Fig. 6.2-5. Completarea arborelui FP-Tree al nivelului l ................................................. 148

Fig. 6.2-6. Arborele FP-Tree al nivelului k ...................................................................... 150

Fig. 6.2-7. Comparaţie MLFP-GrowthI (Metoda I) cu MLFP-GrowthII (Metoda II) ..... 152

Fig. 6.3-1. Arborele AFOPT ............................................................................................. 155

Fig. 6.3-2. Construirea tabelei antet a nivelului k ............................................................ 156

Fig. 6.3-3. Completarea tabelei antet ............................................................................... 157

Fig. 6.3-4. Arborele AFOPT completat al nivelului l....................................................... 158

Fig. 6.3-5. Arborele AFOPT al nivelului k ....................................................................... 160

Fig. 6.3-6. Timpii de execuţie ai algoritmului ML-AFOPT ............................................. 161

Fig. 6.4-1. Funcţia Meets_Min_Support ........................................................................... 166

Fig. 6.4-2. Funcţia Meets_Printing_Min_Support ........................................................... 166

Fig. 6.4-3. Algoritmul ML-ADA-AFOPT ......................................................................... 167

Fig. 6.4-4. Studiu comparativ - algoritmii ML-AFOPT vs. ML-ADA-AFOPT ............... 168

Fig. 6.4-5. Studiu comparativ - algoritmii ML-AFOPT vs. ML-ADA-AFOPT................ 169

Fig. 6.4-6. Studiu comparativ - algoritmii ML-ADA-AFOPT vs. FP-Growth şi

ADA-FP ............................................................................................................... 170

Fig. 6.4-7. Studiu comparativ pentru 5 000 de tranzacţii ................................................. 171

Fig. 6.4-8. Studiu comparativ pentru 10 000 de tranzacţii ............................................... 172

9

Lista de tabele

Tabel 3.1-1. Exemplu de date în format orizontal în regulile de asociere ......................... 54

Tabel 3.1-2. Exemplu de date în format vertical în regulile de asociere ............................ 54

Tabel 3.2-1. Notaţii utilizate ............................................................................................... 57

Tabel 3.4-1. Parametri utilizaţi pentru generarea setului de date ....................................... 71

Tabel 3.4-2. Rezultate pentru baza de date D1 40K ........................................................... 71

Tabel 3.4-3. Rezultate pentru baza de date D2 150K ......................................................... 72

Tabel 3.4-4. Rezultate APRIORI raportate la tranzacţii/suport .......................................... 74

Tabel 4.2-1. Baza de date D cu tranzacţii ........................................................................... 80

Tabel 4.3-1. Extragerea tuturor tiparelor prin crearea bazelor condiţionale de

(sub)–tipare ................................................................................................. 89

Tabel 4.4-1. Tranzacţiile bazei de date D ........................................................................... 96

Tabel 5.2-1. Articole (descriere) ...................................................................................... 116

Tabel 5.2-2. Tranzacţii ..................................................................................................... 116

Tabel 5.2-3. Codificarea tranzacţiilor T[1] ...................................................................... 117

Tabel 5.2-4. 1-itemset-ul L[1,1] ...................................................................................... 117


Tabel 5.2-6. Tranzacţiile filtrate T[2] .............................................................................. 118



Tabel 5.2-9. 3-itemset-ul L[2,3] ..................................................................................... 118

Tabel 5.2-10. 1-itemset-ul L[3,1] ................................................................................... 119

Tabel 5.2-11. 2-itemset-ul L[3,2] .................................................................................... 119

Tabel 6.1-1. Codurile şi descrierea articolelor ................................................................. 135

Tabel 6.1-2. Tranzacţiile bazei de date ............................................................................. 135

Tabel 6.1-3. Tranzacţiile şi codurile produselor ............................................................... 136

Tabel 6.2-1. Codurile şi descrierea categoriilor ............................................................... 144

Tabel 6.2-2. Baza de date tranzacţională .......................................................................... 146

10

Tabel 6.2-3. Crearea bazei condiţionale de tipare pentru nivelul k .................................. 150

Tabel 6.2-4. Rezultatele obţinute de algoritmii MLFP-GrowthI( Metoda I)

şi MLFP-GrowthII (Metoda II) ......................................................................... 151

Tabel 6.3-1. Tranzacţiile bazei de date ............................................................................. 154

Tabel 6.3-2. Articolele bazei de date ................................................................................ 154

Tabel 6.3-3. Articolele sortate ascendent ......................................................................... 154

Tabel 6.3-4. Tranzacţiile adăugate ................................................................................... 158

Tabel 6.3-5. Ordonarea tabelei antet a nivelului k ........................................................... 159

Tabel 6.3-6. Rezultatele obţinute de algoritmul ML-AFOPT ........................................... 161

Tabel 6.4-1. Rezultatele obţinute de algoritmul ML-ADA-AFOPT

(articole speciale rare) ......................................................................................... 168

Tabel 6.4-2. Rezultatele obţinute de algoritmul ML-ADA-AFOPT

(articole speciale comune) .................................................................................... 169

Tabel 6.4-3. Rezultatele obţinute pentru 5 000 de tranzacţii ............................................ 170

Tabel 6.4-4. Rezultatele obţinute pentru 10 000 de tranzacţii .......................................... 171

11

Prefaţă

Datorită creşterii foarte mari din ultimi ani a dimensiunii bazelor de date, cât şi a

aplicaţiilor de baze de date în domeniul comercial, industrial, administrativ şi altele, a

crescut în egală măsură şi interesul utilizatorilor în extragerea automată a cunoştinţelor din

acestea. Din acest motiv, mulţi cercetători au considerat descoperirea şi extragerea de

cunoştinţe din bazele de date un domeniu provocator şi semnificativ de investigat.

Sistemul de descoperire a cunoştinţelor (Knowledge Discovery System) care este

capabil să opereze pe o bază de date de dimensiune mare este numit siatem de descoperire

a cunoştinţelor din baze de date (Knowledge Discovery in Databases System – KDD).

KDD a fost concepută în anul 1989, pentru a desemna o zonă de cercetare bazată pe

metode de Data Mining (DM), recunoaşterea formelor, învăţare automată şi tehnici de baze

de date în contextul bazelor de date de dimensiuni mari. Data Mining poate fi definit în

primă instanţă ca fiind totalitatea proceselor de căutare şi manipulare a datelor din bazele

de date. KDD/Data Mining este un domeniu inter-disciplinar care dezvoltă algoritmi şi

procese pentru descoperirea cunoştinţelor construind modele şi făcând preziceri din date

structurate, semi-structurate sau ne-structurate.

Progresul în tehnologia codurilor de bare a făcut posibil ca firmele de

comercializare a produselor să colecteze şi să stocheze cantităţi imense de date despre

produse şi vânzări, referite ca şi basket data (date despre coşul de cumpărături). Firmele

mari , de succes, privesc aceste baze de date ca şi părţi esenţiale ale infrastructurii de

marketing. Ele sunt interesate în introducerea unor procese de marketing conduse de

informaţii, coordonate prin folosirea tehnologiilor de baze de date, care să permită

agenţilor de marketing să dezvolte şi să implementeze programe şi strategii de marketing

adaptate diverselor categorii de clienţi [DSA90].

Ţinând cont pe de o parte de domeniul vast al sistemelor de descoperire de

cunoştinţe, precum şi de posibilele aplicaţii practice pe care le are descoperirea de reguli de

asociere, în această lucrare s-au luat în considerare tehnicile de extragere a datelor cât şi

cele de descoperire a tiparelor frecvente din bazele de date multi-nivel, care au un rol

important în dezvoltarea sistemelor de descoperirea a regulilor de asociere [HK00].

Extragerea tiparelor frecvente joacă un rol esenţial în descoperirea regulilor de

asociere [HPY00]. Descoperirea regulilor frecvente de asociere dintr-o bază de date de

12

dimensiuni mari este o problemă complexă, deoarece spaţiul de căutare creşte exponenţial

cu numărul de atribute din baza de date şi cu obiectele bazei de date. Se ştie că, în general,

bazele de date implicate în astfel de aplicaţii sunt de dimensiuni foarte mari. Din acest

motiv este foarte important ca algoritmii utilizaţi în aplicaţii pentru extragerea de date din

aceste baze de date să fie cât mai rapizi.

Primii algoritmi propuşi pentru acest gen de aplicaţii au fost de natură iterativă, gen

algoritmul APRIORI [AS94], care însă prezentau dezavantajul unor parcurgeri multiple ale

bazei de date, operaţie foarte costisitoare din punct de vedere al timpului de execuţie.

Pe parcursul studierii procesului de extragere de cunoştinţe (KD), cercetătorii au

încercat prin diverse metode să îndepărteze dintre regulile generate pe cele neinteresante,

propunând câteva măsuri de cuantificare a utilităţii sau gradului de interes pe care regula

respectivă o prezintă [HF95].

Acest fapt, a condus cercetările spre căutarea unor metode de extragere a regulilor

de asociere pe mai multe nivele conceptuale, ceea ce duce la descoperirea nu doar a unor

reguli de asociere la fiecare nivel, dar şi extragerea unor reguli de asociere utile şi

informative, datorită flexibilităţii concentrării atenţiei asupra seturilor diferite de date şi a

posibilităţii aplicării unor praguri diferite ale suportului sau confidenţei pentru nivele

diferite. Metodele de extragere de cunoştinţe de pe mai multe nivele conceptuale au fost, în

general, dezvoltate prin extinderea tehnicilor existente pentru un singur nivel.

În această lucrare s-a încercat dezvoltarea şi îmbunătăţirea metodelor existente,

optimizarea algoritmilor apăruţi până la această oră prin variante noi adaptate la extragerea

regulilor de asociere multi-nivel. Au fost adaptaţi o serie de algoritmi consideraţi

performanţi la această oră, la bazele de date multi-nivel, deoarece acestea şi-au dovedit

superioritatea în optimizarea exploatării şi au şi un potenţial ridicat de a fi însemnate

deoarece sunt flexibile şi pot fi orientate spre diferite seturi de date.

Pe baza experimentelor efectuate, s-a demonstrat că toţi algoritmii propuşi în

această lucrare sunt mai eficienţi decât cei de la care s-a plecat, minimizând timpul de

extragere a datelor şi regulilor de asociere dorite, prin micşorarea drastică a timpului

necesar parcurgerii bazei de date de dimensiuni foarte mari.

Folosind structurile existente FP-Tree [HP00] şi AFOPT [LLX+03] s-au propus

algoritmi care să le utilizeze cât mai eficient, micşorând sau chiar evitând noi parcurgeri

ale bazei de date.

13

1. INTRODUCERE

1.1. Descoperirea cunoştinţelor şi Data Mining

Odată cu creşterea rapidă a numărului şi dimensiunii bazelor de date cât şi a

aplicaţiilor de baze de date în domeniul comercial, industrial, administrativ şi altele, este

necesar şi interesant să examinăm extragerea automată a cunoştinţelor din bazele de date

de mari dimensiuni. Mulţi cercetători au considerat acest domeniu unul provocator şi

semnificativ de investigat.

Descoperirea de cunoştinţe din bazele de date (Knowledge Discovery in

Databases– KDD) sau extragerea de date (Data Mining – DM) reprezintă efortul de a

înţelege, analiza şi eventual de a utiliza o cantitate imensă de date disponibile [Fay+96 ].

KDD a fost concepută în anul 1989, pentru a desemna o zonă de cercetare bazată pe

metode de Data Mining, recunoaşterea formelor, învăţare automată şi tehnici de baze de

date în contextul bazelor de date de dimensiuni mari. Prima conferinţă internaţională pe

Knowledge Discovery şi Data Mining a avut loc în 1995 (KDD’95), în zilele de azi

reprezentând un domeniu de vârf, în plin avânt.

Descoperirea de cunoştinţe în bazele de date este considerat un proces însemnat de

identificare a unor tipare de date valide, noi, potenţial folositoare, care pot fi înţelese, aşa

cum este arătat de către Fayyad în [FPS+96]. În opinia sa, există mai multe etape în

procesul de descoperire de cunoştinţe: selectarea, preprocesarea, transformarea, extragerea

datelor, interpretarea sau evaluarea rezultatelor, aşa cum este arătat în figura 1.1-1.

Datorită extragerii de cunoştinţe din bazele de date, acestea au devenit surse bogate

şi sigure pentru generarea şi verificarea cunoştinţelor, iar cunoştinţele descoperite pot fi

aplicate în managementul informatic, procesul de interogare, luarea deciziilor, controlul

proceselor şi multe alte domenii de larg interes. Aşadar, extragerea de cunoştinţe este

considerat unul dintre cele mai actuale şi importante domenii de cercetare în baze de date,

conform multor cercetători din domeniul bazelor de date [Sil95,Sil96]. Data Mining poate

fi definit în primă instanţă ca fiind totalitatea proceselor de căutare şi manipulare a datelor

din bazele de date. Această exploatare a "zăcămintelor" de date are ca scop descoperirea

unor corelaţii necunoscute sau puţin evidente între date. Marketingul modern foloseşte din

ce în ce mai mult rezultate obţinute prin data mining.

14

Fig. 1.1-1. Etapele procesului de KDD (conform Fayyad et al. din 1996)

Funcţia principală a DM este, deci, de a extrage modele de cunoştinţe din date.

Pentru aceasta, DM utilizează o varietate de algoritmi din statistică, recunoaşterea

formelor, clasificare, logică fuzzy, învăţare automată (machine learning), algoritmi

genetici, reţele neuronale, vizualizarea datelor, etc. Varietatea de algoritmi poate fi grupată

în principalele componente ale DM. Numărul acestor componente diferă de la un autor la

altul, ele fiind în principal:

• modelul - care, ca orice model informatic, se reprezintă printr-o funcţie într-un

spaţiu unidimensional sau multidimensional (un ansamblu de funcţii), depinzând de

parametri. El poate fi reprezentat fie ca o funcţie liniară de parametri, fie ca o

funcţie de probabilitate (de exemplu normală), fie ca o funcţie fuzzy, etc. Obţinerea

modelului se realizează prin diferiţi algoritmi, cum ar fi cei de clasificare şi grupare

(clusterizare);

• criteriile de preferinţă - care pot fi de natură diferită, unele dintre acestea bazându-

se pe ordonare, altele pe interpolare sau cea mai bună aproximare;

• algoritmi de selecţie - care conduc la selectarea a trei elemente importante care apar

în DM, şi anume: modelul (tiparul), care se selectează din baza de modele, datele,

care se selectează din baza de date şi constituie parametri, şi criteriul sau criteriile

de preferinţe, care se selectează din baza de criterii;

Date Date ţintă

Date preprocesate

Date transformate

Tipare

Cunoştinţe

Selectare

Preprocesare

Transformare

Extragere de date

Interpretare/Evaluare

15

• stabilirea abaterilor - care constă în general în algoritmi de determinare a deviaţiei

şi stabilităţii; o categorie specifică de astfel de algoritmi sunt cei statistici, prin care

se stabilesc abaterile modelului faţă de ideal.

Bineînţeles că fiecare produs comercial utilizează mai mulţi algoritmi şi în fiecare

dintre ei se regăsesc o parte sau toate componentele de mai sus în diferite proporţii.

Deoarece extragerea de date (Data Mining) este partea centrală a procesului de

descoperire de cunoştinţe din bazele de date (KDD), termenii data mining şi descoperirea

de cunoştinţe din baze de date au fost utilizaţi alternativ de mulţi cercetători din domeniu.

În ultimul timp însă, se face o distincţie clară între cei doi termeni. Distincţia care se face

este referitoare la faptul că descoperirea de cunoştinţe din bazele de date (KDD) poate fi

considerată ca procesul de extragere a informaţiilor folositoare şi interesante din baza de

date. Aşa cum am arătat şi mai sus, (fig.1.1-1) acest proces include selectarea, pregătirea

datelor, manipularea şi analiza rezultatelor. Pe de altă parte, extragerea datelor (Data

Mining) este considerat procesul de aplicare a algoritmilor de descoperire a cunoştinţelor şi

este o etapă a procesului KDD.

Autorii care fac deosebire între DM si KDD consideră KDD ca fiind un proces

iterativ şi interactiv complex, care include DM. Astfel, în cadrul KDD se considerã cã

extragerea cunoştinţelor se realizează în următorii paşi (fig.1.1-1):

• învăţarea domeniului aplicaţiei - care constă în achiziţia unor cunoştinţe despre

starea iniţială, precum şi despre scopul aplicaţiei;

• stabilirea setului de date - căruia i se va aplica procesul de extragere a

cunoştinţelor; majoritatea autorilor atrag atenţia asupra acestei faze, numite şi

faza de preprocesare;

• curăţirea şi selectarea datelor - care este un proces complex, specific

depozitelor de date, în cadrul căruia se înlătură zgomotele, se reduc

dimensiunile, se stabileşte modul de înlocuire a datelor care lipsesc, etc.;

• aplicarea procedurilor de DM - care este de fapt pasul cel mai important al

procesului KDD;

• interpretarea rezultatelor din punct de vedere al utilizatorului - care este o fază

de decizie; dacă acesta nu este mulţumit de rezultat, poate relua oricare dintre

fazele precedente;

16

• utilizarea cunoştinţelor descoperite - care este faza finală; această utilizare se

realizează fie prin includerea lor în sisteme integrate de cunoştinţe fie, pur şi

simplu, prin rapoarte simple adresate celor interesaţi.

Aşadar, KDD/Data Mining este un domeniu inter-disciplinar care dezvoltă

algoritmi şi procese pentru descoperirea cunoştinţelor (categorii, tipare, concepte, relaţii şi

tendinţe), ne-structurate. Deoarece cercetătorii din domeniul KDD vin din cele mai diverse

domenii, aşa cum era de aşteptat, KDD a împrumutat multe de la teoriile tradiţionale ale

învăţării automate cât şi de la bazele de date.

Învăţarea poate fi definită ca şi achiziţionarea de cunoştinţe fără o programare

explicită. Învăţarea automată are ca scop automatizarea procesului de învăţare, aşa încât

cunoştinţele să poată fi obţinute cu minim de efort din partea experţilor umani. Învăţarea

automată, în mod tradiţional, este orientată pe învăţarea din seturi specificate şi în multe

cazuri din date generate artificial. Extragerea de date (Data Mining) are ca scop să

adapteze aceste paradigme ale învăţării automate la învăţarea din baze de date care conţin

date din lumea reală. Învăţarea din baze de date are câteva avantaje:

• Datele sunt depozitate într-o manieră mai mult sau mai puţin structurată. De

exemplu, într-o bază de date relaţională, datele sunt normalizate în relaţii,

eliminând astfel redundanţa iar relaţiile pot fi combinate prin diferite căi pentru

a regăsi seturile de date cerute din baza de date.

• Unele cunoştinţe din domeniu sunt deja codate în interiorul bazei de date. De

exemplu, existenţa unei constrângeri de not null. De asemenea, cardinalitatea

dintre legături (relaţii) este explicit specificată în interiorul structurii bazei de

date, la fel şi constrângerile.

• Interogarea bazei de date la performanţe ridicate, precum şi existenţa unor

unelte de manipulare a datelor şi a tranzacţiilor

• Numărul de baze de date pe care se aplică tehnici de minare este mare şi în

creştere. Efortul consumat în dezvoltarea unor astfel de unelte este economic

viabil

• Volumul de date este foarte mare. De exemplu, sistemul SKICAT a fost

dezvoltat pentru a procesa trei terabytes de imagini grafice rezultate dintr-o

17

vedere a cerului. Din acest motiv, orice unealtă de extragere de date trebuie să

se execute satisfăcător pe un volum mare de date

• Datele pot conţine zgomot. Uneltele de extragere de date trebuie să ofere un

mecanism adecvat pentru găsirea rezultatelor suficient de corecte din date

zgomotoase.

• Datele pot conţine informaţii incomplete. Nu toate informaţiile folositoare

pentru descoperirea de cunoştinţe pot fi realmente depozitate în baza de date.

De asemenea, pot fi prezente multe date redundante sau inutile. Aşadar uneltele

de extragere de date trebuie să faciliteze atât selectarea datelor relevante cât şi

învăţarea cu cunoştinţe incomplete.

• Datele nu au fost, în general, colectate cu scopul de descoperire a cunoştinţelor.

Uneltele de descoperire a cunoştinţelor trebuie aşadar să acceseze date

depozitate în forme variate.

Un scop general al cercetării în domeniul descoperirii de cunoştinţa şi al extragerii

de date este acela al utilizării avantajelor învăţării din baze de date ţinând cont de

constrângerile impuse.

1.2. Model Data Mining

În acest paragraf este prezentat un posibil model al procesului de extragere de date

(Data Mining) propus de Rainsford în [RR96]. Pentru o bază de date, în general, numărul

de reguli posibile ce pot fi extrase este mult mai mare decât numărul de tupluri din baza de

date. Din acest motiv, descoperirea de cunoştinţe poate fi privit ca un proces cu multiple

faze de selectare a regulilor interesante din totalul regulilor existente în interiorul bazei de

date. Este aşadar un proces de reducere progresivă a totalului de reguli la un subset de

reguli folositoare.

18

Fig. 1.2-1. Model al procesului Data Minnig (conform Rainsford din 1993)

Modelul descris în figura 1.2-1 este bazat pe o rafinare obţinută cu multe din

uneltele de cercetare curente, adică aceea a unui proces de reducere efectuat folosind o

selecţie de filtre care reduc spaţiul de reguli pe baza datelor sursă, tiparelor de reguli,

statisticilor şi semanticii. Există multe cazuri speciale când o fază a procesului de filtrare

nu există sau nu este folosită în cadrul unei anumite unelte de cercetare, în aceste cazuri

filtrul permite ca spaţiul de reguli să treacă ne-redus.

Fiecare din fazele de filtrare poate consta din zero sau mai multe filtrări specificate

de utilizator sau de sistemul de descoperire. Un controler central coordonează operaţia de

filtrare. Aşa cum este arătat şi în figură, setul final de reguli poate fi interogat în baza de

cunoştinţe existentă. Baza de cunoştinţe şi utilizatorul pot interacţiona la fiecare pas al

Aplicaţii

Tipare, Unelte de vizualizare şi selectare

Creşte

Domeniu/Cunoştinţe apriori

Sisteme expert

Optimizarea interogărilor semantice

Sisteme suport de decizie

Inteligenţe artificiale

Proiectarea bazei de date

Asigurarea integrităţii

Baza de date

Baza de cunoştinţe

Set final de reguli

Filtre date

Filtre tipare

Filtre statistice

Filtre semantice

Specificarea regulilor şi tiparelor

Parametri şi praguri Filtre şi Browseri

Intrări utilizator

Control Control Control Control

Reguli Reguli Reguli

19

procesului de reducere a spaţiului de reguli. Filtrările au efect serios asupra ieşirilor în

procesul de extragere de date.

Filtrarea datelor este faza iniţială care implică selectarea datelor de interes pentru

descoperirea cunoştinţelor. Utilizatorul poate direcţiona sistemul KDD la zone de interes

folosind şabloane, unelte de vizualizare sau prin specificare unor strategii de eşantionare.

Rezultatul acestei faze este reducerea setului de date de test şi reducerea corespunzătoare a

spaţiului de reguli.

Filtrarea tiparelor este a doua fază a procesului unde este specificat un tip de

regulă specială de căutat. Acest tip poate fi specificat de limitări ale sistemului sau prin

folosirea unor selecţii de modele sau tipuri de reguli. Tipul de tipar descoperit este limitat

de sistemul KDD însuşi deoarece cele mai multe sisteme pot descoperi un număr limitat de

tipuri de reguli. Tiparul poate fi în continuare limitat prin specificarea de către utilizator a

existenţei unui atribut particular pe o parte sau pe cealaltă a regulii descoperite sau prin

limitarea numărului de conjuncţii pe care o regulă le poate conţine. Efectul filtrului de

tipare este aşadar de a reduce spaţiul de reguli la reguli de un anumit tip, de exemplu reguli

de asociere care au un anumit termen ca şi componentă. Specificarea căutării unui tipar

poate fi realizată intuitiv în forma unei cereri bazate pe şablon astfel:

Găseşte toate regulile de asociere cu consecinţa LAPTE.

În acest exemplu simplu de şablon, cuvintele scrise pot fi înlocuite în diferite forme

cerute. Acesta poate fi implementat într-o interfaţă utilizând unelte cum ar fi liste, care

simplifică interacţiunea utilizatorului cu sistemul. Cele mai multe sisteme KDD

implementează câteva forme de şabloane pentru specificare tiparelor. Un exemplu este

Nielsen Opportunity Explorer, o unealtă de descoperire de cunoştinţe care utilizează

şabloane şi care a fost descris de Anand şi Kahn în [AK93]. În acest sistem şabloanele de

descoperire a cunoştinţelor permit utilizatorului de asemenea să specifice atât tehnicile

analitice care să fie aplicate (filtre statistice) cât şi datele pe care ele vor fi aplicate (filtre

de date).

20

1.3. Cerinţele şi provocările extragerii de date

În dezvoltarea tehnicilor de extragere de date se prefigurează o serie de trăsături şi

cerinţe de bază ale unui sistem aplicat de extragere de cunoştinţe din bazele de date.

1. Tratarea diferitelor tipuri de date – deoarece există o multitudine de date şi de baze de

date, se aşteaptă de la un sistem de descoperire de cunoştinţe să poată trata cât mai

multe tipuri diferite de date. Deoarece cele mai multe baze de date disponibile sunt

relaţionale este crucial ca un sistem de descoperire de cunoştinţe să poată explora

eficient datele relaţionale. Mai mult, multe sisteme de baze de date conţin tipuri de

date complexe, cum ar fi date structurate şi obiecte complexe de date, date de tip

hypertext şi multimedia, date spaţiale şi temporale, tranzacţii, şi altele. Un sistem de

extragere de date trebuie să poată trata şi toate aceste tipuri complexe de date. În

orice caz, cu toată această multitudine de tipuri de date şi ţinând cont de scopurile

diferite ale unui sistem de extragere de date, este absurd să credem că acesta poate

trata chiar toate tipurile de date. Sistemele de extragere de date sunt construite ca şi

sisteme dedicate pentru descoperirea anumitor tipuri specifice de date în funcţie de

destinaţia aplicaţiei respective, cum ar fi sisteme dedicate pentru extragerea de

cunoştinţe din bazele de date relaţionale, din bazele de date tranzacţionale, din bazele

de date spaţiale, din bazele de date multimedia, etc.

2. Eficienţa algoritmilor de extragere de date – pentru a extrage informaţii din cantităţi

enorme de date din bazele de date, algoritmii de descoperire de cunoştinţe trebuie să

fie eficienţi şi să poată fi dezvoltaţi şi îmbunătăţiţi pentru bazele de date de

dimensiuni mari. Astfel, timpul de execuţie al acestor algoritmi pe baze de date de

dimensiuni mari, trebuie să fie previzibil şi acceptabil.

3. Utilitatea, exactitatea şi expresivitatea rezultatelor extragerii de date – cunoştinţele

descoperite trebuie să reflecte exact conţinutul bazei de date şi sa fie utile unor

aplicaţii concrete. Imperfecţiunile trebuie să poată fi exprimate prin măsuri de

incertitudine, sub formă de reguli de aproximare sau reguli cantitative. Aceasta, stă la

baza unui studiu sistematic de măsurare a calităţii cunoştinţelor descoperite, inclusiv

a interesului şi încrederii, prin construirea unor modele şi instrumente statistice,

analitice şi simulative.

21

4. Exprimarea rezultatelor extragerii unor tipuri variate de date – din cantităţi mari de

date pot fi extrase diferite tipuri de cunoştinţe. Aceste cunoştinţe pot fi examinate din

diferite puncte de vedere şi prezentate sub diferite forme. Pentru aceasta, ele trebuie

utilizate în limbaje de programare de nivel înalt sau interfeţe grafice pentru utilizator,

astfel încât să poată fi înţelese şi interpretate de nespecialişti, iar cunoştinţele

descoperite să poată fi utilizate de utilizatori. Din acest motiv sistemele de

descoperire de cunoştinţe trebuie să adopte tehnici de reprezentare cât mai expresivă

a cunoştinţelor descoperite.

5. Extragerea de cunoştinţe interactivă la multiple nivele de abstractizare – deoarece

este foarte dificil de prezis cu exactitate ce se va extrage dintr-o bază de date, o cerere

de extragere de date de înalt nivel trebuie tratată ca o sursă de explorări viitoare

interesante. Trebuie dezvoltată o extragere de date interactivă pentru a permite

utilizatorului să rafineze interactiv cererile de extragere de date, să concentreze

dinamic schimbarea datelor, să adâncească progresiv procesul de extragere de date, şi

să privească flexibil datele şi rezultatele extragerii de date, la nivele multiple de

abstractizare şi din diferite unghiuri.

6. Extragerea de informaţii din diferite surse de date – diversitatea reţelelor locale şi de

largă răspândire, incluzând internetul, conectează o mulţime de surse de date din baze

de date imense distribuite şi eterogene. Extragerea de date din diferite surse de date

formatate sau neformatate cu diferite semantici generează noi provocări domeniului.

Pe de altă parte, extragerea de date poate dezvălui regularităţi de nivel înalt în baze

de date eterogene ce pot fi descoperite foarte greu printr-o interogare clasică a bazei

de date. Mai mult, dimensiunea imensă a bazelor de date, larga distribuţie a datelor şi

complexitatea calculelor unor metode de extragere de date, au dus la dezvoltarea unor

algoritmi de extragere de date paraleli şi distribuiţi.

7. Asigurarea confidenţialităţii şi securitatea datelor – în situaţia în care datele pot fi

privite din diferite puncte de vedere şi la diferite nivele de abstractizare, apare

necesitatea asigurării securităţii datelor şi protejarea împotriva violării

confidenţialităţii datelor. Este important de studiat cazurile în care descoperirea de

cunoştinţe poate duce la invadarea confidenţialităţii, şi ce măsuri de securitate pot fi

luate pentru a preveni dezvăluirea de informaţii sensibile.

22

Unele dintre aceste cerinţe pot duce la rezultate conflictuale. De exemplu

asigurarea securităţii datelor poate intra în conflict cu asigurarea extragerii interactive a

cunoştinţelor de nivel multiplu din diferite puncte de vedere.

1.4. Extragerea de date privită din perspectiva bazelor de date

În ultimii ani, capacitatea noastră de a genera şi stoca date a crescut enorm şi rapid.

Răspândirea pe scară tot mai largă a utilizării codurilor de bare pentru cele mai multe

produse comerciale şi informatizarea multor tranzacţii comerciale şi guvernamentale, cât şi

progresul în domeniul apariţiei uneltelor de lucru avansate în colectarea de date, ne obligă

să avem de-a face cu cantităţi tot mai imense de date de prelucrat. Milioane de baze de date

sunt utilizate la ora actuală în aplicaţii de managementul afacerilor, administrare

guvernamentală, gestionarea datelor ştiinţifice şi inginereşti, cât şi în multe alte tipuri de

aplicaţii.

Această explozie masivă de date în domeniul bazelor de date a generat o nevoie

urgentă de creare de tehnici şi instrumente noi, inteligente care să transforme automat

datele procesate în cunoştinţe şi informaţii utile. Aşadar, extragerea de date (Data Mining)

a devenit un domeniu de cercetare de o deosebită importanţă [PSF91], [FPS+96].

Extragerea de date (Data Mining - DM) denumită şi descoperirea de cunoştinţe din

bazele de date (Knowledge Discovery in Databases – KDD) reprezintă un proces însemnat

de extragere a informaţiilor implicite, previzibile şi potenţial folositoare din bazele de date

[PSF91]. În lucrările de specialitate apărute de-a lungul anilor, au fost folosiţi şi alţi

termeni pentru a defini acest domeniu, cum ar fi: extragere de cunoştinţe din bazele de

date, extragere de date, arheologia datelor, analiza datelor, etc. Prin descoperirea de

cunoştinţe din bazele de date, se extrag informaţii şi cunoştinţe interesante, regulate, din

mulţimi relevante de date din bazele de date care, apoi, sunt investigate din mai multe

puncte de vedere, din diferite unghiuri, pentru a genera surse de cunoştinţa fiabile.

Extragerea de cunoştinţe şi informaţii din bazele mari de date a fost recunoscut de

mulţi cercetători ca fiind un domeniu de cercetare cheie care oferă multe si variate

oportunităţi de investigare. Un interes foarte mare l-au arătat pentru acest domeniu de

cercetare mulţi specialişti din diferite arii: sisteme de baze de date, statistică, inteligenţa

23

artificială, sisteme bazate pe cunoştinţe, învăţare automată, achiziţie de date, baze de date

spaţiale, vizualizarea datelor, servicii on-line şi WWW, şi altele.

Deoarece extragerea de date oferă multe posibilităţi de cercetare, aplicarea directă a

metodelor şi tehnicilor dezvoltate în studierea învăţării automate, a statisticii şi a bazelor de

date nu poate rezolva toate problemele apărute. Astfel, sunt necesare studii dedicate special

pentru a inventa noi metode pentru extragerea de date şi pentru a dezvolta tehnici noi,

integrate pentru o extragere de date eficientă şi efectivă. Din acest motiv, extragerea de

date din bazele de date a devenit un domeniu de cercetare independent şi de sine stătător.

Aşadar, în ultimii ani au fost dezvoltate o mulţime de tehnici şi sisteme pentru a

realiza extragerea de date din bazele de date [CHY96]. Aceste tehnici pot fi clasificate

după o serie de criterii, aşa cum urmează:

� În funcţie de tipul datelor cu care lucrează.

Un sistem de extragere de date poate fi clasificat în funcţie de tipul de baze de date din care

extrage datele. De exemplu, avem un sistem relaţional de extragere de date dacă descoperă

cunoştinţe dintr-o bază de date relaţională, sau avem un sistem orientat pe obiect dacă

extrage cunoştinţe dintr-o bază de date obiectuală. În general, un sistem de extragere de

date poate descoperi cunoştinţe din mai multe tipuri de baze de date:

o relaţionale,

o tranzacţionale,

o obiectuale,

o deductive,

o spaţiale,

o temporale,

o multimedia,

o eterogene,

o active,

o moştenite,

o Web.

� În funcţie de tipul cunoştinţelor extrase

Există o serie de cunoştinţe tipice care pot fi extrase din bazele de bate:

o Reguli de asociere

o Reguli caracteristice

24

o Reguli de clasificare

o Reguli discriminante

o Grupări

o Evoluţii

Mai mult decât atât, datele extrase pot fi categorisite şi în funcţie de nivelul de

abstractizare al cunoştinţelor descoperite, ce poate fi:

o Cunoştinţe generalizate

o Cunoştinţe de nivel primitiv

o Cunoştinţe multi-nivel

� În funcţie de tehnicile utilizate.

Sistemele de extragere de date pot utiliza mai multe tehnici pentru a-şi atinge scopul. De

exemplu, în funcţie de metoda coordonatoare avem:

o extragere determinată de date,

o extragere determinată de interogări,

o extragere determinată de date interactive

� În funcţie de abordarea fundamentală a extragerii de date avem:

o extragere bazată pe generalizări

o extragere bazată pe tipare

o extragere bazată pe teorii statistice

o extragere bazată pe teorii matematice

Extragerea de date din baze de date este o problemă dependentă de aplicaţie,

aşadar, diferite tipuri de aplicaţii vor necesita diferite tehnici de extragere de date.

Extragerea de date din baze de date relaţionale sau tranzacţionale a atras recent

foarte mult atenţia comunităţii cercetătorilor în domeniul bazelor de date. Problema este de

a obţine un set puternic de reguli de asociere de forma „X1 ∧∧∧∧ ... ∧∧∧∧ Xm ⇒⇒⇒⇒ Y1 ∧∧∧∧ ... ∧∧∧∧ YBn „,

unde Xi (pentru i ∈ {1, …, m}) şi Yj (pentru j ∈ {1, …, n}) sunt seturi de perechi atribut-

valoare, din seturi relevante de date din baza de date. De exemplu, putem găsi o regulă de

asociere de forma – un client care cumpără un anumit sortiment de lapte cumpără de

asemenea şi un anumit sortiment de pâine la aceeaşi tranzacţie.

25

Deoarece extragerea de reguli de asociere de acest fel poate necesita parcurgerea

unei baze de date tranzacţionale în mod repetat de nenumărate ori, pentru a găsi diferite

tipare de asociere, timpul de procesare poate creşte enorm aşadar, îmbunătăţirea

performanţei trebuie să fie o preocupare esenţială la extragerea acestor tipuri de reguli. În

capitolul 3 sunt prezentaţi o serie algoritmi pentru extragerea regulilor de asociere şi câteva

metode pentru îmbunătăţirea performanţelor acestora.

Cele mai populare unelte de extragere de date şi de analiză a datelor asociate

sistemelor de baze de date sunt uneltele de generalizare a datelor şi uneltele de rezumare a

datelor care poartă diferite denumiri, cum ar fi: procesare analitică on-line (On-Line

Analitycal Processing – OLAP), baze de date multi-dimensionale, cuburi de date,

abstractizarea datelor, generalizarea datelor, caracterizarea datelor, rezumarea datelor, etc.

O altă aplicare importantă a extragerii de date este abilitatea de a crea clasificări în

cantităţi enorme de date, adică de a crea reguli de clasificare. Clasificarea datelor

presupune clasificarea lor pe baza valorilor atributelor lor. De exemplu, un distribuitor de

maşini are nevoie de o clasificare a clienţilor în funcţie de preferinţele lor pentru maşini,

astfel încât vânzătorul să ştie pe cine să abordeze, iar cataloagele cu noile modele de

maşini să fie expediate direct spre acei clienţi care pot deveni potenţialii cumpărători.

26

2. TEHNICI DE EXTRAGERE DE DATE

(DATA MINING)

2.1 Noţiuni de bază

Datorită faptului că acest domeniu de cercetare este foarte provocator, aplicarea

directă a metodelor şi tehnicilor dezvoltate în domeniile învăţării automate (machine

learning), a statisticii, a bazelor de date, nu mai pot rezolva multitudinea de probleme cu

care se confruntă. Este necesară dezvoltarea unor studii dedicate acestor probleme,

dezvoltarea unor tehnici integrate pentru extragerea eficientă şi efectivă a datelor. Din

acest motiv, extragerea de date a format un nou domeniu de cercetare independent

[BRR01].

Tipurile de date pe care se pot aplica tehnicile Data Mining sunt: baze de date

relaţionale, baze de date deductive, depozite de date (data warehouses), baze de date

tranzacţionale, baze de date avansate şi depozite de informaţii cum ar fi: baze de date

orientate pe obiect şi relaţional-obiectuale, baze de date spaţiale, baze de date text şi

multimedia, etc.

Folosind tehnicile de extragere de date pot fi descoperite diferite tipuri de

informaţii cum ar fi: reguli de asociere, reguli caracteristice, reguli de clasificare, reguli

discriminante sau analiza grupării, evoluţiei şi derivării datelor.

Tehnicile Data Mining utilizează metode din domenii cum ar fi: baze de date,

statistică, învăţare automată, recunoaşterea formelor şi vizualizare.

Tehnicile şi uneltele bazelor de date (SQL) sunt utilizate pentru: depozitarea

datelor, accesarea datelor sursă, selectarea şi integrarea datelor, procesarea datelor.

Tehnicile statistice sunt utilizate pentru: explorarea datelor, preprocesarea datelor şi

postprocesarea datelor, construirea unui model statistic, testarea modelului şi verificarea

rezultatelor. Învăţarea automată oferă algoritmi folositori în extragerea datelor cum ar fi:

inducţia arborilor decizionali, reţele neuronale, gruparea conceptuală, algoritmi genetici.

Recunoaşterea formelor oferă metodologii şi tehnici pentru: clasificare, grupare, selectarea

de caracteristici şi validarea rezultatelor.

27

Extragerea de date este o problemă dependentă de aplicaţie, astfel încât în funcţie

de cerinţele acesteia pot fi folosite o serie de tipuri de tehnici de extragere a datelor.

La ora actuală există mai multe metode de Data Mining. Alegerea metodei potrivite

unei aplicaţii se face ţinând cont de date, de situaţie şi de obiectivele acesteia. Principalele

tehnici de extragere de date sunt prezentate în continuare.

2.2. Clasificarea şi regresia

Clasificarea este probabil cea mai utilizată tehnică de data mining.

Clasificarea datelor este procesul prin care căutăm proprietăţi comune în seturi de

obiecte din bazele de date şi le clasificăm în clase diferite în conformitate cu un model de

clasificare. Clasificarea permite crearea modelelor pentru prezicerea membrilor unei clase.

Estimarea şi predicţia pot fi considerate ca şi tipuri de clasificare. Obiectivul clasificării

este în primul rând analiza datelor antrenate şi dezvoltarea unei descrieri exacte sau a unui

model pentru fiecare clasă, folosind trăsăturile disponibile ale datelor. O astfel de descriere

sau clasă este folosită apoi pentru a clasifica viitoarele date test într-o altă bază de date sau

pentru a dezvolta o descriere mai bună (numită regulă de clasificare) pentru fiecare clasă

din baza de date. Clasificarea este folosită cu succes în domenii ca: aprobări de credite,

găsirea cumpărătorilor ţintă, diagnosticare medicală, analiza tratamentelor ineficiente,

clasificarea tendinţelor financiare, detectarea erorilor în aplicaţiile industriale, etc.

Regresia este utilizată la prezicerea unei valori a unei variabile continue pe baza

valorilor altor variabile, presupunând un model de dependenţă liniar sau neliniar. Regresia

logistică este utilizată pentru prezicerea valorii unei variabile binare. Regresia logistică este

o unealtă de clasificare care este utilizată la precizarea valorii unei variabile, de exemplu:

„dacă o persoană este cumpărător sau nu”, de asemenea este utilizată la prezicerea

variabilelor continue, de exemplu: „probabilitatea ca o persoană să facă cumpărături sau

nu”.

Datele utilizate la construcţia unui model de clasificare sunt:

� Un set de înregistrări

� Toate înregistrările au acelaşi număr de câmpuri

� Un câmp conţine indicatorul clasei căreia aparţine înregistrarea

28

� Restul câmpurilor sunt numite câmpuri independente şi descriu obiecte

individuale care compun înregistrarea

În figura 2.2-1. este prezentat ca şi exemplu un set de date de antrenare al

cumpărătorilor de calculatoare.

Vârsta Student Venit Nivel_creditare

31...40 nu mare normal

<=30 da mic excelent

31...40 da mediu normal

>40 nu mediu excelent

>40 nu mare excelent

<=30 da mediu normal

31...40 nu mic normal

31...40 nu mare excelent

<=30 da mic normal

Fig. 2.2-1. Set de date de antrenare

Clasificare datelor a fost îndelung studiată în statistică, învăţarea automată, reţele

neuronale şi sisteme expert fiind o problemă importantă în extragerea datelor [FPS+96]. La

ora actuală există o serie de algoritmi de extragere a datelor importanţi pentru clasificare şi

regresie, bazaţi pe: arbori de decizie, reţele neuronale, algoritmi genetici, algoritmul celor

mai apropiaţi k vecini (k-nearest neighbors), modelul regulilor de asociere, etc.

2.2.1. Clasificarea bazată pe arbori de decizie

2.2.1.1. Definiţie

Un arbore de decizie (arbore de clasificare) este o structură folosită pentru a divide

o colecţie mare de articole în seturi mai mici succesive aplicând o secvenţă de reguli

simple de decizie. Această tehnică construieşte un arbore pentru a modela un proces de

clasificare. O dată arborele construit, el este aplicat fiecărui articol (tuplu) al bazei de date

29

şi rezultatelor clasificării acelui articol. Tehnica are doi paşi de bază: construirea arborelui

şi aplicarea arborelui la baza de date.

Metoda de clasificare bazată pe arbori de decizie a fost foarte des folosită în

studierea învăţării automate [Qui86]. Este o metodă de supervizare a învăţării care

construieşte arbori de decizie dintr-un set de exemple. Clasificarea bazată pe arbori de

decizie este o metodă pentru aproximarea funcţiilor ţintă cu valori discrete, în care funcţia

de învăţare este reprezentată printr-un arbore de decizie. Calitatea arborelui depinde atât de

acurateţea clasificării cât şi de dimensiunea arborelui.

Metoda alege în primul rând un subset din exemplele antrenate pentru a forma un

arbore de decizie. Dacă arborele creat nu oferă răspunsul corect pentru toate obiectele, se

adaugă o selecţie a excepţiilor la arbore şi procesul continuă până când setul corect de

decizie este găsit. Arborii de decizie execută mai multe teste şi apoi încearcă să ajungă la

cea mai bună secvenţă pentru precizarea scopului. Fiecare test creează ramuri care conduc

la mai multe testări, până când testarea se termină într-un nod frunză (Fig. 2.2-2).

Arborii de decizie pot fi construiţi fie de sus în jos fie de la stânga la dreapta. Nodul

de sus (marginea stângă) este nodul rădăcină. Nodurile descendente sunt noduri fii, iar

nodurile de jos (marginea dreaptă) sunt noduri frunză. Calea unică de la nodul rădăcină la

un nod frunză formează o regulă.

Fig. 2.2-2 Exemplu de arbore de decizie

Decizia 1

Decizia 2 Decizia 3

Decizia 4 Decizia 5

DA

DA

DA

DA

DA

NU

NU NU

NU NU

frunze

ramuri

Regula

30

Calea de la nodul rădăcină la nodul frunză ţintă, reprezentată cu linie punctată în

fig. 2.2-2, este regula care clasifică scopul. Regulile sunt exprimate sub formă de reguli if-

then.

Un arbore de decizie este o structură în care:

� Nodurile interne indică un test pe un atribut

� Ramurile reprezintă rezultatul unui test

� Nodurile frunză reprezintă etichete ale claselor

2.2.1.2. Inducţia arborelui de decizie

Inducţia este procesul care creează arborele de decizie folosind un set de date

antrenate. Ea cere un număr mic de treceri prin setul e antrenare [Qui86]. Crearea arborilor

de decizie este de cele mai multe ori alcătuită din două faze: faza de construcţie (creştere) a

arborelui (prin divizare – „splitting”) urmată de faza de tăiere (pruning).

Faza de construire a arborelui este un proces iterativ care implică divizarea

progresivă a datelor în subseturi. Prima iteraţie consideră că nodul rădăcină conţine toate

datele. Următoarea iteraţie lucrează pe noduri derivate care vor conţine subseturi de date.

La fiecare divizare, sunt analizate variabilele şi este aleasă cea mai bună divizare. O

caracteristică importantă a divizării este faptul că ea este „lacomă” (greedy), ceea ce

înseamnă că algoritmul nu verifică arborele înainte să vadă dacă o altă decizie ar produce

un rezultat final mai bun. Faza de tăiere identifică şi mută ramurile care reflectă zgomote

sau excepţii.

Arborii de decizie sunt utilizaţi pentru clasificarea exemplelor necunoscute prin

testarea valorilor atributelor exemplelor prin arborele de decizie.

Algoritmii de construire a arborilor de decizie au de obicei reguli de oprire. Aceste

reguli sunt bazate, în general, pe adâncimea maximă a arborelui, numărul minim de

elemente dintr-un nod care este considerat pentru divizare sau numărul minim de elemente

care trebuie să fie într-un nod nou. Utilizatorul poate modifica parametri asociaţi acestor

reguli. Unii algoritmi încep prin construirea arborilor de decizie la adâncimea lor maximă.

Un astfel de arbore poate preciza exact toate exemplele din setul de date de antrenare

(exceptând înregistrările conflictuale).

Folosind exemplul din fig. 2.2-1. al cumpărătorilor de calculatoare, se poate

construi arborele de decizie astfel:

31

Fig. 2.2-3. Arborele de decizie pentru „cumpărătorii de calculatoare”

Algoritmul de inducţie al arborelui de decizie este alcătuit din algoritmul de bază

(algoritm „Greedy”) şi din condiţiile de oprire a partiţionării.

� Algoritmul de bază numit şi algoritm „Greedy” constă din următorii paşi:

• Arborele este construit folosind metoda divide şi cucereşte („divide et impera”)

recursiv de sus în jos

• La început, toate exemplele de învăţare sunt în nodul rădăcină

• Atributele sunt de tip enumerare (dacă valorile sunt continue, mai întâi sunt

discretizate)

• Exemplele unt partiţionate recursiv pe baza atributelor selectate

• Atributele de test sunt selectate pe baza unei măsuri euristice sau statistice

� Condiţiile de oprire a partiţionării sunt:

• Toate exemplele pentru un anumit nod aparţin unei aceleiaşi clase

• Nu mai există nici un atribut pentru partiţionări ulterioare

• Nu rămâne nici un exemplu

Vârsta?

31…40

Student? Nivel_creditare? DA

DA NU DA NU

DA NU normal excelent

<=30 >40

32

În momentul în care arborele este complet, se poate explora modelul pentru a găsi

nodurile de ieşire, subarborii care sunt de nedorit, sau regulile care sunt apreciate ca

neadecvate.

Tăierea este o tehnică obişnuită pentru a face un arbore mai general. Algoritmii

care construiesc arborii la adâncimea maximă vor invoca automat tăierea. În unele aplicaţii

utilizatorii au posibilitatea de a tăia arborele interactiv.

2.2.1.3. Extragerea regulilor din arbore

Un sistem tipic de învăţare bazat pe arbore de decizie adoptă o strategie top-down

care caută doar într-o parte a spaţiului de căutare. Acesta garantează găsirea unui arbore

simplu, fără a fi neapărat cel mai simplu.

Un arbore de decizie, după ce a fost antrenat, poate prezice o instanţă nouă de date

pornind de la nodul rădăcină şi parcurgând ramurile până se ajunge la un nod frunză. Calea

este determinată prin evaluarea regulilor de tăiere pe baza valorilor variabilelor

independente din noua instanţă.

Arborii de decizie pot fi folosiţi atât pentru modele predictive cât şi descriptive.

Predicţia poate fi făcută caz cu caz prin parcurgerea arborelui. De cele mai multe ori,

predicţia poate fi făcută prin procesarea cazurilor noi prin arbore sau prin setul de reguli

automat şi generând un fişier de ieşire cu valorile precizate sau adăugând clase. O serie de

implementări oferă opţiunea de exportare a regulilor pentru a fi utilizate extern sau

înglobate în alte aplicaţii.

Extragerea de reguli de clasificare din arbore poate fi realizată în modul următor:

• Reprezentarea cunoştinţelor sub formă de reguli if-then

• O regulă este creată pentru fiecare cale de la nodul rădăcină la un nod

frunză (vezi fig. 2.2-2.)

• Fiecare pereche de valori de atribute de-a lungul căii formează o conjuncţie

• Un nod frunză conţine clasa predicţiei

• Regulile sunt uşor de înţeles de către oameni

33

2.2.1.4. Algoritmi de decizie

Cei mai cunoscuţi şi des utilizaţi algoritmi care implementează arbori de decizie

sunt: CART (Classification and Regression Trees) [IE00], CHAID (Chisquared Automatic

Interaction Detection) [BRR01], ID3/C4.5 şi C5.0 [Qui93]. Toţi aceşti algoritmi sunt

potriviţi pentru clasificare. Unii dintre ei sunt adaptaţi şi pentru regresie.

Algoritmul CART se bazează pe divizare binară folosind GINI (diversitatea

populaţiei) - partiţionare recursivă motivată printr-o predicţie statistică. Arborele construit

are 2 ramuri de la oricare nod neterminal (care nu e nod frunză). Tăierea este bazată pe

măsurarea complexităţii arborelui. Algoritmul suportă atât clasificarea cât şi regresia,

tratând variabile continue şi necesitând pregătirea datelor.

Algoritmul CHAID utilizează pentru divizare teste „chi-square” - detectarea

relaţiilor statistice complexe. În construirea arborelui, numărul de ramuri variază de la

două la numărul de categorii de preziceri.

Algoritmii ID3/C4.5 şi C5.0 includ metode de generalizare a regulilor asociate unui

arbore, acesta îndepărtând redundanţele. Aceşti doi algoritmi produc arbori cu ramuri

multiple pentru un nod. Numărul de ramuri este egal cu numărul de categorii de preziceri.

Ei combină arbori decizionali multipli într-un singur clasificator utilizând informaţia

câştigată pentru divizare. Tăierea este bazată pe o rată de eroare la fiecare frunză.

Algoritmul SLIQ este un clasificator scalabil rapid, fiind un algoritm de tăiere

rapid.

Algoritmul SPRINT este utilizat pentru seturi mari de date, divizarea fiind bazată

pe valoarea unui singur atribut. Acest algoritm înlătură toate restricţiile de memorie prin

utilizarea structurii de date de tip listă de atribute.

Trăsăturile de bază care fac distincţie între toţi aceşti algoritmi sunt:

� Cei mai mulţi algoritmi de decizie necesită variabile ţintă de tip enumerare, ei

solicită ca variabilele continue să fie grupate pentru a folosi regresia

� Mulţi algoritmi suportă doar divizarea binară (fiecare nod părinte se poate

diviza în cel mult două noduri fii). Alţii generează mai mult de două divizări şi

produc o ramură pentru fiecare valoare a unei categorii de variabilă

� Măsurarea divizării ne ajută să selectăm care variabilă va fi folosită pentru a

diviza un anumit nod. Cele mai obişnuite măsurări includ criterii bazate pe

GINI, chi-square, rata de câştig şi entropie.

34

� Generarea regulii se face folosind metode de generare asociate arborilor (în

cazul algoritmilor C4.5 şi C5.0). Aceasta elimină redundanţa. Alţi algoritmi pur

şi simplu cumulează toate testele dintre nodul rădăcină şi nodul frunză pentru a

produce o regulă.

Dintre toţi aceşti algoritmi, cel mai des utilizat este algoritmul ID3/C4.5. ID3

[Qui86] este un sistem de învăţare bazat pe arbori de decizie tipic. El adoptă o strategie de

parcurgere de sus în jos (top-down) care caută doar într-o parte a spaţiului de căutare.

Acesta garantează găsirea unui arbore simplu, fără a fi neapărat cel mai simplu. C4.5 este o

extensie la ID3 care extinde domeniul clasificării de la atribute de tip enumerare la unele

numerice. Paşii algoritmului sunt prezentaţi în continuare:

1) selectează atributele care au cea mai mare informaţie câştigată

2) presupunând că există două clase P şi N:

a) fie un set de exemple S care conţin p elemente din clasa P şi n elemente din clasa N

b) cantitatea de informaţie necesară pentru a decide dacă un exemplu arbitrar din S

aparţine clasei P sau clasei N este definită astfel:

( )np

nlog

np

n

np

plog

np

pn,pI

++−

++−=

22 (2.2.1)

3) presupunem că utilizând atributul A, un set S va fi partiţionat în seturile {S1, S2, ..., Sv}

a) dacă Si conţine pi exemple din P şi ni exemple din N, atunci entropia sau informaţia

necesară clasificării tuturor obiectelor din toţi subarborii Si este:

∑= +

+=

n

i

iiii )n,p(Inp

np)A(E

1

(2.2.2)

4) informaţia de codificare care ar fi câştigată pe ramura A este dată de:

)A(E)n,p(I)A(Gain −= (2.2.3)

Selecţia atributelor pe baza informaţiei câştigate pentru problema „cumpărătorilor

de calculatoare” prezentată în figura 2.2-3 este următoarea:

35

o clasa P: cumpărător_calculator = ”DA”

o clasa N: cumpărător_calculator = „NU”

o 0.940 = (9,5) = ),( ΙΙ np

o Entropia pentru atributul vârsta este:

69402314

504

14

432

14

5.),(I),(I),(I)sta(varE =++=

aşadar

)sta(varE)n,p(I)sta(varGain −=

similar

029.0)venit(Gain =

151.0)student(Gain =

048.0)creditare_nivel(Gain =

2.2.1.5. Avantajele şi dezavantajele arborilor de decizie

Principalele avantajele ale arborilor de decizie sunt că ei produc modele eficiente,

uşor de înţeles, uşor de utilizat şi că nu sunt afectaţi de lipsa valorilor unor date [BRR01].

De asemenea ei sunt perfect aplicabili unor probleme reale cum ar fi regulile comerciale.

Aceşti arbori se potrivesc bazelor de date de dimensiuni mari deoarece dimensiunea

arborelui este independentă de dimensiunea bazei de date.

Dintre dezavantaje amintim faptul că arborii de decizie impun anumite restricţii

asupra datelor care sunt analizate [KWG+97]. În primul rând, arborii de decizie permit doar

o singură variabilă dependentă. Pentru a prezice mai mult de o variabilă dependentă,

fiecare variabilă cere un model diferit. De asemenea, cei mai mulţi algoritmi pentru arbori

de decizie pretind ca datele continue să fie grupate sau convertite la date de tip enumerare,

mulţi algoritmi bazaţi pe arbori de decizie fiind instabili.

Varsta pi ni I(pi,ni)

<=30 2 3 0.971 30…40 4 0 0 >40 3 2 0.971

36

2.2.2. Reţele neuronale

Reţelele neuronale (neuronal networks NN) au fost utilizate în domeniul

calculatoarelor pentru prima dată în anii 1980 [SM83]. Ele au fost adesea denumite reţele

neuronale artificiale (artificial neuronal networks ANN) [Has95] pentru a le deosebi de

reţelele neuronale biologice după modelul cărora au fost construite, folosind modelul de

lucru al minţii umane.

La ora actuală ele reprezintă un sistem de procesare a informaţiei reprezentat printr-

un graf, cât şi o serie de algoritmi care accesează acel graf. Ca şi mintea umană, reţelele

neuronale constau din mai multe elemente de procesare interconectate. Aşadar, o reţea

neuronală este un graf cu mai multe noduri (elemente de procesare) şi arcuri

(interconexiuni) între ele. Nodurile grafului sunt ca şi neuronii individuali, în timp ce

arcurile sunt interconexiunile dintre aceştia.

Reţelele neuronale reprezintă unii dintre cei mai complecşi algoritmi de clasificare

şi regresie, fiind adesea considerate adevărate cutii negre [Hay99]. Deşi o reţea neuronală

are o mulţime de date pentru antrenare, consumând astfel timp, ea poate face predicţii

pentru noi cazuri foarte repede, chiar în timp real. Mai mult, o reţea neuronală poate oferi

ieşiri multiple reprezentând predicţii simultane multiple. O trăsătură cheie a reţelelor

neuronale este aceea că ele operează direct numai pe numere. Astfel, orice dată aflată în

coloane independente sau dependente (ieşiri) care nu este de tip numeric trebuie convertită

în număr (de exemplu, valorile de tip „yes/no”, „high/low” ale unei variabile trebuie

înlocuite cu „0/1”).

Cele mai comune arhitecturi de reţelele neuronale conţin trei nivele: nivelul

unităţilor de intrare (surse), nivelul unităţilor ascunse (interne) şi nivelul unităţilor de ieşire

(rezultate) .

O reţea neuronală (NN) este un graf direct F=‹V,A›, care are mulţimea nodurilor

V={1,2,…n} şi mulţimea arcelor A={‹i,j› | 1≤i, j≤n }, cu următoarele restricţii [Dun03]:

1. mulţimea V este împărţită în submulţimile VI (noduri de intrarea), VH (noduri

ascunse) şi VO (noduri de ieşire)

2. mulţimea arcelor {1,2,…k} este împărţită în nivele

a. nodurile de intrarea pe nivelul 1,

b. nodurile ascunse pe nivelele 2, ..., k-1

c. nodurile de ieşire pe nivelul k

37

3. orice arc ‹i,j› trebuie să aibă nodul i pe nivelul h-1 şi nodul j pe nivelul h

4. arcul ‹i,j› primeşte o etichetă - valoarea numerică wij

5. nodul i primeşte o etichetă – funcţia fi

Un exemplu de reţea neuronală este prezentat în figura 2.2-4, unde se observă că

nivelul nodurilor de intrare (I1, I2, I3) este conectat la nivelul nodurilor ascunse (H1, H2),

care este conectat la nivelul nodurilor de ieşire (O1).

Fig. 2.2-4. Exemplu de reţea neuronală cu 6 noduri

Arcele care leagă nodurile (w1, ...,w8) determină ponderea (gradul de importanţă)

a acelui nod.

Nodurile de intrare preiau informaţia de intrare şi o introduc în reţea. Activarea

fiecărei unităţi din nivelul ascuns este determinată de activarea nodurilor de intrare şi de

ponderile legăturilor dintre nodurile de intrarea şi nodurile ascunse. Ieşirea unui nod i

dintr-o reţea neuronală este dată de funcţia de activare a acelui nod, F(I) asociată lui.

Funcţia de activare a unui nod în reţea este calculată astfel:

( ) kk2211 wx...wxwxIF ⋅++⋅+⋅= (2.2.4)

O reţea neuronală execută o transformare neliniară a intrărilor. Funcţia de transfer,

transformata neliniară a funcţiei de activare F(I) este F’(I). În figura 2.2-5. se poate

observa ce se întâmplă în interiorul fiecărui nod din reţea.

X1

Predicţia (rezultatul)

w8

w7

w6

w5

w4

w3

w2

w1 I1

I2

I3

H1

O1

H2

X2

X3

Nivelul de intrare Nivelul ascuns Nivelul de ieşire

38

Fig. 2.2-5. Nod al reţelei neuronale

Comportamentul unităţilor de ieşire depinde de activarea unităţilor ascunse şi de

ponderile legăturilor dintre unităţile ascunse şi unităţile de ieşire. Nivelul ascuns face ca

reţeaua să recunoască mai multe tipare, astfel numărul nodurilor ascunse creşte deseori cu

numărul de intrări şi cu complexitatea problemei. Folosirea a prea multor noduri ascunse

poate duce la o potrivire excesivă (overfitting), iar a prea puţine noduri poate duce la

obţinerea de modele cu o acurateţe (precizie) scăzută. Găsirea unui număr potrivit de

noduri ascunse este o parte importantă a oricărei tehnici Data Mining ce foloseşte reţele

neuronale [Mit99].

Multe produse care folosesc reţele neuronale includ algoritmi de căutare pentru

găsirea numărului optim de noduri ascunse (algoritmi genetici). Ponderile dintre unităţile

de intrare şi unităţile ascunse determină dacă un nod este activ, şi astfel, prin modificare

acestor ponderi, un nod ascuns poate alege ce va reprezenta.

2.2.2.1. Avantaje şi dezavantaje ale reţelelor neuronale

O reţea neuronală poate fi privită adesea ca o cutie neagră fiind incapabilă să

explice găsirea dependenţelor (relaţiilor) dintre noduri. Ea lucrează doar cu date numerice,

cele nenumerice fiind convertite. Mai mult, intrările trebuie normalizate între 0 şi 1.

O reţea neuronală poate prezice repede un caz nou dacă este antrenată cum trebuie.

Faza de antrenare este destul de delicată, deoarece trebuie aleasă o structură potrivită. În

unele pachete, acest lucru a fost făcut cu ajutorul altor unelte Data Mining (de exemplu

algoritmi genetici). Dezavantajul este acela că o reţea neuronală nu poate fi niciodată

exactă, chiar dacă ea este antrenată la infinit.

w1 X1

F’(I)

wk

w2

.

.

.

F(I) X2

Xk

39

2.2.3. Algoritmul celor mai apropiaţi k vecini (k-nearest neighbors)

Algoritmul celor mai apropiaţi k vecini (k – nearest neighbors k-NN) este o tehnică

predictivă potrivită pentru clasificarea modelelor. Tehnica k-NN presupune că întregul set

de antrenare include atât datele cât şi clasificările dorite pentru fiecare item. Ca urmare a

aplicării tehnicii datele de antrenare devin modelul. K reprezintă numărul de cazuri

similare sau numărul de articole din grup.

La apariţia unui caz sau exemplu nou în model algoritmul verifică toate datele

pentru a găsi un subset care este cel mai apropiat de cel nou şi oferă acest subset ca şi

rezultat, plasându-l în clasa care conţine cei mai mulţi itemi din acest set al celor mai

apropiaţi k itemi.

Algoritmul k-NN are doi parametri principali:

• numărul celor mai apropiate (similare) cazuri – k

• o metrică pentru măsurarea similarităţii

La fiecare utilizare a algoritmului k-NN este necesar să se specifice o valoare

întreagă pozitivă pentru k. Această valoare reprezintă numărul de cazuri existente care sunt

analizate la precizarea unui nou caz. De exemplu, în figura 2.2-6. este prezentat cazul

pentru k=3, algoritmul 3-NN va folosi cele mai apropiate 3 cazuri pentru a prezice

rezultatul unui nou caz.

Fig. 2.2-6. Clasificarea folosind 3-NN

Algoritmul k-NN decide în ce clasă să plaseze un nou caz prin examinarea unui

număr k de cazuri (vecini) cu un grad mare de asemănare. Algoritmul calculează distanţa

de la noul caz (N) la fiecare caz din setul de antrenare (X, Y). Noul caz N este atribuit

6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9

X X X X X X X X

• t X X X

40

clasei căreia îi aparţin majoritatea cazurilor din cele k cazuri, considerate cele mai

apropiate din setul de antrenare. Astfel, noul caz este asignat acelei clase căreia îi aparţin

cele mai multe cazuri similare, respectiv clasei X, deoarece în interiorul elipsei sunt mai

multe elemente X decât elemente Y (Fig. 2.2-7).

Fig. 2.2-7. Exemplu de clasificare k-NN

Algoritmul k-NN este bazat pe conceptul de distanţă iar aceasta necesită o metrică

pentru determinarea distanţelor. Presupunând că avem n vectori de caracteristici x1, x2, ...,

xn şi că aceştia fac parte din grupări compacte, cu c<n. Fie mi media vectorilor din

gruparea i. Dacă grupările sunt bine separate putem utiliza un clasificator de distanţă

minimă pentru a le separa. Adică putem spune că x este în gruparea i dacă distanţa ║x-mi║

este minimul dintre toate cele k distanţe.

Pentru atributele continue putem folosi distanţa Euclidiană iar pentru variabilele de

tip enumerat trebuie să găsim un mod potrivit pentru calcularea distanţelor dintre atributele

din setul de date. Alegerea unei metrici potrivite este o problemă dificilă deoarece diferite

metrici folosite pe acelaşi set de antrenare pot da rezultate complet diferite. Aceasta

înseamnă că avem nevoie de un expert în domeniu care să ajute la alegerea unei metrici

potrivite.

2.2.3.1. Avantaje şi dezavantaje ale algoritmului k-NN

Algoritmul k-NN este un model vast, deoarece foloseşte întregul set de antrenare ca

şi model. Numărul de clase este dat, în general, ca şi variabilă de intrare, ceea ce, în

anumite probleme, nu este întotdeauna uşor de presupus. Timpul de calcul a algoritmului

k-NN este de ordinul factorialului numărului total de puncte, deoarece se realizează

recalcularea pentru fiecare caz nou.

X X X Y

Y X X X N Y X X

41

Măsurile de similaritate bazate pe distanţe nu pot să facă faţă unor date de

dimensiune mare deoarece noţiunea de vecini devine fără sens. În astfel de cazuri se

foloseşte o metodă mai sofisticată (de exemplu, SOM-self organizing map).

Un alt dezavantaj îl reprezintă tratarea unor inexactităţi în date şi a suprapunerii

grupărilor, cu alte cuvinte de a decide de care grupă aparţin datele care sunt în regiunea

frontierelor. În astfel de cazuri se foloseşte o abordare fuzzy. O tehnică fuzzy k-NN este de

fapt o tehnică k-NN în care tehnica de măsurare este fuzzy.

2.3. Gruparea

Gruparea (clustering) este o tehnică similară clasificării deoarece face o grupare a

datelor. Spre deosebire însă de clasificare, grupurile nu sunt predefinite. Gruparea este

realizată prin găsirea similarităţilor dintre date în conformitate cu caracteristicile găsite în

datele actuale. Grupurile sunt numite clusteri (clusters). O bună parte dintre autorii de

specialitate [TB70], [JD88], [HK99] consideră gruparea ca fiind un tip special de

clasificare. Alţii [Dun03] cred că cele două tehnici sunt diferite. Clusterii au fost definiţi în

multe moduri, de exemplu:

� Seturi de elemente asemănătoare (similare). Elementele din diferite grupări nu sunt

asemănătoare.

� Distanţa dintre punctele aparţinând unei grupări este mai mică decât distanţa dintre un

punct din interiorul grupării şi altul din afara grupării.

Analiza bazată pe grupare ne ajută să realizăm parţionarea unui mare set de obiecte

folosind tehnica „divide et impera” („divide and conquer”, „împarte şi stăpâneşte”) care

descompune un sistem de dimensiuni mari în componente mici, pentru a simplifica

proiectarea şi implementarea.

Ca o metodă de extragere de date (Data Mining), gruparea datelor identifică grupuri

sau regiuni dens populate ţinând cont de măsuri de distanţă, în seturi mari sau

multidimensionale de date.

Gruparea este o metodă studiată în mai multe domenii cum ar fi statistica [JD88],

învăţarea automată [Fis95], baze de date spaţiale [EKX95], extragerea de date [NH94],

42

medicina, biologia, antropologia, economia sau marketing. Aplicaţiile bazate pe grupare

includ clasificarea de animale, plante, diagnostice, imagini procesate, recunoaştere de

tipare şi regăsirea de documente. În aplicaţiile de extragere de date bazate pe grupare, acest

concept de asociere trebuie văzut ca un fel de măsură numerică a gradului de similaritate.

R. Ng [NH94] afirmă că o grupare este bună dacă:

• Un grup (cluster) conţine membrii care au un grad mare de similaritate

• Metoda standard de măsurare a similarităţii în interiorul unui grup este

varianţa (suma pătratelor diferenţelor dintre elementul principal şi

fiecare element în parte). Sunt considerate cele mai bune grupurile cu

varianţa cea mai mică.

• Deoarece dimensiunea grupului este de asemenea importantă, o altă

abordare este folosirea variaţiei medii (variaţia totală împărţită la

dimensiunea grupului).

M. Dunham [Dun03] foloseşte pentru grupare un termen similar – segmentarea

bazei de date (database segmentation). În acest caz, articolele (tuplurile) unei baze de date

sunt grupate împreună prin partiţionarea sau segmentarea datelor în componente care apoi

dau utilizatorului o vedere mai generală asupra datelor. Putem evidenţia câteva trăsături de

bază ale grupării (ca fiind opusă clasificării):

� Numărul de clusteri nu este cunoscut

� Clusterii rezultaţi sunt dinamici

Gruparea poate fi definită astfel:

Fiind dată o bază de date de articole (tupluri) D = {t1, t2, ..., tn} şi o valoare întreagă

k, problema grupării este definirea unei mapări f : D → {1,2,...,n}, unde fiecare articol

(tuplu) ti este asociat unui grup (cluster) Kj, 1 ≤ j ≤ k. Un grup Kj, conţine acele

articole (tuplur)i care au fost mapate în el; adică Kj = {ti | f(ti ) = Kj, 1 ≤ i ≤ n şi ti ∈

D}.

43

Fig. 2.3-1. Clasificarea algoritmilor de grupare

În timp au apărut o serie de algoritmi folosiţi în grupare care pot fi clasificaţi ca în

figura 2.3-1.

Algoritmii folosiţi în grupare pot fi de asemenea clasificaţi şi pe baza tehnicilor de

implementare folosite.

Dintre cei mai des folosiţi algoritmi în grupare amintim: algoritmi cu măsuri de

similaritate şi distanţă, algoritmi cu reţele neuronale (SOM – Self Organizing Map).

2.3.1. Algoritmi bazaţi pe măsuri de similaritate

Pentru a rezolva o problemă specifică de grupare au fost create multe proprietăţi de

dorit. Cea mai importantă dintre ele este aceea că un articol dintr-o grupare este mult mai

asemănător cu celelalte articole din interiorul grupului decât cu cele din afara lui. Ca şi în

cazul clasificării, aşadar, putem defini între oricare două articole (tupluri) ti şi tk, o măsură

a similarităţii sim(ti,tk), astfel:

Fiind dată o bază de date de articole (tupluri) D = {t1, t2, ..., tn}, o măsură de

similaritate sim(ti, tj) definită între oricare două articole (tupluri) ti, tj ∈ D şi o

valoare întreagă k, problema grupării este definirea unei mapări f : D → {1,2,...,k},

unde fiecare articol (tuplu) ti este asociat unui grup (cluster) Kj, 1 ≤ j ≤ k. Aşadar,

având un grup Kj , ∀ tjl, tjm ∈ Kj şi ti ∉ Kj , sim(tjl, tjm) ≥ sim(tjl, ti).

Gruparea

Ierarhică

Partiţionată

Categorică

BD mari

Aglomerativă

Divizivă

Eşantionare

Compresie

44

În cazul în care avem o mulţime X de obiecte de grupat, putem defini o măsură de

similaritate peste X = (x1, x2, ..., xd) ca fiind o funcţie S : X*X → R, care satisface axiomele:

a) S(x,y) ≥ 0, S(x,y) = S(y.x), ∀ x, y ∈ X

b) S(x,x) = S(y,y) > S(x,y), ∀ x, y ∈ X

Dacă X este o submulţime a spaţiului Rd, atunci ca o măsură a similarităţii

vectorilor x şi y din X, putem considera ca fiind cosinusul unghiului dintre cei doi vectori.

Aşadar măsura de similaritate este:

(2.3.1)

unde:

(x*y) – este produsul scalar a doi vectori, pentru cazul dat avem x1y1+x2y2+...+xdyd

[x]T – transpusa matricei componentelor formei x

║x║- normala lui x : 2d

22

21 x...xxx +++=

Această măsură de similaritate este utilă atunci când mulţimea X a datelor este

formată din grupuri liniare. O distanţă poate induce o măsură de similaritate. Dacă d este o

distanţă peste X, atunci putem defini distanţa normalizată d/dmax, unde:

)y,x(dd maxXy,x

max

∈= (2.3.2)

Măsura de similaritate indusă de distanţa d se defineşte prin:

max

2d

)y,x(d1)y,x(S −= (2.3.3)

În cazul în care avem o mulţime de obiecte de grupat, cea mai generală măsură de

similaritate pe care o putem defini peste X este o funcţie D : X*X → R, care satisface

axiomele:

a) D(x,y) ≥ 0 ∀ x,y ∈ X

[ ] [ ]yx

yx

yx

)y*x()y,x(S

T

1 ⋅=

⋅=

45

b) D(x,x) = 0 ∀ x ∈ X

c) D(x,y) = D(y,x) ∀ x,y ∈ X

Admitem că X este o mulţime de instruire (în care se cunoaşte pentru fiecare obiect,

clasa căreia el aparţine), iar D este o măsură de disimilaritate adecvată. În aceste condiţii,

este de aşteptat ca disimilaritatea dintre obiectele aceluiaşi grup să fie sensibil mai mică

decât disimilaritatea dintre obiecte aflate în grupuri diferite. În cazul în care datele sunt

obiecte dintr-un spaţiu euclidian vom considera metrica spaţiului ca o măsură a

disimilarităţii.

Dacă X şi Y sunt puncte dintr-un spaţiu euclidian d-dimensional

X=(x1, x2, ..., xd)

Y=(y1, y2, ..., yd)

atunci, pentru orice număr real p ≥ 1, se poate defini metrica:

p

1

d

1i

p

ii yx)Y,X(d

−= ∑

− (2.3.4)

Formula de mai sus, reprezintă de fapt o familie infinită de metrici. Pentru p=1, din

(2.3.4) se obţine:

∑−

−=d

1i

ii yx)Y,X(d (2.3.5)

numită metrica absolută sau distanţa City Block.

Dacă p=2, se obţine distanţa euclidiană:

2

1

d

1i

2

ii yx)Y,X(d

−= ∑

− (2.3.6)

iar pentru p → ∞, se obţine metrica valorii maxime:

ii

i

yx)Y,X(d max −= (2.3.7)

În cazul în care valorile posibile ale caracteristicilor de clasificat sunt un număr

finit d, se pot utiliza ca măsuri de disimilaritate distanţele Hamming şi Lee.

Distanţa Hamming dintre vectorii X şi Y este dată de numărul componentelor

(poziţiilor) în care cei doi vectori diferă. Ponderea Hamming a vectorului X, notată cu

WH(X), se defineşte ca fiind numărul de componente nenule ale lui X. Rezultă că distanţa

Hamming dintre X şi Y este egală cu ponderea Hamming a diferenţei lor:

46

)YX(W)Y,X(d HH −= (2.3.8)

Distanţa Lee dintre vectorii X şi Y se defineşte astfel:

Fie vectorul X=(x1, x2, ..., xd), cu xi ∈ {0,1, …, q-1}, unde q este un număr pozitiv , q ≥ 2.

Ponderea Lee a vectorului X, notată cu WL(X), se defineşte ca fiind:

∑=

=d

1i

iL x)X(W (2.3.9)

unde:

−≤<−

≤≤=

1qx2

qdacaxq

2

qx0dacax

x

ii

ii

i (2.3.10)

Distanţa Lee a vectorilor X şi Y este ponderea Lee a diferenţei lor:

)YX(W)Y,X(d LL −= (2.3.11)

Pentru q=2, distanţa Hamming este:

∑−

−=d

1i

iiH yx)Y,X(d

Pentru q=2 şi q=3, distanţele Hamming şi Lee coincid. Pentru q> 3, avem:

Y,X)Y,X(d)Y,X(d HL ∀≥

2.3.2. Algoritmi cu reţele neuronale

Reţelele neuronale care folosesc învăţarea ne asistată încearcă să găsească trăsături

ale datelor care să caracterizeze ieşirile dorite. Aceste tipuri de reţele neuronale sunt

denumite adesea SONN (Self-Organizing Neural Networks). Ele au fost dezvoltate prin

observarea modului de lucru al neuronilor din creierul uman [BS97].

SOM (Self Organizing Map) este o reţea neuronală care foloseşte învăţarea

competitivă neasistată. SOM este un tip special de arhitectură de reţea neuronală care oferă

o mapare din spaţiul multidimensional de intrare într-o latice de celule regulate de ordin

redus. Dacă setul de intrări este multidimensional, algoritmii tradiţionali de grupare nu

oferă un mod uşor de vizualizare a „apropierii” de alte grupări.

O astfel de grupare este folosită pentru identificarea grupărilor de elemente care

sunt similare în spaţiul original. Probabil cel mai obişnuit exemplu de SOM este reţeaua

47

Kohonen [Koh82], care este folosită foarte des în produsele de extragere de date

comerciale pentru a realiza gruparea.

Într-o SOM, grupările sunt de obicei organizate într-o latice, de obicei o matrice

bidimensională, dar se folosesc şi unidimensionale sau multidimensionale [FAQ95].

Matricea există într-un spaţiu care este separat de spaţiul de intrare. În schimb, reciproca

nu este adevărată: centrele de grupări care sunt apropiate unele de altele în spaţiul de

intrare nu corespund în mod necesar unor grupări apropiate în matrice.

Spre deosebire de alte abordări bazate pe reţele neuronale, SOM efectuează o

antrenare neasistată. O abordare mai des întâlnită a reţelelor neuronale necesită o antrenare

asistată a reţelei, cu alte cuvinte, reţeaua este alimentată cu un set de cazuri de antrenare iar

ieşirea generală este comparată cu ieşirea corectă cunoscută. Nodurile din reţeaua SOM

converg în formarea unor grupări pentru a reprezenta grupuri de entităţi cu proprietăţi

similare. Numărul şi compoziţia grupurilor pot fi determinate vizual pe baza distribuţiei de

ieşire generată de procesul de antrenare.

SOM este o reţea de propagare înainte (feed-forward) fără nivele ascunse. Ea are

două nivele de noduri: nivelul de intrare şi nivelul Kohonen. SOM foloseşte măsura

euclidiană pentru măsurarea distanţei.

Algoritmul bazat pe SOM asignează centrelor de grupări o locaţie într-o matrice

organizată spaţial. Datele sunt procesate urmând următorii paşi:

1. asignează o funcţie de „vecinătate” care, pentru un centru dat, identifică centrele

grupărilor învecinate.

2. pentru fiecare punct:

a. găseşte centrul grupări care este cel mai „apropiat” punctului considerat

(„câştigător”)

b. mută centrul câştigător spre punctul considerat

c. foloseşte funcţia de „vecinătate” pentru a identifica centrele învecinate şi

pentru a le muta spre punctul considerat

3. descreşte dimensiunea vecinătăţii şi repetă procesul până când vecinătatea include

doar centrul câştigător.

Astfel, gruparea începe ca şi un proces foarte general şi continuă devenind din ce în

ce mai localizat pe măsură ce vecinătatea descreşte.

48

2.3.2.1. Avantaje şi dezavantaje ale metodei SOM

Unul dintre principalele avantaje ale SOM este faptul că poate învăţa din date

complexe multidimensionale şi le poate transforma într-o reţea (map) de dimensiuni mai

reduse, de exemplu bidimensionale. Reprezentarea bidimensională oferă o interfaţă grafică

utilizator uşor de folosit pentru a ajuta factorul de decizie să vizualizeze, de exemplu,

similarităţile dintre tiparele preferinţelor clienţilor. Metoda este foarte puternică pentru

vizualizarea unor interacţiuni multiple dintre caracteristici astfel oferind o mai bună

înţelegere a datelor.

Ca şi dezavantaj putem aminti faptul că la o primă abordare, SOM este o tehnică

destul de dificil de tratat iar rezultatele nu pot fi interpretate întotdeauna uşor.

2.4. Alte tehnici Data Mining

Pe lângă tehnicile prezentate în acest capitol, în literatura de specialitate, mai sunt

întâlnite şi altele, cum ar fi: analiza discriminantă, algoritmi genetici, logica fuzzy şi BBN

(Bayesian Belief Networks).

Analiza discriminantă are rolul de a găsi hiperplane de separare a claselor.

Rezultatul modelului este foarte uşor de interpretat deoarece utilizatorii trebuie doar să

determine pe care latură se află un punct.

Algoritmii genetici sunt cei mai folosiţi în probleme de optimizări şi foarte puţin în

Data Mining. În general, ei sunt încorporaţi într-o reţea neuronală pentru a mări

performanţa reţelei.

Logica fuzzy este o tehnică utilizată pentru grupare şi clasificare. Tehnica este

folosită în extragerea de date din paginile Web, deoarece grupările şi asocierile nu au

graniţe pronunţate, astfel suprapunerile sunt cel mai bine descrise prin seturi fuzzy.

BBN este un model pentru reprezentarea incertitudinii în domeniul cunoştinţelor.

Pentru tratarea incertitudinii este utilizată teoria probabilităţii pentru reprezentarea

explicită a dependenţelor condiţionale dintre diferite componente. Aceasta oferă o

vizualizare grafică intuitivă a cunoştinţelor incluzând interacţiuni între diferite surse de

incertitudine. BBN poate fi utilizată la gruparea clienţilor (cumpărătorilor).

49

2.5. Concluzii

În acest capitol au fost prezentate principalele tehnici utilizate în extragerea de date

şi rolul acestora în descoperirea de cunoştinţe.

Dintre metodele Data Mining existente, cel mai des sunt utilizate metodele de

descoperire a regulilor de asociere. Aceste metode sunt utilizate frecvent în analiza

vânzărilor cu amănuntul, dar ele pot fi aplicate cu acelaşi succes şi în serviciile de

marketing (analiza coşului de cumpărături) pentru determinarea caracteristicilor comune

ale clienţilor. Industria serviciilor financiare utilizează, de asemenea, frecvent extragerea

de reguli de asociere. Analiştii folosesc aceste tehnici pentru a analiza cantităţi masive de

date pentru a construi afaceri şi modele de risc pentru dezvoltarea strategiilor de investiţii.

Multe companii din sectorul financiar au testat aceste tehnici care au produs rezultate

pozitive în analiza conturilor clienţilor şi la identificarea serviciilor financiare pe care

aceştia le solicită împreună.

KDD/DM este un domeniu interdisciplinar care dezvoltă algoritmi şi procese

pentru descoperirea de cunoştinţe (categorii, tipare, concepte, relaţii şi tendinţe), construind

modele şi făcând preziceri din date structurate, semi-structurate sau nestructurate. De

asemenea, extrage informaţii de interes sau tipare din baze de date de dimensiuni mari.

Datorită importanţei ţi aplicabilităţii pe care o au, aşa cum am arătat, în diverse

domenii, descoperirea regulilor de asociere din baze de date de dimensiuni mari a fost şi

este în continuare una din tehnicile Data Mining cel mai mult studiate.

Descoperirea regulilor de asociere este probabil cea mai semnificativă contribuţie a

colectivelor de cercetători din domeniul descoperirii de cunoştinţe din baze de date.

50


3.1. Definiţii şi terminologie

Descoperirea de reguli de asociere înseamnă să găsim asocieri interesante sau

relaţii de legătură (corelaţii) în seturi mari de date, de exemplu, să identificăm seturi de

valori ale atributelor (predicate sau itemi) care apar frecvent împreună, şi apoi să formulăm

reguli care să caracterizeze aceste relaţii. Descoperirea acestor reguli poate identifica tipare

sau comportamente care sunt apoi utilizate în diferite scopuri.

O definiţie formală a unei reguli de asociere poate fi formulată astfel [Zhu98]:

O regulă de asociere este o regulă de forma

A1, A2, ..., Am → B1, B2, ..., Bn

unde Ai şi Bj sunt predicate sau articole (itemi) şi care poate fi interpretată astfel:

„Când într-o tranzacţie apar articolele A1, A2, ..., Am, în cele mai multe cazuri apar şi

articolele B1, B2, ..., Bn în aceeaşi tranzacţie”.

Primele dezvoltări ale regulilor de asociere au fost făcute în anul 1993 de către

Agrawal, care a propus atunci un algoritm [AIS93] pentru descoperirea lor.

De atunci, foarte mulţi cercetători au studiat din multe puncte de vedere această

problemă, ea devenind la ora actuală un instrument util şi important în extragerea de date.

În timp, cercetările au dus la diferite moduri de formulare a acestor tehnici:

� Extragerea de reguli de asociere booleene uni-dimensionale din baze de

date tranzacţionale

� Extragerea de reguli de asociere multi-nivel din baze de date

tranzacţionale

� Extragerea de reguli de asociere multi-dimensionale din baze de date

tranzacţionale şi depozite de date (warehouse)

� Extragerea de asocieri bazate pe constrângeri

51

Extragerea regulilor de asociere a fost iniţial generată de analizarea coşului de

cumpărături. Mai târziu ea a fost aplicată în multe alte domenii cum ar fi: afaceri, inginerie,

medicină sau finanţe [FPS+96]. Mai mult decât atât, unul din scopurile principale ale

extragerii de reguli de asociere a fost utilizat pentru a atinge scopul altor probleme de

extragere de date cum ar fi modelarea datelor, prezicerea viitoarelor ieşiri sau suport de

decizii:

� Analiza coşului de cumpărături - Pentru a înţelege obiceiurile şi preferinţele

cumpărătorilor este important să luăm diferite decizii cum ar fi: ce punem în vânzare,

cum să proiectăm ambalajul, cum să plasăm marfa în rafturi astfel încât să mărim la

maximum profitul, etc. Regulile de asociere pot oferi aceste informaţii. O aplicaţie

eficientă de extragere de date analizează obiceiurile clienţilor de a asocia produsele

cumpărate si poate extrage reguli de asociere între produse. Aceste tehnici pot fi

aplicate cu succes la dezvoltarea campaniilor de marketing, în vânzările cu amănuntul,

la crearea pachetului unei campanii promoţionale.

� Cross-marketing – În prezent, în puternicul mediu competitiv din interiorul serviciilor,

păstrarea clienţilor şi folosirea mai eficient a bazei de date a cumpărătorilor a devenit o

treabă la fel, dacă nu mai importantă decât atragerea de noi clienţi. Tot mai multe

companii oferă mai mult de un serviciu sau produs. Din moment ce ei ştiu tot mai

multe despre clienţii lor obişnuiţi cu ajutorul datelor colectate despre ei, faptul că le

oferă acestora produse pe care încă nu le au poate aduce profituri rapide. Acest tip de

vânzare prin care se oferă un produs vechilor clienţi ai companiei, care nu sunt încă

cumpărători ai acestui produs se numeşte – vânzare încrucişată (cross-sale). O aplicaţie

de extragere de reguli de asociere poate descoperi cunoştinţe utile pentru acest domeniu

pentru a ajuta rezolvarea acestui tip de vânzare.

� Clasificarea parţială – Multe aplicaţii din viaţa reală necesită clasificări parţiale ale

datelor, de exemplu, descrierea descoperiri de modele care să arate caracteristicile unei

clase de date, dar care să nu acopere toate clasele şi toate exemplele unei anumite clase.

În mod convenţional clasificarea nu este eficientă atunci când sunt foarte multe atribute

şi cele mai multe dintre valorile acestor atribute lipsesc. Acest tip de problemă se

rezolvă folosind analiza asocierilor. Un exemplu în această direcţie ar fi testele

medicale la care este supus un pacient. Aşa cum se ştie există mii de teste medicale,

însă doar unele dintre acestea sunt făcute unui anumit pacient. Medicii pot folosi reguli

şi modele descoperite prin analiza asocierilor pentru a vedea care teste pot fi combinate

52

cu altele. Astfel, ei pot evita supunerea pacienţilor unor teste inutile, redundante, iar

testele complexe pot fi înlocuite cu unele mai simple.

� Servicii financiare – Industria serviciilor financiare utilizează frecvent extragerea de

reguli de asociere. Analiştii folosesc aceste tehnici pentru a analiza cantităţi masive de

date pentru a construi afaceri şi modele de risc pentru dezvoltarea strategiilor de

investiţii. Multe companii din sectorul financiar au testat aceste tehnici care au produs

rezultate pozitive în analiza conturilor clienţilor şi la identificarea serviciilor financiare

pe care aceştia le solicită împreună.

Formularea clasică a unei probleme de extragere de reguli de asociere este

următoarea:

Fie I = {I1, I2, .., Im} un set de articole, şi D = {t1, t2, ..., tn} o bază de date

tranzacţională, unde fiecare tranzacţie are un identificator unic (tid) şi conţine un set de

articole ti = {Ii1, Ii2, ..., Iik} şi Iij ∈ I, o regulă de asociere este o implicare de forma X ⇒ Y

unde X,Y ⊂ I sunt seturi de articole (itemi) numite articolset-uri (itemset-uri) şi X ∩ Y =

∅. O mulţime de articole se numeşte articolset (itemset).

Altfel, putem spune: găseşte toate regulile care asociază prezenţa unui articolset în

coşul de cumpărături cu alt articolset. De exemplu:

40% din cei care cumpără o berebereberebere cumpără de asemenea şi alunealunealunealune.

Regula extrasă nu trebuie să fie restricţionată de numărul de obiecte cumpărate în

acel moment, înainte sau după. Există însă şi posibilitatea de a specifica anumite

constrângeri pe reguli (de exemplu doar reguli care invoca anumite obiecte, cum ar fi:

bere). Tiparele secvenţiale maximale găsite trebuie să fie susţinute de mai mult decât un

procentaj specificat de clienţi. Fiecare regulă are două măsuri suportul şi confidenţa.

Pornind de la aceste formulări iniţiale, se definesc conceptele de bază utilizate

[Dun03].

a) Frecvenţa unui articolset este numărul total de tranzacţii care conţine acel articolset.

b) Suportul (preponderenţa) unei reguli X ⇒ Y este procentul de tranzacţii din baza de

date care conţine X ∪ Y. Pentru calculare suportului folosim formula:

)YX(P)YX(S ∪=⇒ (3.1.1.)

53

sau

tranzactiidetotalNumarul

YsiXpecontincaretranzactiideseturideNumarulSuportul ≅ (3.1.2.)

Interpretare: Regula de asociere este validă în s% din totalul tranzacţiilor.

c) Confidenţa (încrederea în regulă) (α) unei reguli de asociere X ⇒ Y este raportul

dintre numărul de tranzacţii care conţin X ∪ Y şi numărul de tranzacţii care conţin X.

)X(P)YX(P)XY(P)YX( ∪==⇒α (3.1.3.)

sau

XpecontincaretranzactiideseturideNumarul

YsiXpecontincaretranzactiideseturideNumarulConfidenta ≅ (3.1.4.)

Interpretare: Dacă X şi Y sunt în acelaşi coş (sunt cumpărate de aceeaşi persoană), atunci Z

este de asemenea în coş în α% din cazuri.

d) Scopul unei reguli de asociere este de a identifica toate regulile X ⇒ Y cu un suport

minim şi o confidenţă minimă. Aceste valori sunt date ca şi intrări ale problemei, fiind

stabilite de utilizatori sau de specialişti în domeniu.

Selecţia unei reguli de asociere se bazează pe cele două măsuri: confidenţa care

măsoară puterea unei reguli şi suportul care măsoară frecvenţa cu care ea apare în baza de

date. Ea se face de obicei în două etape:

� pasul 1: găsirea tuturor tiparelor frecvente. Prin definiţie, fiecare din

aceste tipare va apare cu o frecvenţă cel puţin egală cu o valoare

predefinită denumită suport minim.

� pasul 2: generarea unor reguli puternice din aceste tipare frecvente.

Prin definiţie, aceste reguli trebuie să satisfacă suportul minim şi

confidenţa minimă.

Datele utilizate de algoritmii de asociere sunt formate din entităţi şi atribute şi pot

exista în unul din cele două formate vertical sau orizontal.

54

Formatul orizontal presupune existenţa unui rând pentru fiecare entitate şi de

asemenea coloane pentru fiecare atribut, de exemplu, un rând pentru fiecare coş de

cumpărături (market basket) şi coloane pentru fiecare produs (vezi tabelul 3.1-1)

Tranz ID Articol 1 Articol 2 Articol 3 Articol 4 Articol 5

312 DA DA DA

842 DA DA

Tabel 3.1-1. Exemplu de date în format orizontal în regulile de asociere

Problema care apare este aceea că numărul de coloane poate creşte foarte mult

(numărul de produse poate fi peste 100 000). În acest caz, este nevoie ca produsele similare

să fie grupate împreună pentru a ajunge la un număr rezonabil de coloane.

Formatul vertical presupune folosirea mai multor rânduri pentru memorarea unei

entităţi, utilizând un rând pentru fiecare atribut. Rândurile care corespund unei singure

entităţi au un număr de identificare comun (Tranz ID) (vezi tabelul 3.1-2.). Acest tip de

reprezentare este normalizat în sens relaţional şi permite ca o entitate să aibă o variabilitate

mai mare referitor la numărul de atribute.

Tranz ID Produs

312 Item 1

842 Item 2

842 Item 3

312 Item 4

312 Item 5

Tabel 3.1-2. Exemplu de date în format vertical în regulile de asociere

Unele produse Data Mining suportă operaţia de conversie din format orizontal în

format vertical. Algoritmii de asociere pot opera doar cu date de tip enumerare (categorical

data). Dacă trebuie analizate date care nu sunt de tip enumerare, cum ar fi de exemplu

venitul, atunci aceste date trebuie grupate într-un interval (de exemplu: 0 ÷20 000; 20 001÷

40 000; 40 001 ÷ 70 000; > 70 001) transformând fiecare interval într-un atribut.

55

Descoperirea regulilor de asociere este probabil cea mai semnificativă contribuţie a

cercetătorilor din domeniul descoperirii de cunoştinţe din baze de date. Descoperirea

eficientă a unor astfel de reguli este încă o problemă intens cercetată de specialişti.

Unele dintre principalele domenii în care găsim aplicaţii ale extragerii regulilor de

asociere sunt:

o descoperirea regulilor de asociere în sisteme GIS (Geographic

Information System)

o descoperirea regulilor de asociere în date temporale

o descoperirea regulilor de asociere în baze de date multimedia şi în baze

de date text

o descoperirea regulilor de asociere în baze de date multi-nivel şi multi-

dimensionale

3.2. Descoperirea seturilor frecvente de articole (large itemsets)

Problema descoperirii regulilor de asociere constă în generarea acelor reguli care au

un suport mai mare decât suportul minim s şi o confidenţă mai mare decât confidenţa

minimă α.

Cea mai comună abordare a problemei descoperirii regulilor de asociere este de a

descompune această problemă în două etape:

1. Găsirea tuturor seturilor de articole (articolset, itemsets) care au suportul

mai mare decât suportul minim. Suportul pentru un articolset este numărul

de tranzacţii care conţin articolset-ul. Seturile de articole care au suportul

minim sunt denumite seturi frecvente (mari) de articole (large itemsets), iar

toate celelalte sunt denumite seturi mici de articole (small itemsets)

2. Folosirea seturilor de articole pentru generarea regulilor dorite. Acest pas

presupune găsirea, pentru fiecare set frecvent de articole l, a tuturor

subseturilor nevide ale lui l. Pentru fiecare astfel de subset x, se tipăreşte o

regulă de forma x ⇒ (l-x), dacă raportul suport(l) / suport (x) este cel puţin

minconf (confidenţa minimă). Se iau în considerare toate subseturile lui l în

generarea regulilor.

56

Odată ce s-a găsit un set frecvent de articole (large itemset), se ştie că orice regulă

de asociere X ⇒ Y, trebuie să aibă X ∪ Y în acest set al articolset-urilor frecvente. Orice

subset al unui set frecvent de articole este de asemenea mare. Din acest motiv, deşi găsirea

seturilor frecvente se face relativ uşor, datorită dimensiunii lor această operaţie este destul

de costisitoare.

Fiind dat un set de articolset-uri de dimensiune m, acesta are 2m subseturi. Deoarece

nu ne interesează să obţinem seturi vide, numărul potenţial de seturi frecvente este aşadar

2m -1. Datorită creşterii explozive a acestui număr, provocarea extragerii regulilor de

asociere se rezumă adesea la eficientizarea determinării numărului seturilor frecvente.

Algoritmii de descoperire a seturilor frecvente de articole, în general, fac mai

multe treceri asupra datelor. În prima trecere, se calculează suportul pentru articole

individuale şi se determină care dintre ele sunt frecvente, adică satisfac suportul minim. În

următoarele treceri, se porneşte cu seturile de articole găsite a fi frecvente. Acestea sunt

folosite pentru generarea de noi seturi de articole potenţial frecvente, denumite seturi de

articole candidat (C), şi se calculează suportul actual pentru aceşti candidaţi. La sfârşitul

trecerii, se determină care dintre candidaţi sunt într-adevăr frecvenţi şi aceştia sunt folosiţi

în următoarea trecere. Procesul continuă până când nu mai sunt găsite seturi frecvente de

articole.

Dimensiunea lui C este adesea folosită ca o măsură de performanţă a algoritmilor

pentru descoperirea regulilor de asociere.

O caracteristică comună a algoritmilor pentru descoperirea regulilor de asociere

este ierarhia de articole (itemi). Ierarhia de articole poate fi utilizată pentru a reduce

numărul de combinaţii la o dimensiune rezonabilă prin gruparea articolelor similare

împreună. Utilizarea ierarhiei de articole duce la reducerea numărului de combinaţii şi

totodată ajută la o mai mare generalizare şi la o mai bună folosire a relaţiilor.

În descrierea algoritmilor de descoperire de reguli de asociere se utilizează, în

general, un set de notaţii prezentate mai jos, în tabelul 3.2-1.

Presupunem că articolele din fiecare tranzacţie sunt păstrate într-o ordine

lexicografică. În acest caz, adaptarea algoritmilor de extragere de reguli de asociere la

bazele de date normalizate este o operaţie relativ simplă deoarece în acest tip de baze de

date fiecare înregistrare constă din perechi <TID, articol>, unde TID este identificatorul de

tranzacţie.

57

Numărul de articole (itemi) dintr-un set reprezintă dimensiunea acestuia, iar un set

de articole de dimensiune k, se numeşte k-articolset (k-itemset). Articolele din cadrul unui

set sunt menţinute în ordina lexicografică.

Un articolset cu k articole se notează

c = c[1] . c[2] ..... c[k]

şi are articolele c[1], c[2], ... , c[k], unde c[1] < c[2] < ... < c[k].

Dacă c = X . Y şi Y este un m- articolset, denumim Y ca fiind o m-extensie a lui X.

Fiecare articolset are asociat un câmp contor care stochează suportul pentru acel

articolset. Câmpul contor este iniţializat cu 0, atunci când setul este creat.

Notaţie Descriere

D Baza de date de tranzacţii

ti O tranzacţie din D

s Suport

α Confidenţă

X,Y Articolset-uri (Itemset-uri)

X ⇒ Y Regulă de asociere

L Set frecvent de articole

k-itemset Un set care are k articole (itemi)

Lk

Set de k-articolset-uri (k-itemset-uri) frecvente (cele care au suport

minim) Fiecare membru al acestui set are două câmpuri:

o Articolset (Itemset)

o Contor suport

C Set de itemset-uri candidaţi

Ck

Set k-articolset-uri (k-itemset-uri) candidaţi (seturi de articole

potenţial frecvente) Fiecare membru al acestui set are două câmpuri:

o Articolset (Itemset)

o Contor suport

kC Set de k-articolset-uri (k-itemset-uri) candidat care au TID-urile

tranzacţiilor generatoare asociate cu seturile candidat

p Număr de partiţii

Tabel 3.2-1. Notaţii utilizate

58

3.3. Algoritmi pentru descoperirea regulilor de asociere

Descoperirea regulilor de asociere are ca scop descoperirea unui set de atribute

comune care aparţin unui număr mare de obiecte dintr-o bază de date în general.

Pentru descoperirea asocierilor, se presupune că există un set de tranzacţii, fiecare

tranzacţie fiind o listă de articole (listă de cărţi, listă de alimente). Un utilizator ar putea fi

interesat de găsirea tuturor asocierilor care au s% suport (preponderenţă) cu α% confidenţă

(încredere), aşadar:

• trebuie găsite toate asocierile care satisfac constrângerile utilizatorului

• asocierile trebui găsite eficient dintr-o bază de date de dimensiuni mari

O dată cu progresul în tehnologia codurilor de bare, firmele de comercializare a

produselor au acumulat şi stocat cantităţi imense de date despre produse, despre vânzări

referite ca şi date despre coşul de cumpărături (basket data). În cazul acestor tipuri de date,

o înregistrare (articol, item) constă în mod tipic dintr-un identificator de tranzacţie, data

tranzacţiei şi produsele cumpărate la acea tranzacţie.

Firmele de succes privesc aceste baze de date ca şi părţi esenţiale ale infrastructurii

de marketing. Ele sunt interesate în introducerea unor procese de marketing conduse de

informaţii, coordonate prin folosirea tehnologiilor de baze de date care să permită agenţilor

de marketing să dezvolte şi să implementeze programe şi strategii de marketing adaptate

diverselor categorii de clienţi.

Primele abordări ale problemei le-a făcut Agrawal care a propus algoritmul AIS în

anul 1993 [AIS93]. În anul 1994, tot el a propus algoritmul APRIORI [AS94]. În anul

1995, apare algoritmul SETM propus de Houtsma şi Swami [HS95]. Însă algoritmul

APRIORI a avut cel mai mare impact, rămânând şi la ora actuală tehnica majoră utilizată

de producătorii comerciali pentru a detecta seturile frecvente de item-uri.

Găsirea acestor tipuri de reguli sunt folosite adesea atât în analizarea coşului de

cumpărături, cât şi pentru design-ul de cataloage, pentru aşezarea mărfurilor în rafturi,

pentru categorisirea clienţilor pe baza tiparelor de cumpărături pe care aceştia le fac, etc.

De obicei, aşa cum am mai arătat, bazele de date implicate în astfel de aplicaţii sunt

de dimensiuni foarte mari. Din acest motiv, este foarte importantă utilizarea unor algoritmi

cât mai rapizi pentru aceste aplicaţii.

59

Descoperirea regulilor frecvente de asociere dintr-o bază de date de dimensiuni

mari este o problemă complexă deoarece spaţiul de căutare creşte exponenţial cu numărul

de atribute din baza de date şi cu obiectele bazei de date. Cele mai recente abordări sunt de

natură iterativă necesitând scanări multiple ale bazei de date, ceea ce este foarte costisitor.

Cei mai importanţi algoritmi utilizaţi la această oră pe piaţă pentru descoperirea

regulilor de asociere sunt prezentaţi în continuare. La final am făcut şi un studiu

comparativ al acestora.

3.3.1. Definirea problemei

Formularea clasică a unei probleme de extragere de reguli de asociere este

următoarea:

Fie I = {I1, I2, .., Im} un set de articole, şi D = {t1, t2, ..., tn} o bază de date

tranzacţională, unde fiecare tranzacţie are un identificator unic (TID) şi conţine un set de

articole ti = {Ii1, Ii2, ..., Iik} şi Iij ∈ I:

O regulă de asociere este o implicare de forma X ⇒ Y unde X,Y ⊂ I sunt seturi

(mulţimi) de articole (itemi) numite articolset-uri (itemseturi) şi X ∩ Y = ∅.

Regula de asociere trebuie să aibă două măsuri: un suport (preponderenţă) minim

(s) şi o confidenţă (încredere) minimă (α). Aceste valori (s, α) sunt date ca şi parametri de

intrare.

Suportul indică frecvenţa de apariţie a unui tipar, de exemplu cât de des apar

articolele împreună. Măsura suport este calculată cu formulele:

)YX(P)YX(S ∪=⇒ (3.1.1.)

sau

tranzactiidetotalNumarul

YsiXpecontincaretranzactiideseturideNumarulSuportul ≅ (3.1.2.)

A doua măsură, confidenţa, indică puterea unei asocieri, de exemplu cât de mult un

anumit articol este dependent de altul (de exemplu, dacă produsul X este cumpărat de o

persoană, atunci în α% din cazuri este cumpărat şi produsul Y). Ea se calculează cu

formulele:

60

)X(P)YX(P)XY(P)YX( ∪==⇒α (3.1.3.)

sau

XpecontincaretranzactiideseturideNumarul

YsiXpecontincaretranzactiideseturideNumarulConfidenta ≅ (3.1.4.)

Problema descoperirii regulilor de asociere constă în generarea unor reguli care să

aibă un suport mai mare decât suportul minim s şi o confidenţă mai mare decât confidenţa

minimă α.

Abordarea este independentă de reprezentarea bazei de date D, care poate fi un

fişier cu date, o tabelă relaţională sau rezultatul unei interogări.

3.3.2. Algoritmul APRIORI

Algoritmul APRIORI este cel mai cunoscut algoritm pentru descoperirea regulilor

de asociere şi este folosit în cele mai multe produse comerciale. El a fost propus de

Agrawal şi Strikant în 1994 [AS94] pentru a extrage articolset-uri frecvente folosind

generarea candidaţilor. Algoritmul foloseşte proprietatea itemset-urilor frecvente:

Orice subset al unui articolset frecvent trebuie să fie la rândul său frecvent.

Algoritmul porneşte de la presupunerea că un articolset este format din două

câmpuri: unul care păstrează numărul de tranzacţii suportate de articolset-ul respectiv (un

contor) şi altul un set de articole.

În prima parte a algoritmului, se numără, pentru fiecare articol i ∈ L în câte

tranzacţii apare i. Dacă rezultatul depăşeşte suportul minim smin atunci acel articol devine

1-articolset (1 – itemset) frecvent (set de articole frecvente de lungime 1). Orice pas

ulterior, de exemplu pasul k, constă mai departe din două faze.

În figura 3.3-1. este prezentat algoritmul APRIORI în limbaj pseudocod.

61

Fig. 3.3-1. Algoritmul APRIORI

În prima fază, articolset-urile frecvente găsite la pasul (k -1) sunt folosite pentru

generarea articolset-urilor candidat Ck, folosind funcţia AprioriGen, descrisă în figura 3.3-

2.

În faza a doua se scanează baza de date D şi se calculează, pentru fiecare tranzacţie

t, care dintre candidaţi se găsesc în t. Dacă un candidat se găseşte în t, contorul său este

mărit cu 1. Pentru un calcul rapid, se determină într-un mod eficient candidaţii din Ck care

sunt conţinuţi într-o anumită tranzacţie t cu ajutorul funcţiei Subset prezentată în secţiunea

3.3.2.2.

3.3.2.1. Funcţia AprioriGen

Funcţia AprioriGen constă la rândul ei din două faze. Ea primeşte ca şi argument

Lk-1, setul tuturor (k-1) articolset-uri frecvente şi întoarce un superset al setului tuturor k-

articolset-urilor frecvente.

În prima fază, numită faza reuniune, se reuneşte Lk-1 cu el însuşi. Se presupune că

articolele unui articolset sunt sortate în ordine lexicografică. Această primă fază generează

mai multe articolset-uri decât este necesar.

În faza a două se şterg toate itemset-urile c ∈ Ck a căror oricare (k-1) subset nu se

regăseşte în Lk-1.

Intrare: baza de date de tranzacţii D şi suportul minim smin Ieşire: setul L care conţine toate itemset-urile frecvente ale lui D. Funcţia: (1) L1 = {1 – itemset frecvent}; (2) k ← 2; (3) while (Lk-1 ≠ 0) do begin (4) Ck = AprioriGen (Lk-1); // generare noi candidaţi (5) forall tranzacţii t ∈ D do begin (6) Ct ← Subset (Ck, t) ; // candidaţi în t (7) forall candidaţi c ∈ Ct do (8) c.count ++; (9) end; (10) Lk = {c ∈ Ck c.count ≥ smin }; (11) k ++; (12) end; (13) L = ∪kLk; // rezultat

62

Fig. 3.3-2. Funcţia AprioriGen

Exemplu:

Fie L3 = {{1 2 3}, {1 2 4}, {1 3 4}, {1 3 5}, {2 3 4}}. După prima fază de reuniune,

C4 = {{1 2 3 4}, {1 3 4 5}}. A doua fază, cea de curăţare, va şterge articolset-ul {1 3 4 5}

deoarece articolset-ul {1 4 5} nu este în L3. Aşadar, în C4 va rămâne doar {1 2 3 4}.

3.3.2.2. Funcţia Subset

Seturile de articole (itemi) candidat Ck sunt păstrate într-un arbore hash (hash-tree).

Un nod al acestui arbore conţine fie o listă de articolset-uri (un nod frunză), fie o tabelă

hash (un nod interior).

Într-un nod interior, fiecare intrare în tabelă pointează către un alt nod. Rădăcina

arborelui este definită a avea adâncimea 1. Un nod interior la adâncimea d pointează spre

noduri cu adâncime d+1.

Articolset-urile sunt stocate în noduri frunză. Când adăugăm un articolset c, pornim

de la rădăcină şi parcurgem în jos arborele până când atingem un nod frunză. La un nod

interior la adâncimea d, pentru alegerea ramurii de parcurs, se aplică o funcţie hash asupra

articolului d a articolset-ului.

Toate nodurile sunt create iniţial ca şi noduri frunză [AS94]. Când numărul de

articolset-uri dintr-un nod frunză depăşeşte un anumit prag specificat, nodul frunză

respectiv este convertit într-un nod interior.

Intrare: setul Lk - al tuturor (k-1) itemset-uri frecvente. Ieşire: superset-ul Ck al setului tuturor k-itemset-urilor frecvente. Funcţia: (1) function AprioriGen( Lk-1 : setul celor (k-1)-itemset-uri frecvente): setul

celor k-itemset-uri frecvente (2) // faza reuniune: (3) insert into Ck (4) select p.item1, p.item2, …, p.itemk-1, q.itemk-1

(5) from Lk-1p, Lk-1q (6) where p.item1 = q.item1, …, p.itemk-2 = q.itemk-2, p.itemk-1 < q.itemk-1; (7) // faza de curăţare: (8) forall itemset-urile c ∈ Ck do (9) forall (k-1) subset-uri s al lui c do

(10) if (s ∉ Lk-1) then (11) Ck ← Ck \ c; // şterge c din Ck (12) return Ck ; (13) end;

63

Începând de la nodul rădăcină, funcţia Subset găseşte toţi candidaţii conţinuţi într-o

anumită tranzacţie t după cum urmează.

Dacă suntem la un nod frunză, găsim care dintre articolset-uri din nodul frunză sunt

conţinute în t şi adăugăm referinţe la ele în setul de răspuns.

Dacă suntem la un nod interior la care am ajuns prin aplicarea funcţiei hash pe

articolul i, aplicăm funcţia hash pe fiecare articol care urmează după articolul i în

tranzacţia t şi în mod recursiv aplicăm această procedură nodului corespunzător. Pentru

nodul rădăcină aplicăm funcţia hash pe fiecare articol din t.

3.3.2.3. Avantaje şi dezavantaje ale algoritmului APRIORI

a) Avantaje

- utilizează proprietăţile articolset-urilor frecvente

- poate fi uşor paralelizat

- este uşor de implementat

b) Dezavantaje

- presupune că baza de date tranzacţională este încărcată în memorie

- necesită mai mult de m scanări ale bazei de date

3.3.3. Algoritmul SAMPLING (de eşantionare)

Pentru a facilita reducerea numărării articolset-urilor din bazele de date de

dimensiuni mari se foloseşte de obicei eşantionarea bazei de date. Algoritmul SAMPLING

original reduce numărul de parcurgeri ale bazei de date la una în cazul cel mai favorabil şi

la două în cazul cel mai nefavorabil [Dun03]. Eşantionul din baza de date este ales astfel

încât să poată fi încărcat în memorie. După aceasta, orice algoritm, cum ar fi Apriori, poate

fi utilizat la găsirea seturilor frecvente din eşantion. Acestea sunt văzute ca şi seturi de

articole potenţial frecvente (potentially large – PL) şi sunt utilizate ca şi seturi candidat

care sunt numărate folosind întreaga bază de date. În plus, seturile candidat sunt

determinate prin aplicarea unei funcţii de graniţă negativă (negative border function – BD-)

asupra setului de articole frecvente din eşantion. Setul total de candidaţi C este calculat cu

relaţia următoare: C = BD- (PL) ∪ PL. Funcţia de graniţă negativă este o generalizare a

64

algoritmului Apriori-Gen, descris în figura 3.3-2. Această funcţie este definită ca un set

minimal de seturi de articole care nu sunt în PL, dar ale căror subset-uri sunt toate în PL.

Pentru a ilustra această idee folosim următorul exemplu: Presupunem că setul de

articole este {A, B, C, D}. Setul de articole frecvente găsit în eşantionul din baza de date

este PL = {A, C, D, CD}. La primul pas scanăm întreaga bază de date, apoi generăm

seturile de candidaţi după cum urmează:

C = BD- (PL) ∪ PL = { B, AC, AD}∪ {A, C, D, CD}.

Se adaugă AC, deoarece atât A cât şi C sunt în PL. Din acelaşi motiv se adaugă AD.

În schimb, nu se poate adăuga ACD deoarece nici AC şi nici AD nu sunt în PL. În laticea

din figura 3.3-3 se observă că pot fi adăugate doar acele seturi în care toate subset-urile

sunt deja în PL.

Fig. 3.3-3. Graniţa negativă

Algoritmul SAMPLING este prezentat în limbaj pseudocod în figura 3.3-4. În acest

caz, se utilizează algoritmul APRIORI pentru a găsi seturile de articole frecvente dintr-un

eşantion, dar, în aceeaşi manieră, se poate utiliza orice algoritm pentru descoperirea de

seturi de articole frecvente.

Φ

A B C D

CD AC AD BC BD

ABC ABD ACD BCD

ABCD

AB

Φ

A B C D

CD AC AD BC BD

ABC ABD ACD BCD

ABCD

AB

(a) PL (b) PL ∪ BD- (PL)

65

Setul de articole frecvente este utilizat ca şi set de candidaţi pe durata scanării bazei

de date. Dacă un set de articole este frecvent într-un eşantion al bazei de date, atunci el este

privit ca şi potenţial frecvent în întreaga bază de date. Astfel, setul de articole frecvente

dintr-un eşantion este notat PL. Într-o încercare de a obţine toate seturile de articole

frecvente pe durata unei scanări a bazei de date, PL este expandat prin graniţa sa negativă.

Deci, setul total de candidaţi este C = PL ∪ BD- (PL).

Pe parcursul primei scanări a bazei de date toţi candidaţii din C sunt număraţi. Dacă

toţi candidaţii care sunt frecvenţi sunt în PL şi nici unul în BD- (PL), atunci toate seturile

de articole frecvente sunt găsite. În cazul în care câteva seturi de articole frecvente sunt pe

graniţa negativă, atunci este necesară o a doua scanare a bazei de date. Considerăm BD-

(PL) ca fiind o zonă tampon pe graniţa articolset-urilor frecvente.

Setul articolset-urilor este divizat în patru zone: cele care sunt frecvente, cele care

nu sunt frecvente, cele care sunt pe graniţa negativă a seturilor frecvente şi altele. Graniţa

negativă este o zonă tampon dintre cele frecvente şi altele. Ea reprezintă cel mai mic set

posibil de articolset-uri care ar putea fi potenţial frecvent. Datorită proprietăţilor seturilor

frecvente, ştim că dacă nu există în această zonă articolset-uri frecvente, atunci nu pot fi

nici în restul seturilor.

Cea de-a doua scanare a bazei de date, adaugă articolset-urile candidat care au fost

generate şi numărate. Acest lucru este făcut pentru a asigura că toate articolset-urile

frecvente sunt găsite. Notăm cu ML acele articolset-uri frecvente care lipsesc, adică cele

care sunt în L dar nu sunt în PL. Pentru a găsi toate articolset-urile rămase după cea de-a

doua scanare a bazei de date, algoritmul SAMPLING repetă aplicarea funcţiei de graniţă

negativă până când setul de candidaţi posibili nu mai creşte.

Se observă în figura 3.3-4, că în algoritmul SAMPLING, aplicarea algoritmului

APRIORI pe eşantionul de date este făcută utilizând un factor suport, notat cu small, mai

mic decât S. Utilizând un factor suport mai mic vom descoperi articolset-uri frecvente din

întreaga bază de date.

66

Fig. 3.3-4. Algoritmul SAMPLING

3.3.3.1. Exemplu de aplicare

Pentru a exemplifica aplicarea algoritmului SAMPLING, vom considera o bază de

date tranzacţională cu suportul s = 20%.Presupunem că eşantionul bazei de date sunt

primele două tranzacţii:

DS = {t1 = {Pâine, Gem, Unt}, t2 = {Pâine, Unt}}

Intrări: I // seturi de articole (itemi) D // baza de date de tranzacţii S // suportul Ieşiri: L // seturi de articole frecvente Algoritmul Sampling: (1) DS = eşantion din baza de date; (2) PL = Apriori ( I, DS; smalls); (3) C = PL ∪ BD- (PL); (4) L = ∅; (5) for each Ii ∈ C do (6) ci = 0; // contorul iniţial este 0 pentru fiecare itemset (7) for each tj ∈ D do // prima scanare a bazei de date (8) for each Ii ∈ C do

(9) if Ii ∈ tj then (10) ci = ci + 1; (11) for each Ii ∈ C do (12) if ci ≥ ( S x | D | ) then (13) L = L ∪ Ii; (14) ML = {x | x ∈ BD- (PL) ∧ x ∈ L}; // absenţa seturilor de articole frecvente (15) if ML ≠ ∅ then (16) C = L; //setează candidaţi ca şi seturi de articole frecvente (17) repeat (18) C = C ∪ BD- (C); // măreşte seturile de candidaţi (19) until nu mai sunt adăugate seturi de articole noi la C; (20) for each Ii ∈ C do (21) ci = 0; // contorul iniţial este 0 pentru fiecare itemset (22) for each tj ∈ D do // a doua scanare a bazei de date (23) for each Ii ∈ C do

(24) if Ii ∈ tj then (25) ci = ci + 1; (26) if ci ≥ ( S x | D | ) then (27) L = L ∪ Ii;

67

Dacă reducem suportul s astfel încât să fie smalls = 10%, atunci pentru ca un

articolset să fie frecvent în eşantion el trebuie să apară în cel puţin 0.1 x 2 tranzacţii.

Aşadar, el trebuie să apară în una sau două tranzacţii.

La aplicarea algoritmului APRIORI la DS vom obţine:

PL = {{Pâine}, {Gem}, {Unt}, {Pâine, Gem}, {Pâine , Unt}, {Gem, Unt},

{Pâine, Gem, Unt}}

La aplicarea graniţei negative vom obţine:

BD- (PL) = {{Bere}, {Lapte}}

Aşadar se vor folosi acest set de candidaţi pentru a număra pe parcursul primei

scanări:

PL = {{Pâine}, {Gem}, {Unt}, {Pâine, Gem}, {Pâine , Unt}, {Gem, Unt},

{Pâine, Gem, Unt},{Bere}, {Lapte}}

Amintim că pe parcursul acestei scanări am utilizat s = 20% şi l-am aplicat tuturor

celor cinci tranzacţii din întreaga bază de date. Aşadar, pentru ca un articolset să fie

frecvent, el trebuie să apară în cel puţin una sau în 20% x 5 tranzacţii. Aflăm astfel că atât

{Bere} cât şi {Lapte} sunt frecvente. Urmărind algoritmul mai întâi se consideră C = L,

care în acest caz este şi PL. Aplicând graniţa negativă vom obţine:

C = BD- (C) = {{Bere, Pâine}, {Bere, Unt}, {Bere, Lapte}, {Bere, Unt},

{Bere, Lapte}, {Gem, Lapte},{Lapte, Unt}, {Gem, Lapte}}

3.3.3.2. Avantaje şi dezavantaje ale algoritmului SAMPLING

a) Avantaje

- reduce numărul de scanări ale bazei de date la una în cel mai bun caz şi la două în

cel mai rău caz

- măsoară mai bine

b) Dezavantaje

- la a doua trecere există un număr mai mare de potenţiali candidaţi

68

3.3.4. Algoritmul PARTITIONING ( de partiţionare)

Diferite abordări ale generării articolset-urilor frecvente a fost propuse pe baza

partiţionării seturilor de tranzacţii.

Algoritmul PARTITIONING abordează problema generării seturilor de articole

frecvente bazându-se pe o partiţionare a setului de tranzacţii din baza de date [SON95].

Astfel, baza de date D este divizată în p partiţii: D1, D2, ..., Dp. Partiţionarea poate

îmbunătăţi performanţa găsirii seturilor de articole frecvente prin câteva metode:

� Prin luarea în considerare a proprietăţii unui articolset frecvent, ştim că un

articolset frecvent trebuie să fie frecvent în cel puţin una din partiţii. Această

idee poate ajuta ca algoritmul proiectat să fie mai eficient decât cei bazaţi pe

căutarea în întreaga bază de date.

� Algoritmul de partiţionare poate fi adaptat mai bine la limitările memoriei

principale. Fiecare partiţie poate fi creată astfel ca ea să se încarce în memorie.

În plus, se presupune că numărul de articolset-uri pe partiţie să fie mai mic

decât cele din întreaga bază de date.

� Prin utilizarea partiţionării pot fi uşor creaţi algoritmi paraleli şi/sau distribuiţi,

iar fiecare partiţie poate fi gestionată pe o maşină separată.

� Generarea incrementală a regulilor de asociere poate fi uşor făcută prin tratarea

stării curente a bazei de date ca şi o partiţie şi tratând noua stare a bazei de date

ca a doua partiţie.

Algoritmul PARTITIONING reduce numărul de scanări a bazei de date la două şi

împarte baza de date în partiţii astfel ca fiecare partiţie să poată fi încărcată în memorie.

La scanarea bazei de date, algoritmul aduce acea partiţie a bazei de date în memoria

principală şi numără numai articolele din acea partiţie.

La prima scanare a bazei de date, algoritmul găseşte toate articolele frecvente din

fiecare partiţie. Cu toate că, orice algoritm ar putea fi utilizat în acest scop, propunerea

originală presupune că se adoptă o abordare pe nivele, asemănătoare algoritmului

APRIORI. Aici Li reprezintă articolset-urile frecvente din partiţia Di.

69

Pe parcursul celei de-a doua scanări, numai acele articolset-uri care sunt frecvente

în cel puţin una din partiţii sunt folosite ca şi candidate şi sunt numărate pentru a determina

dacă ele sunt frecvente în întreaga bază de date.

Algoritmul PARTITIONING este prezentat în figura 3.3-5.

Fig. 3.3-5. Algoritmul PARTITIONING

3.3.4.1. Exemplu de aplicare

În figura următoare 3.3-6, este prezentat un exemplu de aplicare a algoritmului de

partiţionare aplicat pe o bază de date cu 5 tranzacţii:

t1 Pâine, Gem, Unt

D1 t2 Pâine, Unt

t3 Pâine, Lapte, Unt

t4 Bere, Pâine

D2

t5 Bere, Lapte

Fig. 3.3-6. Exemplu de aplicare a algoritmului PARTITIONING

Intrări: I // seturi de articole (itemi) D= {D1, D2, …, Dp} // baza de date divizată în p partiţii S // suportul Ieşiri: L // seturi de articole frecvente Algoritmul Partitioning:

(1) C = ∅; (2) for each i = 1 to p do //găseşte itemset-urile frecvente în fiecare partiţie

(3) Li = Apriori ( I, Di; s); (4) C = C ∪ Li; (5) L = ∅; (6) for each Ii ∈ C do (7) ci = 0; // contorul iniţial este 0 pentru fiecare itemset (8) for each tj ∈ D do // numără candidaţii la a doua scanare a bazei de date (9) for each Ii ∈ C do

(10) if Ii ∈ tj then (11) ci = ci + 1; (12) for each Ii ∈ C do (13) if ci ≥ ( S x | D | ) then (14) L = L ∪ Ii;

L1 = {{Pâine}, {Gem}, {Unt}, {Pâine, Gem}, {Pâine , Unt}, {Gem, Unt}, {Pâine, Gem, Unt}}

L2 = {{Bere}, {Pâine}, {Lapte}, {Unt}, {Bere, Pâine}, {Bere, Lapte}, {Pâine, Lapte}, {Pâine, Unt}, {Lapte, Unt}, {Pâine, Lapte, Unt} }

70

În acest exemplu, baza de date este divizată în două părţi, prima partiţie (D1)

conţine două tranzacţii (t1, t2) iar cea de-a doua (D2) trei tranzacţii (t3, t4, t5).

Utilizând un suport s = 10%, rezultă seturile de articolset-uri frecvente L1 şi L2.

Dacă articolele sunt uniform distribuite între partiţii, atunci o mare parte din

articole vor fi frecvente.

Dacă datele nu sunt uniform distribuite atunci poate exista un procentaj mare de

candidaţi falşi.

3.3.4.2. Avantaje şi dezavantaje ale algoritmului PARTITIONING

a) Avantaje

- se adaptează memoriei principale disponibile

- poate fi uşor paralelizat

- numărul maxim de scanări a bazei de date este 2

b) Dezavantaje

- poate avea o mulţime de candidaţi pe parcursul celei de-a doua scanări

3.4. Studiu comparativ de performanţă

În vederea evaluării performanţelor am implementat în Java 1.4 algoritmii:

APRIORI [AS94], PARTITIONING [SON95] şi SAMPLING [Dun03] şi am studiat

performanţele acestora pe diverse baze de date. Spre deosebire de raportările efectuate în

alte lucrări, unde s-au folosit baze de date binare, pentru o evaluare cât mai realistă am

optat pentru baze de date stocate pe servere SQL (Microsoft SQL 2000), accesul fiind

realizat prin interfeţele ODBC standard.

Studiul s-a efectuat în cadrul colectivului de cercetare al Catedrei de Calculatoare

din cadrul Universităţii din Oradea, fiind publicat în [Gyo03]. Calculatorul pe care am

realizat testele a fost un Pentium 4 la 1.7 GHz, cu 256 MBRAM sub sistemul Windows

2000.

Pentru studierea performanţelor algoritmilor şi pentru studierea scalabilităţii am

generat seturi de date de la 10 000 până la 500 000 de tranzacţii, şi am folosit factori

suport începând de la 5% până la 40%.

71

Modelul din lumea reală este acela că oamenii tind să cumpere diverse articole

împreună, care formează un set. Fiecare astfel de set este un potenţial articolset maximal

frecvent. O tranzacţie poate conţine mai mult decât un articolset frecvent. Tranzacţiile pot

avea un număr diferit de articole, de asemenea şi dimensiunea unui articolset frecvent

diferă. Unele articolset-uri pot avea mai puţine articole altele pot avea mai multe articole.

Având în vedere aceste observaţii vom genera seturi de date ţinând cont de numărul de

articole dintr-o tranzacţie, de numărul de articolset-uri frecvente, etc. Parametri necesari

pentru generarea setului de date de test sunt definiţi în tabelul Tabel 3.4-1:

|D| Numărul de tranzacţii

|T| Media aritmetică a dimensiunii unei tranzacţii

|L| Numărul maxim de articolset-uri frecvente

N Numărul de articole

Tabel 3.4-1. Parametri utilizaţi pentru generarea setului de date

Seturile de date de test sunt generate prin setarea numărului de articole la N = 100

şi a numărului maxim de articolset-uri frecvente la |L| = 3000. De asemenea se alege media

aritmetică a dimensiunii unei tranzacţii |T| = 10. Aceste tranzacţii generate imită

tranzacţiile din comerţul cu amănuntul a produselor.

Minsuport(%) Timp(secunde)

D1 = 40 000 tranzacţii

Apriori Partitioning Sampling

25 20.90 69.20 40.10

30 11.50 64.80 28.60

35 12.10 62.10 29.10

40 11.60 57.10 26.40

Tabel 3.4-2. Rezultate pentru baza de date D1 40K

Rezultatele din tabelul Tabel 3.4-2 arată că algoritmul APRIORI are performanţă

mult mai bună decât PARTITIONING şi SAMPLING pe o bază de date cu un număr relativ

mic de tranzacţii, (40 000 tranzacţii) pentru un suport mai mare de 25%.

72

0

10

20

30

40

50

60

70

80

25 30 35 40

Suport (%)

Tim

p (

s)


Fig. 3.4-1. Scalabilitatea raportată la suport pentru o baza de date D1 40K

Din figura 3.4-1 se observă că algoritmii APRIORI, PARTITIONING şi SAMPLING

au o valoare aproape constantă a timpului de execuţie pentru un factor suport mai mare de

30%, pe o bază de date cu un număr relativ mic de tranzacţii (D1= 40 000), dar

performanţa cea mai bună o are algoritmul APRIORI. Pentru un suport mai mic de 30% se

observă că timpul de execuţie al algoritmilor creşte semnificativ.

Rezultatele din tabelul Tabel 3.4-3. arată că algoritmul APRIORI are o performanţă

bună pe o bază de date relativ mare, 150 000 tranzacţii, numai pentru o valoare mare a

suportului (minsuport > 30%). Pentru o valoare mai mică sau egală cu 30% a suportului,

timpul de execuţie al APRIORI creşte semnificativ, în timp ce algoritmii PARTITIONING

şi SAMPLING au un timp de execuţie mai mic decât APRIORI pentru un suport mai mic de

30%. Deci, algoritmii SAMPLING şi PARTITIONING sunt mult mai performanţi pe o bază

de date mare şi pentru un factor suport mic (< 30%).

Minsuport(%) Timp(secunde)

D2= 150 000 Tranzacţii


25 870.50 583.90 478.40

30 875.00 565.20 477.30

35 440.00 550.30 476.80

40 441.60 542.10 463.60

Tabel 3.4-3. Rezultate pentru baza de date D2 150K

73

Figura Fig. 3.4-2. prezintă scalabilitatea algoritmilor raportată la număr de

tranzacţii, pentru un suport de 25%. Atât APRIORI, PARTITIONING cât şi SAMPLING

prezintă o scalabilitate liniară cu numărul de tranzacţii pe bază de date cu un număr mai

mare de 80 000 de tranzacţii. Dar algoritmul SAMPLING este mult mai scalabil decât

APRIORI, cu cât numărul de tranzacţii creşte diferenţa dintre APRIORI şi SAMPLING

devine din ce în ce mai mare.

0

200

400

600

800

1000

1200

1400

1600

40 50 80 110 150 190

Număr tranzacţii (în mii)

Tim

p (

s)


Fig. 3.4-2. Scalabilitatea raportată la număr de tranzacţii (25% suport)

În continuare am studiat comportarea algoritmului APRIORI pe baze de date cu un

număr variat de tranzacţii începând de la 10 000 până la 520 000 de tranzacţii şi pentru un

factor suport cuprins între 5% şi 40%, rezultatele fiind raportate în tabela Tabel 3.4-4. Se

observă ca algoritmul APRIORI are o performanţă slabă pentru un factor suport mic, de

exemplu mai mic de 10% chiar şi pentru o bază de date de dimensiuni mici (50 000

tranzacţii). Pentru o bază de date de dimensiuni mari şi cu un factor suport mare

performanţa este satisfăcătoare. Cu cât creştem dimensiunea bazei de date performanţa

algoritmului APRIORI scade chiar şi pentru un factor suport mare.

74

Timp

(Secunde) Suport(%)

Tranzacţii

(în mii) 5 10 15 20 25 30 35 40

10 13.94 10.46 8.58 6.92 6.12 6.16 6.14 4.38

20 21.98 15.90 13.05 11.10 11.00 10.00 9.48 8.38

30 48.37 30.07 25.80 21.57 19.57 18.17 14.27 12.07

40 66.50 40.10 29.60 20.90 20.90 11.50 12.10 11.60

50 107.65 63.40 45.85 31.05 31.30 25.55 17.60 17.05

80 198.30 117.00 83.50 81.80 54.90 56.00 29.60 29.70

110 1471.40 818.90 613.00 614.10 410.30 410.90 207.00 207.60

150 3097.20 2186.10 1308.90 1305.60 870.50 875.00 440.00 441.60

190 5320.60 3764.60 2264.60 2258.50 1501.70 1503.90 1498.90 755.80

300 9904.80 6557.60 4910.30 4908.10 3272.40 3275.80 1641.70 1637.90

400 17259.20 11421.20 8561.80 8547.00 5706.80 5708.90 2854.50 2851.70

520 20262.60 12095.10 12082.00 8053.80 8056.50 8065.20 4031.00 4032.70

Tabel 3.4-4. Rezultate APRIORI raportate la tranzacţii/suport.

Figura Fig. 3.4-3. prezintă scalabilitatea algoritmului APRIORI raportată la o bază

de date cu un număr variat de tranzacţii începând de la 10 000 până la 150 000, pentru un

factor suport cuprins între: 5% şi 40%.

0,00

500,00

1000,00

1500,00

2000,00

2500,00

3000,00

3500,00

5 10 15 20 25 30 35 40

Număr tranzacţii (în mii)

Tim

p (

s)

10 20 30 40 50 80 110 150

Fig. 3.4-3. Scalabilitatea APRIORI raportată la tranzacţii/suport.

75

În urma testelor efectuate a rezultat o performanţă bună a algoritmului APRIORI

atunci când este aplicat pe baze de date cu număr mare de tranzacţii dar pentru un factor

suport mare (>20%). Pentru baze de date mari şi suport mic (<5%) performanţa

algoritmului APRIORI scade dramatic, în timp ce algoritmii SAMPLING şi

PARTITIONING au o performanţă mai bună. De exemplu, pentru o bază de date cu un

număr de 150 000 de tranzacţii la un factor suport de 40% timpul de execuţie a fost de 442

secunde iar pentru un suport de 5% timpul a crescut până la 3098 secunde.

3.5. Concluzii

În urma studiilor de performanţă şi a rezultatelor experimentale obţinute au rezultat

următoarele concluzii:

Algoritmul APRIORI are performanţă slabă când se execută pe baze de date mari

care conţin un număr mare de articole pe tranzacţie. Această performanţă scăzută se

datorează faptului că dimensiunea unui articolset frecvent este mare. De exemplu pentru un

articol set frecvent de dimensiunea N > 4, algoritmul APRIORI necesită N parcurgeri ale

bazei de date pentru a descoperi acel articol, ceea ce este costisitor din punct de vedere al

timpului consumat.

Pe baze de date mari şi pentru un factor suport mare (> 20%) algoritmul APRIORI

are o performanţă mai bună decât algoritmii PARTITIONING şi SAMPLING, dar pentru un

factor suport mic (< 5%) performanţa algoritmului APRIORI scade dramatic.

Algoritmul SAMPLING eşantionează baza de date, caută apoi seturile de articole

frecvente într-un eşantion, reducând numărul de scanări ale bazei de date la una în cel mai

bun caz şi la două în cel mai rău caz.

Algoritmul PARTITIONING reduce numărul de scanări ale bazei de date la două şi

împarte baza de date în partiţii astfel ca fiecare partiţie să poată fi încărcată în memorie. În

timpul celei de-a doua scanări, numai acele articolset-uri care sunt frecvente în cel puţin

una din partiţii sunt folosite ca şi candidate şi sunt numărate pentru a determina dacă ele

sunt frecvente în întreaga baza de date, reducând astfel setul de candidaţi, iar timpul de

execuţie fiind mai mic decât a algoritmului APRIORI.

Algoritmii SAMPLING şi PARTITIONING reduc numărul de scanări ale bazei de

date la două şi au o performanţă mai bună decât APRIORI atunci când sunt aplicaţi pe baze

de date mari şi pentru un factor suport mic (< 5%).

76


FOLOSIND EXTRAGEREA TIPARELOR

FRECVENTE

4.1. Introducere

Extragerea tiparelor frecvente din bazele de date tranzacţionale, şi multe alte tipuri

de baze de date, este un domeniu larg studiat de cercetătorii data mining deoarece aceasta

joacă un rol important în extragerea regulilor de asociere [HPY00] şi a multor altor

activităţi importante din domeniul extragerii datelor.

Problema se pune astfel :

Fie o mulţime de articole I = {i1, ..., in}, o bază de date D = {t1, ..., tn}, unde ti (i ∈

[1, N]) este o tranzacţie şi ti ⊆ I. Fiecare subset al lui I se numeşte articolset (itemset). Dacă

un articolset conţine k articole (itemi), el se numeşte k-articolset (k-itemset). Suportul unui

articolset l este definit ca fiind procentul de tranzacţii ale bazei de date D care conţin

articolset-ul l (suport(l) = {tt∈ D ∧ l ⊆ t} / D). Dacă suportul unui articolset depăşeşte un

prag specificat anterior al suportului minim, atunci articolset-ul este denumit articolset

(itemset) frecvent sau tipar frecvent.

Scopul problemei de extragere a tiparelor frecvente este de a găsi toate tiparele

frecvente într-o bază de date tranzacţională dată cu un prag al suportului minim dat.

Seturile de date obţinute făcând aceasta în anumite domenii (ex. biologic) pot fi

foarte mari şi pot conţine tipare foarte lungi, ceea ce duce la un număr enorm de tipare.

Motivul este acela că fiind dat un set frecvent k- articolset, toate subseturile sale sunt

frecvente, numărul lor fiind 2k-1. Orice algoritm care generează setul complet de tipare

frecvente prezintă dezavantajul că generează o mulţime de tipare scurte, în majoritate

nefolositoare pentru utilizatori.

Ţelurile principale ale procesului de extragere a tiparelor frecvente sunt:

77

a) Reducerea timpului de parcurgere a bazelor de date, ştiind că majoritatea

acestora sunt prea mari pentru a încape în memoria principală iar citirea lor

de pe disc este foarte costisitoare

b) Reducerea spaţiului de căutate, ştiind că fiecare subset a lui I poate fi

frecvent, iar numărul acestora creşte exponenţial cu numărul de itemset-uri

din I

c) Calcularea eficientă a suportului, parcurgerea tuturor subset-urilor este

destul de costisitor ţinând cont de dimensiunea mare a bazelor de date şi de

numărul mare de itemset-uri posibil frecvente.

În ultimii ani au fost dezvoltaţi mai mulţi algoritmi destul de eficienţi pentru

extragerea tiparelor frecvente. Cei mai mulţi dintre aceştia au curăţat spaţiul de căutare

având la bază proprietatea APRIORI [AS94]: dacă un articolset nu este frecvent, nici unul

dintre superset-urile sale nu poate fi frecvent. Multe dintre studiile anterioare, prezentate în

[AS95], [PCY95], [PHM00], au adoptat o tehnică bazată pe algoritmul APRIORI.

Au fost propuse două abordări: generarea şi testarea candidaţilor şi creşterea

tiparelor. Ultima s-a dovedit a fi mult superioară celei dintâi, mai ales în cazul seturilor de

date mari. Ambele abordări au fost implementate într-o manieră iterativă.

Prima, generează toate seturile de dimensiune 1 (1-itemsets). La fiecare pas al

iteraţiei se formează perechi de k-itemset-uri pentru a forma seturi de dimensiune k+1

((k+1)-itemset-uri). Apoi este parcursă baza de date pentru a verifica suportul candidatului

(k+1)-itemset iar setul frecvent rezultat (k+1)-itemset va fi folosit ca şi intrare pentru

următoarea iteraţie.

Spre deosebire de această abordare, a doua, creşterea tiparului evită generarea şi

testarea candidaţilor crescând articolset-ul frecvent folosind prefix-ul său. Se construieşte o

bază de date condiţională pentru fiecare itemset frecvent l, notată Dl. Toate tiparele care au

prefixul l pot fi examinate folosind Dl fără a accesa alte informaţii.

Ideea esenţială a acestuia este de a genera iterativ un set de tipare candidat de

lungime (k+1) dintr-un set de tipare frecvente de lungime k (pentru k ≥ 1) şi verificarea

apoi a frecvenţei de apariţie a acestora în baza de date. Această metodă este bazată pe o

„euristică APRIORI anti-monotonă” [AS94] formulată astfel: Dacă orice tipar de

lungime k nu este frecvent în baza de date, atunci super-tiparul său de lungime

(k+1) nu poate fi niciodată frecvent.

78

Performanţele atinse de „euristica APRIORI” sunt destul de bune datorită reducerii

semnificative a dimensiunii seturilor de candidaţi. Cu toate acestea, în cazul în care există

multe tipare frecvente, tipare lungi sau praguri de suport minim foarte joase, algoritmii

bazaţi pe APRIORI pot întâmpina două situaţii costisitoare:

o Manipularea unui număr mare de seturi de candidaţi este foarte costisitoare.

Astfel, dacă există 104 seturi de articole frecvente de lungime 1, (1- articolset-

uri), algoritmul APRIORI va trebui să genereze mai mult de 107 candidaţi de

lungime 2 şi să acumuleze şi să verifice frecvenţele de apariţie ale acestora. Mai

mult, pentru a extrage un tipar frecvent de lungime 100, cum ar fi (a1, a2, ...,

a100), trebuie să genereze în total mai mult de 2100 ≈ 103 candidaţi.

o Scanarea repetată a bazei de date este destul de greoaie, ca şi verificarea unui

număr mare de candidaţi prin potrivire de tipare, în special pentru extragerea

tiparelor lungi (pentru un tipar de lungime n este necesară scanarea de n+1 ori a

bazei de date).

După o examinare atentă, s-a ajuns la concluzia că principalele probleme ale

metodei APRIORI apar la generarea setului de candidaţi şi la testarea acestuia. Astfel,

evitând generarea unui set mare de tipare candidat, s-ar putea îmbunătăţi substanţial

performanţa acestei metode. Această problemă a fost abordată de către Han [HPY00] prin

trei aspecte.

În primul rând este creată o structură nouă de date, numită arbore de tipare

frecvente – frequent pattern tree, pe scurt FP-Tree, care este o structură de arbore-prefix

extinsă, conţinând informaţii cruciale, cantitative despre tiparele frecvente. Pentru asigura

structura compactă a arborelui, vor exista noduri doar pentru articolele frecvente de

lungime 1, nodurile fiind aranjate astfel încât nodurile cu apariţii mai frecvente vor avea o

probabilitate mai ridicată în a partaja noduri decât cele mai puţin frecvente.

În al doilea rând, este dezvoltată o metodă de creştere a unui fragment de tipar,

bazat pe FP-Tree, care porneşte de la un tipar frecvent de lungime 1 (ca şi un tipar sufix

iniţial), examinează doar baza sa condiţională de tipare (o sub-bază de date care constă din

setul de articole frecvente care apar împreună cu tiparul sufix), construieşte FP-Tree-ul său

condiţional şi efectuează extragerea în mod recursiv pe acesta. Creşterea tiparului este

realizată prin concatenarea tiparului sufix cu noile tipare generate din FP-Tree-ul

79

condiţional. Deoarece setul de articole frecvente din oricare tranzacţie este întotdeauna

codat în calea corespunzătoare arborilor FP, creşterea tiparelor asigură complexitatea

rezultatului. În acest context, metoda nu este gen APRIORI, adică nu se realizează o

generare şi verificare restricţionată ci doar o verificare restricţionată. Operaţiile importante

ale extragerii sunt acumularea de frecvenţe şi ajustarea contoarelor pe căile prefix, care

sunt în general mult mai economice decât operaţiile de generare de candidaţi şi cele de

potrivire de tipare efectuate în majoritatea algoritmilor de tip APRIORI.

În al treilea rând, tehnica de căutare folosită în extragere este bazată pe

partiţionare, o metodă mai degrabă tip divide şi cucereşte („divide et impera”) decât tip

APRIORI, generare de jos în sus a combinaţiilor de seturi de articole frecvente. Aceasta

reduce în mod drastic dimensiunea bazei de date condiţionale generate la fiecare nivel de

căutare ca şi de altfel dimensiunea arborelui condiţional corespunzător. Mai mult,

transformă problema găsirii unor tipare frecvente lungi, în căutarea unora mai scurte şi

apoi a concatenării sufixurilor. Se folosesc cele mai puţin frecvente articole ca şi sufixuri,

ceea ce oferă o selectivitate bună. Toate aceste tehnici contribuie la reducerea substanţială

a costurilor de căutare.

4.2. Proiectarea şi construirea arborelui tiparelor frecvente (FP-

Tree)

4.2.1. Definirea problemei

Fie I = {i1, i2, …, im} un set de articole (itemi), şi D = {T1, T2, ..., Tn} o bază de date

tranzacţională, unde Ti (i ∈ [1..n]) este o tranzacţie care conţine un set de articole din I.

Suportul (sau frecvenţa de apariţie) a unui tipar A, care este un set de articole, se defineşte

ca fiind numărul de tranzacţii din baza de date D care îl conţine pe A. A este un tipar

frecvent dacă suportul său nu este mai mic decât un prag suport minim predefinit – minsup.

Fiind dată o bază de date tranzacţională D şi un prag suport minim, problema

găsirii setului complet de tipare frecvente este denumită problema extragerii tiparelor

frecvente.

80

Cercetătorii au căutat soluţii eficiente pentru rezolvarea acestei probleme. Astfel, au

fost propuse diverse metode în [AS94], [AS95], [SON95], [HPY00], [HP00].

Dintre acestea, prezentăm algoritmul propus de J. Han, J. Pei şi Y. Yin în [HPY00],

numit algoritmul FP-Growth care foloseşte pentru construirea arborelui tiparelor frecvente

o structură de date de tip arbore numită FP-Tree.

Pentru a proiecta o structură de date compactă pentru extragerea eficientă a

tiparelor frecvente vom analiza un exemplu.

Exemplul 1: Fie o bază de date D, reprezentată de primele două coloane din tabelul 4.2-1.

Se consideră pragul suportului minim egal cu 3.

TID Articole cumpărate Articole frecvente (ordonate)

100 f, a ,c ,d ,g ,i ,m ,p f, c, a, m, p

200 a, b, c, f, l, m, o f, c, a, b, m

300 b, f, h, j, o f, b

400 b, c, k, s, p c, b, p

500 a, f, c, e, l, p, m, n f, c, a, m, p

Tabel 4.2-1. Baza de date D cu tranzacţii

La proiectarea unei structuri compacte se ţine cont de următoarele observaţii:

1. Datorită faptului că articolele frecvente vor juca un rol în extragerea tiparelor

frecvente, este necesar să se efectueze o scanare a bazei de date D pentru

identificarea setului de articole frecvente.

2. Dacă se stochează setul de articole frecvente ale fiecărei tranzacţii într-o structură

compactă, se poate evita scanarea repetată a bazei de date D.

3. În cazul în care mai multe tranzacţii au în comun un set de articole frecvente, acestea

ar putea fi reunite într-un singur set, cu numărul de apariţii înregistrate într-o singură

variabilă count. Este uşor de verificat dacă două seturi sunt identice dacă articolele

frecvente în toate tranzacţiile sunt sortate după o anumită ordine dată.

81

4. Dacă două tranzacţii au în comun un anumit prefix, corespunzător unei ordonări a

seturilor frecvente, părţile comune pot fi reunite folosind o structură prefix atât timp

cât numărul de apariţii count este înregistrat în mod corect. Dacă articolele frecvente

sunt sortate descendent după frecvenţa lor de apariţie, există şanse mai mari ca să

avem mai multe şiruri prefix în comun.

4.2.2. Construirea arborelui FP-Tree

Ţinând cont de aceste observaţii se poate construi arborele tiparelor frecvente după

cum urmează.

a) În primul rând, derivăm lista articolelor frecvente printr-o scanare a bazei de date D,

⟨(f:4), (c:4), (a:3), (b:3), (m:3), (p:3)⟩, (numărul ce apare după: reprezintă suportul), în

care articolele sunt ordonate în ordine descrescătoare a frecvenţei lor de apariţie.

Această ordonare este importantă deoarece fiecare cale din arbore va urma această

ordonare. Pentru o mai uşoară înţelegere a algoritmului, în tabelul 4.2-1, coloana din

dreapta arată această ordonare pentru fiecare tranzacţie.

b) În al doilea rând, se creează rădăcina arborelui, etichetată „root”, după care se scanează

baza de date a doua oară.

Scanarea primei tranzacţii duce la construcţia primei căi prin arbore: ⟨(f:1), (c:1), (a:1),

(m:1), (p:1)⟩. Se observă că articolele frecvente din tranzacţie sunt ordonate ţinând cont

de ordinea din lista articolelor frecvente.

Pentru a doua tranzacţie, deoarece lista corespunzătoare de articole frecvente (în

ordinea respectivă) ⟨f, c, a, b, m⟩ partajează un prefix comun ⟨f, c, a⟩ cu calea deja

existentă ⟨f, c, a, m, p⟩, contorul fiecărui nod de-a lungul prefixului este incrementat cu

1. Este creat un nou nod (b:1) şi legat ca şi fiu al nodului (a:2). Apoi este creat din nou

un nod nou (m:1) care este legat ca şi fiu al nodului (b:1).

Pentru a treia tranzacţie, deoarece lista sa de articole frecvente ⟨f, b⟩ partajează doar cu

nodul ⟨f⟩ cu subarborele de prefix f, contorul lui f este incrementat cu 1 şi este creat un

nou nod (b:1) care este legat cu nodul (f:3) ca şi fiu al acestuia.

82

Scanarea celei de a patra tranzacţii conduce la crearea celei de a doua ramuri ⟨(c:1),

(b:1), (p:1)⟩.

Pentru ultima tranzacţie, deoarece lista sa de articole frecvente ⟨f, c, a, m, p⟩ este

identică cu prima, calea este partajată şi contorul fiecărui nod de-a lungul căii este

incrementat cu 1.

Pentru a facilita traversarea arborelui, se construieşte un tabel antet al articolelor, în

care fiecare intrare arată spre apariţia acestuia în arbore printr-un pointer la un nod al

arborelui (cap de listă). Nodurile cu acelaşi articol sunt înlănţuite prin astfel de pointeri.

Arborele rezultat după scanarea tuturor tranzacţiilor este prezentat în figura 4.2-1. Acest

exemplu conduce la proiectarea şi construcţia arborelui tiparelor frecvente.

Fig. 4.2-1. Construirea arborelui FP-Tree pentru Exemplul 1

Un arbore de tipare frecvente (FP-Tree) este un arbore cu structura definită astfel:

1. Arborele are un nod rădăcină etichetat „root”, un set de subarbori prefix de articole

ca şi fii ai rădăcinii şi o tabelă antet pentru articolele frecvente.

2. fiecare nod din subarborele prefix de articole constă din trei câmpuri: nume-articol,

contor şi înlănţuire-nod, unde:

a. nume-articol se referă la articolul pe care acest nod îl reprezintă,

b. contor înregistrează numărul de tranzacţii reprezentate de porţiunea căii

care ajunge la acel nod,

Articol Cap listă

f

c

a

b

m

p

Tabela antet

f : 4

c : 3

a : 3

m : 2

p : 2

root

b : 1

b : 1

m : 1

c : 1

b : 1

p : 1

83

c. înlănţuire-nod face legătura la următorul nod din FP-Tree care se referă la

acelaşi articol sau conţine NULL dacă nu mai există un alt astfel de nod

3. Fiecare intrare în tabela antet pentru articole frecvente constă din două câmpuri (1)

nume-articol şi (2) capul listei care pointează spre primul nod din FP-Tree care se

referă la nume-articol.

Pe baza acestei definiţii, a fost propus, în [HPY00], algoritmul de construcţie a

arborelui FP-Tree prezentat în figura 4.2-2.

Fig. 4.2-2. Algoritmul de construire a arborelui FP-Tree

Analizând procesul de construire a arborelui FP-Tree se poate observa că sunt

necesare exact două scanări complete a bazei de date D. Prima scanare colectează

articolele frecvente, iar a doua scanare construieşte arborele FP-Tree. Costul inserării unei

tranzacţii Trans în arbore este O(Trans), unde Trans este numărul de articole frecvente

din Trans.

Intrare: Baza de date tranzacţională D şi suportul minim s; Ieşire: Arborele tiparelor frecvente corespunzător (FP-Tree); Metoda: Arborele FP-Tree este construit în următorii paşi:

1. Se scanează baza de date D. Se colectează setul de articole frecvente F şi suportul corespunzător acestora. Se sortează F în ordinea descrescătoare a suportului în lista articolelor frecvente L

2. Se creează nodul rădăcină al arborelui FP-Tree, T, şi se etichetează cu „root”. Pentru fiecare tranzacţie Trans din D se efectuează următoarele operaţii:

a. Se selectează şi se ordonează articolele din Trans conform ordonării lui L, adică în ordine descrescătoare a suportului.

b. Fie lista articolelor frecvente din Trans [pP], unde p este primul element iar P este restul listei.

c. Se apelează funcţia insert_tree ([pP], T). Funcţia insert_tree se execută astfel: dacă T are un fiu N, astfel încât N.nume-articol = p.nume-articol, atunci se incrementează contorul lui N cu 1; altfel se creează un nou nod, cu contorul iniţializat pe 1, părintele T şi înlănţuire-nod va fi înlănţuit cu nodurile având acelaşi nume-articol. Dacă P nu este goală, se apelează în mod recursiv insert_tree(P, T).

84

Din procesul de construcţie a arborelui FP-Tree se pot sublinia câteva proprietăţi

importante.

Lema 4.1. Fiind dată o bază de date tranzacţională D şi un suport minim s,

arborele FP-Tree corespunzător conţine informaţia completă din D care este relevantă

pentru extragerea tiparelor frecvente.

Raţionament: Pe baza procesului de construcţie a arborelui FP-Tree, fiecare

tranzacţie din D este mapată pe o cale din arbore, iar informaţia despre tiparele frecvente

din fiecare tranzacţie este stocată complet în arbore. Mai mult, o cale din FP-Tree poate

reprezenta tipare frecvente din mai multe tranzacţii fără nici o ambiguitate, deoarece calea

ce reprezintă fiecare tranzacţie trebuie să pornească de la nodul rădăcină a fiecărui

subarbore prefix. Astfel, rezultă lema de mai sus.

Lema 4.2. Fără a se considera rădăcina, dimensiunea unui FP-Tree este limitată

de numărul total de apariţii ale tiparelor frecvente în baza de date, iar înălţimea arborelui

este limitată la numărul maxim de articole frecvente din orice tranzacţie din baza de date.

Raţionament: Pe baza procesului de construcţie a arborelui FP-Tree, pentru orice

tranzacţie T din D, există o cale în arbore care începe de la subarborele prefix

corespunzător astfel încât setul nodurilor din cale este exact acelaşi ca şi setul articolelor

frecvente din T. Deoarece nici un articol frecvent din nici o tranzacţie nu poate crea mai

mult de un singur nod în arbore, rădăcina fiind singurul nod necreat de o inserţie de articol

frecvent, şi fiecare nod conţine o legătură şi un contor, de aici avem limita asupra

dimensiunii arborelui aşa cum a fost afirmat în lemă. Înălţimea oricărui subarbore p-prefix

este numărul maxim de articole frecvente. Astfel, înălţimea unui arbore este limitată de

numărul maxim de articole frecvente din oricare tranzacţie in baza de date, asta cu condiţia

să nu considerăm nivelul suplimentar adăugat de rădăcină.

Lema 4.2, arată unul din beneficiile importante aduse de FP-Tree: dimensiunea

unui arbore FP-Tree este limitată de dimensiunea bazei de date corespunzătoare deoarece

fiecare tranzacţie va contribui cu cel mult o cale la arborele FP-Tree, cu lungimea egală cu

numărul de articole frecvente din acea tranzacţie.

85

Deoarece există de multe ori mai multe partajări ale articolelor frecvente între

tranzacţii, dimensiunea arborelui este de cele mai multe ori mult mai mică decât aceea a

bazei de date originale.

Spre deosebire de metodele de tip APRIORI, care pot genera un număr exponenţial

de candidaţi în cel mai rău caz, în nici un caz, nu va fi generat un arbore FP-Tree cu un

număr exponenţial de noduri.

FP-Tree este o structură foarte compactă, care stochează informaţia pentru

extragerea tiparelor frecvente. Deoarece o cale „a1 → a2 → ... → ak” pentru orice 1≤ k ≤ n,

dimensiunea arborelui FP-Tree este substanţial mai mică decât dimensiunea bazei de date

şi decât dimensiunea setului de candidaţi generaţi pe parcursul extragerii regulilor de

asociere.

Articolele din setul frecvent de articole sunt ordonate descrescător în funcţie de

suportul lor. Articolele care apar mai frecvent sunt aranjate mai aproape de vârful arborelui

FP-Tree şi astfel au o probabilitate mai mare de a fi partajate. Aceasta indică faptul că

structura FP-Tree este în general foarte compactă. Experimentele arată, de asemenea, că

rezultă un arbore FP-Tree destul de mic prin comprimarea unei baze de date destul de

mari.

4.3. Metoda FP-Growth de extragere a tiparelor frecvente

folosind arborele FP-Tree

Metoda numită FP-Growth (Frequent Pattern Growth) propusă de J. Han, J. Pei

şi Y. Yin în [HPY00], extrage tipare frecvente fără a genera candidaţi. Metoda adoptă

tehnica „divide et impera” pentru proiectarea şi partiţionarea bazei de date pe baza

tiparelor frecvente descoperite şi creşte aceste tipare la dimensiunea bazei de date

proiectate. Mai mult, au fost dezvoltate structuri de date eficiente pentru o comprimare

efectivă a bazei de date şi o traversare rapidă în memorie. O astfel de metodologie poate

elimina sau reduce substanţial numărul de seturi de candidaţi care sunt generate şi poate

reduce de asemenea numărul de examinări iterative ale bazei de date, conducând astfel la o

performanţă mult mai bună.

Metoda FP-Growth este folosită pentru baze de date de dimensiuni mari şi

utilizează structura de date compactă, de tip arbore FP-Tree, pentru a reprezenta datele în

86

memoria calculatorului. Operaţia principală de extragere a tiparelor frecvente din baza de

date se va reduce, în acest caz, la parcurgerea acestui arbore şi extragerea tiparelor

frecvente din această structură compactă.

Aşadar, metoda realizează creşterea numărului tiparelor frecvente datorită a doi

factori: este necesar să examinăm doar o parte a bazei de date şi datele pot fi organizate în

structuri compacte care facilitează creşterea numărului de tipare frecvente controlat.

Construcţia unui arbore FP-Tree compact asigură faptul că extragerile ulterioare

pot fi efectuate folosind o structură destul de compactă. Cu toate acestea, nu este garantat

în mod automat faptul că procesul va fi foarte eficient, deoarece putem totuşi întâlni

problema combinatorică a generării candidaţilor dacă folosim această structură pentru

generarea şi verificarea tuturor tiparelor candidat.

În continuare se prezintă modul de explorare a informaţiilor compacte stocate în

arborele FP-Tree şi o metodă eficientă de extragere a setului complet de tipare frecvente.

Structura FP-Tree are câteva proprietăţi interesante care facilitează extragerea

tiparelor frecvente:

Proprietatea 4.1. (Proprietatea legăturii nodului) Pentru orice articol frecvent ai,

toate tiparele frecvente posibile care îl conţin pe ai pot fi obţinute prin urmărirea

legăturilor nodurilor care conţin pe ai, începând de la intrarea corespunzătoare ai din

tabela antet.

Această proprietate se bazează direct pe procesul de construcţie al arborelui FP-

Tree. Acesta facilitează accesul tuturor informaţiilor tiparelor legate de ai , prin traversarea

arborelui FP-tree, urmărind legăturile nodurilor ai.

Exemplul 2. Pentru exemplificare, vom examina procesul de extragere a tiparelor

frecvente bazat pe arborele FP-Tree construit în fig. 4.2-1, pentru exemplul 1. Pe baza

proprietăţii 4.1, se colectează toate tiparele la care participă un anumit nod ai, începând de

la capul listei lui ai (din tabela antet) şi se urmează legăturile nodurilor ai. Procesul de

extragere este examinat pornind de la începutul tabelei antet.

Pentru nodul p, se derivează un tipar frecvent (p:3) şi două căi în FP-Tree: ⟨f:4, c:3,

a:3, m:2, p:2⟩ şi ⟨c:1, b:1, p:1⟩. Prima cale indică faptul că şirul ⟨f, c, a, m, p⟩ apare de două

ori în baza de date. De notat că, deşi şirul ⟨f, c, a⟩ apare de trei ori şi ⟨f⟩ chiar de patru ori,

87

acestea apar împreună doar de două ori cu p. Astfel, pentru a vedea care şiruri apar

împreună cu p, contează doar calea prefix a lui p şi anume ⟨f:2, c:2, a:2, m:2⟩.

În mod similar, cea de-a doua cale indică şirul ⟨c, b, p⟩ care apare o singură dată în

tranzacţiile din D, respectiv calea prefix a lui p este ⟨c:1, b:1⟩. Aceste două căi prefix ale p,

{⟨f:2, c:2, a:2, m:2⟩} şi {⟨c:1, b:1⟩} formează baza de sub-tipare ale lui p, care se numeşte

baza condiţională de tipare ale lui p (cu condiţia ca p să existe).

Construcţia unui arbore FP-Tree pe această bază condiţională de tipare (numită FP-

Tree condiţional) conduce la o singură ramură (c:3). De aici este derivat doar un singur

tipar frecvent (cp:3). Un tipar este un set de articole (itemset) şi aici este notat ca un şir. În

acest moment se termină căutarea de tipare frecvente asociate cu p.

Pentru nodul m, se derivează tiparul frecvent (m:3) şi două căi ⟨f:4, c:3, a:3, m:2⟩ şi

⟨f:4, c:3, a:3, b:1, m:1⟩. Se observă că p apare împreună cu m, dar cu toate acestea nu este

nevoie să îl includem pe p în analiză deoarece oricare dintre tiparele frecvente care îl

conţin pe p au fost deja analizate în etapa precedentă de analiză a lui p. În mod similar

analizei de mai sus, baza condiţională de tipare a lui m este {⟨f:2, c:2, a:2⟩, ⟨f:2, c:1, a:1,

b:1⟩}. Construind un arbore FP-Tree asupra acestei baze condiţionale, se derivează

arborele FP-Tree condiţional al lui m, ⟨f:3, c:3, a:3⟩, o singură cale de tipare. După aceea

se apelează în mod recursiv funcţia de explorare bazată pe FP-Tree, astfel mine(⟨f:3, c:3,

a:3⟩m).

În figura 4.3-1.(b), este prezentată construirea bazei condiţionale de tipare şi a

arborelui condiţional pentru m, pornind de la exemplul 1 a cărui arbore FP-Tree global a

fost prezentat în figura 4.3-1 şi reprezentat în figura 4.3-1.(a). Apelarea funcţiei mine(⟨f:3,

c:3, a:3⟩m) implică explorarea a trei articole în secvenţă.

Primul, reprezentat în figura 5.3-1.(c), produce un tipar frecvent (am:3) şi un apel

al funcţiei mine(⟨f:3, c:3⟩am).

Al doilea, reprezentat în figura 4.3-1.(d), produce un tipar frecvent (cm:3) şi un

apel al funcţiei mine(⟨f:3⟩cm).

Al treilea, reprezentat în figura 4.3-1.(e), produce doar un singur tipar frecvent

(fm:3). Mai departe, apelul recursiv al funcţiei mine(⟨f:3, c:3⟩am) produce:

I. Tiparul frecvent (cam:3)

II. Un apel recursiv al funcţiei mine(⟨f:3⟩am) care produce tiparul frecvent (fam:3)

88

III. Un alt apel recursiv al funcţiei mine(⟨f:3⟩cam) care produce tiparul frecvent

(fcam:3).

(a) FP-Tree global (b) FP-Tree condiţional a lui m

(c) FP-Tree condiţional (d) FP-Tree condiţional (e) FP-Tree condiţional

a lui am a lui cm a lui cam

Fig. 4.3-1. Arborele FP-Tree condiţional construit pentru m

În mod similar, apelul recursiv al funcţiei mine(⟨f:3⟩cm) va produce tiparul

frecvent (fcm:3). Astfel, întregul set de tipare frecvente implicând m este {(m:3), (am:3),

(cm:3), (fm:3), (cam:3), (fam:3), (fcam:3), (fcm:3)}.

f : 4

c : 3

a : 3

m : 2

p : 2

root

b : 1

b : 1

m : 1

c : 1

b : 1

p : 1

Baza condiţională de tipare a lui m: (f:2, c:2, a:2) (f:1, c:1, a:1, b:1)

Baza condiţională de

tipare a lui cm: (f:3)

root

f : 3


tipare a lui am: (f:3, c:3)

root

f : 3

c : 3


tipare a lui cam: (f:3)

root

f : 3

Articol Cap listă

f

c

a

Tabela antet

c : 3

a : 3

root

89

Aceasta indică faptul că un arbore FP-Tree cu o singură cale poate fi explorat prin

producerea tuturor combinaţiilor de articole din cale.

Dacă se procedează la fel pentru nodul b, se derivă (b:3) şi trei căi {⟨f:4, c:3, a:3,

b:1⟩, ⟨f:4, b:1⟩ şi ⟨c:1, b:1⟩}. Deoarece baza condiţională de tipare frecvente a lui b este:

{⟨f:1, c:1, a:1⟩, ⟨f:1, c:1⟩}, ea nu generează nici un articol frecvent, aşadar explorarea se

termină.

Nodul a produce doar un singur tipar frecvent {(a:3)} şi o bază de sub-tipare, {(f:3,

c:3)}, deci un FP-Tree condiţional cu o singură cale. Astfel, setul său de tipare frecvente

poate fi generat prin generarea combinaţiilor lor. Concatenându-le cu (a:3), rezultă { (fa:3),

(ca:3), (fca:3)}.

Nodul c produce (c:4) şi o bază de sub-tipare {(f:3)}, aşadar setul de tipare

frecvente asociate cu (c:3) este {(fc:3)}.

Nodul f produce doar (f:4) fără o bază condiţionlă de tipare.

În tabelul 4.3-1, sunt sintetizaţi bazele condiţionale de tipare şi arborii FP-Tree

condiţionali pentru exemplul prezentat mai sus.

Articol Baza condiţională de tipare FP-tree condiţional

p {⟨f:2, c:2, a:2, m:2⟩, ⟨c:1, b:1⟩} {(c:3)}p

m {⟨f:4, c:3, a:3, m:2⟩, ⟨f:4, c:3, a:3, b:1, m:1⟩} {(f:3, c:3, a:3)}m

b {⟨f:4, c:3, a:3, b:1⟩, ⟨f:4, b:1⟩, ⟨c:1, b:1⟩} ∅

a {(f:3, c:3)} {(f:3, c:3)}a

c {(f:3)} {(f:3)}c

f ∅ ∅

Tabel 4.3-1. Extragerea tuturor tiparelor prin crearea bazelor condiţionale

de (sub) - tipare

Proprietatea 4.2. (Proprietatea căii prefix) Pentru a calcula tiparele frecvente

pentru un nod ai din calea P, trebuie să se cumuleze doar sub-calea prefix a nodului ai din

O, fiecare nod din această sub-cale ar trebui să poarte aceeaşi frecvenţă ca şi nodul ai.

Raţionament: Fie nodurile de-a lungul căii P etichetate cu a1, a2, ..., an într-o

ordine astfel încât a1 este rădăcina sub-arborelui prefix, an este frunză a sub-arborelui P şi

ai (1 ≤ i ≤ n) este nodul referit. Bazându-ne pe procesul de construcţie a arborelui prezentat

90

în algoritmul FP-Tree, pentru fiecare nod prefix ak (1 ≤ k ≤ i), sub-calea prefix a nodului ai

din P apare împreună cu ak exact de ai. count ori. Aşadar, orice astfel de nod prefix ar

trebui să aibă aceeaşi valoare a contorului ca şi nodul ai. De notat faptul că un nod postfix

am (1 ≤ m ≤ n) de-a lungul aceleaşi căi apare de asemenea împreună cu nodul ai. Cu toate

acestea tiparele cu am vor fi generate la examinarea nodului postfix am, incluzându-le aici

ar conduce la generarea redundantă de tipare care ar fi generate pentru am. Aşadar, trebuie

să examinăm doar sub-calea prefix a lui ai din P.

Astfel, în exemplul 2, nodul m este implicat în calea ⟨f:4, c:3, a:3, m:2, p:2⟩, pentru

calcularea frecvenţei tiparelor pentru nodul m din această cale, doar sub-calea prefix a

nodului m, care este ⟨f:4, c:3, a:3⟩, este necesară pentru a fi extrasă şi frecvenţa fiecărui nod

din calea prefix ar trebui să fie aceeaşi ca şi a nodului m. Asta înseamnă că frecvenţa

nodurilor din calea prefix ar trebui să fie ajustată la ⟨f:2, c:2, a:2⟩.

Pe baza acestei proprietăţi, sub-calea prefix a nodului ai din calea P poate fi copiată

şi transformată într-o sub-cale prefix a frecvenţelor ajustate, prin ajustarea frecvenţelor

fiecărui nod din calea sub-prefix la aceeaşi frecvenţă ca şi a nodului ai. Astfel, această

transformare este numită transformarea căii prefix a lui ai pentru calea P.

Setul de transformări a căii prefix a lui ai formează o bază de date de tipare a lui ai.

Astfel, o bază de tipare a lui ai este numită bază condiţională de tipare a lui ai şi este

notată astfel – „pattern baseai” . După asta se pot calcula toate tiparele frecvente asociate

cu ai în această bază condiţională de tipare a lui ai prin crearea unui arbore mic FP-Tree,

numit FP-Tree condiţional a lui ai (vezi fig. 4.3-1.(b), (c), (d), (e)).

Explorarea ulterioară poate fi făcută pe acest arbore mic FP-Tree condiţional.

Procesul de construire a bazei condiţionale de tipare şi a FP-Tree condiţional a fost

demonstrat în exemplul 2.

Acest proces executat recursiv şi tiparele frecvente pot fi obţinute prin metoda de

creştere a tiparelor (FP-Growth), bazată pe următoarea lemă şi corolar.

Lema 4.3. (Creşterea fragmentului) Fie α un itemset din baza de date D, B fiind

baza condiţională de tipare a lui α şi β un itemset din B. În acest caz, suportul lui α ∪ β

din D este echivalent cu suportul lui β din B.

Raţionament: În conformitate cu definiţia bazei condiţionale de tipare, fiecare sub-

tranzacţie din B apare dacă α apare în baza originală de tranzacţii D. Dacă un itemset β

91

apare în B de ψ ori, el apare cu α în D de ψ ori. Deoarece toate itemset-urile sunt

colectate în baza condiţională de tipare a lui α, α ∪ β apare exact de ψ ori în D.

Din această lemă se poate deriva uşor un corolar.

Corolar 4.3. (Creşterea tiparelor) Fie α un itemset din baza de date D, B fiind baza

condiţională de tipare a lui α şi β un itemset din B. În acest caz, α ∪ β este frecvent în D

dacă şi numai dacă β este frecvent în B.

Pe baza corolarului 4.3, explorarea poate fi executată prin identificarea mai întâi a

seturilor de articole frecvente de lungime 1 (1-itemset-uri), α, din baza de date D,

construirea bazei condiţionale de tipare a acestora şi apoi explorând 1-itemset-uri, β, în

bazele condiţionale de tipare, şi aşa mai departe. Aceasta înseamnă că procesul de

extragere a tiparelor frecvente poate fi privit şi ca extragerea mai întâi a seturilor de

articole frecvente de lungime 1 (1-itemset-uri) şi apoi progresiv creştem fiecare itemset

prin explorarea bazei condiţionale de tipare a acesteia, care poate fi executată similar.

Astfel, reuşim să transformăm problema extragerii k-itemset-urilor frecvente într-o

secvenţă de k probleme de explorare a 1-itemset-urilor frecvente prin intermediul unor

baze condiţionale de tipare. Nu este necesar să generăm nici o combinaţie de seturi de

candidaţi în întreg procesul de explorare.

Lema 4.4. (Generarea tiparelor într-un FP-Tree cu o singură cale) Presupunem un

FP-Tree T care are o singură cale P. Setul complet de tipare frecvente a lui T poate fi

generat prin enumerarea tuturor combinaţiilor de sub-căi ale lui P cu suportul minim al

articolelor conţinute în sub-cale.

Raţionament: Fie o singură cale P în arborele FP-Tree ⟨a1:s1 → a2:s2 → ... →

ak:sk⟩. Suportul si al fiecărui articol ai (1 ≤ i ≤ k) este frecvenţa de apariţie a lui ai împreună

cu şirul său prefix. Astfel, orice combinaţie de articole din cale, cum ar fi ⟨ai ,..., aj⟩ (1 ≤ i, j

≤ k) este un tipar frecvent, cu frecvenţa lor de apariţie având suportul minim a acestor

articole. Deoarece fiecare articol în fiecare cale P este unic, nu există tipare redundante cu

o astfel de generare combinatorică. Mai mult, nici un tipar frecvent nu poate fi generat în

afara arborelui FP-Tree.

92

Pe baza celor arătate mai sus, în figura 4.3-2, este prezentat algoritmul FP-Growth

[HPY00] pentru extragerea tiparelor frecvente utilizând arborele FP-Tree prin creşterea

fragmentelor de tipare.

Fig. 4.3-2. Algoritmul FP-Growth

Cu ajutorul proprietăţilor şi lemelor prezentate anterior, se observă că algoritmul

FP-Growth descoperă setul complet de itemset-uri frecvente din baza de date

tranzacţională D.

Arborele FP-Tree al bazei de date D, conţine informaţiile complete ale bazei de

date legate de extragerea tiparelor frecvente care au suportul peste pragul minsup. Dacă

arborele conţine o singură cale, în conformitate cu lema 4.4, tiparele generate sunt

combinaţii ale nodurilor din cale, iar suportul este suportul minim al nodurilor din sub-căi.

Aceasta se realizează în liniile (1) – (3) ale procedurii FP-Growth. Altfel, se construieşte

baza condiţională de tipare şi se explorează arborele FP-Tree condiţional pentru fiecare

itemset frecvent ai. În conformitate cu proprietatea de creştere a fragmentelor, suportul

fragmentelor se ia ca fiind suportul itemset-urilor frecvente generate din baza condiţională

de tipare.

Intrare: Arborele tiparelor frecvente construit pe baza algoritmului FP-Tree utilizând baza de date D şi un suport minim s;

Ieşire: Setul complet de tipare frecvente; Metoda: Apelul funcţiei FP-Growth (FP-Tree, NULL) Procedure FP-Growth (Tree, α) {

(1) if Tree conţine o singură cale P (2) then for each combinaţie (notată cu β) a nodurilor din calea P do (3) generează tiparele α ∪ β cu support = suportul minim al

nodurilor din β (4) else for each ai din tabela antet Tree do { (5) generează tiparele β = ai ∪ α cu support = ai .support; (6) construieşte baza condiţională de tipare a lui β şi apoi (7) arboreal FP-Tree condiţional a lui β, notat Treeβ; (8) if Treeβ = ∅ (9) then call FP-Growth ( Treeβ, β)

} }

93

Procesul de explorare bazat pe algoritmul FP-Growth scanează arborele FP-Tree al

bazei de date D o dată şi generează o bază de tipare mică Bai pentru fiecare articol frecvent

ai, fiecare constând din seturi de căi prefix transformate ale lui ai. Extragerea tiparelor

frecvente este apoi executată recursiv pe baza de tipare mică Bai cu construirea unui arbore

FP-Tree condiţional pentru Bai.

Aşa cum a reieşit din analiza algoritmului FP-Tree, un astfel de arbore al unei baze

de date este în general mult mai mic decât dimensiunea bazei de date. Similar, deoarece

arborele FP-Tree condiţional, „FP-Treeai”, este construit pe baza tiparelor Bai, el ar

trebui să fie mult mai mic şi niciodată mai mare decât Bai. Mai mult, o bază de tipare Bai,

este în general mult mai mică decât arborele său FP-Tree original, deoarece ea constă din

căile prefix transformate, referitor doar la unul din articolele frecvente, ai.

Astfel, procesul de extragere următor lucrează pe un set de baze de tipare şi arbori

FP-Tree condiţionali mult mai mici în general. Din acest motiv, procesul este în general

mult mai puţin costisitor decât generarea şi testarea unui număr foarte mare de tipare

candidat. Aceasta face ca algoritmul FP-Growth să fie mult mai eficient.

Se observă totodată, că procesul de extragere este un proces de tip împarte şi

stăpâneşte („divide et impera”) iar scala de micşorare este impresionantă. În general

factorul de micşorare este în jur de 20 ∼100 pentru construirea unui arbore FP-Tree dintr-o

bază de date.

Se poate menţiona faptul că, chiar dacă o bază de date poate genera un număr

exponenţial de tipare frecvente, dimensiunea arborelui FP-Tree este în general destul de

mică şi niciodată nu va creşte exponenţial.

De exemplu, pentru un tipar frecvent de lungimea 100, ⟨a1 ,..., a100⟩, prin

construcţia arborelui FP-Tree rezultă numai o cale de lungimea 100 pentru tipar, cum ar fi

⟨a1 → ... → a100⟩. Algoritmul FP-Growth va genera însă în jur de 1030 tipare frecvente.

Deoarece arborele FP-Tree conţine numai o cale a tiparului frecvent de 100 de noduri, şi în

conformitate cu lema 4.4, nu este necesar să construim alţi arbori FP-Tree pentru a găsi

toate tiparele.

94

4.4. Algoritmul AFOPT (Ascending Frequency Ordered Prefix-

Tree)

Problemele principale întâmpinate în procesul de extragere a tiparelor frecvente

folosind creşterea tiparelor este reducerea numărului de baze de date condiţionale

construite pe parcursul întregului proces de extragere şi reducerea costurilor de traversare

şi construcţie a fiecărei baze de date condiţionale. Prima depinde de modul în care sunt

sortate articolele frecvente şi de spaţiul de căutare explorat. A doua depinde de modul de

reprezentare a bazelor de date condiţionale şi de strategia de traversare a acestora.

Cu toate acestea, este foarte greu să reduci în acelaşi timp atât costurile de

construcţie cât şi cele de traversare a bazelor de date condiţionale deoarece scopul însăşi de

construire a unei baze condiţionale noi este acela de a evita o nouă traversare (deci

reducerea costului de traversare). Reducerea unuia dintre costuri implică de obicei mărirea

celuilalt şi invers.

Algoritmul AFOPT (Ascending Frequency Ordered Prefix-Tree) a fost propus de

Liu G., Lu H. şi Lou W. în [LLX+03]. Ei au propus o structură de date compactă –

arborele prefixat ordonat crescător după frecvenţă (ascending frequency ordered prefix-

tree - AFOPT) pentru a reprezenta bazele de date condiţionale, arbore parcurs de sus în jos

(top-down). Au demonstrat că această combinaţie de strategii, parcurgerea arborelui de sus

în jos şi ordonarea frecvenţelor ascendent minimizează atât numărul total de baze de date

condiţionale create cât şi costurile de traversare a acestora.

Spaţiul de căutare pentru extragerea tiparelor frecvente poate fi reprezentat folosind

arborele de enumerare introdus de Raymon [Ray92] şi utilizat mai târziu de Bayard

[Bay98], Agarwal [AAP00a], Burdick [BCG01] şi Gouda şi Zaki [GZ01] în cercetările

lor.

4.4.1. Prezentarea problemei

Se dă un set de articole (itemi) I = {i1, i2, …, in} ordonate crescător. Spunem că un

articolset l = {ia1, ia2, ..., ian} este sortat dacă ∀ j ∈ [1, m-1], iaj ≤ iaj+1. Având două

articolset-uri sortate t1 = {ia1, ia2, ..., ian} şi t2 = {ib1, ib2, ..., ibk} (m ≤ k), dacă ∀ j ∈ [1, m], iaj

= ibj, atunci t1 se numeşte prefix-ul lui t2. Dacă k = m+1, atunci spunem că t1 este prefix-ul

imediat a lui t2.

95

Orice subset a lui I poate fi frecvent în D. Acestea formează spaţiul de căutare

extragerea tiparelor frecvente. Se poate construi un arbore pentru a reprezenta spaţiul de

căutare pe baza relaţiilor prefixate. Fiecare nod din arbore reprezintă un articolset. Între

articolset şi prefix-ul său imediat există o muchie. Acest arbore este denumit arborele

spaţiului de căutare sau arborele spaţiului tiparelor.

De exemplu, fiind dat un set de articole I = {a, b, c, d, e}, sortate în ordine

lexicografică, arborele spaţiului de căutare este prezentat în figura 4.4-1. Rădăcina

arborelui (nivelul 0) reprezintă setul vid şi fiecare nod de pe un anumit nivel k reprezintă

un articolset de dimensiune k (k-itemset) ordonat lexicografic.

Pentru a mări orice articolset l din arbore, acestuia i se pot adăuga doar acele

articole care se găsesc după ultimul articol a lui l. Aceste seturi de articole se numesc

extensii candidat a lui l şi sunt notate cand_exts(l).

În cazul în care avem un nod p, care este frecvent, dacă putem adăuga un articol x

la p, pentru a forma un articolset frecvent mai lung, atunci x se numeşte o extensie

frecventă a lui p. Dacă q = p ∪ {x}este fiul lui p şi este frecvent, atunci orice extensie

frecventă a lui p care se găseşte după x poate fi o extensie frecventă a lui q. Acestea se

numesc extensiile candidat ale lui q.

De exemplu, articolele d şi e sunt extensii candidat pentru ac, în timp ce b nu este

extensie candidat pentru ac deoarece b se găseşte înaintea lui c. De asemenea, dacă c, d, e

sunt extensii candidat pentru a, atunci d şi e sunt extensii candidat pentru ac, dar c nu este

extensie candidat pentru ad sau ae.

Fig. 4.4-1. Arborele spaţiului de căutare

96

Prin extinderea unui articolset frecvent l cu una dintre extensiile sale candidat,

obţinem un articolset frecvent care se va numi extensie frecventă a lui l, notată cu

freq_exts(l).

4.4.2. Algoritmul AFOPT

Algoritmul AFOPT începe prin traversarea bazei originale de date pentru a găsi

itemi frecvenţi pe care îi sortează în ordine crescătoare după frecvenţa lor de apariţie. Apoi,

baza de date este parcursă a doua oară pentru a construi o structură AFOPT (arborele

prefixat – prefix-tree) care să reprezinte baza de date condiţională a articolelor frecvente.

Baza de date condiţională a unui articlo i include toate tranzacţiile care conţin articolul i,

iar articolele care nu sunt frecvente şi cele care se găsesc înaintea lui i sunt îndepărtate din

fiecare tranzacţie. La stocarea ramurilor simple din arborele prefixat se folosesc tablouri

(array) pentru a salva spaţiu şi a micşora costurile de construcţie a arborelui. Fiecare nod

din arborele AFOPT conţine trei tipuri de informaţii: identificatorul articolului (ID),

numărul articolset-urilor corespunzătoare căii de la rădăcină până la acel nod şi pointerii

care indică fii nodului respectiv. Fiecare element din tablou păstrează două primele două

informaţii. În continuare vom nota p.item identificatorul nodului p din arborele AFOPT.

Pentru a ilustra construirea structurii AFOPT a unei baze de date vom folosi un

exemplu. Se dă o bază de date tranzacţională D, în tabelul 4.4-1., şi un prag al suportului

minim s = 40%, articolele frecvente sunt F = {c:3, e:3, f:4, d:4, m:5, a:7} ele fiind sortate

în ordinea crescătoare a frecvenţelor lor.

TID Tranzacţii Tranzacţiile proiectate

1 a, c, e, f, h, m, p c, e, f, m, a

2 a, b, c, f, g, m c, f, m, a

3 a, d, e, f, q, s, t e, f, d, a

4 a, b, d, k, m, o, r d, m, a

5 a, e, f, h, m, q, y e, f, m, a

6 a, c, d, j, m, t, w c, d, m, a

7 a, d, u, x, z d, a

Tabel 4.4-1. Tranzacţiile bazei de date D

97

La a doua parcurgere a bazei de date, tranzacţia 1 devine T1 = {c, e, f, m, a},

deoarece articolele h şi p au fost îndepărtate pentru că nu sunt frecvente iar cele rămsei au

fost sortate. Se creează astfel o ramură cu fiecare intrare cu numărul 1. Tranzacţia 2, devine

T2 = {c, f, m, a} în mod analog, după îndepărtarea articolelor nefrecvente şi sortarea celor

rămase. Aceasta are în comun cu tranzacţia 1 un prefix c, deci contorul suport al nodului c

este incrementat la 2, el având 2 fii e şi f. În acest mod sunt inserate toate tranzacţiile,

arborele AFOPT final fiind prezentat în figura 4.4-2.

Fig. 4.4-2. Arborele AFOPT

Dacă T este arborele prefixat construit din baza de date originală, şi p1, ..., pm este

mulţimea nodurilor din T a căror identificator este i, atunci baza de date condiţională a

articolului i este reuniunea subarborilor a căror rădăcină este i.

De exemplu, în arborele din figura 4.4-2., baza de date condiţională a articolului c

este reprezentată de primul subarbore al rădăcinii deoarece, doar rădăcina acestuia este

articolul c. Baza de date condiţională a articolului e conţine 2 subarbori: unul este primul

subarbore al nodului c iar celălalt este al doilea subarbore al rădăcinii.

Arborele AFOPT este o reprezentare compactă a bazei de date condiţionale. El

conţine informaţii complete pentru a putea extrage articolset-urile frecvente din baza de

date originală. Dimensiunea arborelui AFOPT depinde de numărul total de articole

frecvente care apar în baza de date, dar de obicei este mult mai mică decât acesta. După

construirea arborelui AFOPT, restul operaţiei de extragere a tiparelor frecvente se va

efectua doar asupra arborelui, fără a mai fi nevoie să parcurgem baza de date.

Algoritmul traversează arborele (spaţiul de căutare) în adâncime. Mai întâi verifică

prima bază de date condiţională Dc (primul subarbore al rădăcinii), apoi verifică bazele de

date condiţionale descendente lui c, până când vor fi extrase toate tiparele care au prefixul

NULL

c:3 e:2 d:2

f:1 e:1 d:1 f:2 m:1 a:13

f:1

m:1

a:1

m:1

a:1 a:1

m:1 d:1 m:1 a:1

a:1 a:1

98

c. După terminarea examinării lui Dc, acesta nu va mai fi necesar în procesul de extragere.

Toţi subarborii săi vor fi reuniţi cu nodurile fraţi. Noduri fraţi sunt acele noduri care sunt

pe acelaşi nivel şi au acelaşi părinte. Acest pas se numeşte de îndepărtare (push-right step).

În continuare, al doilea subarbore al rădăcinii devine primul subarbore al acesteia,

fiind reprezentarea completă a bazei de date condiţionale a celui de-al doilea item. Procesul

de extragere va continua asupra lui.

În procesul de extragere asupra unei baze de date condiţionale Tl al articolset-ului l,

se execută trei paşi:

• pasul de numărare – Tl este traversat în adâncime de sus în jos, fiecare nod al său fiind

vizitat exact o dată, fiind adunate suporturile tuturor articolelor din Tl. Ieşirea acestui

pas este setul de extensii frecvente ale articolset-ului l.

• pasul de construire - Tl este traversat a doua oară pentru a construi o a doua structură

AFOPT (Tl’) care va stoca baza de date condiţională a extensiilor frecvente ale lui l.

• pasul de îndepărtare – este executat imediat ce sunt extrase toate tiparele care au

prefixul l. Subarborii lui Tl sunt uniţi cei ai cu nodurilor fraţi. Operaţia de unire implică

corectarea pointerilor şi actualizarea suportului, prin traversarea celor doi arbori

deodată. Pe parcursul traversării arborilor se adună suportul aceluiaşi nod şi se

corectează pointerii în cazul în care două noduri cu acelaşi identificator nu au acelaşi

set de fii. Durata acestei operaţii depinde de dimensiunea celui mai mic arbore, în cazul

cel mai nefavorabil, şi este mult mai mică decât dimensiunea celui mai mic arbore în

cazul mediu. Pe parcursul operaţiei de unire nu vor fi create noduri noi, ci vor fi doar

îndepărtate nodurile duplicat.

Considerând în continuare exemplu nostru, în figura 4.4-3. este ilustrat procesul de

extragere pe subarborele c.

Fig. 4.4-3. Parcurgerea subarborelui c

c:3 c:3

f:1 e:1 d:1

f:1

m:1

a:1

m:1

a:1 a:1

m:1

m:3

a:3

99

În primul rând, vor fi extrase din primul subarbore al rădăcinii toate tiparele care

conţin articolul c. Extensia frecventă a lui c este {a, m}. Astfel, se va construi o nouă

structură AFOPT din Dc , care reprezintă baza de date condiţională a lui ca şi cm, aşa cum

s-a prezentat în figura 4.4-3. În continuare, procesul de extragere este aplicat pe noua

structură AFOPT. Aceasta este un arbore cu o singură ramură, astfel încât putem să

scoatem direct toate subseturile lui cam care conţin c, finalizând procesul de extragere

asupra lui Dc.

Fig. 4.4-4. Reunirea fiilor nodului c cu nodurile fraţi ale lui c

La pasul următor, se reunesc toţi subarborii nodului c cu nodurile fraţi din dreapta

ale acestuia, proces ilustrat în figura 4.4-4. Subarborele care are rădăcina ce este reunit cu

NULL

c:3

e:1 d:1

f:1

m:1

a:1

a:1

m:1

f:1

m:1

a:1

e:2

f:2

d:1 m:1

a:1 a:1

d:2

m:1 a:1

a:1

e:3

f:3

d:1 m:2

a:1 a:2

d:3

m:2 a:13

a:2

f:1

m:1

a:1

NULL

merge merge

100

subarborele e, subarborele cf devine al doilea fiu al rădăcinii, şi subarborele cd este reunit

cu subarborele d. După această operaţie, subarborele care are rădăcina e devine primul

subarbore al rădăcinii şi reprezintă baza condiţională a lui e. Procesul de extragere continuă

din acest moment asupra acestui subarbore, şi aşa mai departe.

Corectitudinea algoritmului AFOPT este garantată de faptul că, de câte ori un

subarbore devine primul subarbore al rădăcinii, el reprezintă următoarea bază condiţională

care va fi explorată în totalitate. Cu alte cuvinte, într-o structură AFOPT, baza condiţională

a unui articol (item) i include toţi subarborii care au ca şi rădăcină nodul aferent articolului

i. Presupunând că p este un astfel de subarbore şi p este de asemenea un fiu al rădăcinii,

atunci toţi ceilalţi subarbori trebuie să apară ca şi noduri fraţi stângi ai lui p în conformitate

cu proprietatea structurii AFOPT. În algoritmul AFOPT toţi aceşti subarbori sunt reuniţi

progresiv cu subarborele p. Aşadar, primul subarbore al rădăcinii conţine întotdeauna

informaţiile complete ale bazei condiţionale care trebuie explorată.

Algoritmul AFOPT este prezentat în limbaj pseudocod în figura 4.4-5.

Fig. 4.4-5. Algoritmul AFOPT

Intrare: l este un itemset frecvent;

root este rădăcina arborelui AFOPT reprezentând toate bazele condiţionale ale extensiilor frecvente ale nodului l;

min_sup este pragul suportului minim; Descriere: 1: if există doar o singură ramură în arbore care are rădăcina root then 2: extrage tiparele şi return; 3: for all fii pchild ale rădăcinii root do

4: extrage tiparul s = l ∪ {pchild.item}; 5: traversează subarborele care are rădăcina pchild, notat F, pentru a

găsi itemi frecvenţi şi îi sortează în ordine crescătoare a frecvenţelor;

6: if ||F|| > 1 then 7: traversează subarborele cu rădăcina pchild pentru a construi o nouă

structură AFOPT cu rădăcina newroot; 8: AFOPT (s, newroot, min_sup); 9: else

10: extrage tiparul s ∪ F; 11: for all fii subroot a lui pchild do 12: sibroot = nodul frate drept al lui pchild care are item-ul egal cu

subroot.item; 13: Merge (sibroot, subroot); // reuneşte cei doi subarbori

101

4.5. Studiu comparativ de performanţă

În ciuda tuturor eforturilor depuse de cercetători în ultimii ani, algoritmii care

generează şi testează candidaţi au două dezavantaje:

� Toate necesită generarea unui număr foarte mare de articolset-uri candidat,

multe dintre ele dovedindu-se a fi puţin frecvente după parcurgerea bazei de

date

� Toate necesită parcurgerea bazei de date de mai multe ori, în cel mai

defavorabil caz, numărul de parcurgeri a bazei de date fiind egal cu

lungimea maximă a tiparelor frecvente.

Abordarea prin creşterea tiparelor încearcă să evite aceste două dezavantaje

construind o bază de date condiţională pentru tiparele frecvente. Algoritmii propuşi pentru

aceasta diferă în principal prin maniera prin care este reprezentată baza condiţională. Han

[HPY00] foloseşte o structură de date compactă FP-Tree pentru a reprezenta baza de date

condiţională care este o combinaţie a structurilor arbore prefixat (prefix-tree) şi legătura

nodurilor (node-link). Liu [HPY00] foloseşte o structură de date compactă AFOPT pentru a

reprezenta baza de date condiţională.

Aşa cum am arătat anterior, fiind dată o bază de date condiţională, aceasta poate fi

reprezentată folosind două structuri şi câte o strategie de parcurgere aplicată fiecăreia din

acestea:

1. structura FP-Tree, în care articolele sunt sortate în ordine descrescătoare a

frecvenţei lor de apariţie, şi strategia de parcurgere a arborelui de jos în sus

2. structura AFOPT, în care articolele sunt sortate în ordine crescătoare a

frecvenţei lor de apariţie, şi strategia de parcurgere a arborelui de sus în jos

La prima vedere, se pare că algoritmul AFOPT necesită mai multe traversări ale

bazei de date decât algoritmul FP-Growth. Dar folosirea structurii AFOPT pentru a

reprezenta bazele de date condiţionale duce la obţinerea unor costuri de traversare minime

iar utilizarea ordonării crescătoare după frecvenţă ne conduce la construirea unui număr

minim de baze de date condiţionale. Costurile de traversare ale algoritmului FP-Tree sunt

întotdeauna mai mari decât în cazul algoritmului AFOPT. Numărul total de noduri vizitate

de algoritmul FP-Growth este egal cu lungimea totală a ramurilor arborelui prefixat.

102

Numărul total de noduri vizitate de algoritmul AFOPT este egal cu dimensiunea structurii

AFOPT, care este mai mică decât lungimea totală a ramurilor arborelui prefixat. Aşadar,

algoritmul AFOPT are nevoie de un număr mai mic de traversări decât algoritmul FP-

Growth.

Numărul total de baze de date condiţionale construite pe parcursul procesului de

extragere a tiparelor frecvente depinde ordinea în care sunt sortate articolele şi în care este

explorat spaţiul de căutare. Ordonarea crescătoare după frecvenţă minimizează numărul

total de baze condiţionale. În cazul structurii FP-Tree articolele sunt sortate în ordine

descrescătoare a frecvenţei lor, motiv pentru care arborele trebuie traversat de jos în sus, de

la nodurile frunze spre rădăcină.

În cazul în care baza de date condiţională a unui articolset poate fi reprezentată

printr-o singură ramură, se pot enumera toate tiparele frecvente conţinute direct în acesta şi

nu este necesară construirea unei noi baze condiţionale chiar dacă articolset-ul respectiv

are mai mult de o extensie frecventă. Structura AFOPT, aşadar, ne ajută să reducem

numărul de baze de date condiţionale construite, deoarece bazele condiţionale sunt de

obicei reprezentate printr-o singură ramură în structura AFOPT.

Folosind structura AFOPT, numărul de noduri vizitate este minim. Dacă baza de

date condiţională poate fi reprezentată printr-o singură ramură folosind structura FP-Tree,

atunci ea trebuie să poată fi reprezentată printr-o singură ramură şi folosind structura

AFOPT. Pe de altă parte, dacă baza de date condiţională poate fi reprezentată printr-o

singură ramură în structura AFOPT, ea poate conţine mai multe ramuri în arborele FP-

Tree. În structura FP-Tree articolele sunt sortate în ordinea descrescătoare a frecvenţelor

lor ceea ce permite distribuirea prefixată. Aşadar, FP-Tree este o structură mai compactă

decât AFOPT. Structura AFOPT, pe de altă parte poate conţine mai multe noduri decât

FP-Tree deoarece ordonarea crescătoare a frecvenţelor reduce posibilitatea distribuirii

prefixate.

Algoritmul FP-Growth păstrează legătura spre nodul părinte şi legături spre fiecare

nod, ceea ce implică costuri suplimentare la construcţia arborelui şi măreşte spaţiul

necesar. Pentru a micşora spaţiul de stocare, algoritmul AFOPT utilizează structura tablou

(array) pentru a stoca o ramură a arborelui, ceea ce duce şi la micşorarea costurilor de

construcţie.

Costurile suplimentare de traversare apărute în algoritmul AFOPT sunt cauzate de

etapa de reunire spre dreapta. Numărul de subarbori care constituie baza de date

condiţională, în cazul cel mai defavorabil, depinde exponenţial de numărul de articole

103

precedente celui considerat. Numărul de operaţii de reunire necesare este egal, în cazul cel

mai defavorabil, cu numărul de articole precedente celui considerat.

Dacă aplicăm atât algoritmul AFOPT cât şi algoritmul FP-Growth direct pe nivelul

3 a arborelui bazei de date luate ca exemplu, vom obţine arborele tiparelor frecvente, iar

după scanarea bazei de date vom obţine rezultatele din figura 6.3-6.

Algoritmii au fost implementaţi cu ajutorul limbajului de programare Java şi

compilaţi cu ajutorul platformei Eclipse. S-a folosit pentru testări un calculator Athlon XP

la 1.6 GHz, cu memorie de 256 MBRAM, sub sistemul Microsoft Windows XP

Professional şi aceleaşi condiţii de testare ca şi în cazurile precedente.

Fig. 4.4-6. Studiu comparativ între algoritmul FP-Growth şi algoritmul AFOPT

4.6. Concluzii

Algoritmul AFOPT utilizează o abordare a creşterii tiparului şi foloseşte o structură

de arbore prefixat (prefix-tree) pentru a reprezenta baza de date condiţională. El foloseşte o

strategie diferită de traversare a arborelui şi o altă metodă de ordonare a articolelor.

Algoritmul AFOPT traversează arborele prefixat de sus în jos, în adâncime iar

articolele sunt sortate în ordine crescătoare a frecvenţei lor de apariţie. Analiza şi

rezultatele studiilor efectuate arată că prin combinarea acestor două metode rezultatul

obţinut este mai eficient decât combinarea traversării de jos în sus a arborelui şi sortarea în

ordine descrescătoare a frecvenţelor folosite de algoritmul FP-Growth.

104


GENERALIZATE (MULTI-NIVEL)

5.1. Definiţii şi terminologie

Extragerea regulilor de asociere din seturi mari de date a fost şi este în continuare

subiectul multor cercetări [AIS93], [AS94], [AS95], [FMMT96], [KMR+ 94], [HK00],

[DXGH00], [WHH00], [PJ02], [Bod03], etc.

Cele mai multe studii efectuate asupra extragerii de date s-au concentrat mai mult

pe extragerea regulilor de asociere de pe un singur nivel conceptual, fie la nivelul primitiv,

fie la cel mai înalt nivel. De multe ori însă este necesar să descoperim cunoştinţe de pe mai

multe nivele conceptuale.










diferite.

Metodele de extragere de cunoştinţe de pe mai multe nivele conceptuale au fost, în


Aşadar, sistemele de extragere de date pot oferi metode eficiente pentru a extrage

reguli de asociere la nivel multiplu (multi-level).

Pentru a extrage reguli de asociere multi-nivel, avem nevoie de:

� Date reprezentate pe mai multe nivele de abstractizare

� Metode eficiente pentru a extrage reguli multi-nivel

105

Prima cerinţă poate fi satisfăcută oferind concepte taxonomice (clasificabile pe

baza relaţiilor naturale dintre ele) de la nivelul primitiv la nivelele superioare. În cele mai

multe aplicaţii aceste date sunt stocate în baze de date.

Taxonomia presupune organizarea datelor sub formă de ierarhie care permite

descoperirea unor relaţii de dependenţă între nivelele acesteia. În figura 4.1-1 este

prezentat un exemplu de ierarhie organizată taxonomic sub forma unui graf direct aciclic.

Fig. 5.1-1. Exemplu de ierarhie taxonomică simplă

În exemplul prezentat, observăm că jachetele sunt de stradă şi că acestea sunt

îmbrăcăminte.

Regulile de asociere de bază restricţionează ca, pentru apariţia unui articol (item) în

acea regulă să fie pe nivelul frunză al ierarhiei taxonomice. Regulile obţinute la nivelele

inferioare pot să nu aibă suportul minim. În multe domenii de aplicare, numărul de articole

este foarte mare, de exemplu produsele unui supermarket.

Dacă articolele sunt organizate în categorii se pot extrage mult mai multe reguli

care altfel nu ar fi putut fi găsite. Clasificarea taxonomică ne ajută de asemenea la

curăţarea regulilor neinteresante sau redundante.

În fig. 5.1-2 este prezentat graful unei ierarhii taxonomice multiple, care clasifică

produsele şi în funcţie de perioada din an de vânzare al acestora (de sezon, fără sezon).

Pe baza conceptului de ierarhie şi a câtorva algoritmi existenţi pentru extragerea

regulilor de asociere simplu-nivel, Han [HF95], [HF97], Rajkumar [RKS03] şi alţii au

propus un set de algoritmi pentru extragerea regulilor de asociere multi-nivel. Astfel, datele

clasificate pe categorii sau ierarhii sunt stocate în baze de date ierarhice (multi-nivel).

îmbrăcăminte

jachete sandale

haine de stradă încălţăminte

pantaloni de ski

izmene pantofi saboţi

106

Fig. 5.1-2. Exemplu de ierarhie taxonomică multiplă

În timp, s-au conturat mai multe direcţii posibile de explorare şi extragere a

regulilor de asociere multi-nivel.

O posibilitate este aplicarea directă a metodelor existente de extragere a regulilor de

asociere simplu-nivel pentru a extrage reguli de asociere multi-nivel. De exemplu, putem

aplica algoritmul APRIORI [AS94], pentru a analiza itemi de date la nivele multiple de

abstractizare folosind acelaşi prag pentru suportul minim şi aceeaşi confidenţă minimă.

Metoda este simplă dar poate oferi rezultate nedorite, în primul rând deoarece

suportul mare apare de obicei la nivele mari de abstractizare. Dacă dorim să obţinem

asocieri puternice la nivele relativ scăzute de abstractizare, pragul suportului minim trebuie

redus substanţial. Aceasta duce în final la obţinerea multor asocieri neinteresante la nivele

înalte sau intermediare. În al doilea rând, aşa cum se arată în cele mai multe dintre studiile

realizate în domeniu [AIS93], [AS94], este greu de obţinut reguli puternice la nivelul

conceptual primitiv, fiind mai uşor la nivele înalte conceptuale.

Aceste dezavantaje prezentate au dus la o altă cale de rezolvare a problemei. S-a

încercat varianta aplicării unor praguri diferite pentru suportul minim şi pentru confidenţa

minimă la diferite nivele de abstractizare. În special, s-a explorat cazul cel mai comun,

scăderea pragului pentru suportul minim odată cu nivelele mai scăzute de abstractizare.

Aceasta a condus la obţinerea unor reguli de asociere interesante la nivele conceptuale

multiple, care, pe lângă faptul că sunt diferite pentru nivele diferite, au şi un potenţial

îmbrăcăminte

haine de stradă încălţăminte

pantaloni de ski

jachete izmene pantofi saboţi sandale

iarnă vară

de sezon fără sezon

107

ridicat de a fi însemnate deoarece sunt flexibile şi pot fi orientate spre diferite seturi de date

şi aplicate pentru diferite praguri ale suportului şi confidenţei la diferite nivele.

Rajkumar a arătat în lucrarea sa [RKS03] că bazele de date multi-nivel folosesc

tabele de tranzacţii codificate ierarhic în locul tabele de tranzacţii originale. Acest lucru ne

ajută în cazul aplicaţilor care utilizează doar o parte din categoriile de articole din baza de

date (de exemplu alimente). Astfel, se pot colecta mai întâi seturile de date relevante şi

abia apoi se poate lucra doar cu articolset-urile relevante.

Se porneşte de la presupunerea că o bază de date conţine:

1. un set de date format din articol (item) şi descrierea sa, de forma ⟨Ai ,

descrierei⟩, unde Ai ∈ I

2. un set de tranzacţii T, ce conţine tranzacţiile de forma ⟨Ti, {Ap, .., Aq}⟩, unde

Ti este identificatorul tranzacţiei şi Ai ∈ I (pentru i = p, ..., q)

Putem spune că un tipar sau un articolset (itemset), A este unul din articolele

(itemii) Ai sau un set de articole (itemi) conjunctivi Ai ∧ ... ∧ Aj, unde Ai , ... , Aj, ∈ I.

Suportul tiparului A dintr-un set T, notat s (A/T) este numărul de tranzacţii (din T)

care conţine pe A împărţit la numărul total de tranzacţii din T.

Confidenţa relaţiei A ⇒ B din T, notată α (A ⇒ B/T), este raportul dintre s (A ∧

B/T) şi s (A/T), de exemplu, probabilitatea ca tiparul B să apară în T când tiparul A apare în

T.

α (A ⇒ B/T) = s (A ∧ B/T) / s (A/T) (5.1.1)

Se ştie că pentru a găsi tiparele care apar relativ frecvent în reguli puternice,

utilizatorul trebuie să specifice suportul minim smin şi confidenţa minimă αmin.

În cazul extragerii regulilor de asociere multi-nivel pot fi specificate valori diferite

pentru suportul minim şi/sau pentru confidenţa minimă pentru diferite nivele. Suportul

unui articol dintr-o ierarhie taxonomică nu este egal cu suma suporturilor fiilor săi, atâta

timp cât unii dintre fii acestuia pot apare într-o singură tranzacţie.

Pentru a înţelege algoritmii de extragere a regulilor de asociere generalizate (multi-

nivel), se folosesc următoarele notaţii. Un articolset (itemset) Z)

este numit un strămoş

(predecesor) a lui Z dacă Z, Z)

⊆ I şi ZZ)

= şi dacă se poate obţine Z)

din Z prin

108

înlocuirea unuia sau mai multor itemi din Z cu strămoşii lor. Nu este important să calculăm

suportul aşteptat al lui Z din Z)

, doar dacă au acelaşi număr de articole.

De exemplu, suportul pentru {îmbrăcăminte} nu ne oferă nici un indiciu despre

suportul pentru {haine de stradă, izmene}.

Regulile YX ⇒)

, YX)

⇒ sau YX))

⇒ se numesc strămoşii regulei YX ⇒ .

Fiind dat un set de reguli, regula YX))

⇒ este numită strămoş apropiat a regulei

YX ⇒ , dacă nu există nici o regulă Y~

X~ ⇒ astfel încât YX

))⇒ să fie un strămoş a

regulei Y~

X~ ⇒ şi Y

~X~ ⇒ să fie un strămoş a regulei YX ⇒ . Analog se aplică

definiţia şi pentru regulile YX ⇒)

şi YX)

⇒ .

Exemplu:

Baza de date D Tipare frecvente

Reguli

Fig. 5.1-3. Exemplu de extragere de reguli de asociere multi-nivel

Tranzacţii Articole (Itemi)

1 Izmene

2 Jachete, saboţi

3 Pantaloni de ski, saboţi

4 Pantofi

5 Pantofi

6 Jachete

Articolset (Itemset) Suport

{jachete} 2

{haine de stradă} 3

{îmbrăcăminte} 4

{pantofi} 2

{saboţi} 2

{încălţăminte } 4

{haine de stradă, saboţi} 2

{îmbrăcăminte, saboţi} 2

{haine de stradă, încălţăminte} 2

{îmbrăcăminte, încălţăminte} 2

Regula Suport Confidenţa

{haine de stradă} ⇒ {saboţi} 0.33 0.67

{haine de stradă} ⇒ {încălţăminte} 0.33 0.67

{saboţi} ⇒ {haine de stradă} 0.33 1.00

{saboţi} ⇒ {îmbrăcăminte} 0.33 1.00

109

Fiind dat un articolset I ={îmbrăcăminte, haine de stradă, jachete, pantaloni de

ski, izmene, încălţăminte, pantofi, saboţi, sandale} ierarhia taxonomică din figura 5.1-1. Se

consideră smin = 0.3 (de ex. 2 tranzacţii) şi αmin = 0.6. Articolset-urile frecvente rezultate şi

regulile corespunzătoare acestor articolset-uri sunt prezentate în figura 5.1-3.

Observăm că regulile {pantaloni de ski} ⇒ {saboţi} şi {jachete} ⇒ {saboţi} nu

au suport minim, în schimb regula {haine de stradă} ⇒ {saboţi} are.

5.2. Algoritmi de extragere a regulilor de asociere multi-nivel

Pe baza conceptului de ierarhie şi a câtorva algoritmi de extragere a regulilor de

asociere simplu-nivel, Han [HF95], [HF99], Strikant [SA95], Rantzau [Ran97], Wang

[WHH00] şi Rajkumar [RKS03], au propus o serie de algoritmi pentru extragerea regulilor

de asociere multi-nivel.

5.2.1. Algoritmul ADAPTIVE APRIORI

Problema extragerii regulilor de asociere multi-nivel poate fi descompusă în trei

paşi:

1. găsirea articolset-urilor frecvente

2. utilizarea articolset-urilor frecvente pentru a genera setul de reguli dorite

3. curăţarea acestui set de toate regulile neinteresante.

Tiparele interesante apar de multe ori pentru nivele diferite ale pragului suport.

Metodele clasice de extragere a regulilor de asociere, cum este APRIORI, se bazează pe

utilizarea unui prag suport uniform. Din acest motiv pot fi pierdute unele tipare interesante

cu un suport scăzut sau pot apărea dificultăţi la generarea articolset-urilor.

Pentru rezolvarea acestor problema, Wang K., He Y. şi Han J. [WHH00], au propus

o nouă abordare, şi anume utilizarea unor constrângeri pentru pragul suport care să

specifice care suport minim este solicitat pentru fiecare articol-set, astfel încât să fie

generate doar articol-seturile necesare.

Cea mai cunoscută strategie de generare a articol-seturilor frecvente, APRIORI

[AIS93, AS94], se bazează pe proprietatea că dacă un articolset nu este frecvent, atunci

nici unul dintre subseturile sale nu este frecvent.

110

Ţinând cont de faptul că algoritmii existenţi presupun un suport minim uniform,

cea mai bună soluţie este de a aplica un astfel de algoritm pentru suportul minim cel mai

scăzut specificat şi apoi să filtrăm rezultatele folosind un suport minim mai ridicat. Această

metodă va genera o mulţime de candidaţi care apoi vor fi îndepărtaţi. Pe baza experienţei

acumulate, s-a demonstrat că această creştere a candidaţilor generează automat o creştere

non-liniară a timpului de execuţie şi o deteriorare drastică a performanţelor, datorită

transferurilor dintre memoria principală şi disc în timpul calculării suportului, când

candidaţii sunt citiţi de pe disc la fiecare tranzacţie.

Din acest motiv, Wang propune noţiunea de constrângere suport (support

constraint) definită astfel:

O constrângere suport (SC) are forma SCi (B1,..., Bs) ≥ θi (sau simplu SCi ≥ θi),

unde s ≥ 0.

Fiecare Bi, denumit bin, este un set de articole care trebuie să fie distincte prin

respectarea suportului minim specificat. θi este suportul minim cuprins în intervalul [0..1].

Ordinea în care apar Bi nu are importanţă, acestea putându-se chiar repeta. O SC este

întemeiată dacă nu conţine nici o variabilă, altfel este neîntemeiată. În acest caz, SC poate

fi instanţiată prin înlocuirea fiecărei variabile cu un bin.

Definiţia de mai sus specifică faptul că orice set de articole care conţine cel puţin

un articol din Bi are suportul minim θi.

Constrângerile suport pot fi interpretate în două moduri:

- interpretare deschisă – specificând câteva articole din articolset

- interpretare închisă – specificând toate articolele din articolset

Un articolset I se identifică cu o SC întemeiată SCi ≥ θi în interpretarea deschisă

dacă I conţine cel puţin un articol din fiecare bin în SCi şi aceste articole sunt distincte. Un

articolset I se identifică cu o SC întemeiată SCi ≥ θi în interpretarea închisă dacă I conţine

exact un articol din fiecare bin în SCi şi aceste articole sunt distincte.

Suportul minim al articolului I, notat minsup(I), este cel mai scăzut θi dintre toate

SCi ≥ θi identificat cu I. Dacă I nu se identifică cu nici o SC, atunci minsup(I) nu este

definit. Un articolset este frecvent, dacă are definit un minsup(I) şi sup(I) ≥ minsup(I)

Utilizatorul final determină Bi şi suportul minim dintr-o SC în funcţie de aplicaţie

pe baza suporturilor (min, max, sau avg), pe baza ierarhiei conceptuale, pe baza specificării

atributelor articolelor, sau uneori, pe baza enumerării tuturor articolelor dintr-un bin.

Scopul acestui nou algoritm propus de Wang este de a forţa astfel de constrângeri

suport la generarea articolset-urilor pentru a curăţa cât mai devreme candidaţii nefolositori.

111

Ideea de bază a algoritmului este de a forţa constrângeri suport urmărind

„înlănţuirea dependenţelor” din generarea APRIORI a articolset-urilor (funcţia APRIORI-

Gen). Aceste dependenţe sunt descrise cel mai bine prin arborele schemei de enumerare.

Aici, fiecare nod (exceptând nodul rădăcină) este etichetat printr-un bin Bi. Un nod v

reprezintă schema dată prin etichetele B1...Bk urmărind calea de la rădăcină până la nodul v.

Exemplu: Considerăm o bază de date având 5 tranzacţii şi constrângerile suport specificate

în figura 5.2-1.

Fig. 5.2-1. Baza de date exemplu

Fiecare articol este reprezentat printr-un întreg de la 0 la 8. Pentru orice articolset I

care conţine un articol din B1, şi un articol din B3, se identifică atât cu constrângerea

SC1(B1, B3) ≥ 0.2 cât şi cu SC2(B3) ≥ 0.4. Cu toate astea, minsup(I) = 0.2 deoarece este cel

mai scăzut suport minim folosit.

Urmărind exemplul considerat, dintre articolset-urile {0,2}, {0,2,3} şi {2,3,4} doar

primul este frecvent, următoarele două nu sunt frecvente. Suportul minim pentru articolset-

urile {2,4,7}, {2,4,8}, {4,7,8} şi {2,4,7,8} este 0.6 deoarece ele se identifică doar cu

SC3(B2) ≥ 0.6. Toate aceste articolset-uri sunt frecvente. Dintre {2,7} şi {2,8}, doar primul

este frecvent, cel de-al doilea nu, iar suportul minim este SC0() ≥ 0.8.

Dacă arborele schemei de enumerare conţine două noduri înlănţuite reprezentând

schemele s1=B1...Bk-2Bk-1 şi s2=B1...Bk-2Bk, unde s1 se găseşte la stânga lui s2, atunci arborele

schemei de enumerare conţine de asemenea nodul care reprezintă schema s=B1...Bk-2Bk-1Bk,

care este fiul nodului s1. s1 şi s2 se numesc în acest caz schemele generatoare ale lui s. De

exemplu, în figura 5.2-2. B2B1 depinde de B2 şi B1, dar nu depinde de B1B0 sau de B3.

Baza de date

TID Articole

100 0,2,7

200 0,4,7,8

300 2,4,5,7,8

400 1,2,4,7,8

500 2,4,6,7,8

bin

B0 1,7,8

B1 2,6

B2 4,5

B3 0,3

SC specificate

SC0() ≥ 0.8

SC1(B1, B3) ≥ 0.2

SC2(B3) ≥ 0.4

SC3(B2) ≥ 0.6

112

0.2/0.2 0.6/0.2 0.8/0.2 0.8/0.2

0.2/0.2 0.4/0.2 0.4/0.2 0.4/0.2 0.6/0.6 0.6/0.6 0.6/0.6 0.8/0.8 0.8/0.8 0.8/0.8

Fig. 5.2-2. Arborele schemei de enumerare T marcat cu Sminsup/Pminsup

Pentru orice funcţie f din scheme cu valori în [0..1], putem spune că un articolset I

al schemei s estefrecvent şi este notat frequent(f) dacă sup(I) ≥ f(s). Se notează F(f) setul de

articolset-uri frecvente - frequent(f).

Se defineşte suportul minim impus - Pminsup care este o funcţie din arborele

schemei de enumerare T, cu valori în intervalul [0..1] şi care satisface următoarele:

- Completitudine: pentru fiecare schemă s din T, se difineşte Pminsup(s) ≤ minsup(s) –

aceasta asigură că

- Proprietatea Apriori: pentru fiecare schemă s şi schemele sale generatoare s1 şi s2,

oricând articolset-ul {i1,...,ik-2, ik-1, ik}lui s este frecvent, la fel sunt şi articolset-urile

{i1,...,ik-2, ik-1} a lui s1 şi {i1,...,ik-2, ik}a lui s2.

- Maximalitate: Pminsup este maximal respectând cele două cerinţe de mai sus

Algoritmul extinde arborele schemei de enumerare iterativ, cu un nivel la fiecare

iteraţie. În fiecare iteraţie k există două faze.

Faza 1. Se generează noi noduri si la nivelul k şi se determină Pminsup(si). Această fază

examinează doar suporturile specificate în schemă nu şi baza de date sau articolseturile.

Fiecare nod p de pe nivelul k-1 este asociat unui set de constrângeri suport SCs pentru acel

nod. Extinderea arborelui la nivelul k, se realizeaă în trei paşi:

Pasul 1. Crează nodurile fii si de pe nivelul k

Pasul 2. Ordonează aceste noduri fie selectând eticheta care specifică cel mai

scăzut suport minim ca următoare înlănţuire, fie selectând eticheta care specifică cele mai

multe constrângeri suport ca şi următoarea înlănţuire.

Pasul 3. Calculează Pminsup(si) aşa cum am arătat mai sus.

Faza 2. Se generează frequent(Pminsup) la nodurile si la fel ca şi în algoritmul APRIORI.

B0 B1 B0 B1 B3 B0 B2 B1 B2 B0

B3 B2 B1 B0

113

5.2.1.1. Avantajele algoritmului

În general, în lumea reală, suportul minim nu este uniform. Excepţiile şi deviaţiile

au adesea un suport minim mai scăzut decât tendinţa generală. Suportul solicitat variază

odată cu suportul articolelor care alcătuiesc articolset-ul respectiv şi totodată variază la

diferite nivele conceptuale ale bazei de date. În acelaşi timp, clasificările ierarhice ale

bazelor de date necesită descoperirea unor reguli de asociere de pe diferite nivele

conceptuale, aşadar, necesită un suport minim neuniform.

Folosind constrângeri pentru suportul minim, aşa cum face algoritmul ADAPTIVE

APRIORI, se obţine un timp de execuţie mult mai bun la generarea articolset-urilor.

De asemenea, prin forţarea constrângerilor suport la generarea articolset-urilor se

obţine curăţarea cât mai devreme candidaţii nefolositori.

5.2.2. Algoritmul ML_T2L1

O altă metodă de extragere a regulilor de asociere multi-nivel este prezentată în

paragraful următor. Aceasta foloseşte tabele de tranzacţii cu informaţia codificată ierarhic

în locul tabelelor originale din bazele de date relaţionale. Acest lucru se bazează pe

următoarele consideraţii. În primul rând, o interogare de extragere de date este de obicei

relevantă doar unora dintre tranzacţiile bazei de date şi nu tuturor. În acest caz este util să

colectăm mai întâi setul de date relevante şi în continuare să lucrăm doar pe acesta. În al

doilea rând, codificarea poate fi făcută în acelaşi timp cu colectarea setului de date

relevante, astfel se evită parcurgerea bazei de date doar pentru codificarea datelor. În al

treilea rând, un şir de date codificat, care reprezintă o poziţie în ierarhie, necesită mai

puţini biţi decât identificatorul obiectului corespunzător sau un cod de bare. Mai mult,

codificarea realizează unirea sau eliminarea mai multor articole datorită codurilor lor

identice, rezultând astfel un tabel de tranzacţii de dimensiuni reduse.

Algoritmul ML_T2L1 propus de Han J. şi Fu Y. în lucrarea [HF95], găseşte seturi

mari de articole pentru extragerea unor reguli de asociere multi-nivel puternice în baze de

date tranzacţionale. Algoritmul este prezentat în figura 5.2-3.

Algoritmul ML_T2L1 descoperă articole suport frecvente la fiecare nivel l. Aceasta

se face în mai multe etape.

114

1. La nivelul 1, 1-itemset-ul L[l,1] (1-articolset-ul) este obţinut din T[1] de către funcţia

get_large_itemsets (T [1], l). La orice alt nivel l, L[l,1] este obţinut din T[2] de

către funcţia get_large_itemsets (T [2], l). În cazul în care l > 2, se vor lua în

considerare doar articolele L[l-1,1] la examinarea lui T[2] pentru a determina 1-

itemset L[l,1]. Acest lucru este implementat prin parcurgerea articolelor fiecărei

tranzacţii t în T[1] (sau T[2]), incrementând contorul suport al articolului i din

articolset, dacă contorul acestuia nu a fost incrementat cu t. După parcurgerea tabelei

de tranzacţii, se filtrează (elimină) acele articole a căror suport este mai mic decât

minsup[l].

2. Tabelul de tranzacţii filtrat T[2] este obţinut de funcţia get_filtered_t_table (T[1],

L[1,1]), care foloseşte L[1,1] ca un filtru pentru a elimina: (1) orice articol care nu

este frecvent de la nivelul 1 şi (2) tranzacţiile care nu conţin articole frecvente.

3. Tabelul setului de articole frecvente k (pentru k > 1) este obţinut în doi paşi:

a. Se calculează mulţimea de candidaţi din L[l, k-1], aşa cum s-a făcut în

algoritmul APRIORI cu ajutorul funcţiei Apriori-gen. Mai întâi se generează

un set Ck în care fiecare articolset conţine k articole, obţinuţi prin reuniunea

a două articole (k-1) în L[l, k] care conţine (k-2) articole. Apoi se şterge k-

articolset-ul c din Ck dacă există un subset k-articol care nu se găseşte.

b. Pentru fiecare tranzacţie t din T[2], pentru fiecare subset c al k-articolset-

ului t, se incrementează contorul suport a lui c, dacă acesta se găseşte în

setul de candidaţi Ck. Apoi se adaugă în L[l, k] fiecare c (împreună cu

suportul său) dacă suportul său este mai mare decât minsup[l].

4. Mulţimea de articole frecvente la nivelul l, LL[l] este reuniunea tuturor L[l, k]

pentru toţi k.

După găsirea articolset-urilor frecvente, se poate obţine mulţimea regulilor de

asociere pentru fiecare nivel l din mulţimea LL[l] pe baza confidenţei minime la acest

nivel, minconf[l]. Pentru fiecare articolset frecvent r, dacă avem un subset a nevid, sau

115

regula r este inserată în rule_set[l], „a → r - a” dacă support (r) / support (a) ≥ minconf

[l], unde minconf[l] este confidenţa minimă la nivelul l.

Algoritmul ML_T2L1 moşteneşte câteva tehnici de optimizare importante din

cercetările anterioare pentru extragerea regulilor de asociere [AIS93], [AS94]. De

exemplu, funcţia get_candidate_set urmăreşte funcţia Apriori-gen din algoritmul APRIORI

[AS94]. Funcţia get_subsets (Ck, t) este implementată folosind tehnica hash tot din [AS94]

Fig. 5.2-3 Algoritmul ML_T2L1

5.2.2.1. Exemplu de utilizare

Presupunem o bază de date tranzacţională conţinând 2 relaţii: articole (vezi tabelul

5.2-1) şi vânzări (vezi tabelul 5.2-2).

Intrare: (1) T[1]o ierarhie codificată de date şi un set tranzacţii relevante ale bazei de date, de forma ⟨TID, itemset⟩,

(2) pragul suportului minim (minsup[l]) pentru fiecare nivel l. Ieşire: L setul multi-nivel al item-ilor Metoda: un proces progresiv de sus în jos (top-down) care colectează

itemset-uri mari de la nivele conceptuale diferite. Începând de la nivelul 1, se obţine pentru fiecare nivel l, setul k de itemi,

L [l, k], pentru fiecare k şi setul LL [l] pentru toţi k. Funcţia:

(1) for (l:=1; L [l,1] ≠0 and l < max_level; l++) do (2) { if l = 1 then (3) {L [l,1] := get_large_1_itemsets (T [1], l);

(4) T [2] := get_filtered_t_table (T [1], L [1,1]); (5) } (6) else L [l,1] := get_large_1_itemsets (T [2], l);

(7) for (k:=2; L[l, k-1] ≠ 0; k++) do

(8) {Ck := get_candidate_set (L[l, k-1]);

(9) foreach transacţie t ∈ T[2] do (10) { Ct := get_subsets ( Ck, t); (11) foreach candidat c ∈ Ct do c.support ++; (12) } (13) L[l, k] := { c ∈ Ck c.support ≥ minsup[l]} (14) }

(15) LL [l] := ∪k L [l, k]; (16) }

116

alimente

lapte pâine carne

graham albă 3,5% 1,8%

Dorna Milli

Cod_bare categorie firmă conţinut dimensiune valabilitate preţ

17325 lapte Dorna 1,8% 1 l 14 (zile) 2.4

. . . . . . . . . . . . . . . . . . . . .

Tabel 5.2-1. Articole (descriere)

Id_tranzacţie Set_cod_bare

531428 {17325, 92108, 55349, 8857, …}

982510 {92458, 77451, 66395, . . .}

. . . {. . . , . . .}

Tabel 5.2-2. Tranzacţii

Ierarhia conceptuală a bazei de date va fi de forma arborelui din figura 5.2-4.

......

... ... ......

... ......

Fig. 5.2-4. Arborele ierarhiei conceptuale

Tabelul 5.2-3., prezentat în continuare, conţine codificarea tranzacţiilor.

117

TID Articole (Itemi)

T1 {111, 121, 211, 221}

T2 {111, 211, 222, 323}

T3 {112, 122, 221, 411}

T4 {111, 121}

T5 {111, 122, 211, 221, 413}

T6 {211, 323, 524}

T7 {323, 411, 524, 713}

Tabel 5.2-3. Codificarea tranzacţiilor TTTT[1]

Nivelul 1

Considerăm suportul minim egal cu 4 (minsup[1]=4). La nivelul 1, tabelul L[1,1]

poate fi obţinut prin parcurgerea tabelului T[1], verificând suporturile fiecărui articol (1**,

..., 4**), verificând dacă tranzacţia conţine un astfel de articol şi filtrând acele articole a

căror contor suport este mai mic decât suportul minim. L[1,1] este folosit pentru a filtra

orice articol care mu este suficient de frecvent în tranzacţie şi tranzacţiile din T[1] care

conţin doar articole puţin frecvente.

Rezultatul este prezentat în tabelul T[2] de mai jos (tabel 5.2-6). Deoarece există

doar 2 intrări, în tabelul 5.2-4, L[1,1] tabelul pentru 2-itemset la nivelul 1 este prezentat în

tabelul 5.2-5, L[1,2], şi poate conţine doar 1 articol candidat {1**, 2**} care apare în 4

tranzacţii din T[2].

Tabel 5.2-4. 1-itemset-ul LLLL[1,1] Tabel 5.2-5. 2-itemset-ul LLLL[1,2]

Articolset

(Itemset)

Suport

{1**} 5

{2**} 5

Articolset

(Itemset)

Suport

{1**, 2**} 4

118

Tabel 5.2-6. Tranzacţiile filtrate TTTT[2]

Nivelul 2

Considerăm suportul minim egal cu 3, minsup[2]=3. La nivelul 2, itemset-urile

frecvente, 1-itemset L[2,1], pot fi obţinute prin filtrarea tabelului tranzacţiilor T[2], prin

incrementarea contorului suport şi prin înlăturarea acelor itemi care au suportul mai mic

decât suportul minim. Obţinem astfel L[2,1] prezentat în tabelul 5.2-7.


Tabel 5.2-9. 3-itemset-ul LLLL[2,3]

TID Articole( Itemi)

T1 {111, 121, 211, 221}

T2 {111, 211, 222}

T3 {112, 122, 221}

T4 {111, 121}

T5 {111, 122, 211, 221}

T6 {211}

Articolset

(Itemset)

Suport

{11*, 12*} 4

{11*, 12*} 3

{11*, 12*} 4

{11*, 12*} 3

{11*, 12*} 3

Articolset

(Itemset)

Suport

{11*} 5

{12*} 4

{21*} 4

{22*} 4

Articolset

(Itemset)

Suport

{11*, 12*, 22*} 3

119

Nivelul 3

minsup[3]=3


Calculul se opreşte atunci când nu mai există un nou nivel şi când se generează un

tabel gol pentru 1-itemset la orice nivel.

5.2.2.2. Avantajele algoritmului

� Realizează extinderea extragerii de reguli de asociere la un singur nivel

pentru mai multe nivele conceptuale din baze de date tranzacţionale prin

dezvoltarea unei tehnici de parcurgere top-down progresivă în adâncime

a arborelui conceptual.

� Explorează tehnici de distribuire a structurii datelor şi a rezultatelor

intermediare între nivele.

5.2.2.3. Dezavantajele algoritmului

� Algoritmul foloseşte abordarea APRIORI. Aşa cum am mai arătat,

algoritmul FP-Growth este mai rapid decât APRIORI. Eficienţa

algoritmului ML_T2L1 poate aşadar fi îmbunătăţită aplicând algoritmul

FP-Growth la fiecare nivel.

� Algoritmul nu poate genera tipare multi-dimensionale.

Articolset

(Itemset)

Suport

{111, 211} 3

Articolset

(Itemset)

Suport

{111} 4

{211} 4

{221} 3

120

5.2.3. Algoritmul ADA-FP

Metoda APRIORI a fost studiată prima dată de Agrawal R. şi Srikant R. în 1994

[AS94]. Liu B, Hsu W. şi Ma Y. au abordat pentru prima dată problema unui suport minim

non-uniform [LHM99]. În lucrarea lor, fiecărui articol i s-a asociat un suport minim

(minimum item support – MIS) iar suportul minim al articolset-ului este definit ca fiind cel

mai mic MIS asociat articolelor din mulţime.

Mai târziu, folosind abordarea APRIORI, Wang K., He Z. şi Han J. [WHH00] au

elaborat o metodă nouă care permite utilizarea unor suporturi diferite pentru articolset-uri

diferite. Ei şi-au numit algoritmul lor „ADAPTIVE-APRIORI”. În abordarea lor, folosesc

predefinirea schemelor pentru articolset-uri. Articolset-urile care au trăsături comune au o

schemă identică. Noutatea acestui algoritm este aceea că sparge bariera suportului minim

uniform, definind „cel mai bun suport minim” (Pminsup) separat pentru fiecare schemă,

folosind în acelaşi timp esenţa algoritmului APRIORI. Ei propun o constrângere asupra

suportului minim la generarea articolset-urilor pentru a curăţa candidaţii cât mai curând

posibil.

Cel mai bun suport minim (Pminsup) a fost definit astfel:

� Fie Pminsup o funcţie a arborelui schemei T la [0..1] care satisface:

o Cerinţele: pentru fiecare schemă s din T, se defineşte Pminsup(s) ≤ minsup(s);

o Abordarea Apriori: pentru orice schemă s şi schemele generate din aceasta s1 şi

s2, oricând {i1, …, ik-2, ik-1, ik} a lui s este suport minim frecvent

frequent(Pminsup), la fel sunt şi {i1, …, ik-2, ik-1} pentru s1 şi {i1, …, ik-2, ik}

pentru s2;

o Maximalitatea: Pminsup este maximal respectând ambele cerinţe de mai sus

Algoritmul parcurge arborele iterativ, un nivel pe iteraţie k, în două faze. Prima

fază generează noduri noi si la nivelul k şi determină Pminsup(si). Această fază examinează

doar suporturile şi schema fără a examina baza de date sau articolset-urile. A doua fază

generează suportul minim frecvent frequent(Pminsup) în nodurile si, în mod similar cu

algoritmul APRIORI.

121

Cea mai mare parte a algoritmilor existenţi în prezent utilizează abordarea

APRIORI. Una din slăbiciunile cele mai mari ale acestei abordări este, însă, parcurgerea în

mod repetat a bazei de date, ceea ce micşorează eficienţa acestor algoritmi.

Algoritmul FP-Growth [HP00] este mai eficient deoarece are nevoie doar de două

parcurgeri ale bazei de date. Acesta generează tipare frecvente în mod recursiv traversând

un arbore prefixat, în care a fost comprimată baza de date anterior. Oricât de mare va fi

dimensiunea tiparului frecvent, algoritmul parcurge doar de două ori baza de date pentru a

genera setul complet de tipare frecvente. Din acest motiv algoritmul FP-Growth este mai

rapid decât APRIORI.

Mao R. propune în lucrarea sa [Mao01] o combinaţie a algoritmilor ADAPTIVE

APRIORI şi FP-Growth, sub denumirea de algoritmul ADA-FP. Algoritmul este o

îmbunătăţire a algoritmului FP-Growth, folosind arborele FP-Tree al tiparelor frecvente,

cât şi metoda divide et impera bazată pe partiţionare. De asemenea, atunci când e necesar

de luat în considerare dimensiunea ca şi informaţie, aceasta este tratată la fel ca un item

(articol) informaţie. La citirea bazei de date tranzacţionale, se ţine cont şi de dimensiune.

Aceasta este considerată frecventă dacă apariţia sa satisface un anumit prag specificat.

Algoritmul ADA-FP propune o constrângere flexibilă pentru suport. Pornind de la

faptul că în viaţa reală bazele de date tranzacţionale includ informaţie taxonomică,

articolele apar la diferite nivele de abstractizare. La fiecare nivel, itemii individuali sunt

clasificaţi în două categorii: un grup de itemi normali care au o frecvenţă rezonabilă de

apariţie şi un alt grup format din itemii speciali . Un exemplu în acest sens sunt itemii lapte

sau diamante. Ambele pot fi considerate articole speciale. Laptele, deoarece este un articol

care apare în cumpărăturile zilnice. Aşadar, este justificabil să-l considerăm infrecvent

dacă apare de mai puţin de 700 de ori în 1000 de tranzacţii. Pe de altă parte, diamantele

sunt produse de lux, aşadar le vom considera frecvente dacă apar măcar de 10 ori în 1000

de tranzacţii.

Cerinţele suportului variază între nivele conceptuale diferite. La fiecare nivel, s-au

folosit două tipuri de praguri suport, atât pentru articolele normale, cât şi pentru articolele

excepţionale. Cele două tipuri de praguri se numesc pragul de trecere al articolului (item

passage threshold) şi pragul tipar al articolului (item printing threshold). De obicei,

pragul tipar este mai mare decât pragul de trecere. Un articol (item) este tratat ca frecvent

1-item dacă apariţiile sale depăşesc pragul tipar. Altfel, cât timp suportul său depăşeşte

pragul de trecere, articolul va putea avea şansa să rămână în baza de date pentru a genere

122

un set frecvent de 2 articole (2-itemsets). Aceasta se explică datorită faptului că tiparele

mai lungi sunt de obicei asociate unor praguri mai mici decât sub-tiparele lor.

5.2.3.1. Descrierea algoritmului

Algoritmul ADA-FP extrage tipare frecvente multi-nivel şi multi-dimensionale prin

extinderea algoritmului FP-Growth. Algoritmul poate fi împărţit în trei paşi.

5.2.3.1.1. Pasul 1- Găsirea articolelor frecvente (1-item)

Pornindu-se de la o bază de date tranzacţională D, cu o mulţime de dimensiuni şi cu

o mulţime de itemi (articole), se consideră pragul suport minim minsup.

În acest pas, baza de date tranzacţională D este parcursă o dată. În timpul acestei

parcurgeri, se contorizează fiecare dimensiune şi articol. În acelaşi timp, se compară

contoarele lor cu cele două tipuri de praguri corespunzătoare – pragul de trecere şi pragul

tipar.

Pentru fiecare dimensiune se compară contorul său cu pragul de trecere al

dimensiunii şi cu pragul tipar al acesteia. Dimensiunile a căror suport nu trece pragul

suport sunt eliminate.

Pentru fiecare articol, se detectează mai întâi nivelul de abstractizare (conceptual)

pe care se găseşte acesta; apoi se verifică dacă este un articol normal sau unul excepţional.

Dacă este un articol normal, se compară suportul său cu pragul de trecere corespunzător şi

cu pragul tipar. Altfel, vom restrânge posibilităţile următoare şi vom eticheta articolul fie

ca unul foarte comun fie ca unul foarte rar, şi vom compara apoi suportul său cu suportul

de trecere şi cu suportul tipar. În orice caz, articolul va fi considerat ca şi 1-item frecvent

doar dacă suportul său depăşeşte pragul tipar corespunzător. Totodată, trebuie să fim

conştienţi că toate articolele a căror suport depăşeşte pragul de trecere e posibil să apară în

tipare frecvente de dimensiune 2 sau mai mare. Articolele a căror suport nu depăşeşte

pragul de trecere nu vor mai fi considerate în continuare.

5.2.3.1.2. Pasul 2- Construirea arborelui FP-Tree

Algoritmul adoptă acelaşi arbore prefixat ca şi FP-Growth, definit astfel:

123

• O rădăcină etichetată „NULL”, un set de subarbori prefixaţi de articole ca şi fii ai

rădăcinii şi un tabel header al articolelor frecvente.

• Fiecare nod din subarborele prefix al articolelor conţine trei câmpuri: nume, contor şi

nodul de legătură. Numele arată articolul pe care nodul în reprezintă. Contorul arată

numărul de tranzacţii reprezentate de porţiunea de cale care duce la acel nod. Nodul de

legătură pointează (face legătura) spre nodul următor din arborele FP-Tree ce poartă

acelaşi nume. Nodul de legătură este „NULL” dacă nu există în continuare alt nod.

• Fiecare intrare în tabelul header al articolelor frecvente conţine două câmpuri: nume şi

capul nodului de legătură. Numele reprezintă numele articolului sau al dimensiunii.

Capul nodului de legătură pointează spre primul nod din arborele FP-Tree care conţine

numele articolului.

Procedura de construire a arborelui FP-Tree este descrisă în continuare printr-un

proces în doi paşi:

• Se parcurge baza de date tranzacţională D o dată. Se colectează un set de articole

frecvente (sau dimensiuni) F şi suporturile acestora. Se ordonează F în ordinea

descrescătoare a suporturilor formându-se lista L, a articolelor frecvente.

• Se creează rădăcina unui arbore FP-Tree, T, etichetată „NULL”. Pentru fiecare

tranzacţie Trans din baza de date se fac următoarele:

• Se selectează şi sortează articolele frecvente din Trans în ordinea din L. Fie

lista articolelor frecvente sortate din Trans, notată [pP], unde p este primul

element şi P este lista rămasă. Se apelează funcţia insert_tree([pP], T).

Această funcţie verifică dacă T are un fiu N astfel încât N.nume=p.nume, şi

atunci incrementează contorul lui N cu 1; altfel creează un nod nou N.

Câmpurile de date ale acestui nou nod N vor fi atribuite astfel: contorul lui N

va fi 1, nodul de legătură va pointa spre T şi va fi legat de noduri prin acelaşi

nume ca şi nodul de legătură. Analog, se poate spune că nodul de legătură a

lui N pointează spre intrarea corespunzătoare p din tabelul antet (header) al

articolelor frecvente. Dacă P nu este vidă, se apelează recursiv funcţia

insert_tree(P, N).

124

5.2.3.1.3. Pasul 3 – Parcurgerea recursivă a arborelui FP-Tree pentru a genera tipare

frecvente multi-nivel şi multi-dimensionale

În pasul 1 şi 2, s-au colectat contoarele pentru fiecare articol în parte. Informaţia

completă din baza de date a fost comprimată sub forma unui arbore FP-Tree. Aceste

lucruri au fost realizate pe parcursul a două parcurgeri a bazei de date. În continuare se

porneşte procesul de generare a tiparelor prin traversarea recursivă a arborelui FP-Tree,

fără a mai implica vreo operaţie cu baza de date. Algoritmul de generare a tiparelor este

prezentat în figura 5.2-9.

Procedura porneşte de la cel mai puţin frecvent articol şi generează baza tiparelor

condiţionale conform căreia se construieşte arborele FP-Tree pentru fiecare membru al

tabelului antet (header). Baza tiparelor condiţionale ale unui articol i, conţine articolele

care sunt în relaţie cu articolul i.

Procedura realizează creşterea fragmentată a tiparelor. Se consideră că suportul

unui articol itemi din baza tiparelor condiţionale a unui tipar k este egal cu suportul

tiparului k+1 corespunzător. Aşadar, dacă un itemi este frecvent în baza tiparelor

condiţionale a tiparului k, Pk, vom obţine tiparul k+1 frecvent, Pk+1, prin concatenarea

acestuia la Pk.

Să nu uităm trăsătura structurii prefix-tree (arbore prefixat) conform căreia, cu cât

un articol este mai frecvent, cu atât există mai multe şanse să se găsească între ramurile

arborelui.

De asemenea, articolele frecvente, indiferent pe ce nivel se găsesc în ierarhia

conceptuală, sunt tratate în mod egal şi vor apare în arborele FP-Tree.

Particularitatea algoritmului ADA-FP este faptul că poate genera tipare frecvente de

pe nivele diferite folosind procedura ADA-FP-Growth, prezentată în figura 5.2-5., la

reparcurgerea arborelui Fp-Tree. A altă noutate adusă de acest algoritm este faptul că spre

deosebire de clasicul FP-Growth care utilizează praguri uniforme, acesta este mai puţin

rigid utilizând constrângeri diferite ale suporturilor. Se introduce un nou concept nou –

pragul de trecere. Astfel, pentru un tipar de lungime k, acesta se evaluează atât faţă de

pragul clasic al suportului cât şi faţă de pragul de trecere al suportului.

Pragul de trecere al suportului are rolul unei bariere împotriva creşterii imposibile a

tiparelor frecvente. Fixarea acestui prag de trecere are o mare influenţă asupra

performanţei. Un prag de trecere prea jos va genera un set mare de candidaţi din care doar

câţiva vor supravieţui.

125

Fig. 5.2-5. Procedura ADA-FP-Growth

În concluzie, algoritmul ADA-FP este un proces în trei etape.

În prima etapă, se parcurge baza de date o dată pentru a contoriza fiecare articol.

Articolele frecvente de dimensiune 1 sunt acelea a căror contor depăşeşte pragul tipar al

suportului.

Intrare: (1) arborele FP-Tree construit la pasul 2; (2) pragul de trecere al nivelului k (k ≥ 2); (3) pragul tipar al nivelului k (k ≥ 2); (4) pragul de trecere pentru articole speciale; (5) pragul tipar pentru articole speciale; Ieşire: L setul multi-nivel al item-ilor (item1, ..., itemn) Procedura: (1) if (arborele conţine o singură cale P) then (2) { foreach( combinaţie rezultată ca β a nodurilor din calea P) do { (3) generează tiparul β∪α cu suportul = minsup al nodurilor din β (4) if (tiparul β∪α conţine itemi speciali) then { (5) if (suportul tiparului β∪α ≥ pragul de trecere ) then { (6) if (suportul tiparului β∪α ≥ pragul tipar ) then (7) add β∪α la L; (8) add β∪α la C; (9) } (10) } (11) else { (12) len = lungimea tiparului β∪α; (13) if (suportul tiparului β∪α ≥ lungimea len a pragului de

trecere) then (14) { if (suportul tiparului β∪α ≥ lungimea len a pragul tipar)

then (15) add β∪α la L; (16) add β∪α la C; (17) } (18) } (19) } (20) } (21) else foreach ( ai din header-ul arborelui) do { (22) generează tiparul β=α cu suportul = ai.support; (23) construieşte baza condiţională a lui β şi apoi arborele

condiţional a lui β FP-Treeβ

(24) } (25) if (Treeβ ≠ ∅) then (26) call ADA-FP-Growth (Treeβ, β) (27) }

126

În etapa a doua, se parcurge baza de date din nou pentru a construi arborele FP-

Tree. Articolele pot să apară în arbore dacă contorul lor depăşeşte pragul lor de trecere

corespunzător. Un articol sau unii dintre descendenţii săi pot să apară pe aceeaşi ramură. În

acest caz, relaţia dintre articolele de pe nivele abstracte diferite nu va fi o relaţie unu-la-

unu. Un articol poate avea mai mulţi ascendenţi diferiţi. Astfel, un tipar frecvent care

conţine toată informaţia taxonomică despre un articol este foarte util pentru utilizator.

În a treia etapă, se parcurge recursiv arborele FP-Tree pentru a genera toate tiparele

frecvente. Algoritmul ADA-FP poate genera seturi de articole frecvente inter-nivel, seturi

de articole frecvente intra-nivel şi seturi de articole frecvente orientate pe dimensiune.

Constrângerile asupra suportului apar de obicei în cuplu (pragul de trecere, pragul

tipar). Primul filtrează membrii imposibili pentru mărirea tiparelor iar al doilea este o

măsură de evaluare a dimensiunii curente a tiparului frecvent. Pe lângă aceste praguri,

există pragurile individuale pentru fiecare articol în parte. Articolele vor fi clasificate într-o

clasă normală şi una specială. La mărirea tiparului se va aplica pragul de lungime

corespunzător. Valoarea pragului de trecere şi cea a pragului tipar au un impact mare

asupra rezultatelor extrase.

5.2.4. Studiu comparativ de performanţă

5.2.4.1. Avantajele ADA-FP faţă de ML_T2L1

Algoritmul ADA-FP prezintă unele avantaje într-un studiu de performanţă

comparativ cu algoritmul ML_T2L1. Acestea sunt:

a) Este mult mai eficient deoarece are nevoie doar de două parcurgeri a bazei de date în

timp ce numărul de parcurgeri ale bazei de la în cazul algoritmului ML_T2L1 depinde

de lungimea tiparelor frecvente (dacă lungimea maximă a tiparelor frecvente este n,

algoritmul are nevoie de n parcurgeri a bazei de date).

b) Poate descoperi tipare frecvente de pe niveluri diferite, deoarece articolele, indiferent

de pe ce nivel abstract sunt, apar în arborele FP-Tree. În timp ce ML_T2L1 adoptă o

metodă progresivă în adâncime, de sus în jos, până ce nu mai poate fi generat nici un

tipar frecvent. La fiecare nivel este aplicat algoritmul APRIORI pentru a descoperi

127

tipare frecvente. Tiparele generate de ML_T2L1 sunt alcătuite din articole de pe acelaşi

nivel abstract.

c) Pentru a creşte flexibilitatea, în procesul de extragere a tiparelor frecvente, s-au

introdus constrângeri diferite pentru suport. Astfel, algoritmul ADA-FP este mult mai

eficient decât ML_T2L1.

5.2.4.2. Avantajele ADA-FP faţă de ADAPTIVE APRIORI

În anul 2000, la a 26a conferinţă internaţională (VLDB 2000), Wang K., He Y. şi

Han J., [WHH00], au propus pentru prima dată utilizarea unor constrângeri diferite pentru

suport la extragerea tiparelor frecvente. Ei au observat că algoritmul clasic APRIORI se

bazează pe folosirea unui prag minim pentru suport uniform. Aceasta duce fie la omiterea

unor tipare interesante cu suport scăzut, fie la apariţia unor încurcături la generarea setului

de itemi. Aceasta i-a determinat să folosească constrângeri diferite pentru suport la

generarea articolelor.

Acesta este punctul de pornire atât la algoritmul ADAPTIVE APRIORI cât şi la

algoritmul ADA-FP. Deosebirea dintre cei doi algoritmi este faptul că ADAPTIVE

APRIORI are la bază metoda APRIORI în timp ce ADA-FP are la bază metoda FP-Growth

care s-a demonstrat că este mai rapidă decât prima. O altă deosebire dintre cei doi

algoritmi este definirea şi implementarea constrângerilor pentru suport.

Comparând cei doi algoritmi, putem concluziona:

a) Este posibil ca, într-un set de articole, mai multe dintre acestea să aibă mai multe

constrângeri pentru suport. În algoritmul ADAPTIVE APRIORI se alege cel cu suportul

minim cel mai mic. În algoritmul ADA-FP se impune un prag tipar de lungime k ca un

criteriu pentru a decide dacă tiparul de lungime k este frecvent sau nu. Astfel este luată

în considerare lungimea caracteristică a unui tipar.

b) În algoritmul ADAPTIVE APRIORI se înlocuieşte suportul minim clasic cu o funcţie

notată Pminsup, care defineşte un superset de articolset-uri frecvente definite prin

minsup generat prin metoda APRIORI. Algoritmul ADA-FP foloseşte pragul de

trecere al suportului pentru a îndepărta seturile de dimensiune 2 care nu sunt frecvente

(2-itemsets) la fiecare încercare de generare a seturilor de dimensiune 3 a articolset-

urilor frecvente (3-itemsets). Astfel creşte claritatea rezultatelor procesului de extragere

a tiparelor frecvente.

128

5.3. Concluzii

Ideea de bază a unui proces eficient de extragere de reguli de asociere din baze

mari de date tranzacţionale este, în primul rând, de a găsi seturi de articole de lungime k (k-

itemsets) (pentru k pornind de la 1), în baza de date, care apar într-un număr suficient de

mare de tranzacţii a căror suport este mai mare decât un prag suport predefinit. În al doilea

rând, asocierea acestor seturi de articole (itemi) de lungime k (k-itemset-uri)în reguli de

asociere cu o confidenţă calculată şi testată pentru a corespunde pragului impus.

Articolele din tranzacţii se presupune că sunt organizate în ierarhii taxonomice (pe

nivele conceptuale) în funcţie de proprietăţile ce le sunt asociate. Fiecare articol poate fi

codificat implicit sau explicit într-un şir de caractere de forma {3***} în funcţie de poziţia

sa în ierarhie.

Algoritmii de extragere de date de pe mai multe nivele conceptuale au fost, în

general, dezvoltaţi prin extinderea tehnicilor existente pentru un singur nivel.

Aşa cum am arătat la prezentarea unora dintre algoritmi, avem posibilitatea de a

adopta praguri diferite ale suportului sau confidenţei pentru diferite nivele conceptuale. În

special, s-a explorat cazul cel mai comun, scăderea pragului pentru suportul minim odată

cu nivelele mai scăzute de abstractizare. Aceasta a condus la obţinerea unor reguli de

asociere interesante la nivele conceptuale multiple, care, pe lângă faptul că sunt diferite

pentru nivele diferite, au şi un potenţial ridicat de a fi însemnate deoarece sunt flexibile şi

pot fi orientate spre diferite seturi de date şi aplicate pentru diferite praguri ale suportului şi

confidenţei la diferite nivele.

Regulile de asociere de bază restricţionează ca, pentru apariţia unui articol în acea

regulă să fie pe nivelul frunză al ierarhiei taxonomice. Dacă articolele sunt organizate în

categorii se pot extrage mult mai multe reguli care altfel nu ar fi putut fi găsite.

Clasificarea taxonomică ne ajută de asemenea la curăţarea regulilor neinteresante sau

redundante.

129

6. ALGORITMI DE EXTRAGERE A DATELOR DIN

BAZE DE DATE MULTI-NIVEL

În ultimii ani asistăm la o creştere explozivă a capacităţii noastre de a genera şi

colecta date. Progresele realizate în colectarea datelor, răspândirea utilizării codurilor bară

pentru majoritatea produselor comerciale şi computerizarea majorităţii tranzacţiilor de

afaceri şi guvernamentale ne-au inundat cu informaţii.

Aceste cantităţi mari de date se memorează în depozite sau antrepozite de date,

numite şi data warehouse, utilizând tehnici speciale, denumite OLTP, OLAP etc. Pentru

astfel de volume de date amorfe, sunt necesare instrumente speciale pentru extragerea

cunoştinţelor. Nu este de mirare că s-a născut o nouă disciplină pe care cei mai mulţi o

denumesc Data Mining (DM), alţii o denumesc Knowledge Discovery (KD), alţii

Knowledge Discovery in Databases (KDD), alţii Information Discovery (ID), alţii

Information Archeology (IA), etc. Fiecare denumire poate fi justificată în felul ei. Trebuie

subliniat însă cã unii autori fac deosebire între unele dintre acestea, de exemplu între DM si

KDD sau KD.



fie la cel mai înalt nivel, ceea ce împiedică uneori găsirea cunoştinţelor dorite în bazele de

date. În primul rând, datorită faptului că, de obicei, seturile de date cu o valoare importantă

a suportului nu se găsesc la nivele conceptuale foarte joase, deoarece tiparele de la nivelele

conceptuale joase tind să fie împrăştiate şi greu au un suport important. În al doilea rând,

regularităţile vor fi găsite mai degrabă la nivele conceptuale înalte, aşadar pot fi deja bine

cunoscute.

Aceste observaţii motivează necesitatea propunerii unor metode de extragere de

cunoştinţe de pe mai multe nivele conceptuale [HF95], [SA95a], [HF97], [Mao01],

[RKS03]. Prin extragerea cunoştinţelor de pe nivele conceptuale diferite putem obţine date

atât de la nivele înalte cât şi de la cele joase. Procesul de extragere de date de pe nivele

multiple poate fi realizat în mai multe moduri:

130

� Adâncirea progresivă – porneşte în cele mai multe cazuri de la nivele înalte

conceptuale, găseşte reguli puternice la acel nivel şi apoi parcurge selectiv

şi progresiv în adâncime nivelele inferioare acestuia pentru a găsi reguli la

aceste nivele.

� Generalizarea progresivă – porneşte în cele mai multe cazuri de la nivele

conceptuale inferioare, găseşte reguli puternice la aceste nivele şi apoi,

generalizează progresiv rezultatele pentru nivelele superioare.

� Parcurgerea interactivă în sus şi în jos – procesul de descoperire de

cunoştinţe poate urca sau coborî pe diferite nivele conceptuale interactiv, la

instrucţiunile utilizatorului, folosind chiar factori suport diferiţi.




respectivă o prezintă [HF95]. Acest fapt, a condus cercetările spre căutarea unor metode de

extragere a regulilor de asociere la mai multe nivele conceptuale, ceea ce duce la

descoperirea nu doar a unor reguli de asociere la fiecare nivel, dar şi extragerea unor reguli

de asociere utile şi informative, datorită flexibilităţii concentrării atenţiei asupra seturilor

diferite de date şi a posibilităţii aplicării unor praguri diferite ale suportului sau confidenţei

pentru nivele diferite.

Folosind ierarhiile conceptuale, datele din bazele de date pot fi exprimate la diferite

nivele de abstractizare care conduc la baze de date multi-nivel şi astfel la generarea unor

reguli multi-nivel. Într-o bază de date pot fi descoperite o multitudine de tipuri de reguli:

� Reguli caracteristice [HCC93] – care totalizează caracteristicile generale

ale unui set de date specificate de utilizator în baza de date.

� Reguli de asociere [HF95] – descoperite dintr-un set relevant de date din

baza de date de forma “A1 ∧ … ∧ Am → B1 ∧ … ∧ Bn“, unde Ai (pentru i ∈

{1, ..., m}) şi Bi (pentru j ∈ {1, ..., n}) sunt mulţimi de perechi „atribut-

valoare”.

� Reguli discriminante [HCC93] – care deosebesc trăsăturile generale ale

unui set de date, numit clasa ţintă, de alte seturi de date, numite clase

contrastante.

131

� Reguli de clasificare [Qui93] – folosite pentru a clasifica un set de date pe

baza valorilor atributelor acestora.

� Reguli de grupare [Fis95] – folosite pentru a grupa un set de date pe baza

principiului de grupare conceptual: maximizarea asemănărilor din interiorul

clasei şi minimizarea asemănărilor dintre clase.

� Reguli de evoluţie a datelor [SA95a] – care sunt un set de reguli ce reflectă

evoluţia comportamentului general al setului de date.

Majoritatea studiilor asupra extragerii regulilor de asociere ([AIS93], [AS94],

[KMR+94], [HF97], [DXGH00], [HGN00], [PJ02], [RKS03]) au folosit bazele de date

tranzacţionale ca şi model tipic de investigare, deoarece procesul de găsire a relaţiilor

dintre articolele bazelor mari de date este solicitat în multe aplicaţii care au nevoie de

performanţă.

Ideea generală a extragerii regulilor de asociere din bazele mari de date

tranzacţionale este următoarea: găsirea tuturor mulţimilor mari de articole (k-itemsets,

cu k pornind de la 1) din baza de date, unde un k-itemset este o mulţime de k

articole (itemi) care apar împreună (în aceeaşi tranzacţie) într-un număr cât mai

mare de tranzacţii şi a căror factor suport nu este mai mic decât un prag suport

specificat sau pre-definit. Apoi, se grupează seturile de k articole în reguli de

asociere cu o confienţă calculată, testată în comparaţie cu un prag impus.

Regulile de asociere multi-nivel pot fi descoperite prin extinderea algoritmilor

existenţi de extragere a regulilor de asociere ale unui singur nivel.

Pornind de la algoritmii propuşi de Han [HF95], [HF99], Strikant [SA95], Rantzau

[Ran97], Wang [WHH00] şi Rajkumar [RKS03] pentru extragerea regulilor de asociere

multi-nivel, am propus în continuare câteva metode originale pentru îmbunătăţirea şi

optimizarea acestora.

132

6.1. Algoritmul Depth First Multi-Level APRIORI (DFMLA)

Primul algoritm propus în acest paragraf, denumit DFMLA, pe care l-am publicat

la Conferinţa microCAD 2005, din Miskolcs, [PGG+05a], are la bază algoritmul APRIORI

[AS94], adaptat de Han pentru extragerea regulilor de asociere multi-nivel ML_T2L1

[HF99], îmbunătăţind performanţele acestuia, prin reducerea numărului de tranzacţii

verificate inutil la generarea regulilor de asociere între articole, înlăturând astfel risipa de

memorie generată de algoritmul APRIORI.

După cum se ştie, algoritmul APRIORI se bazează pe următoarea observaţie:

� Dacă avem un set de articole {item1, item2,} cu suportul S1, în

cazul în care dorim să adăugăm un articol (item3) la această

mulţime, suportul noului set format va fi mai mic sau egal cu S1.

Altfel spus, dacă un articol (item1) se găseşte în N tranzacţii,

acelaşi articol (item1) împreună cu un alt articol (item2) nu pot să

fie găsite în mai multe tranzacţii decât în câte s-a găsit item1

singur. Aşadar, dacă S1 va fi mai mic decât suportul minim, este

evident că suportul noului set format va fi şi el mai mic decât

pragul minim al suportului, deci nu merită să fie luat în

considerare.

În elaborarea algoritmului DFMLA, am plecat de la această observaţie extinzând-o

la cazul bazelor de date multi-nivel. Am prezentat în capitolul anterior avantajele utilizării

bazelor de date multi-nivel.

6.1.1. Prezentarea algoritmului(DFMLA1)

Aşa cum a arătat Han [HF99] şi Rajkumar [RKS03], o bază de date tranzacţională

poate fi transformată într-o bază de date multi-nivel, folosind codificarea informaţiei

ierarhic în locul tabelelor tranzacţionale clasice. Pentru a crea ierarhia bazei de date se

folosesc relaţiile existente între articolele bazei de date, numite taxonomia informaţiei.

Astfel, în tabela tranzacţiilor, fiecare articol va fi codificat ca o secvenţă de cifre. Acest

133

lucru este foarte util atunci când ne interesează doar o parte din tranzacţiile bazei de date

(de exemplu o categorie de produse). Astfel, vom putea colecta mai întâi setul relevant de

date şi apoi să lucrăm doar asupra acestuia în loc să parcurgem de fiecare dată întreaga

bază de date.

Pentru a prezenta algoritmul propus, am considerat un exemplu folosit şi în testarea

acestuia. Am considerat o bază de date tranzacţională, D = {T1, …, Tn} ca fiind o mulţime

de tranzacţii Ti ,(i∈{1, ..., n}), unde fiecare tranzacţie este o mulţime de articole (articolset-

itemset).

Baza de date este alcătuită din:

1. un set de articole (itemset) care conţine descrierea fiecărui articol (item) sub

forma Ai, ce reprezintă codul fiecărui produs

2. un set de tranzacţii de forma (TID, Ai), unde TID reprezintă identificatorul

tranzacţiei.

Fiecare articolset X are o importanţă statistică reprezentată prin suport şi frecvenţă.

Suportul unui articolset S(X) este a cea parte din tranzacţiile bazei de date D care

conţin acel articolset raportată la numărul total de tranzacţii (vezi formula 3.1.2).

||

|}|{|)( ...

D

TXDTXS

⊆∈= (6.1.1)

Se ştie de asemenea că o regulă de asociere este o implicare de forma X ⇒ Y.

Regula se menţine cu o confidenţă (încredere) α care este raportul dintre numărul de

tranzacţii care conţin X ∪ Y şi numărul de tranzacţii care conţin X (vezi formula 3.1.4).

)X(S

)YX(S)Y,X(

U=α (6.1.2)

Confidenţa reflectă puterea unei reguli. Pentru a exclude regulile care nu sunt

destul de puternice pentru a fi interesante am folosit un prag minim pentru confidenţă, αmin.

Ca atare, există şi un prag minim pentru suport Smin care exclude toate regulile care au un

număr sub acest prag de tranzacţii care conţin reuniunea lui X şi Y. Articolset-urile cu un

suport minim sunt denumite articolset-uri frecvente.

134

0 alimente

1 lapte

2 băuturi

1 2%

0 1,8%

1 graham

0 albă

0

Coca 1

Pepsi

0 Cola

1 Prigat

0 pâine

Cele două praguri nu trebuie confundate. Pragul pentru suport este definit asupra

articolset-urilor. Când este aplicată asupra regulilor de asociere, el reprezintă procentul

minim din tranzacţiile care conţin toţi itemii ce apar în regulă. Pragul confidenţei specifică

probabilitatea minimă pentru ca Y să fie adevărat dacă X este adevărat. O confidenţă

apropiată de 100%, este o caracteristică doar a regulilor foarte puternice.

Baza de date, considerată ca şi exemplu, este prezentată sub forma unei ierarhii

conceptuale incluzând categorii şi produse în figura 6.1-1.

Fig. 6.1-1. Baza de date ierarhică multi-nivel

Descrierea şi codificarea articolelor (item-ilor, produselor) este prezentată în tabelul

6.1-1. Pentru a exemplifica, considerăm articolul „Pepsi-Cola” care este codificat „0201”

conform tabelului 6.1-1. Prima cifră „0” reprezintă categoria „alimente” de pe primul

nivel, a doua cifră „2” reprezintă categoria „băuturi” de pe al doilea nivel, a treia cifră „0”

reprezintă categoria „Cola” de pe al treilea nivel şi a patra cifră „1” reprezintă produsul

„Coca”.

Tabelul 6.1-1. conţine codurile categoriilor şi descrierea fiecărui cod (de articol sau

categorie).

135

Tabel 6.1-1. Codurile şi descrierea articolelor

În cazul în care baza de date este alcătuită din cinci tranzacţii, prezentate în tabelul

6.1-2., acestea vor putea fi reprezentate cu ajutorul codurilor articolelor ca în tabelul 6.1-3.

Tabel 6.1-2. Tranzacţiile bazei de date

Cod Descriere

0 Alimente

00 Pâine

01 Lapte

02 Băuturi

000 Albă (Pâine)

001 Graham (Pâine)

010 1,8% (Lapte)

011 2% (Lapte)

020 Cola

021 Prigat

0200 Coca (Cola)

0201 Pepsi (Cola)

Tranzacţie Produs (Articol)

T1 Pâine albă, Lapte 1.8%,

Coca Cola, Prigat

T2 Pâine graham, Lapte 1.8%,

Lapte 2%, Prigat

T3 Lapte 2%, Coca Cola

T4 Lapte 2%, Pepsi Cola

T5 Pâine graham, Coca Cola,

Lapte 2%, Prigat

136

Tabel 6.1-3. Tranzacţiile şi codurile produselor

Am calculat cei doi factori suportul şi confidenţa pentru exemplificare folosind

formulele (6.1.1) şi (6.1.2):

� suportul

%20100*5

1100*

alNrTranzTot

PaineAlbacuNrTranz)Alba.Paine(S ===

%40100*3

2100*

TotalNrTraz

igatPrsiaNrTranzCoc)igatPrCoca((S ===∪

� confidenţa

%66100*3

2100*

CocacuNrTranz

)igatPrsiCocacuNrTranz)igatPrCoca( ===→α

Tranzacţie Cod Produs

(articol)

T1 000

T1 010

T1 0200

T1 021

T2 001

T2 010

T2 011

T2 021

T3 011

T3 0200

T4 011

T4 0201

T5 001

T5 0200

T5 011

T5 021

137

În bazele de date multi-nivel putem descoperi reguli care conţin articole nu doar de

pe un nivel conceptual, ci de pe nivele conceptuale diferite. Aşadar, putem să ne

concentrăm atenţia pe descoperirea unor reguli informative între diferite categorii de

produse, sau chiar între articole şi categorii, nu doar reguli între produse (itemi).

În acest caz, factorii suport şi confidenţă se referă atât la articole cât şi la categorii.

Astfel, suportul unei categorii reprezintă procentul de tranzacţii în care apare acea

categorie. Spre exemplu, suportul categoriei Lapte este calculat mai jos:

%100100*5

5100*

TotalNrTranz

produs.LaptecuNrTranz)Lapte(S ===

Trebuie să ţinem cont de faptul că suportul unei categorii poate să fie diferit de

suma suporturilor descendenţilor săi, dar nu poate fi mai mic decât suportul oricăruia dintre

aceştia.

În acest caz, putem extinde observaţia pe care se bazează algoritmul APRIORI la

nivelul categoriilor:

� Dacă avem o categorie sau un set de categorii cu suportul S1, un

element al acelei categorii va avea un suport mai mic sau egal cu S1.

Aşadar, dacă o categorie nu are suportul mai mare decât pragul

suportului minim, nici un element al său nu va putea avea suportul

mai mare decât pragul suportului minim.

De la această observaţie pleacă algoritmul DFMLA1 pe care l-am propus în acest

paragraf.

Aşa cum a demonstrat Han şi Fu [HF99], nu toate regulile generate trebuie luate în

considerare, ci doar acelea care sunt considerate ca şi importante. În acest caz, importanţa

unei reguli este măsurată prin factorul suport.

Astfel, presupunând că avem 2 categorii, Cat1 şi Cat2, atunci suport(Cat1) >

suport minim şi suport(Cat2) > suport minim deci, suport(1.x) şi suport(2.y) pot fi >

suport minim, adică descendenţii acestor categorii pot avea suport mai mare decât

suportul minim.

Astfel, dacă între Cat1 şi Cat2 nu există o regulă, atunci nici între descendenţii

celor două categorii (1.x şi 2.y) nu va exista nici o regulă (vezi figura 6.1-2).

138

Fig. 6.1-2. Moştenirea unei reguli

Algoritmul fiind proiectat pentru baze de date multi-nivel ne oferă avantajul

utilizării metodei parcurgerii în adâncime a arborelui ierarhiei conceptuale. Această

metodă găseşte articolele frecvente la cel mai înalt nivel şi apoi, progresiv

adânceşte procesul de extragere la descendenţii frecvenţi ai acestora de pe nivele

conceptuale mai joase.

De fiecare dată când găseşte o nouă regulă între două articolset-uri (f → g), i se

testează acestei reguli importanţa (suportul). Dacă nu depăşeşte pragul suport atunci ştim

că nu vor exista reguli de asociere între descendenţii acestor categorii.

Noutatea adusă de algoritmul DFMLA1 este funcţia CheckDescendants(),

prezentată în figura 6.1-3., care este apelată recursiv în cazul în care regula

descoperită trece testul de importanţă.

Fig. 6.1-3. Funcţia recursivă pentru verificarea descendenţilor

S-a notat:

- k – numărul de articole din setul k-articolset

- f, g – articolset-uri din regula f → g

- lvl – nivelul pe care se găseşte f şi g

function CheckDescendants (k, lvl, f, g) { for (f2=1; f2<nr.of.itemsets.descented.from.f.on.lvl+1; f2++) for (g2=1; g2<nr.of.itemsets.descented.from.g.on.lvl+1; g2++) if (f2 → g2 rule is interesting) { Add.Itemset (f2,g2( to L[k, lvl+1]; CheckDescendants (k, lvl+1, f2, g2); //dacă f2 şi g2 există } }

139

Funcţia trebuie apelată înainte de a încerca să găsim o nouă regulă la acelaşi nivel

(lvl) deoarece trebuie să ştim exact care subset-uri (f şi g) au fost folosite în această regulă.

6.1.2. Versiune optimizată a algoritmului (DFMLA2)

Aşa cum arată Han şi Fu în [HF95], o interogare pentru extragere de date este

relevantă doar pentru o parte din tranzacţiile bazei de date (de exemplu, doar pentru cele

referitoare la lapte), nu pentru totalitatea lor. Din acest motiv, am introdus în algoritmul

DFMLA1, filtrarea tranzacţiilor, ceea ce înseamnă că fiecare tranzacţie care nu mai este

folosită este îndepărtată. Am obţinut astfel o versiune optimizată a acestui algoritm pe care

am numit-o DFMLA2.

Deoarece f2 şi g2 sunt derivate din subset-urile f şi g, tranzacţiile

(T(k,lvl+1)) în care acestea au fost găsite sunt de fapt unele (sau toate) din

tranzacţiile în care au fost găsite f şi g (T(k,lvl)). Aşadar, la apelul funcţiei

CheckDescendants() putem să-i transmitem o selecţie (sau doar TID) a

tranzacţiilor în care au fost găsite f şi g (T(k,lvl)). Astfel, funcţia nu va trebui să mai

scaneze întreaga bază de date pentru a verifica importanţa unei reguli ci doar

tranzacţiile selecţionate. În acest mod, la trecerea în adâncime de pe un nivel

conceptual (lvl) pe următorul nivel conceptual (lvl+1), numărul tranzacţiilor va fi tot

mai mic, iar parcurgerea bazei de date va fi tot mai rapidă.

În implementarea versiunii DFMLA2, am filtrat din selecţia anterioară de tranzacţii,

doar pe acelea care conţin articole comune din f şi g.


6.1.3.1. Avantaje

Aceşti algoritmi (DFMLA1 şi DFMLA2) nu caută să găsească reguli între toate

subset-urile k-articolset ci doar între derivaţiile unui subset din acele reguli care au fost

găsite anterior interesante (importante). Ei parcurg arborele ierarhiei conceptuale în

adâncime şi dacă găsesc o regulă la primul nivel conceptual între două categorii caută apoi

care sunt subcategoriile la care se aplică regula. Dacă regula nu trece testul de importanţă,

atunci nu vor exista reguli importante între subcategoriile de pe următorul nivel

conceptual.

140

Spre deosebire de algoritmii propuşi de mine, algoritmul lui Han foloseşte funcţia

de generare a candidaţilor din algoritmul APRIORI la fiecare nivel conceptual. Când

termină de examinat un nivel în întregime, trece la următorul nivel, parcurgând aşadar

arborele ierarhiei conceptuale în lăţime. Pentru a sublinia avantajul algoritmilor propuşi,

am comparat DFMLA1 şi DFMLA2 cu algoritmul APRIORI multi-nivel (ML_T2L1) propus

de Han şi Fu în [HF95].

Studiul comparativ al algoritmilor a fost publicat la conferinţa CSCS’15, Bucureşti

2005, [PGG+05b]. Algoritmii au fost implementaţi cu ajutorul limbajului de programare

Java şi compilaţi cu ajutorul platformei Eclipse. Testările s-au efectuat pe un calculator

Athlon XP la 1.6 GHz, cu memorie de 256 MBRAM, sub sistemul Microsoft Windows

XP Professional, folosind Microsoft SQL 2000 Server şi interfaţa standard ODBC.

Studiul s-a făcut pe baza de date prezentată ca şi exemplu anterior. Baza de date are

50 000 de intrări, 750 de articole distincte codificate pe 10 nivele conceptuale, 7 500 de

tranzacţii, fiecare tranzacţie având cel mult 15 articole.

Ambii algoritmi au fost testaţi pentru regulile: 1→2, 1.1→2.1, 1.1.1→2.1.1, 1→3 şi

2→3. Regulile 1→3 şi 2→3 nu trec testul de importanţă, aşadar algoritmul DFMLA1 nu va

verifica regulile 1.1→3.1, 1.1→3.2, 2.1→3.1, etc. Spre deosebire de celălalt algoritm care

va testa aceste reguli când va ajunge la nivelul respectiv. Se evită astfel multe teste inutile.

Fig. 6.1-4. Comparaţie Multi-level APRIORI (ML_T2L1)cu DFMLA1

141

Versiunea optimizată a algoritmului, DFMLA2, foloseşte filtrarea

tranzacţiilor. Acest lucru măreşte viteza de lucru a algoritmului deoarece la fiecare

trecere la nivelul conceptual următor vom elimina unele tranzacţii. Cu cât baza de

date are mai multe nivele conceptuale, algoritmul poate deveni mai rapid o dată cu

eliminarea unor categorii. Observăm acesta în figura 6.1-5.

Fig. 6.1-5. Comparaţie DFMLA1 cu DFMLA2

6.1.3.2. Dezavantaje

În cazul în care nu sunt eliminate tranzacţii, algoritmul va fi mai lent datorită

timpului pierdut cu filtrarea tranzacţiilor şi celui alocat efectuării testelor de importanţă.

Un alt dezavantaj al acestui algoritm este cantitatea mare de memorie ocupată cu

reţinerea TID-urilor tranzacţiilor testate pentru a putea reveni la nivelul inferior.

142

6.2. Algoritmul Multi-Level FP-Growth (MLFP-Growth)

Bazele de date simplu-nivel conţin de cele mai multe ori informaţii prea complexe

care sunt uneori mai puţin interesante pentru extragerea regulilor de asociere. Aceste

informaţii se găsesc de obicei pe ultimul nivel al bazelor de date multi-nivel, unde se

găsesc informaţii mai concrete, mai specifice decât la nivelele superioare. Astfel, în

practică, managerii unor magazine vor să ştie, de exemplu, dacă pot să aşeze toate tipurile

de pâine lângă lapte sau nu, aşa încât cumpărătorii să aleagă ce pâine doresc. Ei vor să

cunoască reguli mai generale. Pentru a obţine acest gen de informaţii este necesar putem

extrage date la orice nivel conceptual dorim.

Acest lucru este posibil folosind algoritmul APRIORI multi-nivel. Se parcurg astfel

progresiv nivelele de abstractizare ale bazei de date de sus în jos (top-down) reducând în

acest mod setul de candidaţi şi numărul de citiri din baza de date.

O altă metodă este folosirea algoritmului de generare a arborelui FP-Tree care are

nevoie doar de două parcurgeri a bazei de date şi nu generează seturi de candidaţi.

Eficienţa metodei FP-Tree este realizată cu ajutorul a trei tehnici:

1. Bazele de date de dimensiuni mari sunt comprimate în structuri de date

mult mai mici foarte condensate care evită numărul mare şi costisitor de

parcurgeri a bazelor.

2. Extragerea datelor folosind FP-Tree foloseşte metoda creşterii setului de

tipare frecvente pentru a evita costurile mari provocate de generarea

unui număr mare de seturi de candidaţi.

3. Foloseşte o metodă de partiţionare bazată pe tehnica „divide et impera”

pentru a descompune procesul de extragere de date în procese mai mici

fapt ce reduce simţitor intervalul de căutare.

Baza de date este parcursă tot de sus în jos progresiv. Informaţiile obţinute de la

nivele conceptuale înalte sunt insuficiente pentru a trece la nivelele conceptuale următoare.

Deci este necesară o nouă parcurgere a bazei de date pentru a obţine informaţiile care

lipsesc. În acest mod, pentru a obţine informaţii de pe cel mai jos nivel conceptual vom

avea nevoie de cel puţin n+1 parcurgeri a bazei de date.

143

În concluzie, această metodă de folosire a arborelui FP-Tree nu este în totalitate

eficientă. Cu toate acestea, aplicarea algoritmului FP-Growth direct la ultimul nivel, pentru

a obţine informaţii de pe acesta, este o metodă mai rapidă decât aplicarea algoritmului

APRIORI multi-nivel. Am arătat acest lucru comparând timpul de execuţie al celor doi

algoritmi, în figura 6.2-1, testele fiind efectuate în aceleaşi condiţii ca şi în paragraful

anterior.

Fig. 6.2-1. Comparaţie ML_T2L1 cu FP-Growth

6.2.1. Prezentarea algoritmului MLFP-Growth

În continuare am propus un alt algoritm, numit MLFP-Growth, publicat la

Conferinţa CSCS’15, Bucureşti 2005, [GGP+05c]. Pentru a putea explica mai bine

realizarea algoritmului propus, am considerat un exemplu, o bază de date a cărei ierarhie

conceptuală de trei nivele este prezentată în figura 6.2-2.

144

Fig. 6.2-2. Baza de date ierarhică multi-nivel

Codurile şi descrierea categoriilor extrase din figura 6.2-2. sunt prezentate în

tabelul 6.2-1.

Cod Descriere

0 Alimente

01 Fructe

02 Legume

03 Lapte

011 Mere

012 Pere

0111 Mere roşii

0112 Mere verzi

021 Varză

022 Roşii

031 Lapte 1,8%

032 Lapte 2%

Tabel 6.2-1. Codurile şi descrierea categoriilor

0 Alimente

0.2 Legume

0.3 Lapte

0.2.2 Roşii

0.2.1 Varză

0.1.2 Pere

0.1.1 Mere

0.1.1.1 Mere roşii

0.1.1.2 Mere verzi

0.3.1 1,8%

0.3.2 2%

0.1 Fructe 0.4 0.5

0.4.1 0.5.1

145

Aşa cum am arătat la începutul paragrafului 6.2., de multe ori este necesar să putem

extrage informaţii direct de pe un anumit nivel conceptual k al ierarhiei bazei de date.

Pentru a realiza aceasta, există o metodă:

1. obţinerea arborelui FP-Tree şi apoi aplicarea algoritmului FP-Growth

direct pe nivelul conceptual dorit k

O altă metodă, mai eficientă, am propus în această lucrare:

2. dacă avem disponibile informaţiile de pe un nivel l, putem obţine

informaţiile de pe nivelul superior k (l >k) folosind nivelul l.

6.2.1.1. Metoda I: Obţinerea arborelui FP-Tree şi apoi aplicarea

algoritmului FP-Growth direct pe nivelul conceptual k. (MLFP-

Growth I)

Tranzacţiile unei baze de date conţin de obicei articole de pe cel mai jos nivel

conceptual. Pentru a putea obţine informaţii de pe un anumit nivel conceptual va trebui să

transformăm tranzacţiile (sau să le privim într-o altă manieră). Acest lucru se poate realiza

folosind codurile fiecărui produs aşa cum au fost prezentate în tabelul 6.2.1. În cazul în

care rădăcina arborelui nu este considerată un nivel conceptual, fiecare articol este

codificat prin 3 cifre.

Dacă suntem interesaţi de informaţiile de pe al 2-lea nivel conceptual vom folosi

doar primele 2 cifre din identificatorul articolului respectiv. Considerând că suportul

minim este 3, atunci după executarea primului pas al algoritmului de obţinere a arborelui

FP-Tree vom obţine rezultatele prezentate în ultima coloană a tabelului 6.2-2.

146

TID Articole cumpărate Categoriile frecvente de

pe al 2-lea nivel

(ordonate)

1 3.1.1, 1.2.2, 2.2.3,

2.1.1, 1.1.4

1.1, 1.2, 2.1, 3.1

2 2.1.2, 4.1.1 2.1, 4.1

3 2.1.2, 4.1.2, 5.1.3 2.1, 4.1

4 1.2.3, 1.1.2, 3.1.1,

4.1.1

1.1, 1.2, 3.1, 4.1

5 1.1.2, 3.1.1, 1.2.3 1.1, 1.2, 3.1

Tabel 6.2-2. Baza de date tranzacţională

Pe parcursul celui de-al doilea pas al algoritmului obţinem arborele condiţional din

figura 6.2-3. Se poate observa că au fost eliminate categoriile 2.2 şi 5.1 deoarece nu

îndeplineau condiţia de suport minim.

Metoda este mai rapidă decât cazul în care aplicăm algoritmul FP-Growth

pe baza de date văzută ca un singur nivel deoarece avem mai puţine elemente pe

un nivel conceptual oarecare decât pe cel inferior lui.

Fig. 6.2-3. Arborele FP-Tree al celui de-al 2-lea nivel conceptual

Articol Cap listă

1.1

1.2

2.1

3.1

4.1

Tabela

antet

1.1

1.2

2.1

3.1

rădăcina

3.1

4.1

2.1

4.1

147

6.2.1.2. Metoda II: Obţinerea arborelui FP-Tree pentru nivelul k din

arborele nivelului l (l>k) (MLFP-Growth II)

Această metodă am propus-o pentru a putea extrage informaţii direct de pe un

anumit nivel conceptual k, fără a accesa baza de date, folosind arborele FP-Tree al unui

nivel inferior l, obţinut deja.

Deoarece arborele FP-Tree al nivelului conceptual despre care avem

informaţii l, se află deja în memorie, obţinerea arborelui FP-Tree al nivelului k se

face mult mai rapid decât în cazul metodei I. Există cazuri în care nu mai e

necesară o nouă citire din baza de date sau sunt citite foarte puţine tranzacţii.

Arborele FP-Tree obţinut pentru nivelul l conţine aproape toate informaţiile pentru

a construi arborele FP-Tree al nivelului k dorit. Informaţiile care lipsesc sunt cele din

articolele care nu au îndeplinit pragul suportului minim.

Folosind exemplul prezentat anterior vom avea:

Pasul 1. Crearea antetului nivelului k

Se construieşte antetul noului arbore FP-Tree pentru nivelul k (fig. 6.2-4). Acesta

se obţine folosind informaţiile codificate.

Fig. 6.2-4. Crearea tabelei antet pentru nivelul k

Se observă în exemplul considerat, că în antetul nivelului l avem articolele 1.1, 1.2,

2.1, 3.1 şi 4.1, astfel rezultă că la nivelul k sigur vom avea categoriile 1, 2, 3 şi 4.

Nivelul l Nivelul k

Tabela antet Tabela antet

Articol Cap listă

1

2

3

4

Articol Cap listă

1.1

1.2

2.1

3.1

4.1

148

Pasul 2. Completarea antetului

Antetul nivelului k trebuie completat cu articolele care lipsesc. Pentru a face asta,

trebuie citite nodurile care lipsesc din antet, operaţie uşoară în cazul în care antetul a fost

salvat înaintea pasului de curăţare sau dacă articolele au fost doar ascunse în loc să fie

şterse. Astfel se iau toate articolele de pe nivelul k al bazei de date (din figura 6.2-2.

observăm că mai poate exista categoria 5) care nu au fost adăugate şi se verifică dacă

acestea îndeplinesc condiţia de suport minim, fiind adăugate în antet în caz afirmativ.

În exemplul meu, articolul 5 este luat în considerare, dar nu este adăugat pentru că

nu îndeplineşte condiţia de suport minim.

Pasul 3. Completarea arborelui FP-Tree al nivelului l

Înainte de a crea structura arborescentă a nivelului k, trebuie completată cea a

nivelului l. Va trebui să adăugăm la arborele FP-Tree al nivelului l acele tranzacţii care

conţin nodurile adăugate. Aceasta presupune accesarea bazei de date, însă doar a câtorva

tranzacţii spre deosebire de cele două parcurgeri necesare în metoda I.

În exemplul meu, (fig. 6.2-5), categoria 2, din antetul nivelului k are 2 fii în nivelul

l. Unul dintre ei, 2.2, nu apare în arborele nivelului l, aşa încât îl adăugăm (adăugăm toate

tranzacţiile în care apare 2.2). De asemenea articolul 5.1, nu a fost adăugat pentru că nu

îndeplineşte pragul suportului minim.

Fig. 6.2-5. Completarea arborelui FP-Tree al nivelului l

Articol Cap listă

1.1

1.2

2.1

3.1

4.1

2.2 5.1

Tabela antet

1.1

1.2

2.1

3.1

rădăcina

3.1

4.1

2.1

4.1

2.2 2.2

149

Pasul 4. Reordonarea antetului nivelului k

Antetul nivelului k a fost completat la pasul 2 şi conţine în acest moment

identificatorii (ID) articolelor corespunzătoare nivelului k. Elementele antetului nivelului k

vor fi reordonate în funcţie de factorul suport. Putem afla suportul fiecărui element din

antet fără a citi baza de date din nou. Toate informaţiile necesare se găsesc acum în

arborele obţinut la pasul 3.

Pentru a calcula factorul suport al articolelor de pe nivelul k, vom folosi un

algoritm recursiv aplicat pe arborele nivelului l. Pornind de la rădăcină parcurgem arborele

în jos şi:

1. suportul categoriei 1 este suportul primului element din categorie găsit (ex. 1.1

sau 1.1.1, etc.)

2. dacă ajungem la o intersecţie înainte să găsim un astfel de element, atunci,

pentru fiecare ramură aplicăm din nou regula 1. Suportul va fi egal cu suma

suporturilor găsite pe fiecare ramură.

De exemplu, suportul categoriei 3 va fi suma suporturilor articolelor 3.1 de pe cele

2 ramuri.

Antetul nivelului k este acum finalizat.

Pasul 5. Crearea arborelui FP-Tree pentru nivelul k

Pornim de la nodurile terminale spre rădăcina arborelui nivelului l. Vom urma

tiparele lor condiţionale (ramurile arborelui) şi vom extrage toate articolele nivelului k care

apar. În cazul în care apar mai multe articole ale aceleaşi categorii (ex. 2.1 şi 2.1) vom lua

categoria o singură dată iar suportul ei va fi egal cu suma suporturilor articolelor (ex.

suport 2.1 + suport 2.2). Se creează astfel o mulţime (articolset-itemset) care este adăugată

noului arbore al nivelului k (vezi tabelul 6.2-3).

150

NR Tiparele condiţionale extrase Articolset-urile adăugate în

arbore (ordonate)

1 1.1, 1.2, 2.1, 3.1, 2.2 1, 2, 3

2 2.1, 4.1, 5.1 2, 4

3 2.1, 4.1 2, 4

4 1.1, 1.2, 3.1, 4.1 1, 3, 4

Tabel 6.2-3. Crearea bazei condiţionale de tipare pentru nivelul k

În exemplul considerat, extragem din arborele nivelului l (fig. 6.2-5), de jos în sus,

articolele: 2.2, 3.1, 2.1, 1.2, 1.1. obţinem astfel categoriile: 2, 3, 2, 1, 1. După ce facem

reordonarea antetului k vom avea: 3, 2, 2, 1, 1. Luăm articolele o singură dată: 3, 2, 1. Apoi

adăugăm această ramură la arborele nivelului k. Analog procedăm cu fiecare ramură a

arborelui obţinând în final arborele FP-Tree al nivelului k (fig. 6.2-6). Aşa cum ştim,

categoria 5 a fost curăţată deoarece nu îndeplinea condiţia suportului minim.

În cazul în care, rar în practică, nici un articol nu va fi curăţat din arborele nivelului

l, paşii 2 şi 3 nu sunt necesari iar baza de date nu va fi accesată deloc. Astfel, dacă avem

arborele FP-Tree al celui mai jos nivel conceptual din care nu sunt îndepărtate articole,

putem obţine informaţii pentru orice alt nivel conceptual fără să accesăm baza de date.

Acest lucru este util atunci când avem nevoie de informaţii de pe mai multe nivele

conceptuale.

Fig. 6.2-6. Arborele FP-Tree al nivelului k

Articol Cap listă

1

2

3

4

Tabela

antet

1

2

3

rădăcina

3

4

2

4

151


6.2.2.1. Avantaje

Unul din principalii factori care micşorează viteza de lucru a algoritmului de creare

a arborelui FP-Tree este numărul de accesări a bazei de date. Metoda II propusă în

această lucrare (MLFP-Growth II) utilizează informaţii anterioare pentru a evita

accesarea bazei de date lucrând în special cu memoria calculatorului, ceea ce

este mult mai rapid. Baza de date este eventual accesată doar pentru a obţine

informaţiile care lipsesc (vezi pasul 2 şi 3 al metodei).

Pentru a demonstra eficienţa algoritmilor propuşi am făcut o serie de teste de

performanţă, publicate la Conferinţa CSCS’15, Bucureşti 2005, [GGP+05c]. Pentru

aceasta, algoritmii au fost implementaţi cu ajutorul limbajului de programare Java şi

compilaţi cu ajutorul platformei Eclipse. Testările s-au efectuat pe un calculator Athlon XP

la 1.6 GHz, cu memorie de 256 MBRAM, sub sistemul Microsoft Windows XP

Professional, folosind Microsoft SQL 2000 Server şi interfaţa standard ODBC.

Am studiat comparativ cele două metode pe o bază de date reală, cu 50 000 de

intrări, 750 de articole codificate pe 10 nivele conceptuale, 6 000 de tranzacţii, fiecare

având cel mult 10 articole. În ambele cazuri factorul suport a variat de la 5% până la 40%.

În tabelul 6.2-4. sunt prezentaţi timpii obţinuţi de algoritmul MLFP-Growth I (Metoda I),

iar în tabelul 6.2-5. sunt prezentaţi timpii obţinuţi prin executarea algoritmului MLFP-

Growth II (Metoda II).

Timp

(sec)

Suport (%)

Nr

tranz

(în mii) 5 10 15 20 25 30 35 40 60 80 90

5.000 0.75 0.72 0.66 0.64 0.61 0.60 0.58 0.54 0.42 0.35 0.13 5.000 0.52 0.63 0.61 0.57 0.46 0.43 0.42 0.39 5.000 0.52 0.63

Tabel 6.2-4. Rezultatele obţinute de algoritmii MLFP-Growth I (Metoda I) şi

MLFP-Growth II (Metoda II)

Cu cât distanţa dintre nivelele conceptuale k şi l este mai mare, cu atât pot exista

mai multe informaţii lipsă, ceea ce forţează accesarea bazei de date pentru obţinerea lor. În

cazul în care nu există informaţii lipsă între cele două nivele conceptuale, singurul motiv

152

de accesare a bazei de date rămâne pentru verificarea factorului suport (vezi pasul 2 al

algoritmului) iar uneori nici aceasta nu este necesar.

Performanţa MLFP-Growth II faţă de MLFP-Growth I depinde de asemenea

de pragul suportului minim. Dacă acesta este foarte scăzut, vom avea foarte

puţine informaţii îndepărtate la cel mai jos nivel conceptual, ceea ce face MLFP-

Growth II mai rapid.

Fig. 6.2-7. Comparaţie MLFP-GrowthI( Metoda I) cu MLFP-GrowthII (Metoda II)

Algoritmul MLFP-Growth II cere ca algoritmul FP-Tree să fie rulat înaintea

sa pentru a obţine arborele iniţial. În cazul în care MLFP-Growth II este folosit

pentru mai multe nivele conceptuale, arborele FP-Tree iniţial este creat o singură

dată.


Cu cât distanţa dintre cele două nivele conceptuale (k şi l) este mai mare, cu atât pot

exista mai multe informaţii lipsă, ceea ce forţează accesarea bazei de date. Cu cât avem

mai puţine informaţii lipsă între nivelele k şi l, accesarea bazei de date va fi necesară doar

pentru verificarea şi calcularea suportului, uneori nici aceasta nu este necesară.

Timpul de execuţie al algoritmului MLFP-Growth pentru acelaşi nivel conceptual

diferă în funcţie de distanţa dintre cele două nivele conceptuale.

153

6.3. Algoritmul Multi-Level AFOPT (ML-AFOPT)

În continuare, am propus un algoritm pentru extragerea tiparelor frecvente din baze

de date multi-nivel, ML-AFOPT, pornind de la algoritmul AFOPT prezentat de Liu G. în

[LLX+03]. Deoarece am arătat anterior avantajele oferite de utilizarea bazelor de date

multi-nivel, am încercat să adaptez algoritmul propus de Liu G. asupra acestora.

Algoritmul propus de mine, a fost publicat la Conferinţa SYNASC 2005, Timişoara,

[GGP+05a].

Algoritmul AFOPT [LLX+03] utilizează o abordare a creşterii tiparului şi foloseşte

o structură de arbore prefixat (prefix-tree) pentru a reprezenta baza de date condiţională. El

foloseşte o strategie diferită de traversare a arborelui şi o altă metodă de ordonare a item-

ilor.

Folosirea structurii AFOPT pentru a reprezenta bazele de date condiţionale

duce la obţinerea unor costuri de traversare minime iar utilizarea ordonării

crescătoare după frecvenţă ne conduce la construirea unui număr minim de baze

de date condiţionale, deoarece bazele condiţionale sunt de obicei reprezentate

printr-o singură ramură în structura AFOPT.

Aşa cum am arătat în paragraful 6.2.1., pentru a obţine o anumită informaţie situată

pe nivelul conceptual K, există două posibilităţi (am folosit de această dată structura

AFOPT în locul structurii FP-Tree):

1. folosirea directă a structurii AFOPT pe nivelul respectiv k

2. dacă avem informaţii obţinute anterior pe un nivel inferior l (l>k), atunci putem

folosi aceste informaţii pentru a obţine informaţiile dorite de pe nivelul k

În cazul algoritmilor de extragere a tiparelor frecvente, bazaţi pe abordarea

APRIORI (de exemplu algoritmul ML_T2L1), nu este indicat să folosim metoda parcurgerii

de sus în jos a arborilor, deoarece aceştia au nevoie de k+1 parcurgeri a bazei de date

pentru obţinerea unor informaţii de pe nivelul conceptual k, în timp ce folosind aplicarea

algoritmului AFOPT (sau FP-Growth) direct pe nivelul k, sunt necesare doar două

parcurgeri a bazei de date pentru a obţine aceste informaţii.

154

6.3.1. Prezentarea algoritmului

Vom considera în continuare, o bază de date tranzacţională ale cărei tranzacţii sunt

prezentate în tabelul următor 6.3-1.

TID Articole

T1 3.1.1 1.2.2 2.2.3 2.1.1 1.1.4 1.1.2 T2 2.1.2 4.1.1 1.2.2 1.1.2 3.1.1 T3 2.1.2 4.1.2 5.1.3 1.1.2 T4 1.2.3 1.1.2 3.1.1 4.1.1 T5 1.1.2 3.1.1 1.2.3 1.2.2

Tabel 6.3-1. Tranzacţiile bazei de date

Având în vedere faptul că metoda propusă are la bază algoritmul AFOPT,

traversarea bazei de date originale pentru a găsi articole frecvente sau nivele abstracte

frecvente se face în acelaşi mod ca şi în algoritmul original [LLX+03]. De asemenea,

ordonarea articolelor în ordinea crescătoare a frecvenţei lor de apariţie este aceeaşi.

În tabelul 6.2-2. sunt prezentate valorile factorului suport pentru articolele care apar

în aceste tranzacţii, următorul tabel, 6.3-3., prezentând sortarea acestora în ordine

crescătoare a frecvenţei de apariţie.

Tabel 6.3-2. Articolele bazei de date Tabel 6.3-3. Articolele sortate ascendent

Cod articol Sup

3.1.1 4 1.2.2 3 2.2.3 1 2.1.1 1 1.1.4 1 1.1.2 5 2.1.2 2 4.1.1 2 4.1.2 1 5.1.3 1 1.2.3 2

Cod articol Sup

4.1.1 2 2.1.2 2 1.2.3 2 1.2.2 3 3.1.1 4 1.1.2 5

------------------ -------- 2.1.1 1 2.2.3 1 4.1.2 1 1.1.4 1 5.1.3 1

155

După prima parcurgere a bazei de date se obţine ordonarea crescătoare a articolelor

după frecvenţa lor de apariţie, tabelul 6.3-3. Observăm ca în partea superioară a acestui

tabel, până la linia punctată, apar articolele frecvente, iar sub aceasta articolele care nu sunt

frecvente.

Apoi, baza de date originală este parcursă a doua oară pentru a construi structura

arborescentă AFOPT care reprezintă baza condiţională de articole frecvente. Mai întâi este

construită tabela antet, folosind doar acele articole (categorii) a căror suport depăşeşte

pragul suportului minim, şi care sunt sortate în ordinea crescătoare a frecvenţei de apariţie,

spre deosebire de sortarea în ordine descrescătoare folosită în algoritmul FP-Growth.

Baza de date condiţională a unui articol i include toate tranzacţiile care conţin

articolul i, iar articolele (itemii) care nu sunt frecvente şi cele care se găsesc înaintea lui i

sunt îndepărtate din fiecare tranzacţie. La stocarea ramurilor simple din arborele prefixat se

folosesc tablouri (array) pentru a salva spaţiu şi a micşora costurile de construcţie a

arborelui. Fiecare nod din arborele AFOPT conţine trei tipuri de informaţii: identificatorul

articolului (ID), numărul articolset-urilor corespunzătoare căii de la rădăcină până la acel

nod şi pointerii care indică fii nodului respectiv. Fiecare element din tablou păstrează

primele două informaţii. În continuare, vom nota p.item identificatorul nodului p din

arborele AFOPT.

Fig. 6.3-1. Arborele AFOPT

În aceşti doi primi paşi este numărat fiecare articol individual, iar informaţiile

complete despre baza de date tranzacţională este comprimată în structura

arborescentă AFOPT. Aceste operaţii sunt realizate cu costul a două parcurgeri

ale bazei de date.

156

Din acest moment, procesul de generare a tiparelor frecvente este realizat

prin parcurgerea recursivă a structurii AFOPT fără a implica alte operaţii

costisitoare asupra bazei de date.

Metoda ne permite să obţinem informaţii de pe un anumit nivel conceptual k, atunci

când avem deja informaţiile de pe nivelul l, care este un nivel conceptual mai jos decât k.

Arborele AFOPT obţinut pentru nivelul l conţine deja aproape toate informaţiile necesare

construirii arborelui AFOPT necesar nivelului k. Singurele informaţii care lipsesc sunt cele

din articolele care au fost eliminate deoarece nu au îndeplinit suportul minim, dar care pot

afecta arborele nivelului k. O structură AFOPT este formată dintr-o tabelă antet şi arborele

propriu-zis. Nodurile de legătură din tabela antet ne arată poziţia elementelor respective în

arbore.

Pentru a obţine structura arborescentă AFOPT a nivelului k se parcurg următorii

paşi:

Pasul 1. Crearea tabelei antet pentru nivelul k:

Arborele AFOPT al nivelului k are nevoie de o tabelă antet care este obţinută folosind

clasificarea informaţiile pe categorii şi subcategorii specifică bazelor de date multi-nivel.

Astfel, din tabela antet a nivelului l se poate obţine tabela antet parţială a nivelului k, care

va fi completată la pasul 2.

Tabela antet al nivelului l Tabela antet al nivelului k Articol Noduri de legătură

3.1.1

1.2.2

2.2.3

........

Articol Noduri de legătură

3.1

1.2

2.2

........

Fig. 6.3-2. Construirea tabelei antet a nivelului k

Pasul 2. Completarea tabelei antet

Tabela antet a nivelului l, pe care o avem, trebuie completată cu articolele care lipsesc,

acelea care au fost eliminate deoarece nu aveau suport minim. Pentru aceasta, se citesc

nodurile lipsă, ceea ce este foarte simplu dacă tabela antet a fost salvată înainte de pasul de

curăţare sau dacă articolele au fost doar ascunse în loc să fie şterse. Pentru fiecare articol

adăugat în tabela antet a nivelului l, trebuie să adăugam categoria corespunzătoare în tabela

antet a nodului k, şi să obţinem suportul acesteia. Dacă în nivelul k aceste articole

(categorii) nu îndeplinesc suportul minim ele sunt curăţate (îndepărtate); articolele

corespunzătoare din nivelul l sunt de asemenea curăţate, chiar dacă ele tocmai au fost

adăugate. După acest pas vom avea două tabele antet pentru nivelele k şi l (fig. 6.3-3).

Fig. 6.3-3. Completarea tabelei antet

Pasul 3. Completarea arborelui nivelului l

Pentru toate articolele adăugate la pasul anterior trebuie să adăugăm din baza de date

tranzacţiile care conţin aceste articole (vezi tabelul 6.3-4). Aceasta presupune accesarea

bazei de date, dar numai pentru citirea tranzacţiilor necesare, spre deosebire de cele două

parcurgeri integrale necesare în cazul utilizării metodei 1.

Completarea arborelui AFOPT cu articolele lipsă este prezentată în figura 6.3-4.

Observăm ca articolele 5.1.3 şi 2.2.2 nu au fost adăugate (au fost adăugate şi apoi

îndepărtate) deoarece articolele (categoriile) corespunzătoare lor de pe nivelul k (5.1 şi 2.2)

Nivelul l Suport

2.1.1 1 2.2.3 1 4.1.2 1 1.1.4 1 5.1.3 1

----------- ------- 4.1.1 2 2.1.2 2 1.2.3 2 1.2.2 3 3.1.1 4 1.1.2 5

Nivelul k Suport

2.1 3 2.2 1 4.1 3 1.1 5 5.1 1

------- ------- 4.1 2.1 1.2 1.2 3.1 1.1

158

nu îndeplinesc suportul minim. De asemenea tranzacţiile care conţin aceste articole nu au

fost adăugate în arborele AFOPT.

TID Articole

T1 2.1.1 1.1.4 1.2.2 3.1.1 1.1.2

T2 Nu se citeşte T3 4.1.2

2.1.2 1.1.2 T4 Nu se citeşte T5 Nu se citeşte

Tabel 6.3-4. Tranzacţiile adăugate

Fig. 6.3-4. Arborele AFOPT completat al nivelului l

Pasul 4. Reordonarea tabelei antet a nivelului k

Tabela antet a nivelului k a fost completată la pasul 2 şi conţine identificatorii articolelor

corespunzătoare nivelului conceptual k. Pentru fiecare articole nou introdus în tabela antet

trebuie calculat suportul. Pentru aceasta folosim un algoritm recursiv aplicat pe arborele

AFOPT al nivelului l. Astfel, pornind de la rădăcină în jos, vom avea:

- Suportul pentru categoria X (de exemplu) va fi suportul primului articol găsit

care face parte din categoria X. În cazul nostru concret, suportul pentru

categoria 2.1 va fi suportul primului articol găsit care face parte din categoria

2.1, adică 2.1.1

- Dacă ajungem la o ramificaţie (şi nu am găsit articolul căutat) vom aplica aceşti

paşi pe fiecare ramură adunând suporturile obţinute. În exemplul nostru, există

159

o ramificaţie chiar sub rădăcină. Astfel, pentru categoria 2.1, suportul se va

obţine adunând suportul obţinut pe fiecare ramură:

• Pe prima ramură, întâlnim 2.1.1 cu suportul 1 ⇒ suportul parţial pentru

2.1 va fi 1

• Pe ramura a doua, întâlnim 2.1.2 cu suportul 1 ⇒ suportul parţial pentru

2.1 va fi 1

• Pe ramura a treia, întâlnim 2.1.2 cu suportul 1 ⇒ suportul parţial pentru

2.1 va fi 1

• Adunând suporturile parţiale obţinem suportul total 1+1+1 = 3

Reordonăm tabela antet a nivelului k şi obţinem (tabelul 6.3-5):

Tabel 6.3-5. Ordonarea tabelei antet a nivelului k

Pasul 5. Crearea arborelui AFOPT pentru nivelul k

Pornind de la fiecare nod terminal al arborelui nivelului l, vom urma tiparul lor condiţional

şi vom extrage toate articolele de pe nivelul k care apar şi suportul corespunzător al

acestora. Dacă articolele apar de mai multe ori, le vom considera o singură dată dar vom

aduna suporturile lor. Vom crea astfel un itemset care este adăugat noului arbore al

nivelului k.

În exemplul nostru concret, extragem toate ramurile posibile din arbore:

• 2.1, 1.1, 1.2, 3.1

• 4.1, 2.1, 1.2, 3.1, 1.1

• 4.1, 2.1, 1.1

• 1.2, 4.1, 3.1, 1.1

• 1.2, 3.1, 1.1

Nivelul k Suport

2.1 3 4.1 3 3.1 4 1.2 4 1.1 5

160

Reordonăm antetul şi în final, se obţine arborele AFOPT al nivelului k (fig. 6.3-5).

Aplicând asupra acestuia algoritmul FP-Growth putem obţine articolset-urile frecvente de

pe primul nivel conceptual.

Fig. 6.3-5. Arborele AFOPT al nivelului k

Există cazuri, destul de rare în practică, în care nici un articol din arborele AFOPT

al nivelului l nu este îndepărtat. În acest caz, paşii 1-3 nu sunt necesari, deci baza de date

nu va fi accesată deloc. Astfel, dacă avem un arbore AFOPT pentru cel mai jos nivel

conceptual din care nu sunt îndepărtate articole, atunci vom putea obţine informaţii

de pe orice nivel conceptual fără a fi necesară o accesare a bazei de date. Acest

caz este util atunci când avem nevoie de informaţii de pe mai multe nivele

conceptual.


6.3.2.1. Avantaje

Prin traversarea nodurilor structurii AFOPT în adâncime, de sus în jos, fiecare nod

va fi vizitat exact o dată.

Numărul total de noduri vizitate în cazul algoritmului FP-Growth este egal cu

lungimea totală a ramurilor arborelui FP-Tree.

Numărul total de noduri vizitate în cazul algoritmului ML-AFOPT este egal

cu dimensiunea structurii AFOPT, care este mai mică decât lungimea totală a

ramurilor sale nfp. Aşadar, algoritmul ML-AFOPT necesită costuri mai mici de

traversare decât algoritmul FP-Growth.

161

În cazul structurii FP-Tree articolele sunt sortate în ordine descrescătoare, aşa cum

am arătat, ceea ce favorizează distribuirea prefixată. Astfel, structura FP-Tree este mai

compactă decât structura AFOPT. Aplicarea algoritmului ML-AFOPT asupra structurii

AFOPT este aproximativ acelaşi lucru ca şi transformarea arborelui FP-Tree, deoarece sunt

extrase aceleaşi tipare frecvente (maximale), singura diferenţă fiind ordinea (inversă). Pe

de altă parte, aşa cum am arătat mai înainte, algoritmul ML-AFOPT necesită costuri de

traversare mai mici decât algoritmul FP-Growth.

Dacă este disponibilă informaţia de pe cel mai jos nivel de abstractizare

(salvată pe disc sau în memorie), folosind algoritmul ML-AFOPT nu va mai fi

necesară nici o parcurgere a bazei de date (vezi fig. 6.3-7.).

Timp

(sec)

Suport (%)

Nr tranz

(în mii) 5 10 15 20 25 30 35 40 60 80 90

5.000 0.8 0.68 0.45 0.20 0.18 0.14 0.13 0.11 0.1 0.06 0.04

Tabel 6.3-6. Rezultatele obţinute de algoritmul ML-AFOPT

Fig. 6.3-6. Timpii de execuţie ai algoritmului ML-AFOPT

162

Studierea comparativă a acestor algoritmi a făcut subiectul lucrării [GGP+05a]

publicate la Conferinţa SYNASC 2005, Timişoara. Testările s-au efectuat pe un calculator

Athlon XP la 1.6 GHz, cu memorie de 256 MBRAM, sub sistemul Microsoft Windows

XP Professional, folosind Microsoft SQL 2000 Server şi interfaţa standard ODBC.

Am folosit o bază de date reală de 50 000 de intrări în 6 000 de tranzacţii.

Implementarea algoritmilor s-a realizat în limbajul Java şi au fost compilate folosind

platforma Eclipse.


Este posibil ca, în unele cazuri particulare, toate bazele de date condiţionale ale

extensiilor frecvente ale seturilor de articole frecvente să poată fi reprezentate printr-o

singură ramură în arborele FP-Tree, în timp ce în structura AFOPT să fie necesare mai

multe ramuri.

În aceste cazuri, nici unul din cei doi algoritmi nu necesită construirea unei noi

baze de date condiţionale, dar în acest caz, algoritmul AFOPT are nevoie de costuri mai

mari de traversare. Aceste costuri suplimentare de traversare sunt cauzate de pasul de

reunire spre dreapta.

În orice caz, posibilitatea să existe astfel de cazuri este mult mai mică decât

posibilitatea ca baza de date condiţională să fie reprezentată printr-o singură ramură.

Numărul de subarbori care constituie baza de date condiţională, în cazul cel mai

defavorabil, depinde exponenţial de numărul de articole precedente celui considerat.

Numărul de operaţii de reunire necesare este egal, în cazul cel mai defavorabil, cu numărul

de articole precedente celui considerat.

163

6.4. Algoritmul ML-ADA-AFOPT

Algoritmul pe care l-am propus în acest paragraf ML-ADA-AFOPT, este inspirat

din algoritmul ADA-FP [Mao01], care s-a dovedit a fi mai rapid decât algoritmii FP-

Growth [HPY00] şi AFOPT [LLX+03], acesta din urmă dovedindu-se a fi mai rapid decât

algoritmii FP-Growth şi APRIORI [AS94]. Algoritmul propus a fost publicat la Conferinţa

SYNASC 2005, Timişoara, [GGP+05b].

Am arătat în capitolele anterioare că toţi algoritmii bazaţi pe extragerea tiparelor

frecvente sunt superiori celor care au la bază ideea algoritmului APRIORI, în special în

cazul bazelor de date mai dense.

Am văzut că una dintre particularităţile algoritmului AFOPT o reprezintă structura

AFOPT (Ascending Frequency Ordered Prefix-Tree) care este creată, şi care este o

structură arborescentă ce reprezintă baza de date condiţională, traversată de algoritm de sus

în jos. Combinarea celor două strategii de traversare a arborelui de sus în jos şi cea de

sortare în ordine crescătoare a frecvenţelor de apariţie a articolelor are ca efect minimizarea

atât a numărului total de baze condiţionale cât şi a costurilor de traversare a bazelor de date

individuale.

Structura AFOPT este o reprezentare compactă a bazei de date condiţionale. Ea

conţine informaţii complete pentru a putea extrage seturile frecvente de articole din baza

de date originală. Dimensiunea structurii AFOPT este limitată de numărul total de articole

frecvente care apar în baza de date, fiind de obicei mult mai mică decât acesta.

O dată structura AFOPT construită, procesul de extragere va continua asupra

acesteia. Ca şi în cazul algoritmului FP-Growth, care foloseşte structura arborescentă FP-

Tree, nu este necesară parcurgerea din nou a bazei de date originale. Cu toate acestea,

există destul de multe diferenţe între procesul de extragere aplicat pe o structură FP-Tree şi

cel aplicat pe o structură AFOPT.

6.4.1. Prezentarea algoritmului

Algoritmul propus în continuare, ML-ADA-AFOPT, poate fi utilizat pentru

extragerea tiparelor frecvente multi-nivel. Acesta s-a obţinut prin adaptarea algoritmului

AFOPT [LLX+03] la baze de date multi-nivel, păstrându-se toate trăsăturile de bază ale

algoritmului original AFOPT.

164

În practică există cazuri în care trebuie să se ţină cont, de multe ori, de informaţia

dimensiune. Astfel, apare problema de adaptare a algoritmilor existenţi de extragere a

tiparelor frecvente (AFOPT, FP-Growth) astfel încât aceştia să ţină cont şi de informaţia

despre dimensiune la fel ca şi de informaţia despre articole (itemi) aşa cum o face

algoritmul ADA-FP [Mao01].

Pentru a evita problemele cauzate de utilizarea unui prag suport uniform, cum ar fi

generarea unor tipare lipsite de importanţă la nivele de abstractizare superioare, sau

pierderea unor potenţiale tipare interesante la nivele de abstractizare joase, algoritmul

ADA-FP foloseşte un prag suport flexibil.

La fiecare nivel de abstractizare, vom clasifica articolele individuale în două

categorii: articole normale şi articole speciale. Astfel, la fiecare nivel vor fi necesare două

tipuri de prag suport, atât pentru articolele normale cât şi pentru cele speciale. Cele două

tipuri de prag suport sunt pragul de trecere (item passage threshold) şi pragul de afişare

(item printing threshold). De obicei, cel de-al doilea este mai mare decât primul.

Un articol este tratat ca un 1-itemset frecvent dacă numărul său de apariţii depăşeşte

pragul de afişare. Pe de altă parte, cât timp suportul său depăşeşte pragul de trecere, item-ul

va putea avea şansa să rămână în baza de date pentru a genera un set frecvent de 2 itemi (2-

itemsets). Aceasta se bazează pe observaţia că tiparele de dimensiune mare au de obicei

asociate praguri suport mai mici decât sub-tiparele lor.

Exemplu: Pentru a ilustra cele afirmate mai sus, considerăm 1 000 de tranzacţii în care

ciocolata apare de 50 de ori, laptele apare de 500 de ori, diamantul apare 1 dată. Articolele

au fost împărţite în două categorii: normale şi speciale. Cele speciale pot fi de asemenea de

două tipuri: rare şi frecvente. În acest caz, atât laptele cât şi diamantul sunt articole

speciale. Laptele este un articol special frecvent, iar diamantul este un articol special rar.

Ambele necesită însă un prag suport de trecere cât şi un prag suport de afişare.

Folosirea unui prag suport uniform poate duce la pierderea unor informaţii importante.

Astfel, este important orice set se articole care conţine diamant, chiar dacă s-a vândut unul

singur (având în vedere preţul acestuia). Pe de altă parte, sunt mai puţin importante seturile

de articole care conţin lapte din care s-au vândut câteva sute de litri, acestea ar fi

importante dacă s-ar vinde în cantităţi mult mai mari (mii de litri).

Vom avea astfel trei tipuri de prag suport: prag suport minim pentru articolele speciale

rare (diamant), prag suport minim pentru articolele speciale frecvente (lapte, pâine) şi

prag suport minim pentru articolele normale (ciocolata).

165

Algoritmul ADA-FP ajută utilizatorii, prin utilizarea acestor tipuri variate de

praguri suport în tranzacţiile bazei de date, îmbunătăţind consistent generarea de tipare

frecvente. Acest avantaj va fi exploatat în algoritmul ML-ADA-AFOPT.

Fiind bazat pe algoritmul AFOPT, algoritmul propus în acest paragraf, ML-

ADA-AFOPT, parcurge baza de date originală prima dată pentru a găsi articolele

frecvente sau nivelele de abstractizare şi pentru a le sorta în ordine crescătoare a

apariţiei lor. Apoi, baza de date originală este parcursă a doua oară pentru a

construi structura arborescentă AFOPT care reprezintă baza de date condiţională

a articolelor frecvente.

Baza de date condiţională a unui articol i include toate tranzacţiile care conţin acest

articol i, articolele care nu sunt frecvente şi cele care se găsesc înaintea acestora fiind

îndepărtate din fiecare tranzacţie.

Pentru a stoca ramurile simple ale arborelui AFOPT sunt utilizate structuri de date

tablou (array) deoarece acestea economisesc spaţiu de memorie şi micşorează costurile de

construcţie.

Fiecare nod din arborele AFOPT conţine trei tipuri de informaţii:

• Identificatorul articolului (ID)

• Numărul de articolset-uri corespunzătoare căii de la rădăcină la acel nod

• Pointeri spre fii nodului respectiv

După primii doi paşi prezentaţi mai sus se obţine un contor (care va conţine

numărul de apariţii) pentru fiecare articol în parte iar informaţiile complete despre

tranzacţiile bazei de date sunt comprimate în structura arborescentă AFOPT.

În continuare, procesul de generare a tiparelor frecvente este aplicat prin

vizitarea recursivă a structurii AFOPT. Această vizitare nu implică costuri

suplimentare asupra bazei de date.

Am prezentat mai jos cele două funcţii care realizează verificarea îndeplinirii de

către fiecare set de articole a condiţiei de suport minim (fig. 6.4-1.) şi a pragului suport de

afişare (fig. 6.4-2.).

Folosirea structurii AFOPT, care este un arbore prefixat, presupune sortarea în

ordine crescătoare a frecvenţei de apariţie a articolelor. Acest arbore este traversat în

adâncime de sus în jos. Fiecare nod este vizitat o singură dată. În cazul algoritmului FP-

Growth, numărul total de noduri vizitate este egal cu lungimea totală a ramurilor arborelui.

166

În cazul algoritmului AFOPT, numărul total de noduri vizitate este egal cu dimensiunea

structurii AFOPT, care este mai mică decât lungimea totală a celor nFP ramuri. Aşadar,

algoritmul AFOPT are nevoie de costuri mai mici de traversare decât algoritmul FP-

Growth.

Fig. 6.4-1. Funcţia Meets_Min_Support

Fig. 6.4-2. Funcţia Meets_Printing_Min_Support

În cazul algoritmului AFOPT, costurile suplimentare de traversare sunt cauzate de

pasul de reunificare spre dreapta a subarborilor. Dacă nu am avea acest pas, am obţine o

bază de date condiţională formată din mai mulţi subarbori. Numărul de subarbori care

constituie baza de date condiţională creşte exponenţial, în cazul cel mai defavorabil, cu

numărul articolelor care se găsesc înaintea celui considerat. În acelaşi timp, numărul de

operaţii de unificare necesar, este egal, în cazul cel mai defavorabil, cu numărul de articole

care se găsesc înaintea celui considerat. Aşadar, pentru a micşora costurile de traversare

este indicat să efectuăm cât mai multe operaţii de unificare.

boolean meets_min_support ( pattern b) { return (pattern b is special item and support>special_min_support) or (pattern b support > support[pattern b length]) }

boolean meets_printing_min_support (pattern b) { return (pattern b is special item and support>special_print_min_support) or (pattern b support>print_support[pattern b length]) }

167


Evoluţia timpilor de execuţie ai algoritmului ML-ADA-AFOPT în funcţie de

factorul suport este reprezentată în graficul din figura 6.4-3.

Fig. 6.4-3. Algoritmul ML-ADA-AFOPT

Experimentele au fost realizate pe un calculator ATHLON XP la 1,6 GHz, cu

memorie de 256 MB, sub sistemul Microsoft Windows XP Profesional, folosind o bază de

date reală de 50 000 de intrări în 6 000 de tranzacţii. Implementarea algoritmilor s-a

realizat în limbajul Java şi au fost compilaţi folosind platforma Eclipse.

În primul test comparativ dintre algoritmii ML-AFOPT şi ML-ADA-AFOPT, a cărui

rezultate sunt prezentate în graficul din figura 6.4-4., unele articole au fost considerate

speciale rare. S-a considerat că nu există articole speciale frecvente. Astfel, algoritmul ML-

ADA-AFOPT a trebuit să prelucreze mai multe informaţii decât în mod normal ţinând

seama şi de pragurile de suport de trecere şi de afişare corespunzătoare acestor articole

speciale. În mod normal, un articol rar (de exemplu diamant) ar fi fost eliminat pentru că

nu ar fi avut un suport suficient de mare, dar în acest caz el va fi inclus în calcule chiar

dacă are un suport mic.

168

Timp

(sec)

Suport (%)

Nr tranz

(în mii) 5 10 15 20 25 30 35 40 60 80 90

5.000 1.02 0.93 0.7 0.36 0.32 0.29 0.27 0.24 0.23 0.19 0.11

Tabel 6.4-1. Rezultatele obţinute de algoritmul ML-ADA-AFOPT (articole speciale

rare)

Fig. 6.4-4. Studiu comparativ - algoritmii ML-AFOPT vs. ML-ADA-AFOPT

(articole speciale rare)

În cel de-al doilea test, ale cărui rezultate sunt reprezentate în graficul din figura

6.4-5., s-au aplicat aceleaşi condiţii atât pentru algoritmul AFOPT cât şi pentru algoritmul

ML-ADA-AFOPT, considerându-se că există articole speciale comune frecvente care au

praguri suport de trecere şi de afişare (mai mari decât pragul suportul obişnuit).

Este nevoie de un suport mai mare decât în mod normal pentru ca aceste articole să

fie luate în considerare. Astfel, în final vor fi mai puţine elemente luate în considerare,

astfel încât algoritmul ML-ADA-AFOPT va fi executat mai rapid decât ML-AFOPT.

169

Timp

(sec)

Suport (%)

Nr tranz

(în mii) 5 10 15 20 25 30 35 40 60 80 90

5.000 0.69 0.61 0.2 0.11 0.1 0.098 0.097 0.095 0.087 0.045 0.025

Tabel 6.4-2. Rezultatele obţinute de algoritmul ML-ADA-AFOPT ( articole speciale

comune)

Fig. 6.4-5. Studiu comparativ - algoritmii ML-AFOPT vs. ML-ADA-AFOPT

(articole speciale comune)

În următorul test, prezentat în graficul din figura 6.4-6., au fost comparaţi algoritmii

FP-Growth standard, ADA-FP şi ML-ADA-AFOPT. Aşa cum am arătat mai devreme,

algoritmul AFOPT clasic este mai rapid decât algoritmul FP-Growth. Aşadar, ca o

consecinţă, algoritmul ML-ADA-AFOPT (care are la bază algoritmii ADAPTIVE şi

AFOPT) este mai rapid decât ADA-FP (care are la bază algoritmii ADAPTIVE şi FP-

Growth). Acest lucru este adevărat chiar şi în cazul cel mai defavorabil în care algoritmul

AFOPT are de parcurs mai multe articole iar algoritmul FP-Growth foloseşte pragul

standard al suportului.

170

Fig. 6.4-6. Studiu comparativ - algoritmii ML-ADA-AFOPT vs. MLFP-Growth

şi ML-ADA-FP

În final, am comparat toţi algoritmii propuşi în aceleaşi condiţii, pentru un factor

suport cuprins în intervalul 0.1% – 0.9%, utilizând în cadrul bazei da date reale 5 000 de

tranzacţii, pentru a evidenţia evoluţia timpilor de execuţie ai acestora.

Timp

(sec)

Tranzactii

5 000

Minsup

(%) ML_T2L1 DFMLA1 DFMLA2 MLFP-

Growth1

MLFP-

Growth2

ML-

AFOPT

ML-

ADA-

AFOPT

10 587 552 520 181 126 96 103 30 523 493 434 136 94 85 92 60 394 375 268 97 76 59 60 90 308 286 112 88 64 52 58

Tabel 6.4-3. Rezultatele obţinute pentru 5 000 de tranzacţii

171

Fig. 6.4-7. Studiu comparativ pentru 5 000 de tranzacţii

În cazul în care baza de date are 10 000 de tranzacţii timpii de execuţie obţinuţi

sunt prezentaţi în continuare.

Timp

(sec)

Tranzactii

10 000

Minsup

(%) ML_T2L1 DFMLA1 DFMLA2 MLFP-

Growth1

MLFP-

Growth2

ML-

AFOPT

ML-

ADA-

AFOPT

10 1357 1311 1269 465 402 231 250 30 1198 1058 945 344 285 170 176 60 852 688 592 187 146 93 121 90 324 248 176 81 64 59 66

Tabel 6.4-4. Rezultatele obţinute pentru 10 000 de tranzacţii

172

Fig. 6.4-8. Studiu comparative pentru 10 000 de tranzacţii

Se poate observa clar din cele două teste, pentru 5 000 şi 10 000 de tanzacţii, că

algoritmul ML-AFOPT a obţinut cei mai buni timpi de execuţie în ambele cazuri, urmat

îndeaproape de algoritmul ML-ADA-AFOPT. Următorii în clasamentul timpilor de

execuţie se situează cele două variante ale algoritmului MLFP-Growth I şi II. Cei mai lenţi

algoritmi s-au dovedit algoritmii care au la bază algoritmul APRIORI, şi anume DFMLA1

şi DFMLA2.

6.5. Concluzii

În general, algoritmii de extragere a tiparelor frecvente sunt orientaţi pe un singur

nivel. În acest caz, pot fi descoperite doar asocierile puternice dintre articole. Din acest

motiv au fost extinşi aceşti algoritmi pentru a realiza extragerea tiparelor frecvente multi-

nivel.

Algoritmul ML-AFOPT traversează aceste structuri arborescente în adâncime de

sus în jos, iar articolele din arborii prefixaţi sunt sortaţi în ordine crescătoare a frecvenţei

173

lor de apariţie. Combinarea acestor două metode este mult mai eficientă decât combinând

traversarea arborelui de jos în sus şi sortarea articolelor în ordine descrescătoare, folosită

de algoritmul FP-Growth.

Pe de altă parte, oricare din aceste două combinaţii este mult mai eficientă decât

celelalte combinaţii posibile: traversarea de sus în jos şi sortarea descrescătoare şi

traversarea de jos în sus şi sortarea în ordine crescătoare.

174

7. CONCLUZII ŞI CONTRIBUŢII PERSONALE

În această lucrare mi-am propus să prezint un domeniu relativ nou, şi anume

extragerea de date (Data Mining), care reprezintă una dintre etapele unui domeniu mai

larg, descoperirea de cunoştinţe din bazele de date (KDD), punând accent mai mult pe una

din subramurile acesteia şi anume extragerea regulilor de asociere, aducând şi câteva

contribuţii personale la dezvoltarea acesteia.

Descoperirea regulilor de asociere din bazele de date de dimensiuni mari este o

problemă complexă deoarece spaţiul de căutare creşte exponenţial cu numărul de atribute

din baza de date şi cu obiectele bazei de date. Extragerea regulilor de asociere a fost iniţial

generată de analizarea coşului de cumpărături. Mai târziu ea a fost aplicată în multe alte

domenii cum ar fi: afaceri, inginerie, medicină sau finanţe. Mai mult decât atât, unul din

scopurile principale ale extragerii de reguli de asociere a fost utilizat pentru a atinge scopul

altor probleme de extragere de date cum ar fi modelarea datelor, prezicerea viitoarelor

ieşiri sau suport de decizii. Descoperirea regulilor de asociere are ca scop descoperirea

unui set de atribute comune care aparţin unui număr mare de obiecte dintr-o bază de date în

general.

Cea mai comună abordare a problemei descoperirii regulilor de asociere este de a

descompune această problemă în două etape:

3. Găsirea tuturor seturilor de articole (itemsets) care au suportul mai mare

decât suportul minim.

4. Folosirea seturilor de articole pentru generarea regulilor dorite.

De obicei, aşa cum am mai arătat, bazele de date implicate în astfel de aplicaţii sunt

de dimensiuni foarte mari. Din acest motiv, este foarte importantă utilizarea unor algoritmi

cât mai rapizi pentru aceste aplicaţii. Cele mai recente abordări sunt de natură iterativă

necesitând scanări multiple ale bazei de date, ceea ce este foarte costisitor. Etapa cea mai

costisitoare din punct de vedere computaţional este descoperirea tiparelor sau seturilor de

articole (itemset-uri) frecvente datorită cantităţii enorm de mari de date ce trebuie

prelucrate.



fie la cel mai înalt nivel. De multe ori însă este necesar să descoperim cunoştinţe de pe mai

175

multe nivele conceptuale. Pe parcursul studierii procesului de extragere de cunoştinţe

(KD), cercetătorii au încercat prin diverse metode să îndepărteze dintre regulile generate pe

cele neinteresante, propunând câteva măsuri de cuantificare a utilităţii sau gradului de

interes pe care regula respectivă o prezintă.






diferite.

Metodele de extragere de cunoştinţe de pe mai multe nivele conceptuale au fost, în


Deoarece acesta este considerat domeniul de vârf în descoperirea regulilor de

asociere, contribuţiile aduse în această lucrare sunt metode originale de

îmbunătăţire a performanţelor unor algoritmi de extragere a regulilor de asociere

din bazele de date multi-nivel.

7.1. Contribuţii personale

Contribuţiile personale aduse de această lucrare la domeniul abordat sunt

următoarele:

Prezentarea unui studiu de performanţă a algoritmilor clasici din

domeniu: APRIORI [AS94], PARTITIONING [SON95] şi SAMPLING

[Dun03].

Abordarea unor algoritmi de extragere a regulilor de asociere

consideraţi noi şi performanţi din punctul de vedere al bazelor de date

multi-nivel.

Prezentarea unui studiu de performanţă şi compararea algoritmilor de

descoperire a regulilor de asociere multi-nivel ML-T2L1 [HF95],

Adaptive APRIORI [WHH00] şi ADA-FP [Mao01].

176

Propunerea unei noi metode de parcurgere în adâncime a arborelui

tiparelor frecvente pe care am denumit-o algoritmul DFMLA1, spre

deosebire de parcurgerea în lăţime a algoritmului ML_T2L1 propusă de

Han [HF95], care reduce substanţial numărul de verificări efectuate,

mărind astfel eficienţa sa, algoritm prezentat la Conferinţa microCAD

2005, Miskolcs, [PGG+05a].

Optimizarea algoritmului DFMLA1 prin introducerea unei filtrări a

tranzacţiilor ce trebuie testate ceea ce poate reduce foarte mult, în

cazurile favorabile, numărul acestora. Această variantă optimizată a

algoritmului am numit-o DFMLA2, şi a fost de asemenea prezentată la

Conferinţa microCAD 2005, Miskolcs, [PGG+05a].

Studierea performanţelor şi compararea algoritmilor propuşi în

această lucrare DFMLA1 şi DFMLA2, atât cu algoritmul original

ML_T2L1 propus de Han J. [HF95] cât şi între ei, studiu prezentat la

Conferinţa CSCS’15, Bucureşti, 2005 [PGG+05b].

Propunerea unei metode noi de aplicare a unuia dintre cei mai

promiţători algoritmi de extragere a tiparelor frecvente şi anume

FP-Growth [HPY00] la prelucrarea bazelor de date multi-nivel.

Astfel, în cazul în care sunt necesare informaţii de pe un anumit nivel

conceptual al bazei de date, după construirea arborelui FP-Tree, am

propus două metode de a obţine aceste informaţii:

o Aplicând direct algoritmul FP-Growth direct pe nivelul de pe care

dorim informaţii din baza de date multi-nivel

o Stocând informaţiile de pe cel mai jos nivel conceptual în

memorie sau pe disc, putem folosi aceste informaţii pentru a

construi arborele FP-Tree al nivelului care ne interesează fără a

face o nouă citire a bazei de date. Am numit acest algoritm

MLFP-Growth, fiind prezentat la Conferinţa CSCS’15, Bucureşti,

2005 [GGP+05c] .

177

Studierea performanţelor şi compararea algoritmului propus în

această lucrare MLFP-Growth, cu algoritmul original FP-Growth propus

de Han în [HPY00], studiu prezentat la Conferinţa CSCS’15, Bucureşti,

2005 [GGP+05c].

Adaptarea unui alt algoritm considerat şi mai performant, şi anume

AFOPT [LLX+03], la extragerea tiparelor frecvente din bazele de

date multi-nivel, variantă pe care am numit-o ML-AFOPT şi care

permite obţinerea informaţilor de pe un anumit nivel conceptual al bazei

de date folosind informaţiile stocate pe un nivel inferior al acesteia.

Acest algoritm a fost publicat la Conferinţa SYNASC 2005, Timişoara,

[GGP+05a].

Studierea performanţelor algoritmului propus în această lucrare ML-

AFOPT, studiu ce a fost prezentat la Conferinţa SYNASC 2005,

Timişoara, [GGP+05a], şi compararea utilizării structurii arborescente

FP-Tree cu structura arborescentă AFOPT care s-a dovedit a fi mai

eficientă, studiu comparativ în curs de publicare la Conferinţa ICCC

2006, Oradea [PGGB06].

Propunerea unui algoritm ML-ADA-AFOPT pentru extragerea

tiparelor frecvente din bazele de date multi-nivel, folosind ca punct

de plecare algoritmii AFOPT [LLX+03] şi Adaptive FP-Growth (ADA-FP)

[Mao01], care a fost prezentat la Conferinţa SYNASC 2005, Timişoara,

[GGP+05b].

Studierea performanţelor algoritmului propus în această lucrare ML-

ADA-AFOPT, şi compararea acestuia cu algoritmii originali de la care s-

a plecat cât şi cu algoritmul propus anterior ML-AFOPT, studiu care a

fost prezentat la Conferinţa SYNASC 2005, Timişoara, [GGP+05b].

Studierea şi compararea performanţelor tuturor algoritmilor propuşi în

această lucrare

178

7.2. Concluzii finale

Extragerea de date (Data Mining - DM) denumită şi descoperirea de cunoştinţe din

bazele de date (Knowledge Discovery in Databases – KDD) reprezintă un proces însemnat

de extragere a informaţiilor implicite, previzibile şi potenţial folositoare din bazele de date

[PSF91].

La ora actuală există mai multe metode de Data Mining, aşa cum au fost prezentate

în capitolul doi al acestei lucrări. Alegerea metodei potrivite unei aplicaţii se face ţinând

cont de date, de situaţie şi de obiectivele acesteia.

Dintre metodele Data Mining existente, cel mai des sunt utilizate metodele de

descoperire a regulilor de asociere. Aceste metode sunt utilizate frecvent în analiza

vânzărilor cu amănuntul, dar ele pot fi aplicate cu acelaşi succes şi în serviciile de

marketing (analiza coşului de cumpărături) pentru determinarea caracteristicilor comune

ale clienţilor. Industria serviciilor financiare utilizează, de asemenea, frecvent extragerea

de reguli de asociere. Analiştii folosesc aceste tehnici pentru a analiza cantităţi masive de

date pentru a construi afaceri şi modele de risc pentru dezvoltarea strategiilor de investiţii.

Multe companii din sectorul financiar au testat aceste tehnici care au produs rezultate

pozitive în analiza conturilor clienţilor şi la identificarea serviciilor financiare pe care

aceştia le solicită împreună.

Datorită importanţei şi aplicabilităţii pe care o au, aşa cum am arătat, în diverse

domenii, descoperirea regulilor de asociere din baze de date de dimensiuni mari a fost şi

este în continuare una din tehnicile Data Mining cel mai mult studiate.

Descoperirea şi extragerea regulilor de asociere este probabil cea mai semnificativă

contribuţie a colectivelor de cercetători din domeniul descoperirii de cunoştinţe din baze de

date şi este cercetată în continuare şi la ora actuală.

În capitolul trei sunt prezentaţi principalii algoritmi iterativi de descoperire a

regulilor de asociere din bazele de date, şi anume algoritmul APRIORI [AS94], algoritmul

SAMPLING [Dun03] şi algoritmul PARTITIONING [SON95]. Studiind performanţele

acestor algoritmi pe diferite baze de date cu un număr de tranzacţii începând de la 10 000

până la 520 00 de tranzacţii şi pentru factori suport de la 5% până la 40%, am realizat un

studiu comparativ al acestora.

179

Astfel, din experimentele pe care le-am făcut, a rezultat că algoritmul APRIORI are

performanţă slabă când se execută pe baze de date mari care conţin un număr mare de

articole pe tranzacţie. Această performanţă scăzută se datorează faptului că dimensiunea

unui articol-set frecvent este mare. De exemplu, pentru un articol-set frecvent de

dimensiune N > 4, algoritmul APRIORI necesită N parcurgeri ale bazei de date pentru a

descoperi acel articol, ceea ce este costisitor din punct de vedere al timpului consumat.

Pentru baze de date mari şi pentru un factor suport mare (> 20%) algoritmul

APRIORI are o performanţă mai bună decât algoritmii PARTITIONING şi SAMPLING, dar

pentru un factor suport mic (< 5%) performanţa algoritmului APRIORI scade dramatic.

Algoritmii SAMPLING şi PARTITIONING reduc numărul de scanări ale bazei de

date la două şi au o performanţă mai bună decât APRIORI atunci când sunt aplicaţi pe baze

de date mari şi pentru un factor suport mic (< 5%).

Algoritmul PARTITIONING reduce numărul de scanări ale bazei de date la două şi

împarte baza de date în partiţii astfel ca fiecare partiţie să poată fi încărcată în memorie. În

timpul celei de-a doua scanări, numai acele itemset-uri care sunt frecvente în cel puţin una

din partiţii sunt folosite ca şi candidate şi sunt numărate pentru a determina dacă ele sunt

frecvente în întreaga baza de date, reducând astfel setul de candidaţi, iar timpul de execuţie

fiind mai mic decât a algoritmului APRIORI.

În concluzie, algoritmul APRIORI are o performanţă mai bună decât ceilalţi

doi pentru baze de date mari şi cu un factor suport mare. În cazul în care sunt

aplicaţi pe baze de date mari cu un factor suport mic, algoritmii SAMPLING şi

PARTITIONING sunt mai performanţi decât algoritmul APRIORI.

În cazul algoritmilor iterativi, de tip APRIORI, sunt obţinute performanţe mai bune

prin reducerea seturilor de candidaţi. Cu toate acestea, în cazurile în care se obţine un

număr mare de tipare frecvente, de lungime mare, sau sunt aplicate praguri de suport

minim foarte joase, aceşti algoritmi prezintă două dezavantaje majore: primul este

manipularea unui număr mare de seturi de candidaţi iar al doilea este generat de a doua

parcurgere a bazei de date şi verificarea unui număr mare de candidaţi prin potrivire de

tipare, mai ales în cazul extragerii tiparelor lungi.

Metodele de extragere a tiparelor frecvente, prezentate în capitolul patru al lucrării,

bazate pe o structură de arbore denumită arbore de tipare frecvente, FP-Tree, reduc doar la

două numărul de parcurgeri a bazelor de date, micşorând astfel semnificativ timpul de

descoperire şi extragere a acestora.

180

În ultimii ani au fost dezvoltaţi mai mulţi algoritmi destul de eficienţi pentru

extragerea tiparelor frecvente. Au fost propuse două abordări: generarea şi testarea

candidaţilor şi creşterea tiparelor. Ultima s-a dovedit a fi mult superioară celei dintâi, mai

ales în cazul seturilor de date mari. Ambele abordări au fost implementate într-o manieră

iterativă.

În ciuda tuturor eforturilor depuse de cercetători în ultimii ani, algoritmii care

generează şi testează candidaţi au două dezavantaje:

� Toate necesită generarea unui număr forte mare de itemset-uri candidat,

multe dintre ele dovedindu-se a fi puţin frecvente după parcurgerea bazei de

date

� Toate necesită parcurgerea bazei de date de mai multe ori, în cel mai

defavorabil caz, numărul de parcurgeri a bazei de date fiind egal cu

lungimea maximă a tiparelor frecvente.

Abordarea prin creşterea tiparelor încearcă să evite aceste două dezavantaje

construind o bază de date condiţională pentru tiparele frecvente. Algoritmii propuşi pentru

aceasta diferă în principal prin maniera prin care este reprezentată baza condiţională. Han

[HPY00] foloseşte o structură de date compactă FP-Tree pentru a reprezenta baza de date

condiţională care este o combinaţie a structurilor arbore prefixat (prefix-tree) şi legătura

nodurilor (node-link). Pe de altă parte, Liu [LLX+03] utilizează o altă structură compactă

de date AFOPT pentru reprezentarea bazei de date condiţionale.

Aşa cum am arătat anterior, fiind dată o bază de date condiţională, aceasta poate fi

reprezentată folosind una din cele două structuri şi câte o strategie de parcurgere aplicată

fiecăreia din acestea, utilizate de algoritmii FP-Growth şi AFOPT:

1. structura FP-Tree [HPY00], în care articolele sunt sortate în ordine

descrescătoare a frecvenţei lor de apariţie, şi strategia de parcurgere a arborelui de

jos în sus

2. structura AFOPT [LLX+03], în care articolele sunt sortate în ordine crescătoare a

frecvenţei lor de apariţie, şi strategia de parcurgere a arborelui de sus în jos

Folosirea structurii AFOPT pentru a reprezenta bazele de date condiţionale duce la

obţinerea unor costuri de traversare minime iar utilizarea ordonării crescătoare după

frecvenţă ne conduce la construirea unui număr minim de baze de date condiţionale.

Costurile de traversare ale algoritmului FP-Tree sunt întotdeauna mai mari decât în cazul

181

algoritmului AFOPT. Numărul total de noduri vizitate de algoritmul FP-Growth este egal

cu lungimea totală a ramurilor arborelui prefixat. Numărul total de noduri vizitate de

algoritmul AFOPT este egal cu dimensiunea structurii AFOPT, care este mai mică decât

lungimea totală a ramurilor arborelui prefixat. Aşadar, algoritmul AFOPT are nevoie de un

număr mai mic de traversări decât algoritmul FP-Growth.

Numărul total de baze de date condiţionale construite pe parcursul procesului de

extragere a tiparelor frecvente depinde ordinea în care sunt sortaţi item-ii şi în care este

explorat spaţiul de căutare. Ordonarea crescătoare după frecvenţă minimizează numărul

total de baze condiţionale. În cazul structurii FP-Tree item-ii sunt sortaţi în ordine

descrescătoare a frecvenţei lor, motiv pentru care arborele trebuie traversat de jos în sus, de

la nodurile frunze spre rădăcină.

În cazul în care baza de date condiţională a unui itemset poate fi reprezentată printr-

o singură ramură, se pot enumera toate tiparele frecvente conţinute direct în acesta şi nu

este necesară construirea unei noi baze condiţionale chiar dacă itemset-ul respectiv are mai

mult de o extensie frecventă. Structura AFOPT, aşadar, ne ajută să reducem numărul de

baze de date condiţionale construite, deoarece bazele condiţionale sunt de obicei

reprezentate printr-o singură ramură în structura AFOPT.










diferite.

Metodele de extragere de cunoştinţe de pe mai multe nivele conceptuale sunt

analizate în capitolul cinci, ele fiind, în general, dezvoltate prin extinderea tehnicilor

existente pentru un singur nivel.

Pentru a extrage reguli de asociere multi-nivel, avem nevoie de:

� Date reprezentate pe mai multe nivele de abstractizare

� Metode eficiente pentru a extrage reguli multi-nivel

182

Pe baza conceptului de ierarhie şi a câtorva algoritmi de extragere a regulilor de

asociere simplu-nivel, Han [HF95], [HF99], Strikant [SA95], Rantzau [Ran97] şi

Rajkumar [RKS03], au propus o serie de algoritmi pentru extragerea regulilor de asociere

multi-nivel.

Astfel, în capitolul şase al lucrării sunt prezentaţi principalii algoritmi de extragere

a regulilor de asociere multi-nivel existenţi la ora actuală, şi anume algoritmul ADAPTIVE

APRIORI [SA95b], algoritmul ML-T2L1 [HF95] şi algoritmul ADA-FP [Mao01].

La fel ca şi în cazul celorlalţi algoritmi prezentaţi am realizat un studiu comparativ

al performanţelor acestor algoritmi.

Astfel, putem spune că algoritmul ADA-FP este mult mai eficient decât algoritmul

ML_T2L1 deoarece are nevoie doar de două parcurgeri a bazei de date, în timp ce numărul

de parcurgeri ale bazei de date în cazul algoritmului ML_T2L1 depinde de lungimea

tiparelor frecvente (dacă lungimea maximă a tiparelor frecvente este n, algoritmul are

nevoie de n parcurgeri a bazei de date).

Algoritmul ADA-FP poate descoperi tipare frecvente de pe niveluri diferite,

deoarece articolele, indiferent de pe ce nivel abstract sunt, apar în arborele FP-Tree, în

timp ce ML_T2L1 adoptă o metodă progresivă în adâncime, de sus în jos, până ce nu mai

poate fi generat nici un tipar frecvent. În cazul algoritmului ML-T2L1, la fiecare nivel este

aplicat algoritmul APRIORI pentru a descoperi tipare frecvente. Tiparele generate de

ML_T2L1 sunt alcătuite din articole de pe acelaşi nivel abstract.

Pentru a creşte flexibilitatea, în procesul de extragere a tiparelor frecvente, s-au

introdus constrângeri diferite pentru suport. Astfel, algoritmul ADA-FP este mult mai

eficient decât ML_T2L1.

Deoarece algoritmul clasic APRIORI se bazează pe folosirea unui prag minim

pentru suport uniform. Aceasta duce fie la omiterea unor tipare interesante cu suport

scăzut, fie la apariţia unor încurcături la generarea setului de itemi. Aceasta a determinat

folosirea unor constrângeri pentru suport la generarea item-ilor.

Acesta este punctul de pornire atât la algoritmul ADAPTIVE APRIORI cât şi la

algoritmul ADA-FP. Deosebirea dintre cei doi algoritmi este faptul că ADAPTIVE

APRIORI are la bază metoda APRIORI în timp ce ADA-FP are la bază metoda FP-Growth

care s-a demonstrat că este mai rapidă decât prima. O altă deosebire dintre cei doi

algoritmi este definirea şi implementarea constrângerilor pentru suport.

183

În algoritmul ADAPTIVE APRIORI se înlocuieşte suportul minim clasic cu o

funcţie notată Pminsup, care defineşte un superset de itemset-uri frecvente definite prin

minsup generat prin metoda APRIORI. Algoritmul ADA-FP foloseşte pragul de trecere al

suportului pentru a îndepărta seturile de dimensiune 2 care nu sunt frecvente (2-itemsets)

la fiecare încercare de generare a seturilor de dimensiune 3 a itemset-urilor frecvente (3-

itemsets). Astfel creşte claritatea rezultatelor procesului de extragere a tiparelor frecvente.



fie la cel mai înalt nivel, ceea ce împiedică uneori găsirea cunoştinţelor dorite în bazele de

date. În primul rând, datorită faptului că, de obicei, seturile de date cu o valoare importantă

a suportului nu se găsesc la nivele conceptuale foarte joase, deoarece tiparele de la nivelele

conceptuale joase tind să fie împrăştiate şi greu au un suport important. În al doilea rând,

regularităţile vor fi găsite mai degrabă la nivele conceptuale înalte, aşadar pot fi deja bine

cunoscute.

Pornind de la algoritmii propuşi de Han [HF95], [HF99], Strikant [SA95], Rantzau

[Ran97], [WHH00] şi Rajkumar [RKS03] pentru extragerea regulilor de asociere multi-

nivel, am încercat îmbunătăţirea şi optimizarea acestora propunând în capitolul şase al

acestei lucrări metode noi sau versiuni mai performante.

Primul algoritm propus în această lucrare, denumit DFMLA, cu cele două

variante ale sale DFMLA1 şi DFMLA2, are la bază algoritmul APRIORI multi-nivel

(ML_T2L1) propus de Han şi Fu în [HF95], îmbunătăţind performanţele acestuia,

prin reducerea numărului de tranzacţii verificate inutil la generarea regulilor de

asociere între articole, înlăturând astfel risipa de memorie generată de algoritmul

APRIORI.

Aceşti algoritmi (DFMLA1 şi DFMLA2) nu caută să găsească reguli între toate

subset-urile k-itemset ci doar între derivaţiile unui subset din acele reguli care au fost găsite

anterior interesante (importante). Ei parcurg arborele ierarhiei conceptuale în adâncime şi

dacă găsesc o regulă la primul nivel conceptual între două categorii caută apoi care sunt

subcategoriile la care se aplică regula. Dacă regula nu trece testul de importanţă, atunci nu

vor exista reguli importante între subcategoriile de pe următorul nivel conceptual.

Pentru a sublinia acest avantaj, am comparat DFMLA1 cu algoritmul APRIORI

multi-nivel (ML_T2L1). Algoritmul lui Han foloseşte funcţia de generare a candidaţilor din

algoritmul APRIORI la fiecare nivel conceptual. Când termină de examinat un nivel în

184

întregime, trece la următorul nivel, parcurgând aşadar arborele ierarhiei conceptuale în

lăţime. Cu cât baza de date are mai multe nivele conceptuale, algoritmul poate deveni mai

rapid o dată cu eliminarea unor categorii.

Bazele de date simplu-nivel conţin de cele mai multe ori informaţii prea complexe

care sunt uneori mai puţin interesante pentru extragerea regulilor de asociere. Aceste

informaţii se găsesc de obicei pe ultimul nivel al bazelor de date multi-nivel, unde se

găsesc informaţii mai concrete, mai specifice decât la nivelele superioare. Pentru a obţine

acest gen de informaţii este necesar putem extrage date la orice nivel conceptual dorim.

Folosind algoritmul APRIORI multi-nivel se parcurg progresiv nivelele de abstractizare ale

bazei de date de sus în jos (top-down) reducând în acest mod setul de candidaţi şi numărul

de citiri din baza de date.

O altă metodă este folosirea algoritmului de generare a arborelui FP-Tree care are

nevoie doar de două parcurgeri a bazei de date şi nu generează seturi de candidaţi.

Aplicarea algoritmului FP-Growth direct la ultimul nivel, pentru a obţine informaţii de pe

acesta, este o metodă mai rapidă decât aplicarea algoritmului APRIORI multi-nivel.

Unul din principalii factori care micşorează viteza de lucru a algoritmului de creare

a arborelui FP-Tree este numărul de accesări a bazei de date. Metoda II propusă în

această lucrare (MLFP-Growth II) utilizează informaţii anterioare pentru a evita

accesarea bazei de date lucrând în special cu memoria calculatorului, ceea ce

este mult mai rapid. Baza de date este eventual accesată doar pentru a obţine

informaţiile care lipsesc (vezi pasul 2 şi 3 al metodei).

Am studiat comparativ cele două metode pe o bază de date cu 50 000 de intrări,

750 de articole codificate pe 10 nivele conceptuale, 5 000 de tranzacţii, fiecare având cel

mult 10 articole. În ambele cazuri factorul suport a variat de la 0.1% până la 0.9%. Cu cât

distanţa dintre nivelele conceptuale k şi l este mai mare, cu atât pot exista mai multe

informaţii lipsă, ceea ce forţează accesarea bazei de date pentru obţinerea lor. În cazul în

care nu există informaţii lipsă între cele două nivele conceptuale, singurul motiv de

accesare a bazei de date rămâne pentru verificarea factorului suport (vezi pasul 2 al

algoritmului) iar uneori nici aceasta nu este necesar.

Performanţa MLFP-Growth II faţă de MLFP-Growth I depinde de

asemenea de pragul suportului minim. Dacă acesta este foarte scăzut, vom avea

foarte puţine informaţii îndepărtate la cel mai jos nivel conceptual, ceea ce face

MLFP-Growth II mai rapid.

185

În continuare este propus un algoritm pentru extragerea tiparelor frecvente din baze

de date multi-nivel pornind de la algoritmul AFOPT prezentat de Liu G. în [LLX+03].

Deoarece am mai arătat anterior avantajele oferite de utilizarea bazelor de date multi-nivel,

am încercat să adaptez algoritmul propus de Liu G. asupra acestora.

Algoritm propus ML-AFOPT, poate fi utilizat pentru extragerea tiparelor frecvente

multi-nivel. Acesta s-a obţinut prin adaptarea algoritmului AFOPT [LLX+03] la baze de

date multi-nivel, păstrându-se toate trăsăturile de bază ale algoritmului original AFOPT.

Algoritmul AFOPT utilizează o abordare a creşterii tiparului şi foloseşte o structură

de arbore prefixat (prefix-tree) pentru a reprezenta baza de date condiţională. El foloseşte o

strategie diferită de traversare a arborelui şi o altă metodă de ordonare a item-ilor.

Folosirea structurii AFOPT pentru a reprezenta bazele de date condiţionale duce la

obţinerea unor costuri de traversare minime iar utilizarea ordonării crescătoare după

frecvenţă ne conduce la construirea unui număr minim de baze de date condiţionale,

deoarece bazele condiţionale sunt de obicei reprezentate printr-o singură ramură în

structura AFOPT.

În urma testelor de performanţă pe care le-am realizat, am observat că în cazul

algoritmilor de extragere a tiparelor frecvente nu este indicat să folosim metoda parcurgerii

de sus în jos a arborilor ca şi în cazul algoritmilor bazaţi pe abordarea APRIORI (de

exemplu algoritmul ML_T2L1) deoarece aceştia au nevoie de k+1 parcurgeri a bazei de

date pentru obţinerea unor informaţii de pe nivelul conceptual k, în timp ce folosind

aplicarea structurii AFOPT (sau FP-Tree) direct pe nivelul k, sunt necesare doar două

parcurgeri a bazei de date pentru a obţine aceste informaţii.

Prin traversarea nodurilor structurii AFOPT în adâncime, de sus în jos, fiecare nod

va fi vizitat exact o dată.

Numărul total de noduri vizitate în cazul algoritmului FP-Growth este egal

cu lungimea totală a ramurilor arborelui FP-Tree. Numărul total de noduri vizitate

în cazul algoritmului ML-AFOPT este egal cu dimensiunea structurii AFOPT, care

este mai mică decât lungimea totală a ramurilor sale nfp. Aşadar, algoritmul ML-

AFOPT necesită costuri mai mici de traversare decât algoritmul FP-Growth.

Am văzut că una dintre particularităţile algoritmului AFOPT o reprezintă structura

AFOPT (Ascending Frequency Ordered Prefix-Tree) care este creată, şi care este o

structură arborescentă ce reprezintă baza de date condiţională şi care este traversată de

algoritm de sus în jos. Prin combinarea celor două strategii de traversare a arborelui de sus

în jos şi cea de sortare în ordine crescătoare a frecvenţelor de apariţie a articolelor are ca

186

efect minimizarea atât a numărului total de baze condiţionale cât şi a costurilor de

traversare a bazelor de date individuale.

Structura AFOPT este o reprezentare compactă a bazei de date condiţionale. Ea

conţine informaţii complete pentru a putea extrage seturile frecvente de articole din baza

de date originală. Dimensiunea structurii AFOPT este limitată de numărul total de articole

frecvente care apar în baza de date, fiind de obicei mult mai mică decât acesta.

O dată structura AFOPT construită, procesul de extragere va continua asupra

acesteia. Ca şi în cazul algoritmului FP-Growth, care foloseşte structura arborescentă FP-

Tree, nu este necesară parcurgerea din nou a bazei de date originale. Cu toate acestea,

există destul de multe diferenţe între procesul de extragere aplicat pe o structură FP-Tree şi

cel aplicat pe o structură AFOPT.

Pentru a evita problemele cauzate de utilizarea unui prag suport uniform, cum ar fi

generarea unor tipare lipsite de importanţă la nivele de abstractizare superioare, sau

pierderea unor potenţiale tipare interesante la nivele de abstractizare joase, am propus în

continuare un algoritm care foloseşte un prag suport flexibil ML-ADA-AFOPT.

Fiind bazat tot pe algoritmul AFOPT, şi acest algoritm parcurge baza de date

originală prima dată pentru a articolele frecvente sau nivelele de abstractizare şi pentru a le

sorta în ordine crescătoare a apariţiei lor. Apoi, baza de date originală este parcursă a doua

oară pentru a construi structura arborescentă AFOPT care reprezintă baza de date

condiţională a articolelor frecvente.

Ca o consecinţă, algoritmul ML-ADA-AFOPT (care are la bază algoritmii

ADAPTIVE şi AFOPT) este mai rapid decât ADA-FP (care are la bază algoritmii

ADAPTIVE şi FP-Growth). Acest lucru este adevărat chiar şi în cazul cel mai

defavorabil în care algoritmul AFOPT are de parcurs mai multe articole iar

algoritmul FP-Growth foloseşte pragul standard al suportului.

În concluzie, se poate spune că descoperirea de cunoştinţe şi în cadrul acesteia

descoperirea regulilor de asociere, iar mai nou descoperirea regulilor de asociere multi-

nivel, rămâne în continuare un domeniu de cercetare care prezintă un real interes pentru

cercetătorii din ziua de azi. În contextul în care cantitatea de date acumulate devine din ce

în ce mai mare, iar nevoia de informaţie şi cunoştinţe necesare unui suport decizional de

bună calitate şi util în timp creşte, cercetările din domeniul abordat pot să ducă la

îmbunătăţiri semnificative în acest sens.

187

BIBLIOGRAFIE

[AAP00a] Agrawal R., Aggarwal C., and Prasad V., “A tree projection algorithm for

generation of frequent itemsets”, Parallel and distributed Computing,

2000.

[AAP00b] Agrawal R., Aggarwal C., and Prasad V., “Depth first generation of long

patterns”, In Proc. of ACM SIGKDD Conf., pages 108.118, 2000.

[AAP01] Agrawal R., Aggarwal C., and Prasad V., “A tree projection algorithm for

finding frequent itemsets”, Journal on Parallel and Distributed

Computing, 61(3):350.371, 2001.

[Agr94] Agrawal R., „Tutorial database mining”, Proceeding of ACM

International Conference on Management of Data, pg.75-76, 1994

[Agr95] Agrawal R., „Data Mining: The quest perspective”. Tutorial presented at

EDBT Summer School Advances in Database Technology, September

1995

[AIS93] Agrawal R., Imielinski T. And Swami A.N., „Mining association rules

between sets of items in large databases”, Proceeding of ACM

International Conference on Management of Data, pg.207-216, 1993

[AK93] Anand T. and Kahn G., „Opportunity Explorer: Navigating Large

Databases Using Knowledge Discovery Templates”, AAAI-93 Workshop

on Knowledge Discovery in Databases, Washington DC, USA, ACM

Press, Vol.22, pg.207-216, 1993

[AS94] Agrawal R. and Srikant R., „Fast Algorithms for Mining Association

Rules”, Proc. of 20th International Conference on VLDB pg.487-499,

1994

[AS95] Agrawal R. and Srikant R., “Mining Sequential Patterns”, Proceedings of.

1995 Int'l Conf. Data Eng., pg. 3-14, Taipei, Taiwan, Mar. 1995.

188

[Bay98] Bayardo, R.J. Jr., “Efficiently mining long patterns from databases”,

Proceedings of the 1998 ACM SIGMOD Conference, ACM Press, pp.

85–93, 1998

[BCG01] Burdick D., Calimlim M., and Gehrke J., “Mafia: A maximal frequent

itemset algorithm for transactional databases”, Proceedings of ICDE

Conf., pages 443.452, 2001

[BFR98] Bradley P., Fayyad U. and Reina C., “Scaling clustering algorithm to

large databases”, Proceeding of the International Conference on

Knowledge Discovery and Data Mining, pg.9-15, 1998

[Bod03] Bodon F., “A fast APRIORI implementation”, Informatics Laboratory,

Computer and Automation Research, Proceedings of the IEEE ICDM

Workshop on Frequent Itemset Mining Implementations (FIMI'03), 2003

[BRR01] Bounsaythip C and Rinta-Runsala E., “Overview of Data Mining for

Customer Behavior Modeling”, VTT Information Technology, Finland,

2001

[BS97] Berson A. and Smith S.J., “Data Warehousing, Data Mining and OLAP”,

McGraw-Hill, 1997

[CHY96] Chen Ming-Syan, Han J. and Yu P.S., “Data Mining: An Overview from

Database Perspective”, IEEE Transaction on Knowledge and Data

Enginering, 8(6):866-883, December 1996

[Dun03] Dunham M.H., “Data Mining Introductory and Advanced Topics”,

Prentice Hall, Pearson Education Inc. Upper Saddle River, New Jersey,

2003

[DXGH00] Dunham M, Xiao Y, Gruenwald L. and Hossain Z., ”A survey of

association rules. Technical report”, Southern Methodist University,

Department of Computer Science, TR 00-CSE-8, 2000

[EKX95] Ester M., Kriegel H.P. and Xu X., “Knowledge discovery in large spatial

databases: Focusing techniques for efficient class identification”,

189

Proceedings of 4th Int. Symp. On Large Spatial Databases (SSD’95),

pg.67-82, Portland, Maine, 1995

[FAQ95] FAQ on Neural Networks,

http://fangorn.ci.tuwien.ac.at/docs/services/nnfaq/FAQ.html

[Fay+96] Fayyad U, et al., “From Data Mining to Knowledge Discovery in

Databases “, Ai Magazine, 1996

[Fis95] Fisher D., “Optimization and simplification of hierarchical clustering”,

Proceedings of 1st Int. Conf. on Knowledge Discovery and Data Mining

(KDD’95), pg.118-123, Montreal, Canada, 1995

[FMMT96] Fukuda T., Morimoto Y., Morishita S. and Tokuyama T., ”Data Mining

Using Two-Dimensional Optimized Association Rules: Scheme,

Algorithms, and Visualization”, Proceedings of. 1996 ACM SIGMOD

Int'l Conf. Management of Data, pg. 13-23, Montreal, June 1996.

[FPS+96] Fayyad U.M., Piatetski-Shapiro G., Smyth P. and Uthurusamy R.,

“Advances in Knowledge Discovery and Data Mining”, AAAI/MIT Press,

1996

[GGBP04] Győrödi C., Győrödi R., Bogan-Marta A., Pater M., ”The distributed

algorithms in mining associations rules”, Revista Academiei Române

„FUZZY SYSTEMS & A.I.” Reports & Letters Vol. 10, 2004

[GGP+05a] Győrödi R., Győrödi C., Pater M., Boc O., David Z., “AFOPT Algorithm

for multi-level databases”, SYNASC’05, The 7th International

Symposium on Symbolic and Numeric Algorithms for Scientific

Computing, September 25 - 29, Timisoara, Romania , 2005

[GGP+05b] Győrödi C., Győrödi R., Pater M., Boc O., David Z., “Adaptive AFOPT

Algorithm”, SYNASC’05, The 7th International Symposium on Symbolic

and Numeric Algorithms for Scientific Computing, September 25 - 29,

Timisoara, Romania , 2005

190

[GGP+05c] Győrödi R., Győrödi C., Pater M., Boc O., David Z., “FP-Growth

algorithm for multi-level databases”, CSCS-15 The 15th International

Conference on Control Systems and Computer Science, Bucuresti, Mai

2005

[GGP03] Győrödi R., Győrödi C., Pater M., “Aplicarea tehnicilor de Data Mining

într-un sistem de gestiune a unei firme de distribuţie”, ALETHEIA 14,

Revistă de ştiinţă şi dialog interdisciplinar, ISBN 973-8032-31-8, ISSN

973-8032-31-8, Oradea, Septembrie, 2003

[GHGP02] Győrödi C., Holban S., Győrödi R., Pater M., “Mining Knowledge in

Relational Databases”, CONTI’2002, The 5th International Conference on

Technical Informatics, Timişoara, Romania, Transactions on Automatic

Control and Computer Science, Scientific Bulletin of „Politehnica”

University of Timişoara, Vol 47(61) nr. 2, October 18-19th 2002

[GPG02] Győrödi C., Pater M., Győrödi R., “Overview of Knowledge Discovery

and Data Mining in Databases”, Proceedings of Arad, Sesiunea Jubiliară

de Comunicări Ştiinţifice, Arad, Romania, November 28-30, 2002

[Gyo03] Győrödi C., “Contribuţii la dezvoltarea sistemelor de descoperire a

cunoştinţelor”, teză de doctorat, Timişoara, 2003

[GZ01] Gouda K. and Zaki M. J.,”Efficiently mining maximal frequent itemsets”,

Proceedings of ICDM conf., pages 163.170, 2001.

[Has95] Hassoun M.H., “Fundamentals of Artificial Neural Networks”,

Cambridge, Mass: The MIT Press, 1995

[Hay99] Haykin S., “Neural Networks – a Comprehensive Foundation, 2nd ed.”

Upper Saddle River, N.J.: Prentice Hall, 1999

[HCC93] Han J., Cai Y. and Cercone N., “Data-driven discovery of quantitative

rules in relational databases”, IEEE Trans. Knowledge and Data

Engineering, pg.29-40, 1993

191

[HF95] Han J. and Fu Y, “Discovery of multiple-level association rules from large

databases” Proceeding of the International Very Large Databases

Conference, pg. 420-431, 1995

[HF97] Han J. and Fu Y., “Mining Multiple-Level Association Rules in Large

Databases”, Technical report, Univ. of Missouri-Rolla, URL:

http://www.umr.edu/~yongjian/pub/ml.ps , 1997

[HF99] Han J. and Fu Y., “Mining Multiple-level Association Rules in Large

Databases”, IEEE Transactions on Knowledge and Data Engineering,

Vol.11, No.5, 1999

[HGN00] Hipp J., Guntzer U., and Nakaeizadeh G., “Algorithms for association

rule mining - a general survey and comparison”, ACM SIGKDD

Explorations, 2(1):58–64, June 2000.

[HK00] Han J. and Kamber M., „Data Mining: Concepts and Techniques”, The

Morgan Kaufmann Series in Data Management Systems, Jim Gray, Series

Editor Morgan Kaufmann Publishers, August 2000. ISBN 1-55860-489-8

[HK99] Hineburg A. and Keim D.A., “Clustering methods for large databases:

From the past to the future. Technical report”, ACM SIGMOD Tutorial,

1999

[HKT01] Han J., Kamber M and Tung A.K.H., “Spatial Clustering Methods in Data

Mining: A Survey”, Philadelphia: Taylor&Francis, 2001

[HP00] Han J. and Pei J,”Mining Frequent Patterns by Pattern-Growth:

Methodology and Implications '', ACM SIGKDD Explorations (Special

Issue on Scaleble Data Mining Algorithms), 2(2), December 2000.

[HPY00] Han J., Pei J. and Yin Z., “Mining Frequent Patterns without Candidate

Generation”, ACM SIGMOD Intl. Conference on Management of Data,

ACM Press, May 2000

192

[HS95] Houtsma M. and Swami A., “Set-oriented mining for association rules in

relational databases”, Proceedings of IEEE International Conference on

Data Engineering, pg.25-34, 1995

[IE00] Ian H.W. and Eibe F., „Data Mining Practical Learning Tools and

Techniques with Java Implementations”, Morgan Kaufmann Publishers,

San Francisco, USA, 2000

[JD88] Jain A.K. and Dubes R.C., “Algorithms for Clustering Data”, Englewood

Cliffs, N.J: Prentice Hall, 1988

[KMR+ 94] Klemettinen M., Mannila H., Ronkainen P., Toivonen H., and Verkamo

A.I, “Finding Interesting Rules from Large Sets of Discovered Association

Rules”, Proceedings of Third Int'l Conf. Information and Knowledge

Management, pg. 401-408, Gaithersburg, Md., Nov. 1994.

[Koh82] Kohonen T., “Self-organized formation of topologically correct feature

maps” Biological Cybernetics, 43:59-69, 1982

[KWG+97] Kamber M., Winstone L., Gong W., Cheng S., and Han J.,

“Generalization and Decision Tree Induction: Efficient Classification in

Data Mining'', Proceedings of 1997 Int'l Workshop on Research Issues on

Data Engineering (RIDE'97), Birmingham, England, April 1997, pg. 111-

120.

[LHM99] Lu B., Hsu W. and Ma Z., “Mining association rules with multiple

minimum supports”, SIGKDD 1999, pg.125-134

[LLL04] Liu G., Lu H. and Lou W., „Efficient Mining of Frequent Patterns Using

Ascending Frequency Ordered Prefix-Tree”, Data Mining and Knowledge

Discovery, 9, 249–274, 2004

[LLX+03] Liu, G., Lu, H., Lou, W., Xu, Y. and Xu Yu, J., “Ascending Frequency

Ordered Prefix-tree: Efficient Mining of Frequent Patterns” Proceedings

of KDD Conf., 2003.

193

[Mao01] Mao R., “Adaptive-FP: An efficient method for multi-level and multi-

dimensional frequent pattern mining”, Simon Fraser University, April

2001

[Mit99] Mitchell T.M., “Machine learning and data mining”, Communications of

the ACM, 42(11):31-36, November 1999

[MPC96] Meo R., Psaila G., and Ceri S., “A New SQL-Like Operator for Mining

Association Rules”, Proceedings of 1996 Int'l Conf. Very Large Data

Bases, pg. 122-133, Bombay, India, Sept. 1996.

[MTV94] Mannila H.,Toivonen H., and Verkamo A.I., “Efficient Algorithms for

Discovering Association Rules”, Proceedings of AAAI '94 Workshop

Knowledge Discovery in Databases (KDD '94), pg. 181-192, Seattle, July

1994.

[NH94] Ng R. and Han J., “Efficient and effective clustering method for spatial

data mining”, Proceeding of 1994 Int. Conf. Very large Data Bases,

pg.144-155, Santiago, Chile, 1994

[PCY95] Park J.S., Chen M.S., and Yu P.S., “An Effective Hash-Based Algorithm

for Mining Association Rules”, Proceedings of 1995 ACM SIGMOD Int'l

Conf. Management of Data, pg. 175-186, San Jose, Calif., May 1995.

[PGG+05a] Pater M., Győrödi R., Győrödi C., Boc O., David Z., “Fast Apriori

algorithm for multilevel database”, Proceedings of microCAD 2005,

International Scientific Conference, pg. 347-352, Miskolcs, Hungary, 10-

11 March 2005

[PGG+05b] Pater M., Győrödi R., Győrödi C., Boc O., David Z., “Multi-level Apriori

Algorithms”, CSCS-15 15th International Conference on Control Systems

and Computer Science, Bucuresti, 2005

[PGG05] Pater M., Győrödi R., Győrödi C., “Comparison study of leading data

mining tools”, Proceedings of EMES ‘05, May 26-28, Oradea, 2005

194

[PGGB06] Pater M., Győrödi C., Győrödi R and Bogan-Marta A., “Mining Multi-

Level Association rules using FP-Tree and AFOPT”, ICCC 2006,

International Conference on Computers and Communications, June 1-3,

2006, Băile Felix Spa-Oradea, INPRESS

[PJ06] Pater M, and Jian I., “Multi-level frequent pattern mining from databases

using AFOPT data structure”, CONTI 2006, The 7th International

Conference On Technical Informatics, 8-9 June 2006, Timişoara,

INPRESS

PHM00] Pei J., Han J. and Mao R.,”CLOSET: An Efficient Algorithm for Mining

Frequent Closed Itemsets'' Proceedings of 2000 ACM-SIGMOD Int.

Workshop on Data Mining and Knowledge Discovery (DMKD'00)},

Dallas, TX, May 2000.

[PJ02] Pudi V. and Jayant R., “On the Efficiency of Association-rule Mining

Algorithms”, Haritsa Database Systems Lab, SERC Indian Institute of

Science, Pacific-Asia Conference on Knowledge Discovery and Data

Mining, 2002

[PSF91] Piatetski-Shapiro G. and Frawley W.J., „Knowledge Discovery in

Databases”, AAAI/MIT Press, 1991

[Qui86] Quinlan J.R., „Induction of decision trees. Machine Learning”, 1: pg.81-

1006, 1986

[Qui93] Quinlan J.R., „C4.5: Programs for Machine Learning”, 1993

[Ran97] Rantzau R., “Extended Concepts for Association Rule Discovery”,

Universitat Stuttgart, D-70565, Stuttgart, 1997

[Ray92] Raymon, R.,” Search through systematic set enumeration”, In

Proceedings of the Internation Conference on Principles of Knowledge

Representation and Reasoning, 1992

195

[RKS03] Rajkumar N., Karthik M.R. and Sivanandam S.N., “Fast Algorithm for

Mining Multilevel Association Rules”, IEEE Web Technology and Data

Mining, pg. 687-692, TENCON, 2003

[RR96] Rainsford C.P. and Roddick J.F., “Temporal Data Mining in information

systems: a model”, Seventh Australian Conference on Information

Systems”, Horbart, Tasmania, vol.2, pg. 545-553, 1996

[SA95a] Srikant R. and Agrawal R., “Mining Generalized Association Rules”, In

Proceedings of the 21st International Conference on Very Large

Databases, Zurich, Switzerland, pg. 407–419, September 1995.

[SA95b] Srikant R. and Agrawal R., “Mining Generalized Association Rules”, In

Research Report RJ 9963, IBM Almaden Research Center, San Jose,

California, USA, June 1995.

[SA96] Srikant R. and Agrawal R., “Mining Quantitative Association Rules in

Large Relational Tables”, Proceedings of the ACM SIGMOD Conference

on Management of Data, Montreal, Canada, June 1996.

[SM83] Salton G. and McGill M.J., “Introduction to Modern Information

Retrieval”, New York: McGraw-Hill, 1983

[SON95] Savasere A., Omiencinski E., and Navathe S., “An Efficient Algorithm for

Mining Association Rules in Large Databases”, Proceedings of the 21st

International Conference on Very Large Databases, Zurich, Switzerland,

pages 432–444, September 1995.

[WHH00] Wang K., He Y. and Han J., “Mining frequent itemsets using support

constrains”, Proceedings of the 26th VLDB Conference, Cairo, Egypt,

2000

[ZKC+02] Zhang M., Kao B., Cheung D. and Yip C., “Efficient Algorithms for

Incremental Update of Frequent Sequences”, Pacific-Asia Conference on

Knowledge Discovery and Data Mining, Sept. 2002

TEZĂ DE DOCTORAT - aspc.cs.upt.roaspc.cs.upt.ro/~calin/research/pater.pdf · universitatea...

Documents

Transcript of TEZĂ DE DOCTORAT - aspc.cs.upt.roaspc.cs.upt.ro/~calin/research/pater.pdf · universitatea...