Upload README.md with huggingface_hub

README.md

@@ -4,8 +4,11 @@ pretty_name: Table Recognition Benchmark (16 sources, 228,099 tables)
 tags:
 - table-recognition
 - table-structure-recognition
+- document-image-analysis
 - ocr
-- document-ai
+- document-understanding
+- cv
+- computer-vision
 - teds
 - paddleocr-vl
 language:
@@ -20,141 +23,235 @@ configs:
 - config_name: default
   data_files:
   - split: test
-    path: benchmarks_v2/*
+    path: "*.parquet"
 ---
 
 # Table Recognition Benchmark
 
-16 public + self-built table sources merged into **64 uniformly sized shards**
-(**228,099** tables, ~9.2 GB of images). Every row carries both an **OTSL**
-and an **HTML** ground truth so you can score with whichever you prefer.
+16 public and self-built table sources merged into **64 uniformly sized shards**
+(**228,099** tables, ~9.2 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.
 
-The repository also keeps the original `eval/` directory (129 shards,
-105,311 rows) untouched, for backward compatibility.
+The legacy `eval/` directory (129 shards, 105,311 rows) is kept untouched for
+backward compatibility.
 
-## Why 64 shards
-
-Shards are balanced by **total image bytes, not row count** — each one holds
-~169 MB of images, and every shard mixes 15–17 different sources. Loading a
-single shard gives you broad source coverage instead of one narrow corpus.
+## Layout
 
 ```
-benchmarks_v2/shard_0000.parquet ... shard_0063.parquet
+shard_0000.parquet ... shard_0063.parquet   # 64 evenly-sized shards
+overlong.parquet                            # oversized / over-long tables
+README.md                                   # you are here
+eval/                                       # legacy, 129 shards, unchanged
 ```
 
+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 | image, as stored (PNG/JPEG) |
+| `bytes` | binary | the table image, as stored (PNG/JPEG) |
 | `source` | string | fine-grained original dataset name |
-| `benchmark` | string | one of the 16 sources below |
-| `sample_id` | string | original sample identifier (empty for some sources) |
+| `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 (PaddleOCR token format) |
+| `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** |
 
-### OTSL ↔ HTML
+---
+
+## 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).
 
-The two representations are interconvertible. Where a source shipped only
-one, the other was generated here:
+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.
 
-- `otsl` derived from `html` for: `pubtables1m`, `mmsci`, `pubtablesv2`,
+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`
-- `html` derived from `otsl` for: `tabrecset`
-- native to the source for: `fintabnet`, `synthtabnet`, `tablet`,
-  `omnidocbench`, `ccocr`, `ocrbenchv2`
+  `pubtabnet_icdar21`, `omnidocbench`
+- **`html` derived from `otsl`** for `tabrecset`
+- **native to the source** for `fintabnet`, `synthtabnet`, `tablet`,
+  `ccocr`, `ocrbenchv2`
+
+**All 228,099 rows have both fields populated.** Rows left with neither
+after conversion were dropped rather than shipped without ground truth.
+
+### 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`.
 
-**All 228,099 rows have both fields populated.** Rows that had neither after
-conversion were dropped rather than shipped without ground truth.
+  ```bash
+  python scripts/fill_otsl.py shard_0000.parquet --workers 128
+  ```
 
-### `structure_only`
+- [`scripts/fill_html.py`](scripts/fill_html.py) — OTSL → HTML, the mirror
+  image: fills `html` wherever it is missing but `otsl` is present.
 
-31,429 rows (13.8%) are *pure structure*: every cell is empty and only the
-grid/span layout is annotated (`synthtabnet` 29,990, `sprint_mustard` 1,429,
-`tabrecset` 7, `tableverse` 3).
+  ```bash
+  python scripts/fill_html.py shard_0000.parquet --workers 128
+  ```
 
-This matters for scoring. TEDS compares **both** structure and cell text; on
-an all-empty ground truth the text half degenerates into "did the model
-correctly output nothing", which is not a meaningful number. For those rows
-use **TEDS** as the headline metric; for the rest use **TEDS-S**. Filter on
-this column to apply the rule.
+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 | GT |
+| benchmark | rows | share | origin | OTSL from |
 |---|---:|---:|---|---|
-| `pubtables1m` | 93,834 | 41.1% | PubTables-1M **test** split | from html |
-| `mmsci` | 52,098 | 22.8% | MMSci-Table (train split) | from html |
-| `synthtabnet` | 29,990 | 13.2% | SynthTabNet test (token lists rejoined) | native |
-| `fintabnet` | 10,397 | 4.6% | FinTabNet_OTSL **test** | native |
-| `pubtabnet_val` | 9,115 | 4.0% | PubTabNet **val** split | from html |
-| `pubtabnet_icdar21` | 9,064 | 4.0% | **ICDAR 2021 official test** (HF images + `final_eval.json`) | from html |
-| `pubtablesv2` | 7,680 | 3.4% | PubTables-v2 **test** split | from html |
-| `tableverse` | 4,951 | 2.2% | TableVerse-5K | from html |
-| `hitab` | 3,597 | 1.6% | HiTab | from html |
-| `scitsr` | 3,000 | 1.3% | SciTSR | from html |
-| `sprint_mustard` | 1,429 | 0.6% | SPRINT-MUSTARD | from html |
-| `tabrecset` | 1,065 | 0.5% | TabRecSet-zh (local cohort) | native otsl |
-| `tablet` | 909 | 0.4% | TABLET **test** split | native |
-| `omnidocbench` | 512 | 0.2% | OmniDocBench v1.5, recropped from `poly` | from html |
-| `ccocr` | 300 | 0.1% | CC-OCR | from html |
-| `ocrbenchv2` | 158 | 0.1% | OCRBench-v2 table-parsing tasks, cropped by bbox | from html |
+| `pubtables1m` | 93,834 | 41.1% | PubTables-1M test split | HTML |
+| `mmsci` | 52,098 | 22.8% | MMSci-Table | HTML |
+| `synthtabnet` | 29,990 | 13.2% | SynthTabNet test | native |
+| `fintabnet` | 10,397 | 4.6% | FinTabNet_OTSL test | native |
+| `pubtabnet_val` | 9,115 | 4.0% | PubTabNet val split | HTML |
+| `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` | 1,065 | 0.5% | TabRecSet-zh | native |
+| `tablet` | 909 | 0.4% | TABLET test split | native |
+| `omnidocbench` | 512 | 0.2% | OmniDocBench v1.5 | HTML |
+| `ccocr` | 300 | 0.1% | CC-OCR | native |
+| `ocrbenchv2` | 158 | 0.1% | OCRBench-v2 table-parsing tasks | HTML |
 | **total** | **228,099** | 100% | | |
 
 ## Deliberate exclusions
 
-These were left out on purpose, not by accident:
-
-- **TABLET train pool** (17,720 rows) — replaced by the 909-row test split.
-  The train pool overlaps the evaluation set, so shipping it would leak.
-- **OCRBench-v2 rows without a bbox** (542) — the question text says "all
-  tables in the image", so there is no region to crop to. Only the 158 rows
-  with an explicit, parseable bbox are included.
+- **TABLET train pool** (17,720 rows) — replaced by the 909-row test split,
+  since the train pool overlaps the evaluation set.
+- **OCRBench-v2 rows without a bbox** (542) — their prompt says "all tables
+  in the image", so there is no region to crop to. Only the 158 rows with an
+  explicit bbox are included.
 - **OmniDocBench v1.6** (665) — no public annotation file ships the table
-  HTML; images alone would be unscorable.
+  HTML, so the images alone would be unscorable.
 - **Rows with neither OTSL nor HTML** (11,177) — no ground truth at all.
 
-## De-duplication
-
-The merged pool was de-duplicated against a 345,915-entry test blocklist
-covering the val/test splits of every public table dataset. Matching was done
-on **both** `sample_id` and `image_sha256`, the latter computed from the
-packed image bytes:
-
-```
-blocklist entries      345,915  (344,334 distinct image hashes)
-matched on sample_id          0
-matched on image_sha256       0
-internal duplicates     2,449  removed
-```
-
-So this pool is disjoint from the val/test splits of the datasets it draws
-from.
-
 ## Loading
 
 ```python
 from datasets import load_dataset
 
 ds = load_dataset("CheneyWong/table_recognition_eval",
-                  data_files="benchmarks_v2/*.parquet", split="train")
-print(len(ds))                       # 228099
+                  data_files="shard_*.parquet", split="test")
+print(len(ds))                                   # 228099
 print(ds.filter(lambda r: r["benchmark"] == "hitab"))
-```
 
-Scoring only the pure-structure rows:
-
-```python
+# structure-only rows, score these with TEDS
 struct = ds.filter(lambda r: r["structure_only"])
-# -> use TEDS on these
+print(len(struct))                                # 31429
 ```
 
+`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 with a unified schema.
+them under a unified schema.