FP-Growth

Compress the transactions into a prefix tree and mine frequent itemsets from it recursively — no candidate generation.

16 min read1736 wordscore10 viewsupdated 2026-10-07

Definition

FP-Growth (frequent-pattern growth) finds every itemset that appears in at least σ\sigma transactions. It reads the database twice to build an FP-tree, a prefix tree in which baskets that start with the same items share nodes, and then mines that tree recursively. For each item it builds a smaller conditional tree of what co-occurs with it. It never generates candidate itemsets and counts them, which is the step that makes Apriori slow.

At a glance

Task
Unsupervised frequent-itemset mining (the first half of association-rule learning)
Input → output
a list of transactions (sets of items) and a minimum support σ\sigma → every itemset XX with sup(X)≥σ\text{sup}(X)\ge\sigma, plus its count
Learns
nothing parametric: it builds a compressed index of the data (the FP-tree) and lists patterns from it
Training cost
2 database scans, O(∑t∣t∣)O(\sum_t |t|), to build the tree; mining costs roughly the number of frequent itemsets times the size of the conditional trees
Prediction cost
none by itself; rules derived from the itemsets are applied by lookup, O(#rules)O(\#\text{rules})
Hyperparameters
min support σ\sigma (the big one), optional max itemset length; min confidence / lift come later, when rules are generated
Assumes
binary presence/absence of items (quantities ignored), and an FP-tree small enough to fit in memory

The problem

Frequent-itemset mining asks which groups of items keep showing up together, for example bread and butter or eggs and milk. With mm distinct items there are 2m−12^m-1 possible itemsets, so nobody enumerates them all. Apriori (see the Apriori article for support, confidence, lift and rule generation) prunes the search with the rule that every subset of a frequent itemset is frequent. It still works generate and test though: at level kk it builds every candidate kk-itemset whose subsets are all frequent, then scans the whole database to count them.

That costs two things. Scans: Apriori reads the database once per level, so a frequent 10-itemset needs about 10 passes. Candidates: with 10410^4 frequent single items, level 2 alone has about 5×1075\times10^7 candidate pairs, and each one has to be stored and counted. Han, Pei and Yin (2000) asked whether the itemsets could be found without generating candidates at all. Their answer was to compress the database into a tree once, then grow patterns from it, with each step working on a smaller and smaller projected database.

The idea

Step 1: compress. Count every item and throw away the infrequent ones, since by downward closure no frequent itemset can contain them. Rewrite each basket as its frequent items sorted from most to least frequent, then insert these sorted lists into a prefix tree (a trie). Baskets that start the same way share a path, and each node stores how many baskets passed through it. Because popular items come first, they sit near the root and get shared most often.

Step 2: divide and conquer. Split the itemsets by their least frequent item. To find every frequent itemset that ends in butter, you only need the baskets that contain butter, and of those only the part above butter in the sorted order. In the tree that part is the path from each butter node up to the root. Collect those paths (the conditional pattern base), build a small FP-tree from them, and repeat. Each recursive call fixes one more item (the suffix) and works on a strictly smaller tree.

Vocabulary

Transaction / basket
one set of items t⊆It\subseteq I, e.g. one shopping receipt; the database DD is a list of them
Itemset
any set of items X⊆IX\subseteq I; a kk-itemset has kk items
Support
sup(X)\text{sup}(X), the number (or fraction) of transactions containing all of XX
Frequent itemset
one with sup(X)≥σ\text{sup}(X)\ge\sigma, the minimum support
F-list
the frequent single items sorted by descending support; it fixes the order of items along every path of the tree
FP-tree
a prefix tree with a null root; each node holds an item, a count, a parent pointer and a link to the next node with the same item
Header table
one row per frequent item: its support and the head of its node-link chain
Node-link
the chain through every tree node that carries the same item, so all occurrences of an item can be visited without searching the tree
Prefix path
the items on the path from the root down to (but not including) a node, weighted by that node's count
Conditional pattern base
the multiset of prefix paths of all nodes of item aa, a small database of everything that co-occurs with aa
Conditional FP-tree
the FP-tree built from a conditional pattern base, after dropping items that are infrequent within it
Suffix (pattern)
the items fixed so far in the recursion; every itemset emitted at that level ends with them

The math

supD(X)=∣{ t∈D:X⊆t }∣,Fσ={X⊆I: supD(X)≥σ}\text{sup}_D(X)=\big|\{\,t\in D : X\subseteq t\,\}\big|,\qquad F_\sigma=\{X\subseteq I:\ \text{sup}_D(X)\ge\sigma\}
DD
the database, a list of transactions tt (each a set of items)
II
the set of all distinct items
XX
an itemset
σ\sigma
the minimum support, as a count (min_support × |D| when given as a fraction)
FσF_\sigma
the output: all frequent itemsets

Downward closure. If X⊆YX\subseteq Y then every transaction containing YY also contains XX, so sup(X)≥sup(Y)\text{sup}(X)\ge\text{sup}(Y). An item with support below σ\sigma therefore belongs to no frequent itemset and can be deleted from every transaction before anything else happens. That deletion is scan 1.

a≺b  ⟺  sup(a)>sup(b)  (ties broken by a fixed rule),path(t)=sort≺(t∩F1)a\prec b \iff \text{sup}(a)>\text{sup}(b)\ \ (\text{ties broken by a fixed rule}),\qquad \text{path}(t)=\text{sort}_\prec\big(t\cap F_1\big)
≺\prec
the F-list order: more frequent items come first
F1F_1
the frequent single items
path(t)\text{path}(t)
the sorted frequent part of transaction t, which is inserted as one root-to-node path

What a node count means. Inserting path(t)\text{path}(t) adds 1 to every node along it, so a node nn whose root path is p1≺⋯≺pkp_1\prec\dots\prec p_k has count = the number of transactions whose sorted frequent part starts with p1…pkp_1\ldots p_k. Each transaction contains an item aa at most once, so it passes through exactly one aa-node. Summing the counts along aa's node-link therefore gives its support:

supD(a)=∑n ∈ links(a)count(n)\text{sup}_D(a)=\sum_{n\,\in\,\text{links}(a)}\text{count}(n)
links(a)\text{links}(a)
all tree nodes labelled aa, reached through the header table's node-link chain
count(n)\text{count}(n)
number of transactions whose sorted path passes through node n

The pattern-growth lemma. Take a set β\beta of items that all come before aa in the order. A transaction contains β∪{a}\beta\cup\{a\} exactly when its path goes through some aa-node nn and β\beta lies on the path above nn. Items before aa can only appear above aa in the path, never below it. Group the transactions by the aa-node they pass through and add up:

supD(β∪{a})=∑n∈links(a)count(n)⋅1[β⊆prefix(n)]=supBa(β)\text{sup}_D(\beta\cup\{a\})=\sum_{n\in\text{links}(a)}\text{count}(n)\cdot\mathbb 1\big[\beta\subseteq\text{prefix}(n)\big]=\text{sup}_{B_a}(\beta)
prefix(n)\text{prefix}(n)
the items on the path from the root down to nn's parent
BaB_a
the conditional pattern base of aa: each prefix(n)\text{prefix}(n) as a transaction with weight count(n)\text{count}(n)
supBa(β)\text{sup}_{B_a}(\beta)
weighted support of β\beta inside that small database

This identity is the whole algorithm. Mining every frequent itemset whose least frequent item is aa is the same as mining BaB_a with the same threshold σ\sigma and attaching aa to every result. BaB_a is again a list of weighted transactions, so we build an FP-tree from it and recurse. Each itemset has exactly one least frequent item, so processing the header items from the bottom up finds every frequent itemset exactly once, with no duplicates and no candidates.

if T is a single path p1 ⁣: ⁣c1→⋯→pk ⁣: ⁣ck,sup(S∪α)=min⁡pi∈Sci  for every ∅≠S⊆{p1,…,pk}\text{if } T \text{ is a single path } p_1\!:\!c_1\to\dots\to p_k\!:\!c_k,\quad \text{sup}(S\cup\alpha)=\min_{p_i\in S}c_i\ \ \text{for every } \varnothing\ne S\subseteq\{p_1,\dots,p_k\}
α\alpha
the current suffix
cic_i
counts along the path, non-increasing (c1≥c2≥…c_1\ge c_2\ge\dots)

Single-path shortcut. When a conditional tree is one chain, the recursion can stop. All 2k−12^k-1 combinations of the chain's items are frequent (every ci≥σc_i\ge\sigma after pruning), and each one's support is its deepest node's count. This is where FP-Growth saves the most on dense data.

How σ\sigma acts. Lowering σ\sigma (i) keeps more items in the F-list, so the tree gets more nodes, and (ii) keeps more items alive in every conditional base, so the recursion goes deeper. The output can grow exponentially: on the worked example it goes from 2 itemsets at σ=7\sigma=7 to 9 at σ=3\sigma=3 and 23 at σ=1\sigma=1. The tree size is bounded by ∑t∣t∩F1∣\sum_t|t\cap F_1|, the number of frequent item occurrences, and reaches that bound only when no two baskets share a first item. Sorting by descending support is a heuristic that maximizes prefix sharing. It is usually good but not guaranteed optimal.

Worked example: 10 grocery baskets

Ten baskets, six products, and minimum support σ=3\sigma=3 baskets (30%). Scan 1 counts the items: bread 8, milk 7, eggs 6, butter 4, coffee 1, jam 1. Coffee and jam fall below 3 and are dropped, and the F-list is bread ≻ milk ≻ eggs ≻ butter.

BasketItemsSorted frequent items
T1bread, milk, eggsbread, milk, eggs
T2bread, butterbread, butter
T3bread, milk, butterbread, milk, butter
T4milk, eggsmilk, eggs
T5bread, milk, eggs, butterbread, milk, eggs, butter
T6bread, eggsbread, eggs
T7milk, eggs, jammilk, eggs
T8bread, milkbread, milk
T9bread, milk, eggsbread, milk, eggs
T10coffee, bread, butterbread, butter
The database, and each basket rewritten as its frequent items in F-list order (what actually gets inserted into the tree). Highlighted: the four baskets containing butter.

Scan 2: building the FP-tree

  1. 1T1 bread, milk, eggs: the tree is empty, so it creates the path bread:1 → milk:1 → eggs:1.
  2. 2T2 bread, butter: shares bread (now 2) and adds a new child butter:1 under bread.
  3. 3T3 bread, milk, butter: bread 3, milk 2, then a new butter:1 under milk.
  4. 4T4 milk, eggs: the root has no milk child, so it starts a second branch milk:1 → eggs:1. There are now two milk nodes, joined by the milk node-link.
  5. 5T5 to T10 continue the same way. T7 loses jam, T10 loses coffee, and T8 and T9 only increment existing counts.
  6. 6Result: 25 frequent item occurrences stored in 9 nodes: bread:8 → {milk:5 → {eggs:3 → butter:1, butter:1}, butter:2, eggs:1}, and milk:2 → eggs:2. Check: the butter nodes sum to 2 + 1 + 1 = 4 = sup(butter).

Mining, least frequent item first

  1. 1butter (support 4, three nodes). Prefix paths: bread:2, bread→milk:1, bread→milk→eggs:1. Inside this base bread has 4, milk 2 and eggs 1, so milk and eggs are pruned and the conditional tree is just bread:4. Emit {butter}:4\{\text{butter}\}:4 and {bread,butter}:4\{\text{bread},\text{butter}\}:4.
  2. 2eggs (support 6, nodes 3 + 1 + 2). Prefix paths: bread→milk:3, bread:1, milk:2. Local counts are milk 5 and bread 4, so both survive and the conditional tree is milk:5 → bread:3 plus a separate bread:1. It has two branches, so we recurse: bread's base is milk:3, giving {bread,eggs}:4\{\text{bread},\text{eggs}\}:4 and {bread,milk,eggs}:3\{\text{bread},\text{milk},\text{eggs}\}:3; milk then gives {milk,eggs}:5\{\text{milk},\text{eggs}\}:5. Together with {eggs}:6\{\text{eggs}\}:6 that is four itemsets.
  3. 3milk (support 7, nodes 5 + 2). Prefix paths: bread:5, plus the root-level milk:2, whose prefix is empty. Emit {milk}:7\{\text{milk}\}:7 and {bread,milk}:5\{\text{bread},\text{milk}\}:5.
  4. 4bread (support 8). Its only node hangs off the root, so the base is empty. Emit {bread}:8\{\text{bread}\}:8.
  5. 5Total: 9 frequent itemsets from 2 database scans. Apriori would scan 3 times and count 6 + 6 + 1 = 13 candidates to reach the same answer.
ItemNode-link countsConditional pattern baseConditional FP-treeItemsets emitted
butter2 + 1 + 1 = 4bread:2 · bread→milk:1 · bread→milk→eggs:1bread:4{butter}:4, {bread, butter}:4
eggs3 + 1 + 2 = 6bread→milk:3 · bread:1 · milk:2milk:5 → bread:3; bread:1{eggs}:6, {bread, eggs}:4, {bread, milk, eggs}:3, {milk, eggs}:5
milk5 + 2 = 7bread:5 · (empty):2bread:5{milk}:7, {bread, milk}:5
bread8(empty):8—{bread}:8
Conditional pattern bases and what each one contributes (σ = 3).

Using the result. Rules come from the itemset counts with no further scans. eggs⇒milk\text{eggs}\Rightarrow\text{milk} has confidence 5/6=0.8335/6=0.833 and lift 0.833/0.7=1.190.833/0.7=1.19, and butter⇒bread\text{butter}\Rightarrow\text{bread} has confidence 4/4=1.04/4=1.0 and lift 1.0/0.8=1.251.0/0.8=1.25. So a new customer who puts eggs in the cart gets milk recommended: 5 of the 6 egg baskets also had milk, 19% more often than milk's 70% base rate. If the cart already holds bread and eggs, {bread,eggs}⇒milk\{\text{bread},\text{eggs}\}\Rightarrow\text{milk} has confidence 3/4=0.753/4=0.75 and lift only 1.07.

▸ fp-growth · minsup 3step 1/25
min supportof 10 baskets
header tablebread8milk7eggs6butter4coffee1jam1minsup = 3scan 1: counting items…basketsT1breadmilkeggsT2breadbutterT3breadmilkbutterT4milkeggsT5breadmilkeggsbutterT6breadeggsT7milkeggsjamT8breadmilkT9breadmilkeggsT10coffeebreadbutter
nodes 0/9scans 1found 0
  1. 1fpgrowth(D, minsup, suffix=∅):
  2. 2 scan 1: count supports, drop < minsup
  3. 3 sort each basket by support (desc)
  4. 4 scan 2: for t in D: insert t
  5. 5 shared prefix → count+1, else new node
  6. 6 for a in header, least frequent first:
  7. 7 emit {a} ∪ suffix
  8. 8 base ← prefix paths of a's nodes
  9. 9 Tₐ ← FP-tree of base (minsup)
  10. 10 fpgrowth(Tₐ, minsup, {a} ∪ suffix)
  11. 11 return all emitted itemsets

Scan 1 counts every item over the 10 baskets: bread 8, milk 7, eggs 6, butter 4, coffee 1, jam 1. coffee and jam fall below minsup 3 and are dropped for good.

fig.FP-Growth on the 10 baskets. Scan 1 counts items and crosses out coffee and jam (support 1). Scan 2 inserts the sorted baskets one by one: shared prefixes light up and gain +1, new nodes appear, and dashed node-links chain nodes of the same item. Mining then takes butter, eggs, milk, bread in turn, highlights each item's prefix paths, lists its conditional pattern base and draws its conditional FP-tree. At min support 3 the tree has 9 nodes and 9 itemsets are found. Change min support to see the tree and the output change: 11 nodes and 23 itemsets at 1, 6 nodes and 5 itemsets at 5.

The algorithm, step by step

FP-Growth(D, σ)

  1. 1Scan 1. Count the support of every item. Keep items with support ≥σ\ge\sigma and sort them by descending support (fix a deterministic tie-break). This is the F-list.
  2. 2Scan 2. For each transaction, keep its frequent items, sort them by the F-list, and insert them from the root: follow an existing child if there is one (count += weight), otherwise create a node and append it to that item's node-link chain.
  3. 3Mine(tree, suffix). For each header item aa, from least to most frequent: emit {a}∪\{a\}\cup suffix with support ∑count\sum\text{count} along aa's node-link.
  4. 4Project. Walk up from every aa-node to the root to get its prefix path, weighted by that node's count. These paths form the conditional pattern base BaB_a.
  5. 5Recurse. Build an FP-tree from BaB_a, dropping items whose support within BaB_a is below σ\sigma. If it is a single path, emit every combination directly. Otherwise call Mine(conditional tree, {a}∪\{a\}\cup suffix).

Complexity

Scans of D
exactly 2, whatever the length of the longest pattern (Apriori needs one per level)
Tree build
O(∑t∣t∣)O\big(\sum_t |t|\big) plus sorting each transaction, O(∣t∣log⁡∣t∣)O(|t|\log|t|); child lookup via a hash map per node
Tree size
at most ∑t∣t∩F1∣\sum_t|t\cap F_1| nodes; often far fewer when frequent prefixes are shared
Mining
one conditional tree per frequent itemset that gets extended; the work is output-sensitive, roughly proportional to the number of frequent itemsets times the size of their conditional trees
Memory
the whole tree must fit in RAM, and conditional trees add to that along the recursion stack. This is the main limit on sparse data where little is shared

Variants and tuning

Setting / variantWhat it doesGuidance
min_support σPrunes items and itemsets below σ; controls tree size and output sizeStart high (1–5%) and lower it until the number of itemsets stops being useful. Output can explode by orders of magnitude
max_lenStops the recursion once the suffix has that many itemsCap it at 3–4 for recommendation rules; long itemsets are rarely actionable
Tie-break in the F-listFixes the order of equally frequent itemsDoes not change the result, only the tree shape. Keep it deterministic so runs are reproducible
FP-Max / FPCloseOutput only maximal or closed itemsetsFar smaller output with the same information (closed) or only the frontier (maximal)
PFP (parallel FP-Growth)Shards items into groups, builds per-group conditional databases on workersSpark MLlib's FPGrowth, for databases that do not fit on one machine
EclatVertical layout: an id-list per item, support from intersectionsOften faster when data is sparse and id-lists are short. See the Eclat article
Knobs and variants you will meet in practice.

In code

python
1import numpy as np
2from collections import defaultdict
3
4T = [["bread","milk","eggs"], ["bread","butter"], ["bread","milk","butter"],
5 ["milk","eggs"], ["bread","milk","eggs","butter"], ["bread","eggs"],
6 ["milk","eggs","jam"], ["bread","milk"], ["bread","milk","eggs"],
7 ["coffee","bread","butter"]]
8
9class Node:
10 def __init__(self, item, parent):
11 self.item, self.parent, self.count, self.children = item, parent, 0, {}
12
13def build_tree(weighted, min_count):
14 """weighted: list of (items, count). Returns root, header{item: [nodes]}, order, supports."""
15 items = sorted({i for t, _ in weighted for i in t})
16 idx = {it: k for k, it in enumerate(items)}
17 # one-hot matrix -> item supports in one vectorised pass (scan 1)
18 X = np.zeros((len(weighted), len(items)), dtype=int)
19 w = np.array([c for _, c in weighted])
20 for r, (t, _) in enumerate(weighted):
21 X[r, [idx[i] for i in t]] = 1
22 sup = w @ X
23 keep = [it for it in items if sup[idx[it]] >= min_count]
24 order = sorted(keep, key=lambda it: (-sup[idx[it]], it)) # descending support, ties alphabetical
25 rank = {it: k for k, it in enumerate(order)}
26 root, header = Node(None, None), defaultdict(list)
27 for t, c in weighted: # scan 2: insert sorted frequent items
28 node = root
29 for it in sorted((i for i in t if i in rank), key=rank.get):
30 if it not in node.children:
31 node.children[it] = Node(it, node)
32 header[it].append(node.children[it]) # node-link
33 node = node.children[it]
34 node.count += c
35 return root, header, order, {it: int(sup[idx[it]]) for it in order}
36
37def fp_growth(weighted, min_count, suffix=()):
38 root, header, order, sup = build_tree(weighted, min_count)
39 out = {}
40 for it in reversed(order): # least frequent first
41 new = (it,) + suffix
42 out[frozenset(new)] = sup[it]
43 base = [] # conditional pattern base
44 for node in header[it]:
45 path, p = [], node.parent
46 while p.item is not None:
47 path.append(p.item); p = p.parent
48 if path:
49 base.append((path[::-1], node.count))
50 out.update(fp_growth(base, min_count, new))
51 return out
52
53result = fp_growth([(t, 1) for t in T], min_count=3)
54for s, n in sorted(result.items(), key=lambda kv: (-kv[1], sorted(kv[0]))):
55 print(f"{n} {{{', '.join(sorted(s))}}}")
56print(len(result), "frequent itemsets")
57# 8 {bread} | 7 {milk} | 6 {eggs} | 5 {bread, milk} | 5 {eggs, milk}
58# 4 {bread, butter} | 4 {bread, eggs} | 4 {butter} | 3 {bread, eggs, milk}
59# 9 frequent itemsets
From scratch: FP-tree with node-links, conditional pattern bases and recursive mining (NumPy one-hot for the support count). Prints the 9 itemsets above.
python
1import pandas as pd
2from mlxtend.preprocessing import TransactionEncoder
3from mlxtend.frequent_patterns import fpgrowth, association_rules
4
5T = [["bread","milk","eggs"], ["bread","butter"], ["bread","milk","butter"],
6 ["milk","eggs"], ["bread","milk","eggs","butter"], ["bread","eggs"],
7 ["milk","eggs","jam"], ["bread","milk"], ["bread","milk","eggs"],
8 ["coffee","bread","butter"]]
9
10te = TransactionEncoder()
11df = pd.DataFrame(te.fit(T).transform(T), columns=te.columns_)
12freq = fpgrowth(df, min_support=0.3, use_colnames=True) # 3 of 10 transactions
13print(freq.sort_values("support", ascending=False).to_string(index=False))
14
15rules = association_rules(freq, metric="confidence", min_threshold=0.8)
16print(rules[["antecedents", "consequents", "support", "confidence", "lift"]].round(3).to_string(index=False))
17# 9 itemsets: bread 0.8, milk 0.7, eggs 0.6, {milk,bread} 0.5, {eggs,milk} 0.5,
18# butter 0.4, {eggs,bread} 0.4, {butter,bread} 0.4, {eggs,milk,bread} 0.3
19# antecedents consequents support confidence lift
20# (eggs) (milk) 0.5 0.833 1.19
21# (butter) (bread) 0.4 1.000 1.25
Library version with mlxtend: same 9 itemsets, then the two rules with confidence ≥ 0.8.

Use when

  • +Data is dense, with a few very frequent items, so prefixes are shared and the tree compresses well.
  • +Frequent patterns are long, where Apriori's level-by-level scans and candidate sets explode.
  • +Rereading the database is expensive (large files, remote storage): FP-Growth needs exactly 2 passes.
  • +You need exact counts for every frequent itemset as input to rule mining.

Avoid when

  • −The FP-tree does not fit in memory (very sparse, huge catalogues). Use PFP, Eclat, or partitioning.
  • −You need incremental updates: new transactions can change the F-list order, forcing a rebuild.
  • −Items carry quantities, prices or timestamps that matter: plain FP-Growth only sees presence. Use sequential or utility pattern mining.
  • −The threshold must be very low on wide data: no algorithm saves you from an exponential output, so mine closed or maximal itemsets instead.

Where it's used

Market-basket analysis

Which products sell together, for shelf placement, bundles and "frequently bought together" widgets.

Recommendation candidates

High-confidence rules give cheap, explainable item-to-item recommendations, or features for a ranking model.

Log and alarm mining

Sets of error codes or events that fire together in the same session point to a shared root cause.

Web usage and clinical data

Pages visited in the same session, or diagnoses and prescriptions recorded together in patient histories.

Check yourself

In the worked example's FP-tree, what is the conditional pattern base of butter?

Check yourself

How many full passes over the transaction database does FP-Growth make, regardless of the longest frequent itemset?

Check yourself

A conditional FP-tree for suffix {x} is the single path a:5 → b:4 → c:3, with σ = 3. How many itemsets containing x does it emit (not counting {x} itself), and what is the support of {a, c, x}?

Check yourself

Why are items inserted in descending order of support?

Remember

  • ✓FP-Growth finds the same frequent itemsets as Apriori, but with 2 database scans and no candidate generation.
  • ✓Scan 1 builds the F-list (frequent items by descending support). Scan 2 inserts each basket's sorted frequent items into a prefix tree whose node counts record how many baskets share each prefix.
  • ✓Key identity: sup(β∪{a})\text{sup}(\beta\cup\{a\}) equals the support of β\beta in aa's conditional pattern base, the prefix paths of aa's nodes weighted by those nodes' counts.
  • ✓Mine items from least to most frequent, recurse on each conditional FP-tree, and on a single path emit all combinations directly. Each itemset is found exactly once.
  • ✓The tree is bounded by the number of frequent occurrences, but the output can still be exponential: control it with min support, max_len, or closed and maximal itemsets.
← back to ML Algorithms roadmap