--- license: apache-2.0 pretty_name: Table Recognition Benchmark (17 sources, 184,074 tables) tags: - table-recognition - table-structure-recognition - document-image-analysis - ocr - document-understanding - cv - computer-vision - teds - paddleocr-vl language: - en - zh - ja - de - fr - ar - hi configs: - config_name: default data_files: - split: test path: "*.parquet" --- # Table Recognition Benchmark 17 public and self-built table sources merged into **64 uniformly sized shards** (**184,074** tables, ~8.6 GB of images). Every row carries **both** an OTSL and an HTML ground truth, plus a flag marking the tables that carry no cell text at all. ## Layout ``` shard_0000.parquet ... shard_0063.parquet # 64 evenly-sized shards overlong.parquet # oversized / over-long tables README.md # you are here scripts/fill_otsl.py # html -> otsl scripts/fill_html.py # otsl -> html ``` Shards are balanced by **total image bytes, not row count** — each holds ~169 MB of images, and every shard mixes 15–17 different sources, so a single shard already gives broad coverage. ## Schema | column | type | meaning | |---|---|---| | `bytes` | binary | the table image, as stored (PNG/JPEG) | | `source` | string | fine-grained original dataset name | | `benchmark` | string | which of the 16 sources this row came from | | `sample_id` | string | original sample identifier (may be empty) | | `rows` / `cols` | int64 | table grid dimensions | | `otsl` | string | OTSL ground truth | | `html` | string | HTML ground truth | | `resolution` | string | `WIDTHxHEIGHT` | | `width` / `height` | int64 | image dimensions | | `structure_only` | bool | true when the table has **no cell text at all** | --- ## What is OTSL **OTSL = Optimized Table Structure Language**, the compact token language PaddleOCR uses to represent table structure. A table is a flat token stream — no nesting, no closing tags: | token | meaning | |---|---| | `` | a new (filled) cell starts here | | `` | an empty cell | | `` | continuation **to the left** (horizontal merge) | | `` | continuation **above** (vertical merge) | | `` | continuation both left and above | | `` | end of row | Cell text is inlined directly after its ``, so the stream alternates structure and content: ``` YearDivision 2023A ``` Compare with HTML for the same table — six characters per cell of pure syntax, and every merge costs a `colspan`/`rowspan` attribute: ```html
YearDivision
2023A
``` OTSL's advantage is that structure and text live in one linear sequence, which is what a sequence-to-sequence table recogniser predicts directly. ## What is TEDS and TEDS-S **TEDS = Tree-Edit-Distance-based Similarity** (PubTabNet). Both tables are turned into ordered trees — `` → `` → `
` — and scored as `1 - normalized_tree_edit_distance`: ``` TEDS = 1 - TD / max(N_pred, N_gt) ``` where `TD` is the tree edit distance and `N` the node count. It combines two signals into one number: - **structure** — did you get the rows, columns, and merges right? - **text** — did you get the cell *contents* right? **TEDS-S** is the structure-only variant: cell text is erased before the trees are compared, while spans (`colspan`/`rowspan`) are preserved. So `TEDS-S = 1 - TD_struct / max(N_pred, N_gt)`. The two bracket each other: | | TEDS | TEDS-S | |---|---|---| | table structure wrong | penalised | penalised | | cell text wrong | penalised | **ignored** | | use for | full-fidelity output | structure/topology comparison | A model that nails the grid but hallucinates cell contents scores high on TEDS-S and low on TEDS — that gap is the diagnostic. ## Why `structure_only` matters, and how to score it **31,429 rows (13.8%)** are *pure structure*: every cell is empty and only the grid and span layout is annotated (`synthtabnet` 29,990, `sprint_mustard` 1,429, `tabrecset` 7, `tableverse` 3). TEDS always compares cell text. Against an all-empty ground truth, that half of the metric degenerates into *"did the model correctly output nothing"* — which is not a meaningful quantity, and a model is rewarded for hallucinating text into a cell that should be blank. The rule used for this benchmark: - `structure_only == true` → score with **TEDS** (TEDS-S is redundant there) - `structure_only == false` → score with **TEDS-S** (structure is the comparable signal across corpora) ```python ds = load_dataset("CheneyWong/table_recognition_eval", data_files="shard_*.parquet", split="test") headline = [TEDS if r["structure_only"] else TEDS_S for r in ds] ``` Report the two groups **separately**. Averaging them into one number mixes incompatible metrics and the ranking stops meaning anything. ## OTSL ↔ HTML are interconvertible Both formats encode the same table, so either can be derived from the other. Where a source shipped only one, the other was generated here: - **`otsl` derived from `html`** for `pubtables1m`, `mmsci`, `pubtablesv2`, `tableverse`, `hitab`, `scitsr`, `sprint_mustard`, `pubtabnet_val`, `pubtabnet_icdar21`, `omnidocbench` - **`html` derived from `otsl`** for `tabrecset_zh`, `tabrecset_en` - **native to the source** for `fintabnet`, `synthtabnet`, `tablet`, `ccocr`, `ocrbenchv2` **All rows have both fields populated.** Rows left with neither after conversion were dropped rather than shipped without ground truth. Round-trip fidelity, measured on a 2,500-row sample: | check | result | |---|---| | byte-identical `otsl → html → otsl` | 41.2% | | identical after ignoring the normalisations below | 72.8% | | span tokens (`colspan`/`rowspan`) fully preserved | 91.0% | The conversion is **structurally faithful but not byte-stable**. Three known normalisations account for the gap: 1. **Row padding.** HTML has no ragged rows — a short row must be padded to the grid width, so converting back yields trailing ``. 2. **Empty-cell spelling.** `` with no text and a bare `` mean the same thing; we canonicalise to ``. 3. **Irregular rowspan layout.** On tables whose vertical merges do not tile cleanly, span placement is re-derived rather than preserved verbatim. If you need exact span placement, keep `otsl` as the source of truth — it is never generated from HTML for the sources that ship it natively. ### Conversion scripts Two scripts, both multi-worker: - [`scripts/fill_otsl.py`](scripts/fill_otsl.py) — HTML → OTSL. Walks the parquet row group by row group (memory stays bounded), collects the rows whose `otsl` is empty but whose `html` is not, converts them across a worker pool, and rewrites the file. Recomputes `structure_only` afterwards, since it is derived from `otsl`. ```bash python scripts/fill_otsl.py shard_0000.parquet --workers 128 ``` - [`scripts/fill_html.py`](scripts/fill_html.py) — OTSL → HTML, the mirror image: fills `html` wherever it is missing but `otsl` is present. ```bash python scripts/fill_html.py shard_0000.parquet --workers 128 ``` Neither loads the whole file into memory: rows are processed per row group and converted in a `multiprocessing.Pool`, so `--workers 128` is safe on a machine with many cores. --- ## Sources | benchmark | rows | share | origin | OTSL from | |---|---:|---:|---|---| | `pubtables1m` | 93,834 | 41.1% | PubTables-1M test split | HTML | | `mmsci` | 12,129 | 6.6% | MMSci-Table **test** split | HTML | | `synthtabnet` | 29,990 | 13.2% | SynthTabNet test | native | | `fintabnet` | 10,397 | 4.6% | FinTabNet_OTSL test | native | | `pubtabnet_icdar21` | 9,064 | 4.0% | ICDAR 2021 official test | HTML | | `pubtablesv2` | 7,680 | 3.4% | PubTables-v2 test split | HTML | | `tableverse` | 4,951 | 2.2% | TableVerse-5K | HTML | | `hitab` | 3,597 | 1.6% | HiTab | HTML | | `scitsr` | 3,000 | 1.3% | SciTSR | HTML | | `sprint_mustard` | 1,429 | 0.6% | SPRINT-MUSTARD | HTML | | `tabrecset_en` | 4,394 | 2.4% | TabRecSet-en | native | | `tabrecset_zh` | 1,065 | 0.6% | TabRecSet-zh | native | | `tablet` | 909 | 0.4% | TABLET test split | native | | `omnidocbench16` | 665 | 0.4% | OmniDocBench v1.6 | HTML | | `omnidocbench15` | 512 | 0.3% | OmniDocBench v1.5 | HTML | | `ccocr` | 300 | 0.1% | CC-OCR | native | | `ocrbenchv2` | 158 | 0.1% | OCRBench-v2 table-parsing tasks | HTML | | **total** | **184,074** | 100% | | | ## Deliberate exclusions - **TABLET train pool** (17,720 rows) — replaced by the 909-row test split, since the train pool overlaps the evaluation set. - **OCRBench-v2 non-table tasks** (9,300) — OCRBench-v2 is a general document-VQA benchmark. POIE, ChartQA, MMMU, textvqa and the rest carry no table annotation at all, so they cannot score a table recogniser. Of the 700 genuinely table-parsing tasks, 542 say "all tables in the image" with no region to crop to; only the 158 with an explicit bbox are included. Rows that ended up with neither OTSL nor HTML were dropped rather than shipped without ground truth. **As of this version there are none: all 184,074 rows carry both.** ## Related datasets in this org The individual source corpora are published separately, so you can pull just the ones you need without downloading the merged 184k-row set above: | dataset | what it is | |---|---| | [`FinTabNet-OTSL`](https://huggingface.co/datasets/CheneyWong/FinTabNet-OTSL) | financial statement tables, OTSL annotations | | [`HiTab`](https://huggingface.co/datasets/CheneyWong/HiTab) | hierarchical tables with dense row/column spans | | [`MMSci-Table`](https://huggingface.co/datasets/CheneyWong/MMSci-Table) | scientific tables from recent papers | | [`PubTabNet`](https://huggingface.co/datasets/CheneyWong/PubTabNet) | the original PubTabNet release | | [`PubTabNet-ICDAR-test-GT`](https://huggingface.co/datasets/CheneyWong/PubTabNet-ICDAR-test-GT) | official ICDAR 2021 challenge ground truth | | [`PubTables-1M`](https://huggingface.co/datasets/CheneyWong/PubTables-1M) | 1M scientific tables, structure annotations | | [`PubTables-v2`](https://huggingface.co/datasets/CheneyWong/PubTables-v2) | PubTabNet + PubTables-1M combined | | [`SPRINT-MUSTARD`](https://huggingface.co/datasets/CheneyWong/SPRINT-MUSTARD) | structure-only tables, 13 languages | | [`SynthTabNet`](https://huggingface.co/datasets/CheneyWong/SynthTabNet) | synthetic tables | | [`TABLET`](https://huggingface.co/datasets/CheneyWong/TABLET) | table QA benchmark, 9 subsets | | [`TableVerse-5K`](https://huggingface.co/datasets/CheneyWong/TableVerse-5K) | 5K complex Chinese tables | | [`SciTSR`](https://huggingface.co/datasets/CheneyWong/SciTSR) | SciTSR train/val/test tars | | [`rebuilt_table_sources`](https://huggingface.co/datasets/CheneyWong/rebuilt_table_sources) | the four rebuilt sources on their own: OmniDocBench v1.5/v1.6, CC-OCR, OCRBench-v2 tables | | [`table_recognition_eval`](https://huggingface.co/datasets/CheneyWong/table_recognition_eval) | this merged benchmark | Full list: https://huggingface.co/CheneyWong/datasets ## Code Pipeline code, the batch evaluation harness, and the vLLM environment notes live in the GitHub project: **[`Cheney20/paddleocr-vl-table-recognition`](https://github.com/Cheney20/paddleocr-vl-table-recognition)** This repository holds the data only. The converters referenced above (`scripts/fill_otsl.py`, `scripts/fill_html.py`) are mirrored there, together with the evaluation runner and the offline vLLM image instructions. The offline vLLM image for PaddleOCR-VL-1.6 (7.34 GB) is on Baidu Netdisk: ``` file : paddleocrvl-docker link : https://pan.baidu.com/s/1Vwt9XtYP5aBPjfdXzxBRAA?pwd=y8na code : y8na sha256 : f40e1d785c7c09c29ff1118cdf7edffec500459c3964ca05c419657d2107a364 ``` ## Loading ```python from datasets import load_dataset ds = load_dataset("CheneyWong/table_recognition_eval", data_files="shard_*.parquet", split="test") print(len(ds)) # 184074 print(ds.filter(lambda r: r["benchmark"] == "hitab")) # structure-only rows, score these with TEDS struct = ds.filter(lambda r: r["structure_only"]) print(len(struct)) ``` `overlong.parquet` holds oversized tables kept out of the 64 so they do not distort their image-byte balance. Load it separately. ## Citation Please cite the original datasets you use. This repository only re-packages them under a unified schema.