Tree Context Kernel (TCK): Hybrid Graph Analysis

• TCK is a graph kernel defined for undirected graphs that integrates discrete labels and real-valued attribute vectors through rooted, ordered tree contexts.
• It employs recursive matching and an atomic Gaussian kernel to compare node attributes, enabling scalable feature mapping for graph classification.
• Empirical evaluations reveal that TCK, with both exact and approximate variants, outperforms competing kernels in accuracy and efficiency on real-world datasets.

The Tree Context Kernel (TCK) is a graph kernel specifically designed for undirected graphs whose nodes possess both discrete labels and real-valued attribute vectors. TCK extends the expressive capacity of subtree-based kernels by enabling the integration of continuous node attributes while maintaining computational efficiency comparable to state-of-the-art discrete-label kernels. The method utilizes features defined by rooted, ordered tree structures—termed "tree contexts"—extracted from local graph neighborhoods using breadth-first searches up to a specified depth. Through a recursive matching scheme and an atomic kernel on attribute vectors, TCK can represent large, discriminative feature spaces and admits scalable approximations for real-world applications (Martino et al., 2015).

1. Formal Mathematical Structure

Let $G=(V_G, E_G, L_G, A_G)$ be an undirected graph with node discrete labels $L_G(v) \in \Sigma$ and real-valued attribute vectors $A_G(v) \in \mathbb{R}^d$. TCK treats $G$ as a multiset of rooted, ordered trees—tree contexts—extracted via breadth-first traversal up to depth $h$.

The atomic node kernel on attributes is defined as:

$$K_A(v_1, v_2) = \exp(-\beta \| A_G(v_1) - A_G(v_2) \|^2)$$

where $\beta > 0$.

The tree-matching function on tree nodes $v_1, v_2$ is recursively defined as:

$$C_{CST}(v_1, v_2) = \begin{cases} \lambda \cdot K_A(v_1, v_2) & \text{if } L(v_1) = L(v_2) \text{ and both are leaves}\ \lambda \cdot K_A(v_1, v_2) \cdot \prod_{i=1}^{\rho(v_1)} C_{ST}(ch_{v_1}[i], ch_{v_2}[i]) & \text{if } L(v_1) = L(v_2),\ \rho(v_1) = \rho(v_2),\ \text{not leaves}\ 0 & \text{otherwise} \end{cases}$$

Here $C_{ST}$ is the classic discrete-label subtree recursion:

$$C_{ST}(v_1, v_2) = \begin{cases} \lambda & \text{if } L(v_1) = L(v_2),\ v_1,v_2\text{ are leaves}\ \lambda \prod_{i=1}^{\rho(v_1)} C_{ST}(ch_{v_1}[i], ch_{v_2}[i]) & \text{if } L(v_1) = L(v_2),\ \rho(v_1) = \rho(v_2)>0\ 0 & \text{otherwise} \end{cases}$$

For two graphs $G_1,G_2$, the final graph kernel is:

$$K(G_1,G_2) = \sum_{OD_1 \in ODD_{G_1}} \sum_{OD_2 \in ODD_{G_2}} \sum_{v_1 \in V_{OD_1}} \sum_{v_2 \in V_{OD_2}} C_{CST}(v_1, v_2)$$

Alternatively, grouping by tree context $t$ using the feature map $\varphi_t(G)$:

$$K(G_1,G_2) = \sum_{t} \langle \varphi_t(G_1), \varphi_t(G_2) \rangle$$

where, for tree $t$ of size $|t|$, matching occurrences at roots $v_1,v_2$ contribute $\lambda^{|t|} K_A(v_1, v_2)$.

2. Tree Context Generation and Feature Representation

A tree context $t$ is a rooted, ordered tree of depth $\leq h$ with nodes carrying discrete labels, generated as follows:

1. For each root $v$, perform a breadth-first (shortest-path) traversal to generate a Decomposition DAG up to depth $h$.
2. Child nodes at each tree node are ordered using a perfect-hash string encoding of their sub-DAGs:

$$(v) = \kappa \left( \kappa(L(v)) \, \| \, (ch_v[1]) \, \| \, \cdots \, \| \, (ch_v[\rho(v)]) \right)$$

with $\kappa$ as a perfect hash, $\|$ as string concatenation.

1. Unfold the ordered DAG into one or more rooted trees $T_j(v)$ for $j=0,\ldots,h$.

Matching of tree contexts between graphs is determined by discrete label and structure (shape), while real-valued label comparison is effected through $K_A$ at all matched nodes recursively.

3. Exact and Approximate Algorithms

Exact Variant

Feature extraction proceeds by hashing every tree context to a unique string and maintaining frequency maps for each node and each context. The evaluation of the kernel involves all pairs of matching contexts between graphs, aggregating over all pairs of node roots.

Algorithmic complexity:

• Feature map computation: $\mathcal{O}(n \cdot (m \log \rho + h H))$, $H = \mathcal{O}(\rho^{h+1})$.
• Kernel evaluation: Worst-case $\mathcal{O}(h H n^2 Q(K_A))$.

Approximate Variant

The computational bottleneck—pairwise evaluation of $K_A$—can be mitigated using random Fourier features (Rahimi-Recht) for the RBF kernel:

$$K_A(v_i, v_j) \approx \langle \hat\varphi_A^D(v_i), \hat\varphi_A^D(v_j) \rangle$$

with explicit feature maps $\hat\varphi_A^D(v) \in \mathbb{R}^D$. This allows aggregation over roots via vector summation per tree context and reduces the inner computational loops to dot products.

Complexity:

• Feature map computation: $\mathcal{O}(n \cdot (m \log \rho + h H D))$
• Kernel evaluation: $$\mathcal{O}(\text{\#features} \cdot D) = \mathcal{O}(n h H D)$$

4. Comparative Evaluation and Performance Metrics

Empirical evaluation used six real-world graph datasets with continuous node attributes:

• ENZYMES ($6$ classes, $\bar{n} \approx 32.6$, $d=18$)
• PROTEINS (binary, $\bar{n} \approx 39.1$, $d=1$)
• SYNTHETIC (random noise, $n=100$)
• COX2, BZR, DHFR (small molecule graphs, $\bar{n} \approx 40$, $d=3$)

Protocol included nested 10-fold cross-validation with Support Vector Machines (SVMs) using the TCK Gram matrix. Parameters were cross-validated: $h \in \{0,1,2,3\}$, $\lambda \in \{0.1, 0.3, ... , 1.2\}$; for the approximate variant, $D=1000$; SVM $C \in \{0.01, ... , 10000\}$.

Observed results:

• Exact TCK outperformed all competing continuous-attribute kernels (GraphHopper, Shortest-Path, CSM, P2K, various Graph-Invariant kernels) on $5$ out of $6$ datasets.
• On pure noise data, TCK was more robust than other RBF-based kernels but did not outperform methods ignoring real-valued labels.
• Approximate TCK ($D=1000$) achieved comparable or slightly reduced accuracy (within $1$–$3\%$) while significantly reducing computation time.

Run-times for Gram matrix computation: | Kernel | PROTEINS | ENZYMES | |-----------------|----------|---------| | Exact TCK | 21 min | 35 min | | Approximate TCK | 5.2 min | 1.8 min | | GraphHopper | 2.8 h | 12 min | | SP-kernel | 7.7 days | 3 days | | P2K | 28 s | 6 s |

5. Parameter Control and Practical Guidelines

Parameter trade-offs are central to TCK deployment:

• Tree depth $h$ governs feature expressiveness versus computational cost. Empirically, $h=1$–$2$ often suffices.
• Decay parameter $\lambda$ down-weights larger trees; typical values lie in $0.3$–$1$.
• RBF approximation dimensionality $D$: $D \approx 1000$ offers a speed/accuracy balance; higher $D$ improves accuracy at the expense of speed.

For moderate-sized graphs and when maximal accuracy is required, the exact variant is recommended. For large datasets or constrained computational resources, the approximate variant provides near-equivalent accuracy with substantially improved efficiency.

6. Contextual Placement and Methodological Significance

TCK (also cited as ODDCL_ST) distinguishes itself from prior graph kernels by enabling direct handling of continuous node attributes in conjunction with discrete structure, avoiding standard trade-offs between expressiveness and efficiency. Unlike walk-based features or subtree kernels that omit real-valued information, TCK leverages tree-shaped contexts and recursive matching under both discrete and continuous semantics. This approach expands the feature space implicitly without prohibitive computational overhead, while the kernel remains tractable via approximation frameworks.

A plausible implication is that TCK provides a template for further kernel methods targeting hybrid-attribute graphs in large-scale or complex domains, where both node labels and vectors encode essential information.

7. Technical Summary

TCK is defined by its recursive matching over ordered, rooted tree contexts, its integration of a Gaussian kernel on attribute vectors, and its feature map aggregation scheme. Its empirical advantage over competing kernels is supported across diverse datasets, except for purely discrete or noise-dominated cases where traditional subtree kernels retain superiority. The architecture supports parameterization for expressiveness, decay, and explicit approximation with controllable accuracy-resource trade-offs. TCK is effective for graph classification tasks taking advantage of both discrete node identity and continuous attribute information, at a runtime cost typically on par with or below existing methods in the literature (Martino et al., 2015).