bhumika-tewari-282006/assistive-ocr-benchmark-results

Assistive OCR — Benchmark Results

Real, reproducible benchmark results for the assistive OCR wearable module (offline, multilingual — English, Bengali+English, Hindi+English). This repository is self-contained: it holds the results, the ground-truth manifest, and the 98 real images they were computed from, so it can be run and demoed directly with no other dataset needed. (The same images are also published at Arko007/assistive-ocr-data-acquisition, folder manual_verification_99/, if you ever need to cross-check provenance.)

What's in this repository

File	What it is
manual100_final.csv	The 99-row ground-truth manifest: id, image_path, language_profile, domain, manual_transcript (each transcript individually re-checked by hand, not auto-generated)
phase4_engine_comparison.json	Full per-image, per-engine results for an isolated (no cross-engine fallback) comparison of Tesseract, EasyOCR, and PaddleOCR against every row in the manifest
images/	The 98 real images (medicine packaging, packaged goods, signage) the manifest and benchmark are computed from — one manifest row (the excluded QR-code junk sample) has no image, by design

Headline results

Isolated per-engine comparison across all 99 manually-verified images (lenient pass = at least one clinically/contextually meaningful word correctly recovered):

Engine	Attempted	Pass rate	Mean keyword recall	Bengali support
Tesseract	99/99	71.7%	43.2%	Yes
EasyOCR	99/99	91.9%	62.7%	Yes
PaddleOCR	65/99 (34 skipped)	90.8% (of attempted)	72.5% (of attempted)	No

Conclusion: EasyOCR remains the primary engine and Tesseract the confidence-gated fallback. PaddleOCR cannot process Bengali+English at all (no Bengali in its published model matrix), and even restricted to the languages it does support, it does not meaningfully outperform EasyOCR — so it was evaluated but not adopted. Full reasoning and the fair same-language-subset comparison are in the project's PROJECT_STATUS.md (2026-07-31 entry) and docs/PROJECT_REPORT.md in the main code repository.

Reproducing this benchmark yourself on Kaggle

You don't need your own computer to be powerful for this — Kaggle gives you a free notebook with everything already installed. Here's the simplest path, in order.

Step 1 — Start a new Kaggle notebook

Go to kaggle.com/code → New Notebook. In the right-hand sidebar, turn on Internet (Settings → Internet → On) so the notebook can install packages and clone the code.

Step 2 — Add this dataset as a notebook input

Click Add Input (top right) and search for this dataset (assistive-ocr-benchmark-results), then add it. Everything you need — the manifest, the images, the prior results — comes in with it, under /kaggle/input/assistive-ocr-benchmark-results/. No second dataset to add.

Step 3 — Install the OCR engines (one notebook cell)

!apt-get -qq update && apt-get -qq install -y tesseract-ocr tesseract-ocr-ben tesseract-ocr-hin
!pip install -q "assistive-ocr[tesseract,easyocr] @ git+https://github.com/Bhumika2006-hue/ocr-wearable-module.git"

Step 4 — Point the manifest at the real image paths (one notebook cell)

The manifest's image_path column is relative (e.g. hf_medicines/...); this cell rewrites it to the actual Kaggle input location so the benchmark can find each image:

import csv, pathlib

IMAGE_ROOT = pathlib.Path("/kaggle/input/assistive-ocr-benchmark-results/images")
MANIFEST_IN = "/kaggle/input/assistive-ocr-benchmark-results/manual100_final.csv"
MANIFEST_OUT = "/kaggle/working/manifest.csv"

rows = list(csv.DictReader(open(MANIFEST_IN, encoding="utf-8")))
for row in rows:
    row["image_path"] = str(IMAGE_ROOT / pathlib.Path(row["image_path"]).name)

with open(MANIFEST_OUT, "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print(f"Wrote {len(rows)} rows to {MANIFEST_OUT}")

Step 5 — Run the benchmark (one notebook cell per engine)

!assistive-ocr-benchmark /kaggle/working/manifest.csv --engine tesseract --output /kaggle/working/tesseract_results.json
!assistive-ocr-benchmark /kaggle/working/manifest.csv --engine easyocr   --output /kaggle/working/easyocr_results.json

(Add --engine paddleocr too if you also want to reproduce the PaddleOCR comparison — it needs one extra install: !pip install -q paddlepaddle==2.6.2 paddleocr==2.7.3 "numpy<2" before running.)

Step 6 — Look at the results

import json

for name in ("tesseract", "easyocr"):
    data = json.load(open(f"/kaggle/working/{name}_results.json"))
    print(name, "->", data["summary"])

Each engine's run produces per-image records plus a summary broken down by language_profile::domain (word/character error rate, exact-match rate, keyword recall, latency, calibration error). Compare this against the headline table above — it should reproduce those numbers, since both were run from the exact same manifest and images.

If something doesn't match

• Different Tesseract/EasyOCR versions than the ones the project pinned can shift numbers slightly (a percentage point or two) — this is expected, not a bug.
• If a row errors out instead of producing a number, check that Step 4 actually found the image files (print(rows[0]) after loading the manifest to sanity-check a resolved path exists with pathlib.Path(...).exists()).
• The full setup/troubleshooting guide (for running the whole assistive OCR app, not just this benchmark) is in docs/SETUP_GUIDE.md in the main code repository.