- Manku's algorithm to find
frequent item sets
generates
a large number
of
intermediate results
- Example:
- Input stream: abcde, abcdf
- Will cause these entries to be inserted into the summary:
- (a, 2, Δ), (b, 2, Δ), (c, 2, Δ), (d, 2, Δ), (e, 1, Δ), (f, 1, Δ), (ab, 2, Δ), (ac, 2, Δ), (ad, 2, Δ), (bc, 2, Δ), (bd, 2, Δ), (cd, 2, Δ), (ae, 1, Δ), (af, 1, Δ), (be, 1, Δ), (bf, 1, Δ), (ce, 1, Δ), (cf, 1, Δ), (de, 1, Δ), (df, 1, Δ), (abc, 2, Δ), (abd, 2, Δ), (bcd, 2, Δ), ....
(All I want to say is: a lot of item sets)
- Input stream: abcde, abcdf
- We have also studied
the Apriori-Algorithm
for finding
frequent itemsets
in a materialized database
This algorithm makes use of the Apriori-property to reduce the number of candidate frequent item sets:
- If an itemset x
is frequent
(i.e., freq(x) ≥
θN),
then:
-
all subsets of x
is also
frequent
- If an itemset x
is frequent
(i.e., freq(x) ≥
θN),
then:
- Jin's idea:
- Jin has incorporated the
Apriori-principle
into his algorithm to
reduce the
number of candidate frequent itemsets
- Jin is also dealing with a data stream and has incorporated the cut-as-you-go idea from Karp's paper into his algorithm
- Jin has incorporated the
Apriori-principle
into his algorithm to
reduce the
number of candidate frequent itemsets
- Notations:
- D =
the data stream
|D| = size of the data stream
- θ =
minimum support level
of frequent item sets
- ε =
maximum error
in the frequency
of the frequent item sets
(This parameter has a similar meaning as the ε parameter in Manku's algorithm)
- L =
collection of all the frequent
item sets
Lk = collection of all the frequent k-item sets
Example:
- L =
{ a, b, c, ab, bc, abc}
Then:
- L1 = {a, b, c}
- L2 = {ab, bc}
- L3 = {abc}
- L =
{ a, b, c, ab, bc, abc}
- L =
L1 ∪
L2 ∪ ...
∪ Lk
- t =
transaction, i.e.,
a set of items
- T = a collection of transactions
- D =
the data stream
- Before we present the algorithm,
let's look at a few
helper routines
used by the algorithm
- Update(t, L, i):
update the count of
item sets in transaction t in Li
Update(Transaction t, Lattice L, int i) { for ( each i-subset S ⊆ t ) do { if ( S ∈ Li ) { /* ---------------------------- Item set S is in Li ---------------------------- */ S.count++; // Tally itemset } else { /* --------------------------------- Item set S is not in Li --------------------------------- */ if ( i ≤ 2 ) { /* ------------------------------------ "Commonly found" item sets, insert ------------------------------------- */ Li.insert(S); // Always insert 1 and 2-itemsets } else { /* --------------------------------------- Larger item sets... Use the Apriori property to save space --------------------------------------- */ if ( every (i-1)-subset U of S ∈ Li-1 ) { Li-1,insert(S); // All subset of S must also be frequent ! } } } } }Comments
- When an item set is
first inserted into
L,
its count is
set to 1
- The Update()
routine keeps a very accurate count
of the
1-item sets and
2-item sets
- The higher order item sets
will only be counted
if all its subsets
are frequent
This is the Apriori Property
- When an item set is
first inserted into
L,
its count is
set to 1
- CrossOver(L, i):
deleting infrequent item sets
from Li
CrossOver(Lattice L, int i) { for ( each i-itemset S ∈ Li ) do { s.count--; if ( s.count == 0 ) { Li.delete(S); // remove completely } } }Comments:
- I don't understand
why the authors call this
function
CrossOver
I would call it DeleteInfreqItemset of something along that line.
- We have seen a similar step in
Karp's Algorithm
- see:
click here
This step is used to reduce the amount of memory used by deleting the infrequent item sets
The unpleasant consequence is the fact that we do not have the exact count of an item set any more.
E.g., item set S is inserted with count=1, then S is deleted; and later S is inserted again with count = 1. The count is not completely accurate
- I don't understand
why the authors call this
function
CrossOver
- NumberOfTwoItemsetsPerTransaction(N, X, t):
estimating the average number of
2-item sets per transaction
*** Note: parameters N and X are passed by reference ! int NumberOfTwoItemsetsPerTransaction(int N, int X, int t) { N++; X = X + ( |t| × (|t|-1) / 2 ); // = # 2-item sets in t return ( X/N ); }Comment:
- Simple combinatorics...
- A note on the algorithm:
- The algorithm
does not
process an arriving item set
immediately
- Instead, it waits
until the set
L2 (frequent 2-items sets)
exceeds
a certain threshold
(1/(θε))*f
(f = average number of 2-item sets contained in a transaction)
- The algorithm
does not
process an arriving item set
immediately
- Algorithm:
L = ∅; // L = all frequent itemsets T = ∅; // T = unprocessed transactions (buffer) N = 0; // N = number of transactions X = 0; // X = number of 2-itemsets in transactions c = 0; // Counts the number of times that "CrossOver" (delete) operation was performed while ( not EOS(D) ) { t = next transaction (set of items) in D; T = T ∪ t; /* ---------------------------------------------------------- Always update the 1-item and 2-items frequent item sets ---------------------------------------------------------- */ Update(t, L, 1); // insert t{1} in L Update(t, L, 2); // insert t{2} in L /* ---------------------------------------------------------- Processing of 3-items and higher-items frequent item sets are delayed until L2 reaches a certain threshold ---------------------------------------------------------- */ f = NumberOfTwoItemsetsPerTransaction(N, X, t); if ( | L2 | ≥ 1/(εθ) * f ) { /* ------------------------------------------ First: Delete infrequent sets in L2 ------------------------------------------ */ CrossOver(L, 2); /* ------------------------------------------------------- Next: (delayed) process transactions into L3, L4, ... ------------------------------------------------------- */ i = 2; while ( Li != ∅ ) { i++; /* ----------------------- Insert phase ----------------------- */ for ( each t ∈ T ) do { Update(t, L, i); } /* ----------------------- Delete phase ----------------------- */ CrossOver(L, i); } c++; // One more deletion completed... T = ∅ // Re-initialize.... } /* -------------------------------------------------------------- Post processing: performs θ × |D| "CrossOver" (delete operation) to remove the non-frequent item sets -------------------------------------------------------------- */ while ( c < θ × |D| ) { c++; for ( each Li ) { if ( Li != ∅ ) CrossOver(Li); } } }
- Running time vs.
Changing support-level θ
- Memory requirement vs.
Changing support-level θ
- Running time vs.
Changing data stream size
- Running time vs.
Changing data stream size
- Memory requirement vs.
Changing data stream size
