README.md

---
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 |
|---|---|
| `<fcel>` | a new (filled) cell starts here |
| `<ecel>` | an empty cell |
| `<lcel>` | continuation **to the left** (horizontal merge) |
| `<ulcel>` | continuation **above** (vertical merge) |
| `<xcel>` | continuation both left and above |
| `<nl>` | end of row |

Cell text is inlined directly after its `<fcel>`, so the stream alternates
structure and content:

```
<fcel>Year<fcel>Division<ecel><ecel><nl>
<fcel>2023<fcel>A<ecel><ecel><nl>
```

Compare with HTML for the same table — six characters per cell of pure
syntax, and every merge costs a `colspan`/`rowspan` attribute:

```html
<table><tr><th>Year</th><th>Division</th><td></td><td></td></tr>
<tr><td>2023</td><td>A</td><td></td><td></td></tr></table>
```

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 — `<table>` → `<tr>` → `<td>` — 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 `<ecel>`.
2. **Empty-cell spelling.** `<fcel>` with no text and a bare `<ecel>` mean the
   same thing; we canonicalise to `<ecel>`.
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.