Presentation is loading. Please wait.

Presentation is loading. Please wait.

ECLAT Jelena Stančić 3212/2015. E CLAT Equivalence Class Transformation A Frequent Itemset Mining (FIM) algorithm scans the database, and finds item-sets.

Published byBasil Fields Modified over 8 years ago

Similar presentations

Presentation on theme: "ECLAT Jelena Stančić 3212/2015. E CLAT Equivalence Class Transformation A Frequent Itemset Mining (FIM) algorithm scans the database, and finds item-sets."— Presentation transcript:

1 ECLAT Jelena Stančić 3212/2015

2 E CLAT Equivalence Class Transformation A Frequent Itemset Mining (FIM) algorithm scans the database, and finds item-sets that occur in transactions more frequently than a given threshold. Scientific and industrial applications, including those in machine learning, computational biology, intrusion detection, web log mining, and e-business benefit from the use of frequent itemset mining. 2/35

3 E CLAT TIDItems 1Bread, Milk 2Bread, Diaper, Beer, Eggs 3Milk, Diaper, Beer, Coke 4Bread, Milk, Diaper, Beer 5Bread, Milk, Diaper, Coke 3/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 Eggs 2 Coke 3 5 Transactions, originally stored in horizontal format, are read from disk and converted to vertical format.

4 E CLAT The frequency of each item is counted and the infrequent items and their corresponding vertical lists are deleted from the vertical list. 4/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 Eggs 2 Coke 3 5 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 Minimum support = 3

5 E CLAT The Eclat algorithm is defined recursively. The initial call uses all the single items with their tidsets. In each recursive call, the function verifies each itemset-tidset pair with all the others pairs to generate new candidates. If the new candidate is frequent, it is added to the set. Then, recursively, it finds all the frequent itemsets in the branch. 5/35

6 E CLAT 6/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

7 E CLAT 7/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

8 E CLAT 8/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Bread, Beer} 2 4

9 E CLAT 9/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Bread, Beer} 2 4

10 E CLAT 10/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Bread, Beer} 2 4

11 E CLAT 11/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Bread, Beer} 2 4 {Bread, Milk, Diaper} 4 5

12 E CLAT 12/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Bread, Beer} 2 4 {Bread, Milk, Diaper} 4 5

13 E CLAT 13/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

14 E CLAT 14/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

15 E CLAT 15/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Milk, Diaper} 3 4 5 {Milk, Beer} 3 4

16 E CLAT 16/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Milk, Diaper} 3 4 5 {Milk, Beer} 3 4

17 E CLAT 17/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

18 E CLAT 18/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

19 E CLAT 19/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Diaper, Beer} 2 3 4

20 E CLAT 20/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4

21 E CLAT 21/35 Bread 1 2 4 5 Milk 1 3 4 5 Diaper 2 3 4 5 Beer 2 3 4 {Bread, Milk} 1 4 5 {Bread, Diaper} 2 4 5 {Milk, Diaper} 3 4 5 {Diaper, Beer} 2 3 4

22 E CLAT 22/35 Uses vertical database – tidset(bitset) intersections. Scans the database only once. Depth-first search algorithm.

23 E CLAT 23/35

24 E CLAT - PARALLEL 24/35

25 E CLAT - PARALLEL 25/35 “Equivalent Class”, which can be defined by a set of candidates with the same size, assumed k, shared the common k−1 prefix. {Bread, Milk} {Bread, Diaper}{Bread, Beer} {Milk, Diaper}{Milk, Beer} {Diaper, Beer}

26 E CLAT - PARALLEL 26/35

27 E CLAT – CPU IMPLEMENTATION I 27/35 public class AlgoEclat{.... public Itemsets runAlgorithm{ final Map > mapItemCount = new HashMap >(); int maxItemId = calculateSupportSingleItems(database, mapItemCount); // (2) create the list of single items List frequentItems = new ArrayList (); // for each item for(Entry > entry : mapItemCount.entrySet()) { Set tidset = entry.getValue(); int support = tidset.size(); int item = entry.getKey(); if(support >= minsupRelative) { frequentItems.add(item); saveSingleItem(item, tidset, tidset.size()); } Collections.sort(frequentItems, new Comparator () { public int compare(Integer arg0, Integer arg1) { return mapItemCount.get(arg0).size() - mapItemCount.get(arg1).size(); }}); // For each frequent item I according to the total order for(int i=0; i < frequentItems.size(); i++) { Integer itemI = frequentItems.get(i); // we obtain the tidset and support of that item Set tidsetI = mapItemCount.get(itemI); int supportI = tidsetI.size();

28 E CLAT – CPU IMPLEMENTATION II 28/35 // We create empty equivalence class for storing all 2-itemsets starting with List equivalenceClassIitems = new ArrayList (); List > equivalenceClassItidsets = new ArrayList >(); for(int j=i+1; j < frequentItems.size(); j++) { int itemJ = frequentItems.get(j); Set tidsetJ = mapItemCount.get(itemJ); int supportJ = tidsetJ.size(); Set tidsetIJ = performANDFirstTime(tidsetI, supportI, tidsetJ, supportJ); if(calculateSupport(2, supportI, tidsetIJ) >= minsupRelative){ equivalenceClassIitems.add(itemJ); // We also keep the tidset of "ij". equivalenceClassItidsets.add(tidsetIJ); } if(equivalenceClassIitems.size() > 0) { // This is done by a recursive call. Note that we pass // item I to that method as the prefix of that equivalence class. itemsetBuffer[0] = itemI; processEquivalenceClass(itemsetBuffer, 1, supportI, equivalenceClassIitems, equivalenceClassItidsets); }... }

29 E CLAT – CPU IMPLEMENTATION III 29/35 private void processEquivalenceClass(int[] prefix, int prefixLength, int supportPrefix, List equivalenceClassItems, List > equivalenceClassTidsets) throws IOException { int length = prefixLength+1; if(equivalenceClassItems.size() == 1) { int itemI = equivalenceClassItems.get(0); Set tidsetItemset = equivalenceClassTidsets.get(0); save(prefix, prefixLength, itemI, tidsetItemset, calculateSupport(length, supportPrefix, tidsetItemset)); return; } if(equivalenceClassItems.size() == 2) { int itemI = equivalenceClassItems.get(0); Set tidsetI = equivalenceClassTidsets.get(0); int supportI = calculateSupport(length, supportPrefix, tidsetI); save(prefix, prefixLength, itemI, tidsetI, supportI); int itemJ = equivalenceClassItems.get(1); Set tidsetJ = equivalenceClassTidsets.get(1); int supportJ = calculateSupport(length, supportPrefix, tidsetJ); save(prefix, prefixLength, itemJ, tidsetJ, supportJ); Set tidsetIJ = this.performAND(tidsetI, tidsetI.size(), tidsetJ, tidsetJ.size()); int supportIJ = calculateSupport(length, supportI, tidsetIJ); if(supportIJ >= minsupRelative) { int newPrefixLength = prefixLength+1; prefix[prefixLength] = itemI; save(prefix, newPrefixLength, itemJ, tidsetIJ, supportIJ); } return; }

30 E CLAT – CPU IMPLEMENTATION IV 30/35 for(int i=0; i< equivalenceClassItems.size(); i++) { int suffixI = equivalenceClassItems.get(i); Set tidsetI = equivalenceClassTidsets.get(i); int supportI = calculateSupport(length, supportPrefix, tidsetI); save(prefix, prefixLength, suffixI, tidsetI, supportI); List equivalenceClassISuffixItems= new ArrayList (); List > equivalenceITidsets = new ArrayList >(); for(int j=i+1; j < equivalenceClassItems.size(); j++) { int suffixJ = equivalenceClassItems.get(j); Set tidsetJ = equivalenceClassTidsets.get(j); int supportJ = calculateSupport(length, supportPrefix, tidsetJ); Set tidsetIJ = performAND(tidsetI, supportI, tidsetJ, supportJ); int supportIJ = calculateSupport(length, supportI, tidsetIJ); if(supportIJ >= minsupRelative) { equivalenceClassISuffixItems.add(suffixJ); equivalenceITidsets.add(tidsetIJ); } if(equivalenceClassISuffixItems.size() >0) { prefix[prefixLength] = suffixI; int newPrefixLength = prefixLength+1; processEquivalenceClass(prefix, newPrefixLength, supportI, equivalenceClassISuffixItems, equivalenceITidsets); }

31 E CLAT – GPU IMPLEMENTATION I 31/35

32 E CLAT – GPU IMPLEMENTATION II 32/35 __shared__ unsigned int sup[MAX_THREAD]; unsigned int* psrc1; unsigned int* psrc2; unsigned int* pdst; unsigned int iter, i, tmp; unsigned int bound; if (blockIdx.x >= list_len) return; sup[threadIdx.x] = 0; iter = (vlist_len - 1) / blockDim.x + 1; psrc1 = src_list_1[blockIdx.x]; psrc2 = src_list_2[blockIdx.x]; pdst = dst_list[blockIdx.x]; __syncthreads(); for (i = 0; i < iter; i++) { int thread_pos = i * blockDim.x + threadIdx.x; if (thread_pos >= vlist_len) break; tmp=psrc1[thread_pos] & psrc2[thread_pos]; sup[threadIdx.x]+=__popc(tmp); pdst[thread_pos]=tmp; } __syncthreads(); for (bound = blockDim.x / 2; bound > 0; bound >>= 1) { if (threadIdx.x < bound) sup[threadIdx.x]+=sup[threadIdx.x+bound]; __syncthreads(); } __syncthreads(); if(threadIdx.x == 0) { *(result+current_block_pos)=sup[0]; } __global__ void kernel_calc( unsigned int** src_list_1, unsigned int** src_list_2, unsigned int** dst_list, unsigned int* result, unsigned int list_len,unsigned int vlist_len) {

33 E CLAT – CPU VS GPU 33/35 ChessRetail System characteristics: Processor: Intel(R) Core(TM) i5-5200 CPU @ 2.20 GHZ Installed memory(RAM):8.00 GB System type: 64-bit Operating system, x64-based processor GPU: NVIDIA GeForce 940M OS: Windows 10

34 E CLAT – CPU VS GPU 34/35 PumsbAccidents MushroomConnect

35 35/35 THANK YOU FOR YOUR ATTENTION! Questions?

Download ppt "ECLAT Jelena Stančić 3212/2015. E CLAT Equivalence Class Transformation A Frequent Itemset Mining (FIM) algorithm scans the database, and finds item-sets."

Similar presentations

Association Rule and Sequential Pattern Mining for Episode Extraction Jonathan Yip.

Association Rule and Sequential Pattern Mining for Episode Extraction Jonathan Yip.
Association Rule Mining

Association Rule Mining
Mining Association Rules in Large Databases

Mining Association Rules in Large Databases
Association Analysis (2). Example TIDList of item ID’s T1I1, I2, I5 T2I2, I4 T3I2, I3 T4I1, I2, I4 T5I1, I3 T6I2, I3 T7I1, I3 T8I1, I2, I3, I5 T9I1, I2,

Association Analysis (2). Example TIDList of item ID’s T1I1, I2, I5 T2I2, I4 T3I2, I3 T4I1, I2, I4 T5I1, I3 T6I2, I3 T7I1, I3 T8I1, I2, I3, I5 T9I1, I2,
1 Frequent Itemset Mining: Computation Model uTypically, data is kept in a flat file rather than a database system. wStored on disk. wStored basket-by-basket.

1 Frequent Itemset Mining: Computation Model uTypically, data is kept in a flat file rather than a database system. wStored on disk. wStored basket-by-basket.
IT 433 Data Warehousing and Data Mining Association Rules Assist.Prof.Songül Albayrak Yıldız Technical University Computer Engineering Department

IT 433 Data Warehousing and Data Mining Association Rules Assist.Prof.Songül Albayrak Yıldız Technical University Computer Engineering Department
Zeev Dvir – GenMax From: “ Efficiently Mining Frequent Itemsets ” By : Karam Gouda & Mohammed J. Zaki.

Zeev Dvir – GenMax From: “ Efficiently Mining Frequent Itemsets ” By : Karam Gouda & Mohammed J. Zaki.
1 Mining Associations Apriori Algorithm. 2 Computation Model uTypically, data is kept in a flat file rather than a database system. wStored on disk. wStored.

1 Mining Associations Apriori Algorithm. 2 Computation Model uTypically, data is kept in a flat file rather than a database system. wStored on disk. wStored.
Data Mining Association Analysis: Basic Concepts and Algorithms

Data Mining Association Analysis: Basic Concepts and Algorithms
Association Mining Data Mining Spring 2012. Transactional Database Transaction – A row in the database i.e.: {Eggs, Cheese, Milk} Transactional Database.

Association Mining Data Mining Spring Transactional Database Transaction – A row in the database i.e.: {Eggs, Cheese, Milk} Transactional Database.
Association Analysis. Association Rule Mining: Definition Given a set of records each of which contain some number of items from a given collection; –Produce.

Association Analysis. Association Rule Mining: Definition Given a set of records each of which contain some number of items from a given collection; –Produce.
Data Mining Techniques So Far: Cluster analysis K-means Classification Decision Trees J48 (C4.5) Rule-based classification JRIP (RIPPER) Logistic Regression.

Data Mining Techniques So Far: Cluster analysis K-means Classification Decision Trees J48 (C4.5) Rule-based classification JRIP (RIPPER) Logistic Regression.
Data Mining Association Analysis: Basic Concepts and Algorithms Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach, Kumar Introduction.

Data Mining Association Analysis: Basic Concepts and Algorithms Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach, Kumar Introduction.
Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,

Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,
Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,

Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,
732A02 Data Mining - Clustering and Association Analysis ………………… Jose M. Peña Association rules Apriori algorithm FP grow algorithm.

732A02 Data Mining - Clustering and Association Analysis ………………… Jose M. Peña Association rules Apriori algorithm FP grow algorithm.
Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,

Data Mining Association Analysis: Basic Concepts and Algorithms Lecture Notes for Chapter 6 Introduction to Data Mining by Tan, Steinbach, Kumar © Tan,Steinbach,
Association Analysis (2). Example TIDList of item ID’s T1I1, I2, I5 T2I2, I4 T3I2, I3 T4I1, I2, I4 T5I1, I3 T6I2, I3 T7I1, I3 T8I1, I2, I3, I5 T9I1, I2,

Association Analysis (2). Example TIDList of item ID’s T1I1, I2, I5 T2I2, I4 T3I2, I3 T4I1, I2, I4 T5I1, I3 T6I2, I3 T7I1, I3 T8I1, I2, I3, I5 T9I1, I2,
Data Mining Association Analysis: Basic Concepts and Algorithms

Data Mining Association Analysis: Basic Concepts and Algorithms
1 Mining Frequent Patterns Without Candidate Generation Apriori-like algorithm suffers from long patterns or quite low minimum support thresholds. Two.

1 Mining Frequent Patterns Without Candidate Generation Apriori-like algorithm suffers from long patterns or quite low minimum support thresholds. Two.

Similar presentations

Ads by Google