README.md

---
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

```python
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](https://huggingface.co/datasets/harsha-desaraju/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](https://huggingface.co/datasets/harsha-desaraju/telugu-book-line-images),
which are line crops segmented from scanned Telugu book PDFs.

Built with `pipelines/label/consensus_labelling.py` from
[TeluguOCR](https://github.com/harsha-desaraju/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

```bibtex
@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}
}
```