💻 computer science

FastTab: A Fast Table Recognizer with a Tiny Recursive Module and 1D Transformers

FastTab is a low-latency table structure recognition model that combines a lightweight Tiny Recursive Module for global reasoning with axial 1D Transformers to accurately predict grid structures and cell spans without relying on autoregressive HTML decoding.

Original authors: Laziz Hamdi, Amine Tamasna, Pascal Boisson, Thierry Paquet

Published 2026-05-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Laziz Hamdi, Amine Tamasna, Pascal Boisson, Thierry Paquet

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 handed a messy, hand-drawn map of a city. Your job is to redraw it perfectly on a computer, figuring out exactly where every street (row) and avenue (column) goes, which buildings are merged together, and which streets are just headers. This is the challenge of Table Structure Recognition (TSR): turning a picture of a table into a clean, digital grid.

Most current AI models try to solve this like a novelist writing a story one word at a time (generating HTML code). This is slow and prone to getting lost in the middle of the sentence.

FastTab is a new, super-fast AI model that takes a different approach. Instead of writing a story, it acts like a surveyor with a laser grid. Here is how it works, broken down into simple concepts:

1. The "Tiny Brain" (The Tiny Recursive Module)

Imagine you are looking at a table from far away. You need to know: "How many rows are there? How many columns? Where is the header?"

The Old Way: The AI might try to guess these details by looking at every single pixel individually, which is exhausting.
FastTab's Way: It uses a Tiny Recursive Module (TRM). Think of this as a tiny, super-smart assistant who looks at the whole picture, makes a quick guess, then looks at the picture again to refine that guess, and does this a few times (about 6 times).
The Analogy: It's like squinting at a blurry photo, then squinting a bit harder, then adjusting your glasses. After a few quick "squints," the assistant knows exactly how big the table is and where the headers are, without needing to read every single word.

2. The "One-Dimensional Scanners" (Axial 1D Transformers)

Once the AI knows the general size, it needs to draw the lines.

The Problem: Tables have long rows and long columns. If you look at the whole table at once, it's like trying to read a whole book in one glance.
FastTab's Way: It splits the problem. It uses 1D Transformers to scan the table in two separate passes:
1. Row Scanner: It looks only horizontally, like a laser beam sweeping across a row to find where the vertical lines should go.
2. Column Scanner: It looks only vertically, like a laser beam sweeping down a column to find where the horizontal lines should go.
The Analogy: Imagine a librarian organizing books. Instead of looking at the whole shelf at once, they scan one row of books to find the gaps, then scan one column of shelves to find the gaps. This is much faster and keeps the AI from getting confused by the whole picture at once.

3. The "Merged Cell Detective" (ROI-Aligned Pooling)

Sometimes, a cell in a table spans across two or three columns (a "merged cell").

The Old Way: The AI might guess randomly where the merge happens.
FastTab's Way: Once the grid lines are drawn, the AI looks only at the specific box where a cell starts (the top-left corner). It asks, "Does this cell stretch to the right? Does it stretch down?"
The Analogy: It's like a real estate agent who has already drawn the property lines on a map. They only need to stand at the front door of a house to ask, "Does this house cover two lots?" They don't need to walk the whole property to know.

Why is this a big deal?

Speed: Because it doesn't write a long story (HTML code) word-by-word, it is incredibly fast. The paper claims it can process tables in real-time (about 40+ frames per second on powerful computers, and still over 4 frames per second on regular laptops).
Accuracy: It is just as good as the slow, complex models at getting the structure right.
Robustness: The authors tested it on "anonymized" tables (where the text is blacked out or blurred to hide secrets). FastTab still works well because it focuses on the shape and lines of the table, not the words inside it.
Curved Tables: They even showed it can handle tables that are slightly bent or curved (like a photo taken of a table on a curved surface), by allowing the "laser lines" to bend slightly.

Summary

FastTab is like a high-speed construction crew. Instead of building a table brick-by-brick (word-by-word), they:

Use a quick team leader (TRM) to decide the blueprint size.
Send laser scanners (1D Transformers) to draw the straight lines for rows and columns.
Have a specialist check the corners to see if any blocks are merged.

The result is a digital table that is built in a fraction of a second, with high precision, even if the original photo is a bit messy or the text is hidden.

Technical Summary: FastTab

Problem Definition
Table Structure Recognition (TSR) aims to recover the logical organization of tables (rows, columns, headers, and merged cells) and their geometric fidelity from document images. This task is challenging due to the need to reconcile global structural coherence (e.g., total row/column counts, header extent) with local spatial precision (e.g., separator localization, borderless layouts). Existing paradigms often struggle to balance these requirements: component-based methods rely on explicit detection and reconstruction, split-and-merge approaches focus on grid construction, and generative models (image-to-sequence) map images to HTML tokens. The latter, while effective, incur high computational costs due to autoregressive decoding and require maintaining global syntactic consistency throughout the sequence generation process.

Methodology
FastTab is a grid-centric TSR model designed to avoid autoregressive HTML decoding. It operates in a single forward pass to predict a table grid and merged cell spans. The architecture consists of three primary components:

Image Encoder: A fully convolutional network (FCN) extracts a high-resolution 2D feature map ( $F$ ). The encoder uses an anisotropic stride schedule ( $H/16, W/8$ ) to preserve finer horizontal sampling for column delineation, outputting 1024 channels.
Global Reasoning (Tiny Recursive Module - TRM): To support table-level decisions (row/column counts, header rows), FastTab computes a global descriptor via average pooling. This is refined over $T$ residual steps (default $T=6$ ) using a lightweight Tiny Recursive Module. The TRM iteratively updates a latent vector $z$ using a two-layer MLP, conditioned on the global descriptor, to capture long-range dependencies necessary for consistent structural decisions.
Axial 1D Transformers (Lines Head): Instead of processing the full 2D map for separators, the model projects $F$ $F$ into two 1D sequences (row-wise and column-wise) by averaging along the orthogonal dimension. These sequences are processed by lightweight 1D Transformer encoders (2 layers, 4 heads) to capture long-range dependencies along each axis with linear computational growth. The head predicts:
- Row and column counts ( $R, C$ ).
- Header row count ( $H_{hdr}$ ).
- Separator locations, parameterized as normalized interval lengths and converted to ordered boundaries via cumulative summation.
Spanning Head: Once the grid boundaries are established, ROI Align pools features for each logical cell. A Multi-Layer Perceptron (MLP) classifies the rowspan and colspan for each cell, supervised only at anchor positions (top-left corners) to avoid ambiguity in merged regions.

Key Contributions

Architecture: Introduction of FastTab, which combines a Tiny Recursive Module for global context with axial 1D Transformers for efficient long-range row/column reasoning, avoiding the overhead of autoregressive decoders.
Performance: Demonstration of competitive structure recovery performance across four benchmarks (PubTabNet, FinTabNet, PubTables-1M, and SciTSR) while operating at low latency (real-time inference).
Robustness Analysis: Evaluation of the model under practical constraints, specifically pixel-level anonymization (showing resilience to layout-preserving obfuscation) and an extension to curved separators to handle geometric distortions like rotation.
Ablation Studies: Systematic analysis confirming that iterative refinement via TRM yields diminishing returns beyond $T=6$ and that axial 1D attention significantly outperforms local convolutional baselines with minimal speed penalty.

Experimental Results
FastTab was evaluated on standard benchmarks using structure-only metrics (S-TEDS, GriTSTop, CAR F1):

PubTabNet: Achieved 96.8% S-TEDS with 44.89 FPS (A100 GPU), outperforming many high-accuracy models in speed while maintaining competitive accuracy. It also runs at ~5 FPS on CPU-only environments.
FinTabNet: Achieved 98.2% S-TEDS with 41.79 FPS.
PubTables-1M: Achieved 98.27% GriTSTop with 39.50 FPS.
SciTSR: Matched the best reported accuracy (99.5% CAR F1) with 35.51 FPS.
Anonymization: The model showed robustness to layout-preserving anonymization (e.g., Gaussian blur, pixelation) but degraded significantly with methods that homogenize text regions (e.g., median fill).
Curved Separators: An extension predicting polyline boundaries for separators maintained strong performance under moderate in-plane rotations (up to $\pm 15^\circ$ ), though performance decreased with larger rotations.

Significance and Claims
The paper positions FastTab as an efficient alternative to both multi-stage reconstruction pipelines and autoregressive generative models. By decoupling global context reasoning (via TRM) from axial dependency modeling (via 1D Transformers), FastTab achieves a favorable trade-off between accuracy and inference speed. The authors claim that the model successfully addresses the tension between global structural coherence and local spatial precision without the computational burden of full 2D self-attention or autoregressive decoding. The work suggests that for many practical applications requiring real-time or resource-constrained deployment, a grid-centric approach with specialized axial modeling is sufficient to recover complex table structures with high fidelity. Future work is identified as extending the model to multi-table pages, improving robustness to severe perspective warps, and developing adaptive grid decoding for very large tables.