Professional Documents
Culture Documents
Market-Basket transactions
Example of Association Rules
{Diaper} {Beer},
{Milk, Bread} {Eggs,Coke},
{Beer, Bread} {Milk},
• Itemset
– A collection of one or more items
• Example: {Milk, Bread, Diaper}
– k-itemset
• An itemset that contains k items
• Support count ()
– Frequency of occurrence of an itemset
– E.g. ({Milk, Bread,Diaper}) = 2
• Support
– Fraction of transactions that contain an
itemset
– E.g. s({Milk, Bread, Diaper}) = 2/5
• Frequent Itemset
– An itemset whose support is greater than
or equal to a minsup threshold
Definition: Association Rule
Association Rule
– An implication expression of the form X
Y, where X and Y are itemsets
– Example:
{Milk, Diaper} {Beer}
• Brute-force approach:
– List all possible association rules
– Compute the support and confidence for each rule
– Prune rules that fail the minsup and minconf thresholds
Computationally prohibitive!
Mining Association Rules
Example of Rules:
{Milk,Diaper} {Beer} (s=0.4, c=0.67)
{Milk,Beer} {Diaper} (s=0.4, c=1.0)
{Diaper,Beer} {Milk} (s=0.4, c=0.67)
{Beer} {Milk,Diaper} (s=0.4, c=0.67)
{Diaper} {Milk,Beer} (s=0.4, c=0.5)
{Milk} {Diaper,Beer} (s=0.4, c=0.5)
Observations:
• All the above rules are binary partitions of the same itemset:
{Milk, Diaper, Beer}
• Rules originating from the same itemset have identical support but
can have different confidence
• Thus, we may decouple the support and confidence requirements
Mining Association Rules
• Two-step approach:
1. Frequent Itemset Generation
– Generate all itemsets whose support minsup
2. Rule Generation
– Generate high confidence rules from each frequent itemset,
where each rule is a binary partitioning of a frequent itemset
A B C D E
AB AC AD AE BC BD BE CD CE DE
ABC ABD ABE ACD ACE ADE BCD BCE BDE CDE
d d k
R
d 1 d k
k j
k 1 j 1
3 2 1
d d 1
null
(¬Y ¬X)
frequent
A B C D E
frequent
infrequent
AB AC AD AE BC BD BE CD CE DE
ABC ABD ABE ACD ACE ADE BCD BCE BDE CDE
infrequent
13
ABCDE
Illustrating Apriori Principle
Found to be
Infrequent
Pruned
supersets
Illustrating Apriori Principle
Item Count Items (1-itemsets)
Bread 4
Coke 2
Milk 4 Itemset Count Pairs (2-itemsets)
Beer 3 {Bread,Milk} 3
Diaper 4
{Bread,Beer} 2 (No need to generate
Eggs 1
{Bread,Diaper} 3 candidates involving Coke
{Milk,Beer} 2 or Eggs)
{Milk,Diaper} 3
{Beer,Diaper} 3
Minimum Support = 3
Triplets (3-itemsets)
– Let k=1
– Generate frequent itemsets of length 1
– Repeat until no new frequent itemsets are identified
• Generate length (k+1) candidate itemsets from length k
frequent itemsets
• Prune candidate itemsets containing subsets of length k that
are infrequent
• Count the support of each candidate by scanning the DB
• Eliminate candidates that are infrequent, leaving only those
that are frequent
Example
A database has five
transactions. Let the min sup
= 50% and min con f = 80%.
Solution
Step 1: Find all Frequent
Itemsets
Frequent Itemset:
{A} {B} {C} {E} {A C} {B C} {B E} {C E} {B C E}
Step 2: Generate strong association rules from the frequent itemsets
Example
A database has five
transactions. Let the min sup
= 50% and min con f = 80%.
Closed Itemset: support of all parents are not equal to the support of the
itemset.
Maximal Itemset: all parents of that itemset must be infrequent.
Itemset {c} is closed as support of parents (supersets) {A C}:2, {B C}:2, {C D}:1, {C E}:2
not equal support of {c}:3. And the same for {A C}, {B E} & {B C E}.
Itemset {A C} is maximal as all parents (supersets) {A B C}, {A C D}, {A C E} are
infrequent. And the same for {B C E}.
Algorithms to find frequent pattern
• Apriori: uses a generate-and-test approach – generates
candidate itemsets and tests if they are frequent
– Generation of candidate itemsets is expensive (in both space and
time)
– Support counting is expensive
• Subset checking (computationally expensive)
• Multiple Database scans (I/O)
• FP-Growth: allows frequent itemset discovery without
candidate generation. Two step:
– 1.Build a compact data structure called the FP-tree
• 2 passes over the database
– 2.extracts frequent itemsets directly from the FP-tree
• Traverse through FP-tree
21
Core Data Structure: FP-Tree
• Nodes correspond to items and have a counter
• FP-Growth reads 1 transaction at a time and maps it to a path
• Fixed order is used, so paths can overlap when transactions
share items (when they have the same prex ).
• In this case, counters are incremented
• Pointers are maintained between nodes containing the same
item, creating singly linked lists (dotted lines)
• The more paths that overlap, the higher the compression. FP-
tree may t in memory.
• Frequent itemsets extracted from the FP-Tree.
Step 1: FP-Tree Construction (Example)
null
After reading TID=1:
a:1
b:1
a:1 b:1
b:1 c:1
d:1
FP-Tree Construction
Transaction
Database
null
a:8 b:2
b:5 c:2
c:1 d:1
27
Step 2: Frequent Itemset Generation
• FP-Growth extracts frequent itemsets from the FP-tree.
• Bottom-up algorithm from the leaves towards the root
– Divide and conquer: rst look for frequent itemsets ending in e, then de, etc. . . then d, then cd,
etc. . .
• First, extract prex path sub-trees ending in an item(set).
Complete FP-tree
prex path sub-trees
Step 2: Frequent Itemset Generation
• Each prex path sub-tree is processed recursively to extract the frequent
itemsets. Solutions are then merged.
• E.g. the prex path sub-tree for e will be used to extract frequent
itemsets ending in e, then in de, ce, be and ae, then in cde, bde, cde,
etc.
• Divide and conquer approach