Frequent subtree mining

In computer science, frequent subtree mining is the problem of finding all patterns in a given database whose support (a metric related to its number of occurrences in other subtrees) is over a given threshold.[1] It is a more general form of the maximum agreement subtree problem.[2]

## Definition

[edit]

Frequent subtree mining is the problem of trying to find all of the patterns whose "support" is over a certain user-specified level, where "support" is calculated as the number of trees in a database which have at least one subtree isomorphic to a given pattern.[3]

### Formal definition

[edit]

The problem of frequent subtree mining has been formally defined as:[1]

Given a threshold minfreq, a class of trees  C {\displaystyle {\mathcal {C}}} , a transitive subtree relation  P ⪯ T {\displaystyle P\preceq T} between trees  P , T ∈ C {\displaystyle P,T\in {\mathcal {C}}} , a finite set of trees  D ⊆ C {\displaystyle {\mathcal {D}}\subseteq {\mathcal {C}}} , the frequent subtree mining problem is the problem of finding all trees  P ⊂ C {\displaystyle {\mathcal {P}}\subset {\mathcal {C}}} such that no two trees in  P {\displaystyle {\mathcal {P}}} are isomorphic and

∀ P ∈ P : f r e q ( P , D ) = ∑ T ∈ D d ( P , T ) ≥ m i n f r e q , {\displaystyle \forall P\in {\mathcal {P}}:\quad \mathrm {freq} (P,{\mathcal {D}})=\sum \nolimits _{T\in {\mathcal {D}}}d(P,T)\geq \mathrm {minfreq} ,}
where d is an anti-monotone function such that if  P ′ ⪯ P {\displaystyle P'\preceq P} then

∀ T ∈ C : d ( P ′ , T ) ≥ d ( P , T ) . {\displaystyle \forall T\in {\mathcal {C}}:\quad d(P',T)\geq d(P,T).}

## TreeMiner

[edit]

In 2002, Mohammed J. Zaki introduced TreeMiner, an efficient algorithm for solving the frequent subtree mining problem, which used a "scope list" to represent tree nodes and which was contrasted with PatternMatcher, an algorithm based on pattern matching.[4]

### Definitions

[edit]

#### Induced sub-trees

[edit]

A sub-tree  S = ( V s , E s ) {\displaystyle S=(V_{s},E_{s})} is an induced sub-tree of  T = ( V , E ) {\displaystyle T=(V,E)} if and only if  V s ⊆ V {\displaystyle V_{s}\subseteq V} and  E s ⊆ E {\displaystyle E_{s}\subseteq E} . In other words, any two nodes in S that are directly connected by an edge is also directly connected in T. For any node A and B in S, if node A is the parent of node B in S, then node A must also be the parent of node B in T.

#### Embedded sub-trees

[edit]

A sub-tree  S = ( V s , E s ) {\displaystyle S=(V_{s},E_{s})} is an embedded sub-tree of  T = ( V , E ) {\displaystyle T=(V,E)} if and only if  V s ⊆ V {\displaystyle V_{s}\subseteq V} and two endpoint nodes of any edge in S are on the same path from the root to a leaf node in T. In other words, for any node A and B in S, if node A is the parent of node B in S, then node A must be an ancestor of node B in T. Any induced sub-trees are also embedded sub-trees, and thus the concept of embedded sub-trees is a generalization of induced sub-trees. As such embedded sub-trees characterizes the hidden patterns in a tree that are missing in traditional induced sub-tree mining. A sub-tree of size k is often called a k-sub-tree.

#### Support

[edit]

The support of a sub-tree is the number of trees in a database that contains the sub-tree. A sub-tree is frequent if its support is not less than a user-specified threshold (often denoted as minsup). The goal of TreeMiner is to find all embedded sub-trees that have support at least the minimum support.

#### String representation of trees

[edit]

There are several different ways of encoding a tree structure. TreeMiner uses string representations of trees for efficient tree manipulation and support counting. Initially the string is set to  ∅ {\displaystyle \varnothing } . Starting from the root of the tree, node labels are added to the string in depth-first search order. -1 is added to the string whenever the search process backtracks from a child to its parent. For example, a simple binary tree with root labelled A, a left child labelled B and right child labelled C can be represented by a string A B -1 C -1.

#### Prefix equivalence class

[edit]

Two k-sub-trees are said to be in the same prefix equivalence class if the string representation of them are identical up to the (k-1)-th node. In other words, all elements in a prefix equivalence class only differ by the last node. For example, two trees with string representation A B -1 C -1 and A B -1 D -1 are in the prefix equivalence class A B with elements (C, 0) and (D,0). An element of a prefix class is specified by the node label paired with the 0-based depth first index of the node it is attached to. In this example, both elements of prefix class A B are attached to the root, which has an index of 0.

#### Scope

[edit]

The scope of a node A is given by a pair of numbers  [ l , r ] {\displaystyle [l,r]} where l and r are the minimum and maximum node index in the sub-tree rooted at A. In other words, l is the index of A, and r is the index of the rightmost leaf among the descendants of A. As such the index of any descendant of A must lie in the scope of A, which will be a very useful property when counting the support of sub-trees.

### Algorithm

[edit]

#### Candidate generation

[edit]

Frequent sub-tree patterns follow the anti-monotone property. In other words, the support of a k-sub-tree is less than or equal to the support of its (k-1)-sub-trees. Only super patterns of known frequent patterns can possibly be frequent. By utilizing this property, k-sub-trees candidates can be generated based on frequent (k-1)-sub-trees through prefix class extension. Let C be a prefix equivalence class with two elements (x,i) and (y,j). Let C' be the class representing the extension of element (x,i). The elements of C' are added by performing join operation on the two (k-1)-sub-trees in C. The join operation on (x,i) and (y,j) is defined as the following.

* If  i > j {\displaystyle i>j} , then add (y,j) to C'.
* If  i = j {\displaystyle i=j} , then add (y,j) and (y, ni) to C' where ni the depth-first index of x in C
* If  i < j {\displaystyle i<j} , no possible element can be added to C'

This operation is repeated for any two ordered, but not necessarily distinct elements in C to construct the extended prefix classes of k-sub-trees.

#### Scope-list representation

[edit]

TreeMiner performs depth first candidate generation using scope-list representation of sub-trees to facilitate faster support counting. A k-sub-tree S can be representation by a triplet (t,m,s) where t is the tree id the sub-tree comes from, m is the prefix match label, and s the scope of the last node in S. Depending on how S occurs in different trees across the database, S can have different scope-list representation. TreeMiner defines scope-list join that performs class extension on scope-list representation of sub-trees. Two elements (x,i) and (y,j) can be joined if there exists two sub-trees  ( t x , m x , s x ) {\displaystyle (t_{x},m_{x},s_{x})} and  ( t y , m y , s y ) {\displaystyle (t_{y},m_{y},s_{y})} that satisfy either of the following conditions.

* In-scope test:  t x = t y , m x = m y , s y ⊂ s x {\displaystyle t_{x}=t_{y},m_{x}=m_{y},s_{y}\subset s_{x}} , which corresponds to the case when  i = j {\displaystyle i=j} .
* Out-scope test:  t x = t y , m x = m y , s y > s x {\displaystyle t_{x}=t_{y},m_{x}=m_{y},s_{y}>s_{x}} , which correspond to the case when  i > j {\displaystyle i>j} .

By keeping track of distinct tree ids used in the scope-list tests, the support of sub-trees can be calculated efficiently.

## Applications

[edit]

Domains in which frequent subtree mining is useful tend to involve complex relationships between data entities: for instance, the analysis of XML documents often requires frequent subtree mining.[1] Another domain where this is useful is the web usage mining problem: since the actions taken by users when visiting a web site can be recorded and categorized in many different ways, complex databases of trees need to be analyzed with frequent subtree mining.[4] Other domains in which frequent subtree mining is useful include computational biology,[5][6] RNA structure analysis,[6] pattern recognition,[7] bioinformatics,[8] and analysis of the KEGG GLYCAN database.[9]

## Challenges

[edit]

Checking whether a pattern (or a transaction) supports a given subgraph is an NP-complete problem, since it is an NP-complete instance of the subgraph isomorphism problem.[7] Furthermore, due to combinatorial explosion, according to Lei et al., "mining all frequent subtree patterns becomes infeasible for a large and dense tree database".[10]

## References

[edit]

1. ^ a b c Chi, Yun; Muntz, Richard R.; Nijssen, Siegfried; Kok, Joost N. (28 June 2005). "Frequent Subtree Mining - An Overview". Fundamenta Informaticae. 66: 161–198\. S2CID 14827585.
2. ^ Deepak, Akshay; Fernández-Baca, David; Tirthapura, Srikanta; Sanderson, Michael J.; McMahon, Michelle M. (July 2013). "EvoMiner: frequent subtree mining in phylogenetic databases". Knowledge and Information Systems. 41 (3): 559–590\. doi:10.1007/s10115-013-0676-0. S2CID 254145982.
3. ^ Dai, H., Srikant, R. and Zhang, C. (2004). "Advances in Knowledge Discovery and Data Mining." 8th Pacific-Asia Conference, PAKDD 2004, Sydney, Australia, May 26–28, 2004, Proceedings. 1st ed. p. 65.
4. ^ a b Zaki, Mohammed J. (2002). "Efficiently mining frequent trees in a forest". Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining. pp. 71–80\. doi:10.1145/775047.775058. ISBN 978-1581135671. S2CID 1649653. Retrieved 16 June 2014.
5. ^ Deepak, Akshay, David Fernández-Baca, Srikanta Tirthapura, Michael J. Sanderson, and Michelle M. McMahon. "EvoMiner: frequent subtree mining in phylogenetic databases." Knowledge and Information Systems (2011): 1-32.
6. ^ a b Chi, Yun, Yirong Yang, and Richard R. Muntz. "Canonical forms for labelled trees and their applications in frequent subtree mining." Knowledge and Information Systems 8, no. 2 (2005): 203–234.
7. ^ a b Chi, Yun; Yang, Yirong; Muntz, Richard R. (2004). "Mining Frequent Rooted Trees and Free Trees Using Canonical Forms" (PDF). Knowledge and Information Systems. Retrieved 16 June 2014.
8. ^ Xiao, Yongqiao; Yao, Jenq-Foung; Li, Zhigang; Dunham, Margaret H. (2003). "Efficient data mining for maximal frequent subtrees". Third IEEE International Conference on Data Mining. ICDM 2003. pp. 379–386\. doi:10.1109/ICDM.2003.1250943.
9. ^ Aoki-Kinoshita, Kiyoko F. (2009). Glycome Informatics: Methods and Applications. CRC Press. p. 141\. ISBN 9781420083347.
10. ^ Zou, Lei; Lu, Yansheng; Zhang, Huaming; Hu, Rong (2006). "Mining Frequent Induced Subtree Patterns with Subtree-Constraint". Sixth IEEE International Conference on Data Mining Workshops. ICDM Workshops 2006. pp. 3–7\. doi:10.1109/ICDMW.2006.112.