Datasets:

harsha-desaraju
/

consensus-labelling

license: other
dataset_info:
  features:
    - name: line_image
      dtype: image
    - name: file_name
      dtype: string
    - name: page_number
      dtype: int64
    - name: image_width
      dtype: int64
    - name: pred_model
      dtype: string
    - name: pred_paddle
      dtype: string
    - name: tier
      dtype: int64
    - name: tier_reason
      dtype: string
    - name: consensus_text
      dtype: string
    - name: has_english
      dtype: bool
    - name: english_frac
      dtype: float64
    - name: disagree_model_tesseract
      dtype: float64
    - name: disagree_model_paddle
      dtype: float64
    - name: disagree_tesseract_paddle
      dtype: float64
    - name: pred_tesseract
      dtype: string
  splits:
    - name: train
      num_bytes: 9994108648
      num_examples: 2442885
  download_size: 9232274883
  dataset_size: 9994108648
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*
task_categories:
  - image-to-text
language:
  - te
tags:
  - ocr
  - telugu
  - pseudo-labelling
  - weak-supervision
size_categories:
  - 1M<n<10M

Telugu line images with three-engine OCR consensus

2.44 million single-line crops from scanned Telugu books, each read independently by three OCR engines, with a label saying how much those engines agreed.

Telugu has almost no labelled OCR data. This dataset is an attempt to manufacture some: run several recognisers over a large pile of real book scans and keep track of where they corroborate each other. Where all three read the same thing, you have a usable training pair without anyone transcribing it by hand. Where they disagree, you have a shortlist worth a human's attention.

Crops are grayscale, 64px tall, width a multiple of 8.

What's in a row

column	meaning
`line_image`	the line crop
`pred_model`	reading from our Telugu CTC recogniser
`pred_tesseract`	reading from Tesseract
`pred_paddle`	reading from PaddleOCR
`tier`	1–4, how strongly the engines agreed (0 = unusable row)
`tier_reason`	which engines agreed
`consensus_text`	the agreed text — empty when all three disagreed
`has_english`, `english_frac`	whether `pred_model` contains Latin letters, and how much
`disagree_model_tesseract`, `disagree_model_paddle`, `disagree_tesseract_paddle`	how far apart each pair of engines was, 0–1
`file_name`, `page_number`, `image_width`	provenance, carried over from the source dataset: which book PDF and page the crop came from, and its pixel width

The tiers

tier	what it means
1	all three engines agree — the strongest signal in the dataset
2	Tesseract and PaddleOCR agree, our model differs
3	our model and PaddleOCR agree, Tesseract differs
4	our model and Tesseract agree, or all three differ
0	an engine errored, or every reading was empty. A handful of rows

Two engines returning nothing on an unreadable crop is not counted as agreement — that would fill tier 1 with rows labelled with the empty string. Agreement is also compared after light normalization (punctuation folded, whitespace collapsed, invisible joiners removed), because Telugu has many sequences that look identical but differ in codepoints, and raw string equality badly understates how often the engines actually concur. The raw predictions are all kept, so nothing is lost.

On an early 50,000-row sample, all three engines agreed on roughly 3% of lines and at least two agreed on roughly 15%. Expect that order of magnitude, but compute it on the full set rather than trusting these figures.

Using it

from datasets import load_dataset

ds = load_dataset("harsha-desaraju/consensus-labelling", split="train")

# Strictest: all three engines agree
gold = ds.filter(lambda r: r["tier"] == 1)

# Anything at least two engines corroborated
usable = ds.filter(lambda r: r["consensus_text"] != "")

# Telugu only, no embedded English
telugu = ds.filter(lambda r: not r["has_english"])

# A review queue: where our model and PaddleOCR diverge most
review = ds.sort("disagree_model_paddle", reverse=True).select(range(5000))

Train on consensus_text — it's already normalized. Nothing has been filtered out of the dataset itself, so how strict you want to be is your decision, not one baked in at build time.

Please read this before you use it

These are not verified labels. No human checked any of them. Three engines agreeing means a reading is corroborated, not that it is correct — recognisers make the same mistakes as each other, and consensus promotes exactly those errors to tier 1.

The disagree_* columns are not error rates. They measure how far two engines are from each other, not from the truth. There is no truth in this file.

So: this is training data and a triage tool. It is not a benchmark. Scoring a model against these labels mostly rewards agreeing with these three engines — and one of the three is our own model, so it rewards agreeing with that in particular. For evaluation, use a human-checked set such as telugu-line-ocr-bench.

Limitations

Tier 1 is easy-biased. Lines all three engines agree on are disproportionately clean, short, and well printed. Training only on tier 1 gives a model an easier world than the corpus really is.
has_english reflects our model's opinion, since it is derived from pred_model.
One narrow domain: printed Telugu book scans from a single collection. No handwriting, no signage, no born-digital text.
consensus_text is normalized, so it won't reproduce a page's exact punctuation.

Where it comes from

Every image in telugu-book-line-images, which are line crops segmented from scanned Telugu book PDFs.

Built with pipelines/label/consensus_labelling.py from TeluguOCR. PaddleOCR runs recognition-only — the inputs are already single lines, and letting it re-detect boxes inside a 64px strip returns fragments out of reading order.

Citation

@misc{telugu_consensus_labelling,
  title  = {Telugu line images with three-engine OCR consensus},
  author = {Desaraju, Harsha},
  year   = {2026},
  url    = {https://huggingface.co/datasets/harsha-desaraju/consensus-labelling}
}