Guided FP-Growth for Targeted Mining

• The paper introduces a targeted mining algorithm that computes exact support counts for a pre-specified list of itemsets using guided FP-tree traversal.
• It employs a TIS-tree to guide selective conditional FP-tree construction, reducing redundant computations and optimizing resource use.
• The approach, validated through the Minority-Report Algorithm, demonstrates speedups of 10x to 80x over traditional FP-growth in imbalanced datasets.

Searching arXiv for the cited paper and closely related FP-growth context. Guided FP-growth (GFP-growth) is a method for multitude-targeted mining: finding the count of a given large list of itemsets in large data. It is designed to focus on the specific multitude itemsets of interest and to optimize the time and memory costs, while yielding the exact frequency-counts for the required itemsets. The method was introduced in the paper "A Guided FP-growth algorithm for multitude-targeted mining of big data" (Shabtay et al., 2018), which also develops the Minority-Report Algorithm as a concrete application to mining minority-class rules from imbalanced data.

1. Problem setting and motivation

Traditional frequent itemset mining algorithms such as Apriori and FP-growth are typically designed to find all itemsets exceeding a minimum support threshold (Shabtay et al., 2018). In contrast, many scenarios require obtaining the support counts for a particular, possibly large set of itemsets rather than all frequent ones. The paper characterizes this setting as multitude-targeted mining and motivates it by the need to efficiently retrieve the frequencies for a multitude of specified itemsets, minimize unnecessary computation, leverage the advantages and optimizations of FP-based algorithms, and provide exact counts for all targets in a single, efficient routine (Shabtay et al., 2018).

The motivation is sharpened by limitations attributed to previous targeted mining methods. According to the paper, such methods often handled one itemset at a time, leading to redundant traversal of parts of the itemset tree or FP-tree; struggled with scalability when the target list is large; and involved data structure designs such as itemset trees that were less efficient than FP-trees (Shabtay et al., 2018). GFP-growth is presented as a response to precisely this gap.

A central misconception addressed by the formulation is that targeted mining is merely a restricted instance of standard frequent pattern mining. The algorithm instead assumes that the itemsets of interest are already specified and restructures traversal around that assumption. This distinction is fundamental: the computational problem is not to enumerate all frequent itemsets, but to obtain exact counts for a pre-specified list.

2. Guided traversal over FP-tree and TIS-tree

The key idea of GFP-growth is a focused, guided mining of the FP-tree using a tree-structured representation of the target itemsets called the TIS-tree (Shabtay et al., 2018). The algorithm traverses both the FP-tree and the TIS-tree in a coordinated way, so that only the relevant targeted parts of the FP-tree are explored and all and only the required itemset counts are computed.

Two data structures organize the procedure. The first is the FP-tree, constructed from transactions using frequent items, as in classical FP-growth. The second is the TIS-tree (Target Item-Set Tree), built from the list of target itemsets and arranged to suit the traversal order of the FP-growth process, namely support-ascending order, which is the reverse of the build order for the FP-tree (Shabtay et al., 2018). Each TIS-tree node has a .target Boolean flag indicating whether the node corresponds directly to a target itemset whose support is required, and a .g-count field that stores the occurrence frequency of this itemset.

The workflow has three stages. First, the FP-tree is built from the data and the TIS-tree is constructed from the list of itemsets to be counted. Second, the TIS-tree is traversed top-down. For each node, the algorithm checks in constant time whether the corresponding item exists in the FP-tree's header table; if the node is marked as a target, its support in the FP-tree is computed and recorded in .g-count; and if the node has children, the conditional FP-tree for that item is constructed as in FP-growth, but includes only items present in the corresponding TIS-tree subtree (Shabtay et al., 2018). If the node is a leaf in the TIS-tree, further recursion and conditional tree building are avoided. Third, on completion, every target node in the TIS-tree contains its exact support count as g-count.

The paper gives the following pseudocode for the core routine (Shabtay et al., 2018):

$\alpha$1

This formulation makes explicit the two principal optimizations emphasized in the paper: constant-time header-table checks and selective conditional FP-tree construction restricted to items present in the relevant TIS-tree subtree.

3. Exactness and formal guarantees

The principal theoretical guarantee is correctness. The paper states the following theorem: at the end of execution of the GFP-growth procedure, with FP-tree and TIS-tree as inputs, for every target itemset $\alpha$ in TIS-tree, TIS-tree(α).g-count equals the true count $C(\alpha)$ of $\alpha$ in the database represented by the FP-tree (Shabtay et al., 2018).

The count semantics are expressed by

$$\text{TIS-tree}(\alpha).\text{g-count} = C(\alpha) = |\{ T_i : \alpha \subseteq T_i \}|.$$

The proof is described as relying on the order of traversal and the correct construction of conditional FP-trees, guaranteeing no omission or double-counting (Shabtay et al., 2018). The method therefore guarantees exactness: the reported counts for requested itemsets are their precise actual support in the data.

The paper also identifies several implementation-level properties that support this guarantee and its efficiency. Computation is shared among overlapping target itemsets by building the TIS-tree for all target itemsets, repeated traversals are avoided because a single execution traverses the FP-tree for all targets, and pruning occurs whenever a branch in the TIS-tree has no further targets, so GFP-growth does not recur into the corresponding FP-tree subtree (Shabtay et al., 2018). This suggests that exactness and efficiency are not treated as competing objectives; the algorithm is structured to preserve both simultaneously.

4. Relation to classical FP-growth

GFP-growth differs from traditional FP-growth in task definition, traversal policy, and output. Classical FP-growth finds all frequent itemsets above a threshold, whereas Guided FP-growth finds support counts for a pre-specified list of possibly many target itemsets (Shabtay et al., 2018). Classical FP-growth recursively explores all branches of the FP-tree, while GFP-growth explores only those branches needed to cover the target itemsets, guided by the TIS-tree. The output of FP-growth is the set of all frequent itemsets; the output of GFP-growth is the exact support counts for the given list of itemsets.

Aspect	FP-growth	Guided FP-growth
Task	Finds all frequent itemsets above a threshold	Finds support counts for a pre-specified list of target itemsets
Traversal	Recursively explores all branches of FP-tree	Explores only those branches needed for the target itemsets
Output	Set of all frequent itemsets	Exact support counts for the given list of itemsets

The paper further states that GFP-growth uses $O(1)$ checks and the TIS-tree structure to focus computation, may avoid waste on unwanted itemsets, especially with low minimum support, and is efficient even when the target list is very large (Shabtay et al., 2018). A common misunderstanding is therefore to regard GFP-growth as merely FP-growth with a post hoc filter. The algorithm is instead target-driven from the outset: the TIS-tree constrains which parts of the FP-tree are explored, which conditional trees are built, and where counts are materialized.

5. Minority-Report Algorithm for imbalanced data

A detailed application developed in the paper is the mining of minority-class rules from imbalanced data, a setting described as common in medical applications, failure prediction, network and cyber security, and maintenance (Shabtay et al., 2018). The computational difficulty arises because relevant itemsets may be infrequent overall, so classic FP-growth run with low support becomes slow and memory-intensive due to huge intermediate results.

The Minority-Report Algorithm is a two-phase procedure combining classical FP-growth and GFP-growth for efficient mining of minority-class class-association rules (Shabtay et al., 2018). In the first pass, it determines which items are frequent within the minority class and uses them to filter the data. Two filtered databases are then formed: $DB'_1$ for minority-class transactions and $DB'_0$ for all others. In the second pass, two FP-trees are built, $FP_1$ for minority-class transactions and $FP_0$ for all others, both including only the filtered items. Classical FP-growth is applied to $FP_1$ to find all frequent itemsets in the minority class, and each discovered itemset $C(\alpha)$0 is inserted into a TIS-tree with .count set to its frequency in $C(\alpha)$1, namely $C(\alpha)$2. GFP-growth is then applied to that TIS-tree and $C(\alpha)$3, filling .g-count for each $C(\alpha)$4 with $C(\alpha)$5, the count in the majority class (Shabtay et al., 2018).

The paper presents the following pseudocode for the procedure (Shabtay et al., 2018):

$\alpha$2

The support and confidence measures used for rule generation are

$C(\alpha)$6

and

$C(\alpha)$7

Theoretical properties claimed for the Minority-Report Algorithm include completeness, meaning that all and only rules that meet the support and confidence thresholds for the minority class are found; correctness, meaning that the supports and confidences reported are exact; and efficiency, with computational effort proportional to the size of the minority class and the number of candidate itemsets rather than to the total number of frequent itemsets in the whole data (Shabtay et al., 2018).

6. Empirical behavior and broader significance

The paper reports results on both simulated and real data (Shabtay et al., 2018). In simulated data, the setup varies the number of items, transactions, and class imbalance rate $C(\alpha)$8, with transactions generated as random Bernoulli samples. Runtime in seconds is used as the evaluation metric for both FP-growth, run to solve the same task, and GFP-growth in the context of Minority-Report.

The reported findings emphasize speedups in highly imbalanced settings. For $C(\alpha)$9, that is, a 1% minority class, GFP-growth within Minority-Report is reported as 10x to 80x faster than classic FP-growth for the same task (Shabtay et al., 2018). Lower imbalances, such as $\alpha$0, yielded smaller but still significant speedups. The analysis and plots are described as repeatedly showing sharp reduction in computational cost for the GFP-growth-driven approach compared to traditional untargeted FP-growth, with improvements tied to the proportion of minority class and to the selectivity of the candidate itemset list being much smaller than all itemsets above a global low support.

For real data, the paper uses the UCI "Adult" Census Income dataset, preprocessed to about 30,000 rows, with target class frequency set as low as needed for the test (Shabtay et al., 2018). In that setting, GFP-growth enabled the Minority-Report Algorithm to be up to 50 times faster than classic FP-growth for mining minority-class rules, especially when the target class is rare.

The broader significance claimed in the paper is that GFP-growth is an exact method for counting the supports of a large list of pre-specified itemsets in big data and is especially useful when only a subset of itemsets, often not all globally frequent ones, are of interest (Shabtay et al., 2018). The paper also states that the approach can be extended to multiple rare classes and to other targeted mining tasks. This suggests a general methodological role for GFP-growth within constrained or target-oriented pattern mining, provided the target itemsets can be specified or generated efficiently.