Hugging Face's logo

Datasets:
florapeterpaul3
/
geeklink-ocr-benchmark

Tasks:
Image-to-Text
Modalities:
Video
Languages:
English
Spanish
Japanese
Size:
1K<n<10K
Tags:
ocr
video
subtitles
benchmark
License:
Dataset card Files
xet
 Community
geeklink-ocr-benchmark / README.md
florapeterpaul3's picture
florapeterpaul3
Fix clipped subtitle text (437 samples), extend to 1140 samples
5d7e191 verified
preview code
|
Raw
History Blame Contribute Delete
12.8 kB
metadata 
license: cc0-1.0
task_categories:
  - image-to-text
language:
  - en
  - es
  - ja
  - ko
  - zh
  - el
tags:
  - ocr
  - video
  - subtitles
  - benchmark
size_categories:
  - 1K<n<10K

GeekLink OCR Benchmark

A benchmark for burned-in video subtitle OCR: 1,140 subtitle images across 6 languages (English, Spanish, Japanese, Korean, Chinese, Greek), rendered onto real film footage with exact known ground truth — so there's no ambiguity about what the "correct" answer is, and no privacy or copyright risk in the images themselves.

Unlike document-OCR benchmarks (scanned pages, receipts, street signs), this targets the specific failure modes of subtitle OCR in video: low-contrast backgrounds, film grain, small text against busy scenes, and — in ~19% of samples — a second overlapping caption/watermark line placed deliberately close to the subtitle, to test whether an engine can isolate the actual subtitle instead of dumping every text region it finds.

Data correction (2026-08-21): an earlier version of this dataset had a real bug — 437 samples (38%) had ground-truth text wider than the video frame, so the rendered subtitle got clipped off-screen and the image didn't actually show the full ground-truth text. All affected samples have been re-rendered with proper line wrapping at their exact original timestamp. The dataset was also extended from 600 to 1,140 samples in the same pass. All baseline numbers below are from the corrected data; if you pulled this before 2026-08-21, please re-sync.

How this was built (and why)

The images are real frames from three public-domain / openly-licensed films (see Sources below), with subtitle lines burned in using the same ffmpeg + libass pipeline used for hard-subtitle export in GeekLink. The subtitle text itself is short, colloquial lines adapted from public-domain literature (Sherlock Holmes, Dracula, Alice in Wonderland, Pride and Prejudice, A Christmas Carol, The Wizard of Oz, Peter Pan, Moby-Dick, and others) — not verbatim quotes, rewritten to read like natural spoken subtitles, then translated into the other 5 languages. Lines that don't fit the frame width at render size are automatically wrapped onto multiple lines (measured per-language, per-font, per-video-width) rather than clipped.

We deliberately did not use real user video or real user OCR corrections for this release: an earlier pass built on real (anonymized) user data turned up enough privacy and copyright edge cases — a portrait video where the subtitle position broke a positioning heuristic and nearly exposed a bystander's face, adult content mixed into the same raw data pool, personal documentary footage with real names — that we decided the safer and more reproducible path was synthetic-but-realistic: real footage, real difficulty, zero real people, zero rights ambiguity.

What's in the data

  • data/manifest.csv / data/manifest.jsonl — one row per sample: id, video_id, lang, image, ground_truth, has_watermark.
  • data/images/ — the rendered frames (full frames, not cropped — there's nothing sensitive to crop out here).
  • baselines/ — GeekLink's own OCR engine's raw output on this set (no post-filtering), both the ONNX/CPU build and the CoreML build actually used in the Mac app, for comparison.
  • external_baselines/ — raw output from PaddleOCR (3 PP-OCRv6 size tiers), EasyOCR, and Tesseract on the same set, same no-filtering methodology (see Baselines below).
lang samples
en 191
es 191
ja 191
ko 191
zh 188
el 188
total 1140

~19% of samples (213/1140) include a synthetic watermark/credit line near the subtitle — a harder detection case.

Running the eval 

python3 eval/eval.py --pred baselines/geeklink_coreml.csv   # score GeekLink's real Mac backend
python3 eval/eval.py --pred your_ocr_output.csv             # score your own engine

Your predictions file needs an id column (matching data/manifest.csv) and a prediction column, as CSV or JSONL. Metrics are CER (character error rate) and WER (word error rate), broken down by language and by whether the sample has a watermark.

WER is not meaningful for Chinese/Japanese without a word segmenter — both languages have no whitespace word boundaries. CER is the reliable metric across all languages here.

Baselines: GeekLink vs. PaddleOCR vs. EasyOCR vs. Tesseract

All engines are scored the same way: raw output, no post-filtering or cropping — every text region the engine detects is concatenated and scored against the single-line ground truth, exactly what eval.py would do with any prediction file you hand it. This is not each tool's product-level accuracy (a real product adds subtitle-region selection on top) — it's meant to isolate the underlying detection+recognition difficulty, especially the watermark-interference case.

What "GeekLink" means here: GeekLink's local OCR is built directly on PaddleOCR's official pre-trained weights (PP-OCRv4/PP-OCRv5, converted to ONNX and CoreML for local inference) — not a custom-trained model. We're in the process of collecting real correction data to eventually fine-tune our own detection/recognition models, but haven't shipped one yet. So "GeekLink" in this table is really "PaddleOCR's official weights, an older version, run through ONNX Runtime or CoreML" — see the Apple Silicon section below for why that's not quite the same as the paddleocr pip package's numbers.

Versions: PaddleOCR = official paddleocr pip package v3.7.0. PP-OCRv6 ships three size tiers (tiny/small/medium); the tier only affects en/es/ja/zh — ko/el aren't covered by PP-OCRv6 yet and always run on PP-OCRv5 regardless of tier. EasyOCR = official easyocr pip package (PyTorch); Tesseract = tesseract-ocr 5.x via pytesseract, no image preprocessing; GeekLink = PP-OCRv5 ONNX/CoreML weights (PP-OCRv4 for Japanese specifically). EasyOCR has no Greek (el) language pack, so its el rows are excluded rather than scored as zero.

engine overall CER overall WER clean CER watermark CER ms/image (CPU)
PP-OCRv6 medium 0.5966 0.6208 0.4509 1.2722 1398.6
PP-OCRv6 small 0.5989 0.6323 0.4481 1.2984 381.0
GeekLink (CoreML) 0.6093 0.7291 0.4599 1.3019 97.3 (see Apple Silicon below)
GeekLink (ONNX/CPU) 0.6098 0.7235 0.4641 1.2855 564.3
EasyOCR 0.6220 0.9425 0.4834 1.2855 591.1
PP-OCRv6 tiny 0.6579 0.6708 0.5069 1.3582 169.4
Tesseract 0.9463 1.2275 0.8883 1.2156 106.4

Speed is wall-clock per image on the same machine (Apple Silicon), CPU execution provider, averaged over 50 English samples, model load time excluded (one warm-up call before timing). Tesseract's speed isn't comparable to the others — it has no scene-text detection stage, so it's doing far less work (and scoring far worse for it).

PP-OCRv6 medium and small are statistically tied (0.5966 vs 0.5989 CER — a 0.4% relative difference, within noise) for 3.7x the latency (1399ms vs 381ms) — medium doesn't buy anything on this benchmark. Tiny is dramatically faster (169ms) but loses a lot specifically on Japanese — the "one model for 50 languages" tradeoff seems to bite hardest on CJK scripts at the smallest size. For a real product, small is the sweet spot, not the medium default.

Per-language CER:

lang v6-tiny v6-small v6-medium GeekLink (CoreML) EasyOCR Tesseract
en 0.4415 0.4362 0.4312 0.4515 0.4497 0.7735
es 0.4300 0.4324 0.4290 0.4456 0.4658 0.7442
el 0.4654 0.4654 0.4654 0.4941 n/a 0.7872
ja 1.4607 0.8414 0.8462 0.7711 0.7795 1.2050
ko 0.8672 0.8672 0.8672 0.9511 0.8727 1.3852
zh 1.3252 1.3518 1.3416 1.2720 1.0887 1.6453

(el/ko are identical across PP-OCRv6 tiers since they always run PP-OCRv5, unaffected by the tier choice.)

Reproduce any row with python3 eval/eval.py --pred baselines/<file>.csv or --pred external_baselines/<file>.csv (paddleocr_medium.csv / paddleocr_tiny.csv / paddleocr_small.csv for the three PP-OCRv6 tiers).

Apple Silicon: using each engine's actual best backend

CPU-only numbers give a level cross-platform comparison, but they understate what you'd actually get on a Mac — GeekLink doesn't run ONNX Runtime CPU in production, it runs the same model weights through CoreML, and PyTorch (which EasyOCR is built on) has an Apple GPU backend (MPS) that isn't enabled by default. Re-running with each engine's real best-available backend on Apple Silicon:

engine backend ms/image overall CER
GeekLink (CoreML) Apple Neural Engine / GPU via CoreML 97.3 0.6093
EasyOCR (MPS) PyTorch Apple GPU backend 141.7 0.6220 (unchanged by backend)
Tesseract CPU only — no GPU backend exists 106.4 0.9463
PaddleOCR (any tier) CPU only — official PaddlePaddle has no Apple GPU/Metal backend 169–1399 0.597–0.658

GeekLink's CoreML path is 5.8x faster than its own ONNX/CPU number (564ms → 97ms) for essentially the same accuracy (0.6098 → 0.6093 CER — within normal float-precision noise between backends, not a real accuracy change) — CoreML lets the Apple Neural Engine and GPU do the work instead of the CPU. EasyOCR gets a real speedup too (591ms → 142ms) once MPS is enabled, though easyocr.Reader(gpu=True) isn't the default. PaddleOCR has no such option on this platform at all: we checked directly (paddle.device.is_compiled_with_mps doesn't exist, no custom device types registered) — the official paddlepaddle package is CPU-only on macOS regardless of which tier you pick.

On Apple Silicon specifically, GeekLink's CoreML path is the fastest option in this entire comparison — faster than Tesseract, which does far less work — while landing within a fraction of a percent of PP-OCRv6's raw accuracy. Reproduce with python3 eval/eval.py --pred baselines/geeklink_coreml.csv.

Not included (yet): dedicated subtitle-extraction tools whose local OCR engine is PaddleOCR itself, since a raw-recognition comparison would just reproduce the PaddleOCR rows above. What's genuinely different about several of those tools is that they ask the user to manually draw a crop box around the subtitle region per video, which sidesteps the watermark problem by construction rather than solving it algorithmically. That's a real and interesting comparison — manual region selection vs. automatic detection — just a different one than this raw-engine table, planned as a follow-up rather than blocking this release.

The headline finding: every engine loses roughly 2.6-2.9x accuracy on the watermark subset, regardless of how well it does on clean subtitles — PP-OCRv6 medium's CER goes from 0.45 to 1.27, GeekLink's from 0.46 to 1.30, EasyOCR's from 0.48 to 1.29. Watermark/overlay interference is a shared blind spot across every general-purpose OCR engine we tested here, not something specific to any one of them — raw text recognition quality barely matters once there's a second text region competing for the same space. Tesseract, which has no scene-text detection stage at all and just OCRs the whole frame as a document, is the outlier: consistently worst, as expected for a tool not built for this.

Note on CJK: WER > 1.0 for ja/ko/zh happens because raw concatenation of multiple detected lines (subtitle + watermark) produces far more "words" than the single-line ground truth when split naively — expected given the no-filtering methodology above, not a WER calculation bug.

Sources

License

  • Code (eval/) — MIT, see LICENSE.
  • Data (data/) — see LICENSE-DATA. The subtitle text is our own writing; two of the three source films are public domain, one is CC BY-SA and requires attribution (included above).

Citing

If this benchmark is useful in your work, a link back to geeklink.dev or this repo is appreciated.