---
title: 'ReCoGNN: Graph-Based Feature Augmentation'
url: https://www.emergentmind.com/topics/recognn
type: topic
---

# ReCoGNN: Graph-Based Feature Augmentation

Searching arXiv for ReCoGNN and related graph-based feature augmentation work.
ReCoGNN is an end-to-end framework for automated feature augmentation on relational datasets, introduced for predictive modeling settings in which the target resides in a base table \(T_0\) and potentially useful predictors are distributed across auxiliary tables \(\{T_1,\dots,T_K\}\) [2508.20986]. It addresses the problem of augmenting \(T_0\) with attributes from auxiliary tables so as to improve prediction accuracy for a target attribute \(T\), while avoiding the wide, noisy, and redundant representations that can result from indiscriminate joins [2508.20986]. The framework combines task-relevant table structuring, graph-based modeling of intra-table attribute relationships, and heterogeneous graph message passing over inter-row relations. The name should be distinguished from the earlier text-classification model ReGNN, “Recursive Graphical Neural Networks for Text Classification,” which is a different method despite the superficial similarity in nomenclature [1909.08166].

## 1. Problem formulation and scope

ReCoGNN is designed for predictive tasks on relational databases in which the target is defined in a base table and useful evidence may be scattered across multiple auxiliary tables [2508.20986]. The formal task is stated as follows: given a base table \(T_0\) with target attribute \(T\) and auxiliary tables \(\{T_1,\dots,T_K\}\), augment \(T_0\) with attributes from \(\{T_k\}\) to improve prediction accuracy for \(T\) [2508.20986].

The framework is motivated by several limitations of conventional relational preprocessing. Many predictive signals are indirectly related to the target and reside in external tables; simply joining all available data can create a wide, noisy, redundant table; and predictive dependencies in relational data are often multi-hop, compositional, and semantic rather than reducible to a single local join [2508.20986]. Within this framing, automated feature augmentation is not treated as a brute-force table concatenation problem, but as a structured selection-and-propagation problem over relational structure.

A central premise of the method is that effective augmentation must answer two coupled questions: which features are useful, and how the relational structure across tables should be exploited without flooding the downstream predictor with irrelevant information [2508.20986]. ReCoGNN addresses these questions by a two-stage graph-based pipeline consisting of Task-Relevant Table Structuring and Graph-based Data Augmentation [2508.20986].

## 2. Two-stage architecture

The first stage, Task-Relevant Table Structuring, identifies task-relevant tuples and organizes attributes into semantically coherent groups [2508.20986]. The second stage, Graph-based Data Augmentation, builds a heterogeneous weighted graph over tuples from the base table and the partitioned auxiliary sub-tables, then applies graph neural message passing to derive augmented representations for downstream prediction [2508.20986].

The first step in stage 1 represents the database schema as a Directed Join Graph (DJG), whose nodes are tables and whose edges are executable joins with types such as \(1{:}1\), \(1{:}n\), and \(n{:}1\) [2508.20986]. Because many join paths may exist, ReCoGNN uses a greedy meta-path search starting from the base table \(T_0\), expanding one join at a time and selecting the next edge using a score that balances simplicity and stability [2508.20986]. The score includes a path length term,
\[
S_L = \frac{1}{1 + L},
\]
a join-directionality penalty,
\[
S_N = \frac{1}{1 + \sum_{i=1}^{L} w_i \cdot \mathbb{I}_{\text{1:n}(e_i)}},
\]
and an overall path score,
\[
S_{\text{path}} = \alpha S_L + \beta S_N,
\]
with tunable weights \(\alpha,\beta\) [2508.20986]. A tuple in an auxiliary table is considered task-relevant if it can be linked to a base-table tuple along the chosen meta-path [2508.20986]. The paper also employs a coreset sampling strategy to reduce the number of tuples processed, by choosing representative tuples from the base table and extending them along meta-paths [2508.20986].

This design indicates that ReCoGNN does not equate relational augmentation with exhaustive enumeration of all reachable data. Instead, it imposes a schema-level bias toward shorter and more stable join paths. A plausible implication is that the framework is intended to balance predictive utility against fan-out and combinatorial growth in intermediate joins.

## 3. Intra-table attribute relationship modeling

For each task-relevant tuple, ReCoGNN converts the non-key attributes into a complete graph [2508.20986]. If a tuple \(t\) has non-key attributes \(\{c_1,\dots,c_N\}\), the corresponding tuple graph is
\[
G_t = (\mathbf{V}_t, \mathbf{E}_t, \mathbf{X}_t),
\]
where each node corresponds to one attribute value, and the graph is complete so that every attribute can interact with every other attribute [2508.20986]. Primary key and foreign keys are excluded because they are mainly identifiers or links, not semantic features [2508.20986].

Attribute values may be numerical, categorical, or text, and are encoded using modality-specific encoders [2508.20986]. The paper gives the encoding scheme as
\[
\mathbf{e}_i =
\begin{cases}
f_{\text{num}}(c_i) \in \mathbb{R}^{d_{\text{num}}}, & \text{if } \text{type}(c_i)=\text{num} \\
f_{\text{cat}}(c_i) \in \mathbb{R}^{d_{\text{cat}}}, & \text{if } \text{type}(c_i)=\text{cat} \\
f_{\text{text}}(c_i) \in \mathbb{R}^{d_{\text{text}}}, & \text{if } \text{type}(c_i)=\text{text}
\end{cases}
\]
and then projects the resulting encodings into a shared output dimension,
\[
\mathbf{h}_j = \mathbf{e}_j \mathbf{W} \in \mathbb{R}^{d_{\text{out}}}
\]
with learnable \(\mathbf{W}\) [2508.20986]. PyTorch Frame is mentioned for table encoding, and for text the paper notes models like Sentence-BERT [2508.20986].

The complete graph for each tuple is processed by a shared-parameter Graph Attention Network (GAT) that learns which attribute pairs are most relevant to the prediction task [2508.20986]. For nodes \(u,v\) in a tuple graph \(G_i\), attention coefficients are defined by
\[
\mathbf{h}^i_u = \mathbf{W} \mathbf{X}^i[u], \quad \mathbf{W}\mathbf{h}_v = \mathbf{X}^i[v],
\]
\[
e^i_{uv} = \text{LeakyReLU}\left( \alpha^\top \left[ \mathbf{h}^i_u \mathbin{\|} \mathbf{h}^i_v \right] \right),
\]
\[
\alpha^i_{uv} = \frac{\exp(e^i_{uv})}{\sum_{w \in V} \exp(e^i_{uw})},
\]
and node updates are
\[
\mathbf{h}^{i\prime}_v=\sigma\!\left(\sum_{u}\alpha^i_{uv} \mathbf{W}' \mathbf{h}^i_u\right)
\]
[2508.20986]. The graph representation is pooled from node embeddings,
\[
\mathbf{g}^i = \text{POOL}( \mathbf{h}^i_v \mid v \in V),
\]
and used by a task-appropriate prediction head, with MSE for regression and cross-entropy for classification [2508.20986]. The total loss is
\[
\mathcal{L}_{total}=\sum_{i=1}^{B}\mathcal{L}_i.
\]

A distinctive aspect of this stage is that the learned edge attentions \(\alpha^i_{uv}\) are later reused as evidence of pairwise attribute relevance across tuples [2508.20986]. This makes the tuple-level GAT not merely an encoder, but also a mechanism for feature-structure discovery.

## 4. Table partitioning and heterogeneous graph augmentation

After training the tuple-level GAT, ReCoGNN aggregates attention weights across all task-relevant tuples [2508.20986]. For tuple \(i\), if \(\mathbf{A}_i\) is the attention matrix with entries
\[
\mathbf{A}_i[u][v] = \alpha^i_{u,v},
\]
then the cumulative matrix is
\[
\mathbf{A}_{sum} = \sum_{i=0}^{B}\mathbf{A}_i.
\]
Following min-max normalization to produce \(\mathbf{A}_{norm}\in[0,1]\), edges whose normalized weights exceed a threshold are retained:
\[
\mathbf{A}_{norm}[u][v] > \tau.
\]
These significant edges form \(E_{sig}\), and from the graph \(G_{sig}(\mathbf{V},\mathbf{E}_{sig})\), ReCoGNN extracts maximal cliques \(\{C_1,\dots,C_t\}\), each of which defines a sub-table [2508.20986].

This partitioning procedure yields disjoint or overlapping sub-tables, each intended to represent a tightly coherent feature group rather than treating the auxiliary table as a single monolithic source [2508.20986]. The paper’s terminology emphasizes semantic coherence rather than purely statistical compression. A plausible implication is that the framework uses clique extraction to turn diffuse pairwise attribute affinities into reusable higher-order feature units.

Stage 2 constructs a heterogeneous graph
\[
\mathcal{G} = (\mathcal{V}, \mathcal{E}, \mathcal{X})
\]
whose nodes are tuples from the base table and all partitioned auxiliary sub-tables [2508.20986]. Node features are formed by encoding attributes with modality-specific encoders and concatenating them [2508.20986]. Two kinds of edges are included.

Explicit edges encode schema-defined join relationships between tuples from different tables [2508.20986]. If a tuple in one table can be joined to another via primary-key/foreign-key relations, an edge is added; if an auxiliary tuple was split into multiple sub-tuples, then a joinable tuple connects to all corresponding sub-tuples [2508.20986].

Implicit edges encode similarity relations within the base table [2508.20986]. Two base-table tuples are connected if their feature similarity exceeds a threshold \(\theta\), or alternatively each node can connect to its top-\(K\) most similar base-table neighbors [2508.20986]. These edges are intended to propagate information among semantically similar base rows even when they are not join-connected.

## 5. Message passing, feature selection, and downstream prediction

Once the heterogeneous graph has been constructed, ReCoGNN applies a heterogeneous GNN [2508.20986]. The update is expressed abstractly in type-specific form. For a target node \(v_i\) and edge type \(t\), messages are aggregated from neighbors \(N_{v_i}^t\):
\[
m_{i}^{t} = \sum_{j \in N_{v_i}^{t}} M(h_j, h_{e_{ji}}, h_i),
\]
and node representations are updated via
\[
h_i^{(l+1)} = U(h_i^{(l)}, \{m_i^t \mid t \in T_e\}),
\]
where \(M\) is a message function, \(U\) is an update function, and \(T_e\) is the set of edge types [2508.20986]. Task loss over labeled nodes is then
\[
\mathcal{L}_{total} = \sum_{i=1}^{N} \mathcal{L}(y_i, f_G(x_i)).
\]

The learned base-table node embeddings are used as the augmented features for the downstream classifier or regressor [2508.20986]. Feature selection therefore occurs at two levels. First, intra-table feature grouping uses GAT attention to identify task-relevant attribute pairs and then forms cliques that define sub-tables [2508.20986]. Second, inter-table propagation and selection is carried out by the heterogeneous graph and GNN, where edge weights and message passing determine which cross-table joins and similarity connections contribute useful evidence while suppressing noise [2508.20986].

The paper explicitly states that ReCoGNN does not merely choose features; it learns augmented latent representations that encode both useful auxiliary-table information and relational structure among tuples [2508.20986]. This framing places the method closer to representation learning over relational systems than to classical filter-based or wrapper-based feature selection.

## 6. Empirical evaluation, ablations, and operational constraints

ReCoGNN is evaluated on 10 datasets: classification datasets Olist, MovieLens, Loyal, PED, Event, and Event-Not, and regression datasets F1, IMDB, Restbase, and Bio [2508.20986]. Compared methods include BASE, All, Random, MI, BE, XGBoost, LightGBM, RF, ARDA, ARDA-NoText, and LEVA [2508.20986]. The reported classification metrics are Accuracy and AUC-ROC, with F1 and Average Precision used in sensitivity studies; regression metrics are MAE and MSE [2508.20986]. The implementation uses Python, PyTorch Geometric for GNNs, GraphSAGE and GAT, PyTorch Frame for table encoding, a default threshold \(\tau = 0.8\) for significant attribute relationships, and an 18-hour time limit for each experiment [2508.20986].

The main classification results reported for ReCoGNN include MovieLens with Accuracy \(0.7980\) and AUC-ROC \(0.8432\), Loyal with Accuracy \(0.5825\) and AUC-ROC \(0.6397\), PED with Accuracy \(0.685\) and AUC-ROC \(0.7462\), and Event-Not with Accuracy \(0.9603\) and AUC-ROC \(0.9233\) [2508.20986]. For regression, the reported results are F1 with MAE \(0.912\) and MSE \(3.227\), IMDB with MAE \(1.113\) and MSE \(2.311\), Restbase with MAE \(0.275\) and MSE \(0.230\), and Bio with MAE \(0.521\) and MSE \(0.5826\) [2508.20986]. The paper states that ReCoGNN is best or near-best across the classification datasets and achieves the best results on all four regression datasets [2508.20986].

Ablation studies identify several influential components. Graph-based attribute relationship mining performs better than random grouping or no mining, supporting the claim that semantically grouping attributes into sub-tables is important [2508.20986]. Weighted graphs outperform unweighted graphs, indicating that GNN-learned weights help suppress noisy relational signals [2508.20986]. Including base-table similarity edges improves performance by improving information flow among semantically similar base tuples [2508.20986]. In the graph discovery comparison, Complete Graph performs better than Girvan-Newman, especially at thresholds such as \(0.5\) and \(0.8\), because it is stricter and captures stronger attribute relations while reducing noise [2508.20986]. Sensitivity analysis shows performance rising as the threshold increases from low values and then declining if the threshold becomes too large, reflecting a balance between retaining useful relations and over-pruning [2508.20986].

The paper also discusses scalability and limitations. ReCoGNN is presented as more scalable than exhaustive join-based augmentation because it avoids materializing all joins, uses a coreset for tuple sampling, partitions tables into smaller sub-tables, and relies on graph propagation rather than wide-table explosion [2508.20986]. At the same time, it retains nontrivial computational costs: building meta-paths over schema graphs, computing tuple-level complete graphs, training GAT over many task-relevant tuples, extracting maximal cliques from significant-edge graphs, and running heterogeneous GNN training [2508.20986]. The reported 18-hour timeout indicates that runtime can remain substantial on large datasets [2508.20986]. The paper further implies limitations associated with threshold sensitivity, graph discovery choice, the complexity introduced by overlapping sub-tables, dependence on strong text encoders for text features, and the possibility that greedy meta-path search may fail to find globally optimal relational paths [2508.20986].

## 7. Relation to ReGNN and terminological clarification

A frequent source of confusion is the resemblance between ReCoGNN and ReGNN. The earlier model “Recursive Graphical Neural Networks for Text Classification” proposes a graph neural architecture for text classification in which documents are converted into graphs using word co-occurrence and local adjacency, neighbor information is aggregated with additive attention, and recursive LSTM-style gating is used to alleviate over-smoothing [1909.08166]. It also introduces a graph-level node to support exchange between local and global information and is evaluated on single-label and multi-label text classification benchmarks [1909.08166].

Despite the name similarity, ReGNN and ReCoGNN address different problem classes. ReGNN is a document-level graph model for text classification with token nodes, word co-occurrence edges, LSTM-controlled graph updates, and a graph-level document representation [1909.08166]. ReCoGNN is an automated feature augmentation framework for relational datasets with schema-level meta-path search, tuple-level complete graphs over non-key attributes, GAT-based attribute relationship mining, sub-table extraction by maximal cliques, and heterogeneous graph propagation over tuples from multiple tables [2508.20986]. The former is centered on modeling linguistic structure in text graphs; the latter is centered on selecting and propagating predictive relational signals across database tables.

This distinction matters because “ReCoGNN” does not appear in the ReGNN paper, and “ReGNN” is not the feature augmentation system introduced in the relational-data setting [1909.08166][2508.20986]. The two models are best understood as separate graph-based methods developed for different data modalities and prediction workflows.

Source: https://www.emergentmind.com/topics/recognn