ReCoGNN: Graph-Based Feature Augmentation

• ReCoGNN is an end-to-end framework that automates feature augmentation on relational datasets using task-relevant table structuring and graph-based modeling.
• It constructs complete tuple graphs over non-key attributes and applies graph attention networks to capture intricate intra-table relationships.
• The framework incorporates heterogeneous graph message passing to propagate useful relational signals, enhancing predictive performance on base tables.

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\}$ (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). 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 (Li et al., 2019).

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 (Qiao et al., 28 Aug 2025). 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$ (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). ReCoGNN addresses these questions by a two-stage graph-based pipeline consisting of Task-Relevant Table Structuring and Graph-based Data Augmentation (Qiao et al., 28 Aug 2025).

2. Two-stage architecture

The first stage, Task-Relevant Table Structuring, identifies task-relevant tuples and organizes attributes into semantically coherent groups (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

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 $\{T_1,\dots,T_K\}$0, $\{T_1,\dots,T_K\}$1, and $\{T_1,\dots,T_K\}$2 (Qiao et al., 28 Aug 2025). Because many join paths may exist, ReCoGNN uses a greedy meta-path search starting from the base table $\{T_1,\dots,T_K\}$3, expanding one join at a time and selecting the next edge using a score that balances simplicity and stability (Qiao et al., 28 Aug 2025). The score includes a path length term,

$\{T_1,\dots,T_K\}$4

a join-directionality penalty,

$\{T_1,\dots,T_K\}$5

and an overall path score,

$\{T_1,\dots,T_K\}$6

with tunable weights $\{T_1,\dots,T_K\}$7 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). If a tuple $\{T_1,\dots,T_K\}$8 has non-key attributes $\{T_1,\dots,T_K\}$9, the corresponding tuple graph is

$T_0$0

where each node corresponds to one attribute value, and the graph is complete so that every attribute can interact with every other attribute (Qiao et al., 28 Aug 2025). Primary key and foreign keys are excluded because they are mainly identifiers or links, not semantic features (Qiao et al., 28 Aug 2025).

Attribute values may be numerical, categorical, or text, and are encoded using modality-specific encoders (Qiao et al., 28 Aug 2025). The paper gives the encoding scheme as

$T_0$1

and then projects the resulting encodings into a shared output dimension,

$T_0$2

with learnable $T_0$3 (Qiao et al., 28 Aug 2025). PyTorch Frame is mentioned for table encoding, and for text the paper notes models like Sentence-BERT (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). For nodes $T_0$4 in a tuple graph $T_0$5, attention coefficients are defined by

$T_0$6

$T_0$7

$T_0$8

and node updates are

$T_0$9

(Qiao et al., 28 Aug 2025). The graph representation is pooled from node embeddings,

$T$0

and used by a task-appropriate prediction head, with MSE for regression and cross-entropy for classification (Qiao et al., 28 Aug 2025). The total loss is

$T$1

A distinctive aspect of this stage is that the learned edge attentions $T$2 are later reused as evidence of pairwise attribute relevance across tuples (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). For tuple $T$3, if $T$4 is the attention matrix with entries

$T$5

then the cumulative matrix is

$T$6

Following min-max normalization to produce $T$7, edges whose normalized weights exceed a threshold are retained: $T$8 These significant edges form $T$9, and from the graph $T_0$0, ReCoGNN extracts maximal cliques $T_0$1, each of which defines a sub-table (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). 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

$T_0$2

whose nodes are tuples from the base table and all partitioned auxiliary sub-tables (Qiao et al., 28 Aug 2025). Node features are formed by encoding attributes with modality-specific encoders and concatenating them (Qiao et al., 28 Aug 2025). Two kinds of edges are included.

Explicit edges encode schema-defined join relationships between tuples from different tables (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

Implicit edges encode similarity relations within the base table (Qiao et al., 28 Aug 2025). Two base-table tuples are connected if their feature similarity exceeds a threshold $T_0$3, or alternatively each node can connect to its top-$T_0$4 most similar base-table neighbors (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). The update is expressed abstractly in type-specific form. For a target node $T_0$5 and edge type $T_0$6, messages are aggregated from neighbors $T_0$7: $T_0$8 and node representations are updated via

$T_0$9

where $T$0 is a message function, $T$1 is an update function, and $T$2 is the set of edge types (Qiao et al., 28 Aug 2025). Task loss over labeled nodes is then

$T$3

The learned base-table node embeddings are used as the augmented features for the downstream classifier or regressor (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). Compared methods include BASE, All, Random, MI, BE, XGBoost, LightGBM, RF, ARDA, ARDA-NoText, and LEVA (Qiao et al., 28 Aug 2025). The reported classification metrics are Accuracy and AUC-ROC, with F1 and Average Precision used in sensitivity studies; regression metrics are MAE and MSE (Qiao et al., 28 Aug 2025). The implementation uses Python, PyTorch Geometric for GNNs, GraphSAGE and GAT, PyTorch Frame for table encoding, a default threshold $T$4 for significant attribute relationships, and an 18-hour time limit for each experiment (Qiao et al., 28 Aug 2025).

The main classification results reported for ReCoGNN include MovieLens with Accuracy $T$5 and AUC-ROC $T$6, Loyal with Accuracy $T$7 and AUC-ROC $T$8, PED with Accuracy $T$9 and AUC-ROC $\{T_1,\dots,T_K\}$0, and Event-Not with Accuracy $\{T_1,\dots,T_K\}$1 and AUC-ROC $\{T_1,\dots,T_K\}$2 (Qiao et al., 28 Aug 2025). For regression, the reported results are F1 with MAE $\{T_1,\dots,T_K\}$3 and MSE $\{T_1,\dots,T_K\}$4, IMDB with MAE $\{T_1,\dots,T_K\}$5 and MSE $\{T_1,\dots,T_K\}$6, Restbase with MAE $\{T_1,\dots,T_K\}$7 and MSE $\{T_1,\dots,T_K\}$8, and Bio with MAE $\{T_1,\dots,T_K\}$9 and MSE $T_0$0 (Qiao et al., 28 Aug 2025). The paper states that ReCoGNN is best or near-best across the classification datasets and achieves the best results on all four regression datasets (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). Weighted graphs outperform unweighted graphs, indicating that GNN-learned weights help suppress noisy relational signals (Qiao et al., 28 Aug 2025). Including base-table similarity edges improves performance by improving information flow among semantically similar base tuples (Qiao et al., 28 Aug 2025). In the graph discovery comparison, Complete Graph performs better than Girvan-Newman, especially at thresholds such as $T_0$1 and $T_0$2, because it is stricter and captures stronger attribute relations while reducing noise (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

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 (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025). The reported 18-hour timeout indicates that runtime can remain substantial on large datasets (Qiao et al., 28 Aug 2025). 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 (Qiao et al., 28 Aug 2025).

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 (Li et al., 2019). 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 (Li et al., 2019).

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 (Li et al., 2019). 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 (Qiao et al., 28 Aug 2025). 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 (Li et al., 2019, Qiao et al., 28 Aug 2025). The two models are best understood as separate graph-based methods developed for different data modalities and prediction workflows.