Technical Summary: GRAB – Latent Bridges for Multi-Table Question Answering

Problem Statement

Table Question Answering (TQA) requires language models to answer natural language questions grounded in structured data. While Large Language Models (LLMs) have shown promise, standard approaches typically treat tables as unstructured text by serializing rows and columns into 1D sequences. This strategy fails to preserve critical relational semantics, such as row-column organization, permutation invariance, hierarchical headers, and cross-cell dependencies. Consequently, LLMs struggle with multi-table settings where reasoning requires navigating join dependencies and aggregating evidence distributed across linked tables. Furthermore, adapting LLMs to tabular data via full fine-tuning or heavy parameter-efficient methods (e.g., LoRA) risks over-specialization and catastrophic forgetting, while often failing to explicitly model the underlying graph structure of relational databases.

Methodology: The GRAB Pipeline

The authors propose GRAB (Graph-Relational Attention Bridge), a pipeline designed to connect relational deep learning with frozen LLMs without modifying the LLM's weights. The architecture consists of three primary components:

1. Relational Graph Constructor ($\gamma$):
   Instead of linearizing tables, the method lifts relational data into an explicit heterogeneous tripartite graph $G = (V_R \cup V_C \cup V_V, E_{RV} \cup E_{CV})$.

   • Nodes: The graph comprises Row nodes ($V_R$), Column-class nodes ($V_C$), and Value-group nodes ($V_V$).
   • Structure: Foreign-key metadata is used to merge columns from different tables into shared column-class nodes, making joins explicit. Repeated values are canonicalized into shared value-group nodes.
   • Initialization: Row and column nodes are initialized via text embeddings of their headers/content. Value nodes act as structural anchors, initialized deterministically based on value-group identifiers and column types, rather than raw cell text.

2. Graph Encoder:
   A Graph Neural Network (GNN) processes the constructed graph using message passing. The encoder maintains separate hidden states for rows, columns, and values. It updates these states by aggregating messages through row-value and column-value incidence matrices. This process allows information to propagate across tables via shared value nodes and column classes, capturing structural dependencies like co-occurrence and join paths within a bounded number of hops.

3. Query-Conditioned Latent Bridge:
   To interface the graph with the LLM, a latent resampler (inspired by Perceiver Resamplers) compresses the variable-sized graph into a fixed sequence of $K$ soft tokens ($Z$).

   • Conditioning: Unlike static prefix tuning, this bridge is query-conditioned. It uses cross-attention between learnable latent queries and the concatenation of graph node embeddings and the natural language question embeddings ($H_Q$).
   • Output: The bridge produces a compact, task-relevant structural prefix that is injected into the frozen LLM alongside the serialized table text.

Training Paradigm:
The LLM remains strictly frozen. Only the lightweight graph encoder and the latent bridge (totaling ~91M parameters) are trained. The objective is to minimize the auto-regressive negative log-likelihood of the target answer, conditioned on the question, the serialized text, and the structural soft tokens.

Key Contributions

1. Architecture: The introduction of GRAB, a GNN-based table encoder that lifts relational data into a tripartite graph and interfaces with frozen LLMs via query-conditioned latent tokens.
2. Diagnostic Taxonomy: The design of a stress-test taxonomy that isolates structural evidence localization from exact arithmetic, providing a novel tool to diagnose LLM failures in TQA.
3. Empirical Validation: Demonstration that GRAB consistently outperforms serialization-only baselines and specialized TQA models across 13 single- and multi-table benchmarks.

Experimental Results

The authors evaluated GRAB on a suite of benchmarks including StructQA, HiTab, WTQ, WikiSQL, HCTQA, TabMWP, MultiHiertt, SCITAT, MMQA, TQA-Bench, Atis, GeoQuery, and Spider.

• Performance Gains: GRAB significantly outperforms serialization-only baselines, with the most substantial improvements observed in structurally demanding scenarios.
  • Multi-table Joins: On Spider (SQL generation), GRAB achieved a +13.3 Cell F1 gain over the frozen baseline.
  • Complex Layouts: On HCTQA, GRAB improved F1 by +17.5 points over the zero-shot baseline.
  • Efficiency: Despite training only ~91M parameters, GRAB approaches or exceeds the performance of a LoRA-finetuned LLM (which updates the backbone weights) and outperforms specialized models like TableLlama and MultiTabQA.
• Stress-Test Analysis:
  • Structural Tasks: GRAB showed massive gains (+14 to +46 F1) on tasks requiring evidence localization (LOOKUP) and counting (COUNT), where the graph explicitly links rows via shared values.
  • Arithmetic Limits: Gains were minimal on exact arithmetic (AVG) tasks, confirming that the structural bridge helps locate relevant rows but does not replace the need for the LLM to perform precise symbolic computation.
• Ablation Studies:
  • Removing question conditioning reduced performance, validating the need for dynamic latent allocation.
  • Removing the serialized text caused a collapse in performance, indicating that the latent bridge acts as a structural supplement rather than a replacement for textual evidence.
  • A single message-passing layer was found sufficient, suggesting the tripartite structure efficiently exposes co-occurrence and membership.

Significance and Claims

The paper posits that tables should be treated as a distinct, structured modality rather than mere text. The authors claim that GRAB offers a practical middle ground between pure text serialization (which underuses relational structure) and symbolic pipelines (which lack LLM flexibility).

Key claims include:

• Structural Bias: Injecting explicit structural bias via a graph encoder is more parameter-efficient than brute-force fine-tuning of LLM weights to learn structure from text.
• Frozen LLM Compatibility: The approach preserves the general reasoning capabilities of the pre-trained LLM while adding an inductive bias for joins and cross-row aggregation.
• Scalability: The method enables efficient training on a single GPU, democratizing multi-table reasoning without the computational cost of full model adaptation.
• Future Direction: The work suggests a path toward "table foundation interfaces," where pre-trained relational encoders can be reused across datasets, analogous to vision encoders in vision-language models.

The authors remain modest regarding limitations, acknowledging that the approach still relies on the context window of the underlying LLM for exact values and that graph construction overhead may be significant for very large, highly connected schemas. They also note that the current implementation assumes relevant tables are already retrieved, leaving schema linking and retrieval as future integration points.