💬 NLP

Decoupling Skeleton and Flesh: Efficient Multimodal Table Reasoning with Disentangled Alignment and Structure-aware Guidance

This paper introduces DiSCo and Table-GLS, a novel framework that efficiently enhances Large Vision-Language Models' table reasoning capabilities by disentangling structural and semantic alignment and employing structure-guided inference, all without requiring expensive supervised training or external tools.

Original authors: Yingjie Zhu, Xuefeng Bai, Kehai Chen, Yang Xiang, Youcheng Pan, Xiaoqiang Zhou, Min Zhang

Published 2026-05-28

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Yingjie Zhu, Xuefeng Bai, Kehai Chen, Yang Xiang, Youcheng Pan, Xiaoqiang Zhou, Min Zhang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a very smart, well-read robot (a Large Vision-Language Model) how to read a messy, complex spreadsheet. The robot is great at reading books and looking at pictures, but when it sees a table, it gets confused. It tries to read the whole thing at once, mixing up the shape of the table (where the rows and columns are) with the words inside the cells. It's like trying to learn the layout of a new city while simultaneously trying to memorize every single street sign; the brain gets overloaded.

This paper introduces a new way to teach the robot, called DISCO and Table-GLS, which works like a two-step "decoupling" process.

The Problem: The "Tangled" Mess

Current methods try to teach the robot by showing it a table image and its text version (like HTML or Markdown) all at once. The paper argues this is like trying to learn to drive a car by staring at the engine and the steering wheel simultaneously. The robot struggles to separate the skeleton (the grid lines, rows, and columns) from the flesh (the actual numbers and words). Because they are so tightly mixed, the robot often guesses wrong or gets lost in complex tables it hasn't seen before.

The Solution: "Decoupling Skeleton and Flesh"

The authors propose a framework that separates these two tasks, much like an architect first draws the blueprints (skeleton) before the interior designer picks the furniture (flesh).

Step 1: DISCO (The Architect)

DISCO stands for Disentangled Structure–Content Orientation. It teaches the robot to look at a table in two distinct phases:

Learning the Skeleton (Structure Alignment): The robot is shown a table image, but all the text inside is replaced with a generic placeholder like "content." The robot is asked to describe the shape only: "This table has 5 rows and 3 columns. There is a header at the top." It learns the layout without getting distracted by the specific words.
Learning the Flesh (Content Alignment): Once the robot knows the shape, it is taught to fill in the blanks. It learns to say, "In Row 1, Column 2, the word is 'Apple'."

By separating these, the robot learns the "map" of the table first, then learns to read the "landmarks" on that map. This makes it much better at understanding tables it has never seen before.

Step 2: Table-GLS (The Detective)

Once the robot understands the table better, the authors introduce Table-GLS (Global-to-Local Structure-guided reasoning). This is a new way for the robot to answer questions without needing expensive tools or extra training.

Think of this as a detective solving a mystery:

Global Exploration: Instead of diving straight into the details, the detective first looks at the whole crime scene (the whole table) to figure out where the clues might be. "I need to look at the 'Sales' column and the '2023' row."
Self-Refinement: The detective pauses and asks, "Did I pick the right clues? Do I need more?" If the plan is wrong, it fixes it before moving on.
Local Extraction & Reasoning: Finally, the detective cuts out just the tiny piece of paper (the sub-table) with the relevant clues and solves the math or logic problem using only that small piece.

This prevents the robot from getting confused by irrelevant data or making up facts because it's looking at too much information at once.

Why This Matters

The paper claims this approach is efficient and lightweight:

No Heavy Tools: It doesn't need external software or complex code to work; the robot does it all itself.
Less Data Needed: It achieves great results with only 10,000 examples, whereas other methods might need 100,000 or more.
Better Generalization: Because it learns the "skeleton" separately, it can handle weird, complex, or unseen table layouts much better than previous methods.

The Result

In their tests, this new method helped the robot understand and reason about tables significantly better than before. It was particularly good at:

Finding specific cells in a grid.
Answering questions about complex financial or scientific tables.
Handling tables it had never seen before (unseen structures).

In short, the paper teaches the robot to stop trying to swallow the whole table at once. Instead, it teaches the robot to first understand the grid, then find the specific piece of the puzzle it needs, and finally solve the problem with that specific piece. This makes the robot smarter, faster, and more reliable when dealing with data tables.

Technical Summary: Decoupling Skeleton and Flesh: Efficient Multimodal Table Reasoning with Disentangled Alignment and Structure-aware Guidance

Problem Statement

Reasoning over table images remains a significant challenge for Large Vision-Language Models (LVLMs) due to complex layouts and the tightly coupled nature of structural information (rows, columns, layout) and semantic content (cell values). Existing approaches to adapt LVLMs for table reasoning generally fall into two categories, both of which have limitations:

Supervised Fine-Tuning (SFT) or Reinforcement Learning (RL): These methods often require extensive, expensive expert annotations for table reasoning data. They risk catastrophic forgetting of the model's original capabilities and suffer from high training costs.
Tool-Augmented Reasoning: These methods rely on external tools (e.g., visual editors, symbolic executors, table parsers) to explicitly steer attention and reasoning. While effective, they increase system complexity, inference latency, and fail to enhance the model's intrinsic capacity for structural understanding.

The core research question addressed is: How can LVLMs be adapted to table reasoning with minimal annotation cost and without reliance on external tools?

Methodology

The authors propose an efficient framework comprising two main components: DISCO (Disentangled Structure–Content alignment) and Table-GLS (Global-to-Local Structure-guided reasoning).

1. DISCO: Disentangled Structure–Content Alignment

The core insight of DISCO is to explicitly separate structural abstraction from semantic grounding during multimodal alignment. Instead of aligning table images with linearized text (e.g., HTML, Markdown) where structure and content are entangled, DISCO decomposes the alignment into complementary objectives:

Structure Alignment: The model is trained to predict a structure representation ( $T_S$ ) derived by anonymizing all cell contents in the textual representation (replacing them with a placeholder token) while preserving layout tokens (delimiters, headers, span markers). This forces the LVLM to learn table layouts independent of cell semantics.
Content Alignment: This is further divided into two levels to ground semantics onto the learned structure:
- Global Content Alignment: The model generates a lightweight semi-structured description of the table, including total row/column counts and a summary of row/column contents.
- Local Content Alignment: The model is trained to identify and describe the textual content associated with specific structural coordinates (e.g., "Row $m$ Column $n$ : [content]").

This disentanglement allows LVLMs to transfer their existing semantic understanding to table structures with minimal additional supervision.

2. Table-GLS: Global-to-Local Structure-Guided Reasoning

Building on the enhanced representations from DISCO, Table-GLS is a training-free, tool-free inference framework that guides the LVLM through a three-stage reasoning process:

Global Structure Exploration: Given a table image and a question, the model analyzes the overall layout to identify task-relevant row and column indices ( $R$ and $C$ ) and formulates a reasoning plan ( $T_t$ ). This enforces a "where-to-look" decision before content extraction.
Self-refined Sub-table Extraction: The model evaluates the adequacy of the initial plan. If necessary, it revises the plan and extracts a minimal sub-table ( $T_{sub}$ ) containing only the evidence required to answer the question. This step includes self-reflection to prevent error propagation.
Evidence-grounded Reasoning: The final answer is generated by reasoning over the extracted sub-table as verifiable evidence, while retaining the original image as auxiliary context for visual grounding. This constrains reasoning to task-relevant data, reducing spurious correlations.

Key Contributions

The paper claims the following contributions:

DISCO Framework: A disentangled alignment framework that improves LVLMs' understanding of table structure and content, particularly for complex and unseen layouts, by separating structure learning from content grounding.
Table-GLS Framework: A global-to-local inference method that enables accurate table reasoning at inference time without external tools or additional fine-tuning, utilizing a structured exploration and evidence-grounded approach.
Robust Performance: The proposed methods achieve robust improvements across 21 table understanding and reasoning tasks, demonstrating strong generalization to unseen table structures with minimal data (10K images for alignment).

Experimental Results

The framework was evaluated on 21 tasks across diverse benchmarks (e.g., MMTab, WTQ, HiTab, TAT-QA, TabFact, PubHealthTab) using various LVLMs (Gemma3, Qwen3-VL, LLaVA).

Table Understanding: DISCO consistently enhanced performance across all evaluated models and tasks. Notably, it achieved comparable or superior results to models trained on 97K images using only 10K images for alignment. It showed particular strength in structure-sensitive tasks (Table Size Detection, Cell Location) and Out-of-Distribution (OOD) settings.
Table Reasoning: Combining DISCO with Table-GLS yielded the best average scores. The framework significantly outperformed direct answering baselines and matched or surpassed heavily optimized LVLMs (e.g., Table-R1, HIPPO) on several benchmarks, especially OOD datasets like AIT-QA and PubHealthTab.
Generalization: The method improved performance on non-tabular tasks (ScienceQA, HallusionBench) compared to standard textual alignment, suggesting that disentangled alignment helps form reusable internal representations rather than causing over-specialization.
Efficiency: While Table-GLS involves multi-stage generation, it avoids the high latency and complexity of tool-augmented methods (e.g., REFOCUS) and achieves a favorable trade-off between inference time and accuracy.

Significance and Claims

The paper positions this work as a scalable and data-efficient solution for multimodal table reasoning. By decoupling "skeleton" (structure) from "flesh" (content), the authors demonstrate that LVLMs can be adapted to complex tabular reasoning without the prohibitive costs of large-scale supervised training or the architectural overhead of external tools. The framework effectively elicits the intrinsic reasoning capabilities of LVLMs, enabling them to generalize to unseen table structures and maintain robustness across diverse layouts. The authors conclude that explicit structure-content modeling and lightweight, structure-guided reasoning are key to advancing LVLM performance in structured data domains.