sdcb/simdpaddleocr-dataset-v1

SimdPaddleOCR Synthetic OCR Benchmark v1

A compact, deterministic, bilingual (Chinese + English) synthetic OCR set: 100 JPEGs, 1,036 text lines, about 26,456 characters.

Fixed-seed regression images for a PaddleOCR-style detect → classify → recognize pipeline. Official accuracy metrics: Exact lines, Exact CLS, and CER. The same images also work for latency benches.

Generator: Sdcb.SimdPaddleOCR.TestData in sdcb/SimdPaddleOCR, seed 20260830.

Mirrors: Hugging Face · ModelScope

中文简介

固定种子生成的中英合成评测集，用来回归 PaddleOCR 式检测 + 方向分类 + 识别流水线。 官方正确率三项：Exact lines（行级精确匹配）、Exact CLS（方向分类）和 CER（字符错误率）。 同一批图也可以用来测耗时。

Preview

img-001.jpg — mixed English / Chinese, dark background, includes a vertical line.

Load

from datasets import load_dataset

ds = load_dataset("sdcb/simdpaddleocr-dataset-v1", split="test")
print(ds[0]["image_id"], ds[0]["line_count"])
print(ds[0]["full_text"])
ds[0]["image"]  # PIL.Image

ModelScope:

from modelscope.msdatasets import MsDataset

ds = MsDataset.load("sdflysha/simdpaddleocr-dataset-v1")

Drop-in folder for SimdPaddleOCR benchmarks (img-*.jpg + metadata.json):

dotnet run --project test/Sdcb.SimdPaddleOCR.Tests -c Release -- --benchmark --input <clone>/dataset

Dataset stats

• Images: 100 (img-001.jpg … img-100.jpg), JPEG quality 95
• Text lines: 1,036 (about 6–16 per image, mean 10.36)
• Characters: 26,456
• Unique text templates: 30 (sampled with replacement)
• Canvas: width 640–1792 px (mean 1233), height 480–1392 px (mean 928)
• Languages: Chinese and English, including mixed lines and digits
• Orientation (world-space draw): 0° × 628, 180° × 223, −90° × 100, 90° × 85
• Required CLS after DET unwarp (cls_degrees): 0° × 728, 180° × 308
• Fonts used at render time (files are not redistributed): arial.ttf, calibri.ttf, times.ttf, segoeui.ttf, consola.ttf, simhei.ttf, msyh.ttc, simsun.ttc
• Each JPEG has a SHA-256 in metadata.json

Single split: test.

Annotation schema

Each parquet row is one image.

Field	Type	Notes
image_id	string	img-001
image	image	original JPEG bytes
width, height	int32	pixel size
background_rgb	uint8[3]	canvas tint
sha256	string	SHA-256 of the JPEG file
lines	list	line-level ground truth
line_count	int32	len(lines)
full_text	string	texts joined with \n in stored order

Each lines[] item:

Field	Type	Notes
text	string	ground-truth transcription
bbox	int32[4]	axis-aligned [x0, y0, x1, y1], top-left origin
natural_width_at_height_48	int32	rendered width if the line height were 48 px (REC width hint)
angle_degrees	float32	in-plane tilt, about −20° to +20°
orientation_degrees	int32	world-space draw: 0, 90, -90, or 180
cls_degrees	int32	required CLS after DET unwarp: 0 or 180
font	string	font file name, e.g. arial.ttf
font_size	int32	pixel size used by SkiaSharp
color_rgb	uint8[3]	ink color

bbox is the axis-aligned box after rotation ([x0, y0, x1, y1]). Rotated or vertical text therefore occupies a larger rectangle than the ink.

cls_degrees is the 0/180 label the classifier should emit after DET perspective unwarp (and the 90° CW vertical-line correction). Map from orientation_degrees: 0 → 0, 180 → 180, 90 → 180, −90 → 0.

The same records live in dataset/metadata.json for tools that do not use datasets.

Official accuracy metrics

Three accuracy numbers are official. They are defined by BenchSummary and mirrored in scripts/evaluate.py.

Exact lines and CER are line-text only. Ground truth is the text strings in metadata.json. Predicted lines and GT lines are compared as unordered multisets (order and boxes do not matter). Extra predictions that never match a GT line are ignored.

Exact CLS is a separate orientation score on cls_degrees.

1. Exact lines

A GT line is exact when some remaining predicted string is identical (Unicode code points, no trim / case fold). That prediction is then consumed and cannot match another GT line.

exact_lines      = number of consumed identical pairs
exact_line_rate  = exact_lines / total_gt_lines

This is the strict score: one missing character, a full-width digit, or a split/merge of a line all count as a miss.

2. Exact CLS

A predicted line is paired to a GT line, then its applied rotation (0 or 180) is compared to cls_degrees. Prefer AABB IoU ≥ 0.3 when predicted boxes are present; otherwise pair by exact text. DET misses (unpaired GT lines) are excluded from the denominator.

exact_cls       = paired lines whose rotation == cls_degrees
cls_total       = paired lines
exact_cls_rate  = exact_cls / cls_total

Text-only prediction files without rotations report exact_cls=n/a.

3. CER

For every GT line that was not an exact match, take the minimum Levenshtein distance to the remaining predictions (the closest leftover string; that leftover is not consumed). If nothing is left, the distance is the GT line length. Sum those distances.

CER       = sum(min_edit_distance) / total_gt_characters
char_acc  = 1 - CER

CER is the soft score. It still credits a line that is almost right (128.50 vs 128.5, one wrong CJK character, etc.).

Alongside the three scores

Number	Meaning
char_acc	1 - CER
exact_img	Images whose every GT line was an exact match

orientation_degrees is render metadata. Official CLS uses cls_degrees. Detection IoU is only used to pair CLS, not to score DET.

Latency (mean ms/image, images/s) is a separate bench on the same files.

The SimdPaddleOCR CLI skips img-001.jpg as warmup and reports n = 99 (1,026 lines). This Hub dataset ships all 100 images / 1,036 lines. State which cut you used.

Reference implementation

# Same pairing rules as BenchSummary.ComputeAccuracy / ScoreCls
def score_image(gt_lines: list[str], pred_lines: list[str]):
    remaining = list(pred_lines)
    exact = errors = chars = 0
    for expected in gt_lines:
        chars += len(expected)
        if expected in remaining:
            remaining.remove(expected)
            exact += 1
            continue
        best = len(expected)
        for actual in remaining:
            best = min(best, levenshtein(expected, actual))
        errors += best
    return exact, len(gt_lines), errors, chars

python scripts/evaluate.py predictions.json --metadata dataset/metadata.json

predictions.json may be { "img-001.jpg": ["...", "..."] }, { "img-001.jpg": { "texts": [...], "rotations": [...], "boxes": [...] } }, or a SimdPaddleOCR bench JSON (rows[].file / rows[].texts / rows[].rotations).

Reported baseline

SimdPaddleOCR sharp engine, PP-OCRv6 small, 4 workers, boxThreshold=0.4, Ryzen 7 5800X, 2026-09-05 (warmup excluded, n=99):

• Exact lines: 940 / 1,026 (91.62%)
• CER: 0.61% (char_acc 99.39%)
• Exact images: 43 / 99 (derived)

SimdPaddleOCR 1.4.2 sharp engine, PP-OCRv6 tiny, 4 workers, full 100 images (no warmup skip), boxThreshold=0.4:

• Exact CLS: 1,022 / 1,022 (100%) when DET pairs the line

How it was generated

dotnet run --project test/Sdcb.SimdPaddleOCR.TestData -c Release -- --out dataset

• Global seed 20260830; image i uses Random(20260830 + i)
• SkiaSharp render → JPEG quality 95
• 10 background tints (6 light / 4 dark) plus low-resolution noise
• About 20% vertical lines, about 25% of horizontal lines also rotated 180°
• Longer templates are oversampled so some lines exceed 320 px at 48 px height (dynamic REC width)

Rebuild the parquet after changing dataset/:

pip install datasets pillow pyarrow
python scripts/build_parquet.py

Limitations

• Synthetic only: no scans, handwriting, perspective, blur, or photographs
• Only 30 text templates; vocabulary is narrow and domain-specific
• Bounding boxes are AABB, not polygons
• Rendered with Windows / CJK system fonts; font binaries are not included
• Too small to train a general OCR model

Good for engine comparison, regression, and long / rotated / vertical lines. ICDAR, FUNSD, and in-the-wild sets cover real documents; this set does not replace them.

License

Apache License 2.0, same as SimdPaddleOCR.

Images were rasterized from system fonts (Arial, Calibri, Times New Roman, Segoe UI, Consolas, SimHei, Microsoft YaHei, SimSun). Font binaries stay with the OS; this repo only ships the JPEGs.

Citation

@misc{simdpaddleocr-dataset-v1,
  title        = {SimdPaddleOCR Synthetic OCR Benchmark v1},
  author       = {Sdcb},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/sdcb/simdpaddleocr-dataset-v1}},
  note         = {Generated by Sdcb.SimdPaddleOCR.TestData, seed 20260830}
}

See also the engine repository: https://github.com/sdcb/SimdPaddleOCR