Indra OCR v1.1.0

.gitattributes

@@ -46,3 +46,5 @@ assets/examples/chinese_essay.png filter=lfs diff=lfs merge=lfs -text
 assets/examples/multi_column.png filter=lfs diff=lfs merge=lfs -text
 assets/examples/rotated_letter.png filter=lfs diff=lfs merge=lfs -text
 assets/examples/table_pmc.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/handwriting_letter.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/korean_letter.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -12,12 +12,55 @@ language:
   - pt
   - nl
   - pl
+  - cs
+  - sk
+  - ro
+  - hu
+  - sv
+  - da
+  - no
+  - fi
+  - tr
+  - az
+  - uz
+  - vi
+  - id
+  - ms
+  - sw
+  - ha
+  - yo
   - ru
   - uk
+  - bg
+  - sr
   - el
+  - zh
+  - ja
+  - ko
+  - ar
+  - fa
+  - ur
+  - ps
+  - he
   - hi
+  - mr
+  - ne
   - bn
-  - zh
+  - ta
+  - te
+  - kn
+  - ml
+  - gu
+  - pa
+  - or
+  - th
+  - lo
+  - km
+  - my
+  - si
+  - ka
+  - hy
+  - am
 tags:
   - ocr
   - onnx
@@ -26,6 +69,8 @@ tags:
   - markdown
   - layout
   - document-parsing
+  - handwriting
+  - multilingual
 ---
 
 <p align="center">
@@ -51,16 +96,16 @@ tags:
 
 # Indra OCR
 
-Indra OCR is a 1M-parameter OCR model that reads up to 49 pages per second on CPU. It turns PDFs and images into markdown, plain text, or JSON with boxes, and it has these features:
-
-- Throughput - 49 pages/s, 11-17x faster than Tesseract and PaddleOCR on the same machine and pages ([table](#throughput))
-- Latency - ~230 ms per page on 4 x86 vCPUs, 12-24x faster than Tesseract and PaddleOCR
-- Accuracy - scores 41.3 on [OmniParseBench](https://github.com/datalab-to/omni_parse_bench) text, ahead of PaddleOCR's PP-OCR text models (35.8) and Tesseract (19.3). Its headline score (62.1) beats PaddleOCR's full PP-StructureV3 pipeline (58.4).
-- Layout and boxes - a bounding box for every line and every layout block, with block labels (headings, lists, tables, captions, footnotes, page headers) and reading order
-- Digital PDFs - reads the PDF's own text layer in any script, and OCRs only what is missing
-- Small - about 18 MB of models on ONNX Runtime, no PyTorch
+Indra OCR is a 1M-parameter OCR model that runs on CPU. It turns PDFs and images into markdown, text, or JSON with boxes, and it reads handwriting, 80+ languages, and pages at any angle.
 
-The main recognizer, `rec.onnx`, has about 1M parameters. See [benchmarks](#benchmarks) for the full results and [limitations](#limitations) for what it does not do yet.
+- **Accurate** - 66.7 on [OmniParseBench](https://github.com/datalab-to/omni_parse_bench) (71.4 with `--math`), ahead of PaddleOCR's full PP-StructureV3 pipeline (58.4). Its text score (46.7) is ahead of PaddleOCR's PP-OCR text models (35.8) and Tesseract (19.3).
+- **Fast** - about 44 pages/s on 32 CPU cores, 15x Tesseract and 10x PaddleOCR's PP-OCR text models on the same machine type and pages, and about 210 ms per page on 4 cores ([benchmarks](#benchmarks))
+- **80+ languages** - Latin-script languages, Russian and the Cyrillic languages, Greek, Chinese, Japanese, Korean, Arabic, Persian, Urdu, Hebrew, Hindi and the Indic languages, Thai, Khmer and more ([languages](#languages))
+- **Handwriting** - handwritten pages and forms (25.2% on the OmniParseBench handwriting tests, see [limitations](#limitations))
+- **Real-world scans** - sideways, upside down, tilted up to 45 degrees, light text on dark ground
+- **Layout** - a box, a label and a reading order for every line and block (headings, lists, tables, captions, footnotes, page headers)
+- **Digital PDFs** - reads the text layer in any script, and OCRs only what is missing
+- **Small** - ONNX Runtime, no PyTorch, no GPU
 
 Indra OCR is named for [Indra](https://en.wikipedia.org/wiki/Indra).
 
@@ -72,7 +117,7 @@ Indra OCR is built for speed on CPUs. When you need the highest accuracy, on han
 
 If you have high volume workloads, we offer a batch processing service that can handle 1B+ pages a day.
 
-Get started with **$5 in free credits** - [sign up](https://www.datalab.to/?utm_source=gh-indra) - or try Chandra in our [public playground](https://www.datalab.to/playground?utm_source=gh-indra).
+Get started with **$5 in free credits** - [sign up](https://www.datalab.to/?utm_source=hf-indra-ocr) - or try Chandra in our [public playground](https://www.datalab.to/playground?utm_source=hf-indra-ocr).
 
 ## Quickstart
 
@@ -86,7 +131,7 @@ indra-ocr scan.png --format json       # lines, boxes, layout blocks, confidence
 indra-ocr-viewer                       # local web viewer on http://localhost:8765
 ```
 
-The first run downloads the models (about 18 MB) from [Hugging Face](https://huggingface.co/datalab-to/indra-ocr).
+The first run downloads the models (about 76 MB) from [Hugging Face](https://huggingface.co/datalab-to/indra-ocr).
 
 ## Examples
 
@@ -94,8 +139,8 @@ Real Indra OCR outputs on OmniParseBench pages. Colored boxes are layout blocks
 
 <table>
 <tr>
-<td width="50%"><img src="assets/examples/rotated_letter.png"/><br/><sub>Scanned upside down: Indra OCR turns the page upright, reads both columns in order and finds the headings.</sub></td>
-<td width="50%"><img src="assets/examples/table_pmc.png"/><br/><sub>A journal page with two tables, output as HTML with their captions.</sub></td>
+<td width="50%"><img src="assets/examples/handwriting_letter.png"/><br/><sub>A handwritten letter in cursive: Indra OCR finds every line and reads the body of the letter.</sub></td>
+<td width="50%"><img src="assets/examples/korean_letter.png"/><br/><sub>A scanned Korean letter: each line goes to the recognizer for its script.</sub></td>
 </tr>
 </table>
 
@@ -108,7 +153,7 @@ The code is [Apache 2.0](https://github.com/datalab-to/indra/blob/main/LICENSE).
 
 # Commercial usage
 
-This code is Apache 2.0, and our model weights use a modified OpenRAIL-M license (free for research, personal use, and startups under $20M funding/revenue, cannot be used competitively with our API). To remove the OpenRAIL license requirements, or for broader commercial licensing, visit our pricing page [here](https://www.datalab.to/pricing?utm_source=gh-indra).
+This code is Apache 2.0, and our model weights use a modified OpenRAIL-M license (free for research, personal use, and startups under $20M funding/revenue, cannot be used competitively with our API). To remove the OpenRAIL license requirements, or for broader commercial licensing, visit our pricing page [here](https://www.datalab.to/pricing?utm_source=hf-indra-ocr).
 
 # Installation
 
@@ -116,7 +161,11 @@ This code is Apache 2.0, and our model weights use a modified OpenRAIL-M license
 pip install indra-ocr
 ```
 
-Python 3.10 or newer. It installs ONNX Runtime, OpenCV and pypdfium2, and no PyTorch. The models download from Hugging Face on the first run and are cached. To use a local copy, set `INDRA_OCR_MODEL_DIR` or pass `--model-dir`.
+The default models are about 76 MB: 30 MB of networks and 46 MB of language models for unsure lines. The main recognizer, `rec.onnx` (Latin script), has about 1.25M parameters, and all default models together have 7.3M (the optional math models are extra).
+
+For the latest code from GitHub instead: `pip install git+https://github.com/datalab-to/indra.git`. To let the viewer compare with Tesseract, install `pip install "indra-ocr[tesseract]"` and a Tesseract binary.
+
+Python 3.10 or newer, tested on Linux (x86_64 and aarch64, Python 3.10 to 3.13) and macOS (Apple silicon). It installs ONNX Runtime, OpenCV and pypdfium2, and no PyTorch. The models download from Hugging Face on the first run and are cached. To use a local copy, set `INDRA_OCR_MODEL_DIR` or pass `--model-dir`.
 
 # Usage
 
@@ -137,7 +186,6 @@ indra-ocr paper.pdf --math                # write math as LaTeX (off by default;
 - `--out DIR`: write one file per input (`.md`, `.txt` or `.jsonl`)
 - `--format [md|text|json]`: output format (default: md)
 - `--mode [auto|ocr|text]`: `auto` reads the text layer where it passes the checks and OCRs elsewhere (default). `ocr` never reads the text layer. `text` uses the text layer even when the checks fail
-- `--model-order`: order text-layer lines with the order model, not the PDF content order
 - `--no-image-ocr`: on text-layer pages, do not OCR text inside images
 - `--cores N`: cores to use, one worker process each (default: all usable cores)
 - `--dpi`: render resolution for PDFs (default: 200)
@@ -163,6 +211,23 @@ for i, page in conv.convert("paper.pdf"):
     page.lines                            # [Line(box, text, conf)] in reading order
 ```
 
+An image file works the same way as a PDF (PNG, JPEG, TIFF, BMP, WebP; one page per TIFF frame). For an image already in memory, pass a grayscale `uint8` numpy array to `conv.ocr`:
+
+```python
+import cv2
+import indra_ocr
+
+conv = indra_ocr.load(threads=4)
+for i, page in conv.convert("scan.png"):  # an image file
+    print(page.text)
+
+gray = cv2.cvtColor(cv2.imread("photo.jpg"), cv2.COLOR_BGR2GRAY)
+page = conv.ocr(gray)                     # an image in memory
+print(page.markdown)
+```
+
+Runnable examples: [`examples/ocr_image.py`](https://github.com/datalab-to/indra/blob/main/examples/ocr_image.py) (one image to markdown, text or JSON with boxes) and [`examples/quickstart.ipynb`](https://github.com/datalab-to/indra/blob/main/examples/quickstart.ipynb).
+
 For many pages or files, `convert_many` runs one single-threaded worker process per core, one page per task, and returns results in input order:
 
 ```python
@@ -178,7 +243,7 @@ if __name__ == "__main__":                # worker processes re-import this file
 
 Without the `if __name__ == "__main__":` guard (needed on macOS and Windows), `convert_many` warns and reads everything in one process.
 
-`indra_ocr.load` takes `path` (model folder), `threads`, `dpi`, `mode`, `pdf_order`, `image_ocr`, `furniture` and `math`. `conv.convert` takes `max_pages` and `password`.
+`indra_ocr.load` takes `path` (model folder), `threads`, `dpi`, `mode`, `image_ocr`, `furniture` and `math`. `conv.convert` takes `max_pages` and `password`.
 
 ## Viewer
 
@@ -198,6 +263,7 @@ Every page is a `Page` with:
 - `blocks`: layout blocks in reading order, `{"label", "bbox", "text"}`
 - `source`: `text` (PDF text layer), `ocr`, `hybrid` (text layer + OCR of text inside images) or `error`
 - `rotation`, `skew`: the quarter or half turn applied (degrees), and the small tilt straightened
+- `vertical`: the page is set in vertical columns (Chinese, Japanese): it was read turned a quarter turn, and its boxes are on the page as it is
 - `timings`: per-step milliseconds, with `total_ms`
 - `note`: why the page took its path
 
@@ -205,7 +271,33 @@ Block labels: `Text`, `Section-Header`, `Page-Header`, `Page-Footer`, `List-Grou
 
 # Languages
 
-**OCR (scans and images):** Latin (about 50 languages), Cyrillic, Greek, Devanagari, Bengali, and Chinese (simplified and traditional). Each line with Chinese characters goes to the Chinese recognizer.
+**OCR (scans and images):** we measured 95 languages on held-out printed pages: 83 read at character F1 0.90 or higher, and 67 at 0.95 or higher. Four recognizers, and a line classifier that sends each line to one of them:
+
+- `rec.onnx`: Latin (about 50 languages, with the letters of Hausa, Fula, Akan, Azerbaijani and Uzbek and the tone marks of Vietnamese and Yoruba), Cyrillic, Greek, and handwriting in Latin script.
+- `rec_cjk.onnx`: Chinese (simplified and traditional), Japanese (kana and kanji), Korean.
+- `rec_rtl.onnx`: Arabic, Persian, Urdu, Pashto, Kurdish, Hebrew. Lines come out in logical order, and a right-to-left page reads its right column first.
+- `rec_world.onnx`: Devanagari (Hindi, Marathi, Nepali), Bengali, Tamil, Telugu, Kannada, Malayalam, Gujarati, Gurmukhi, Odia, Thai, Lao, Khmer, Myanmar, Sinhala, Georgian, Armenian, Ethiopic.
+
+When the classifier is not sure of a line, the main recognizer reads it too, and the more confident reading wins.
+
+OmniParseBench, per script (tests in parentheses):
+
+| Script | Score | Script | Score |
+|---|---|---|---|
+| Latin (9,406) | 61.6 | Thai (39) | 87.2 |
+| Chinese (136) | 64.0 | Lao (52) | 96.2 |
+| Korean (24) | 79.2 | Khmer (34) | 70.6 |
+| Japanese kana (19) | 57.9 | Tamil (25) | 84.0 |
+| Devanagari (23) | 69.6 | Telugu (33) | 87.9 |
+| Bengali (40) | 77.5 | Kannada (48) | 93.8 |
+| Arabic (13) | 69.2 | Malayalam (40) | 65.0 |
+| Hebrew (30) | 80.0 | Gujarati (15) | 80.0 |
+| Georgian (14) | 100 | Gurmukhi (31) | 64.5 |
+| Armenian (60) | 100 | Ethiopic (43) | 100 |
+
+Most scripts have few tests, so one test moves a score by 2 to 8 points. On [OmniDocBench](https://github.com/opendatalab/OmniDocBench) v1.5 (OCR only, 1,651 pages, our run without the formula metric), the text edit distance is 0.114 on English pages and 0.237 on simplified Chinese pages (lower is better), and table TEDS is 0.47.
+
+**Vertical text.** Chinese and Japanese pages set in vertical columns are read turned a quarter turn, so each column is a line for the CJK recognizer. Scans are found by the orientation model, digital PDFs by their text layer. `page.vertical` is set, and boxes are on the page as it is.
 
 **Text layer (digital PDFs): any script.** We checked text mode on 1,125 pages from 75 language families. On pages whose layer passes the checks, Indra OCR keeps at least 98% of the layer's characters in every family, including Arabic, Hebrew, Persian, Urdu, Thai, Khmer, Lao, Myanmar, Georgian, Armenian, Ethiopic, the Indic scripts, Chinese, Japanese and Korean. Right-to-left lines keep their right-to-left order.
 
@@ -214,18 +306,18 @@ Block labels: `Text`, `Section-Header`, `Page-Header`, `Page-Footer`, `List-Grou
 Indra OCR is built for speed on clean print. It is not the right tool for:
 
 - **Complex tables.** Tables with merged or spanning cells, cell text that wraps over several lines, nested headers, or no ruling lines can come out with cells in the wrong rows or columns. Simple grid tables read well.
-- **Handwriting.** Handwritten text is not supported (about 8% on the OmniParseBench handwriting tests).
-- **Scripts outside the OCR list.** OCR reads Latin, Cyrillic, Greek, Devanagari, Bengali and Chinese. Other scripts, including Arabic, Hebrew, Thai, Japanese kana and Korean Hangul, work only through a digital PDF's text layer. On scans and images they come out wrong; a Hangul line, for example, comes out as wrong Chinese characters.
-- **Degraded scans.** Old, faded or low-resolution scans read poorly (about 20% on the OmniParseBench old-scan tests).
+- **Handwriting.** Handwritten pages read, but not well: 25.2% on the OmniParseBench handwriting tests, and about a third of the words on held-out handwritten pages. Cursive and faint pencil read worst.
+- **Scripts outside the OCR list.** Syriac, Tibetan, Mongolian, Santali, Meitei and other scripts not listed under [Languages](#languages) work only through a digital PDF's text layer. Khmer and Malayalam OCR are fair (65 to 71 on OmniParseBench). Written Cantonese characters (嘅 咗 冇) are not in the Chinese recognizer.
+- **Latin languages with many diacritics.** Some of them (Kurmanji, Czech, Lithuanian, Icelandic, Turkish, Slovak) read less well: the recognizer sometimes writes a close diacritic instead of the right one (ñ for ň, ú for ů, é for ė). English, French, German and Spanish are not affected.
+- **Degraded scans.** Old, faded or low-resolution scans read poorly (29.5% on the OmniParseBench degraded-scan tests).
 
 Also:
 
 - Math comes out as plain text unless `--math` is on (see [Math](#math)).
-- No vertical text (such as traditional Chinese newspapers).
+- Vertical pages read their columns right to left and their tiers top to bottom; a newspaper whose articles wind across tiers can come out in the wrong article order. Vertical scans read less well than horizontal ones.
 - Very wide, banner-shaped pages read poorly.
 - Labels inside engineering drawings often come out as small tables.
 - Pages above 100 megapixels at 200 dpi render at a lower dpi, so small text on them can be lost.
-- The orientation model turns about half of the upright Arabic and Hebrew pages that go to OCR by mistake. Do not rely on it for those scripts.
 
 For these documents, [Chandra on Datalab](https://www.datalab.to/?utm_source=hf-indra-ocr) is the accurate option.
 
@@ -237,15 +329,13 @@ On OmniParseBench (all 2,937 pages, default settings otherwise):
 
 | | headline | text | tables | layout | math tests |
 |---|---|---|---|---|---|
-| Indra OCR | 62.1 | 41.4 | 56.4 | 88.5 | 14.3 |
-| Indra OCR `--math` | **66.8** | **57.5** | 54.8 | 88.1 | **56.5** |
+| Indra OCR | 66.7 | 46.7 | 61.1 | 92.2 | 14.0 |
+| Indra OCR `--math` | **71.4** | **62.7** | 59.6 | 92.0 | **55.8** |
 | PaddleOCR PP-StructureV3 | 58.4 | 55.6 | 47.8 | 71.7 | – |
 
 - With `--math`, Indra OCR is ahead of PaddleOCR's PP-StructureV3 on the headline, text, tables and layout. Without it, PP-StructureV3 leads on text.
 - Tables lose 1.5 points: numbers in some table cells are read as math.
-- `--math` is slower. On x86 (AMD EPYC Genoa), one page at a time on 4 cores in auto mode, the median page takes ~360 ms with `--math` and ~210 ms without. With one single-threaded worker per core, throughput is about 30% lower on 4 cores and 35% lower on 32 (4.8 vs 6.8 and 29.2 vs 44.9 pages/s, measured in one container on 300 OmniParseBench pages).
-- The cost falls on the pages where the math path runs. In auto mode, pages read through a digital PDF's text layer slow down most: their median time per page goes from 130 ms to 345 ms in the throughput run (one single-threaded worker per core).
-- Old scanned math gains little (22.2 to 23.1).
+- `--math` is slower. On x86, one page at a time on 4 vCPUs in auto mode, the median page takes 357 ms with `--math` and 212 ms without. With one single-threaded worker per core, throughput is about 30% lower on 4 cores and 38% lower on 32 (measured in one container on 300 OmniParseBench pages).
 
 The math models download only when `--math` is on.
 
@@ -259,20 +349,21 @@ The math models download only when `--math` is on.
 
 | engine | headline | text | tables | layout | median ms / page |
 |---|---|---|---|---|---|
-| Indra OCR (auto: text layer + OCR) | 62.1 | 41.3 | **56.4** | **88.6** | **228** |
-| Indra OCR (OCR only) | 57.5 | 33.5 | 50.9 | 88.2 | 303 |
-| Indra OCR `--math` (auto) | **66.8** | **57.5** | 54.8 | 88.1 | ~360† |
+| Indra OCR (auto: text layer + OCR) | 66.7 | 46.7 | **61.1** | **92.2** | **212** |
+| Indra OCR (OCR only)‡ | 61.2 | 40.7 | 52.7 | 90.3 | 344 |
+| Indra OCR `--math` (auto) | **71.4** | **62.7** | 59.6 | 92.0 | 357 |
 | PaddleOCR PP-OCRv6 small, text models only (RapidOCR) | – | 35.8 | 0.0 | – | 2,685 |
 | PaddleOCR PP-StructureV3 (2,918 pages\*) | 58.4 | 55.6 | 47.8 | 71.7 | 40,958 |
 | Tesseract 5 (our run, Latin model) | – | 19.3 | 0.0 | – | 5,496 |
 
+- Indra OCR's accuracy comes from the benchmark's own Indra OCR adapter and scorer (omni-parse-bench 1.0.0rc1, dataset revision 961c0f89), as on the OmniParseBench leaderboard. ‡The OCR-only row and the other engines come from our runs of the same pages and scorer. The median ms column comes from the x86 run below.
 - The PP-OCR text models and Tesseract output lines, not tables or layout blocks, so their table scores are 0 and their layout family is not scored.
-- PP-StructureV3 is PaddleOCR's full document pipeline (layout, tables, formulas). Without `--math`, it reads text better than Indra OCR (55.6 vs 41.3). With `--math`, Indra OCR is ahead on text too (57.5). It takes about 180 times as long per page as Indra OCR's default mode. \*One of its 150 shards stalled for 6 hours on its first page, so its row leaves out 19 pages.
-- Faster settings exist, but we did not score their accuracy. Tesseract with the `eng` model and 1 thread takes 3.4 s a page (6.1 s as run). PP-StructureV3 without formula, seal and chart recognition, unwarping and orientation, and with its mobile OCR models, takes 10.5 s a page. Indra OCR is still 15-45x faster per page.
+- PP-StructureV3 is PaddleOCR's full document pipeline (layout, tables, formulas). Without `--math`, it reads text better than Indra OCR (55.6 vs 46.7). With `--math`, Indra OCR is ahead on text too (62.7). It takes about 190 times as long per page as Indra OCR's default mode. \*One of its 150 shards stalled for 6 hours on its first page, so its row leaves out 19 pages.
+- Faster settings exist, but we did not score their accuracy. Tesseract with the `eng` model and 1 thread takes 3.4 s a page (6.1 s as run). PP-StructureV3 without formula, seal and chart recognition, unwarping and orientation, and with its mobile OCR models, takes 10.5 s a page. Indra OCR is still 16-50x faster per page.
 - The OmniParseBench leaderboard's own Tesseract run scores 17.6 on text.
-- Median latency varies by about 15% between runs of the same code. †The `--math` latency is from a separate run on x86 (AMD EPYC Genoa, 4 cores, one page at a time), where the default mode gave 208 ms.
+- Median latency varies by about 15% between runs of the same code, so compare engines within one run. The Indra OCR rows come from one run. The other engines ran earlier, on the same container type and pages.
 
-**Chinese** (136 OmniParseBench Chinese tests): Indra OCR 64.7, PaddleOCR PP-OCRv5 mobile Chinese text models 65.4, PP-StructureV3 68.4.
+**Chinese** (136 OmniParseBench Chinese tests): Indra OCR 64.0, PaddleOCR PP-OCRv5 mobile Chinese text models 65.4, PP-StructureV3 68.4.
 
 ## olmOCR-bench
 
@@ -290,28 +381,30 @@ Born-digital splits and old scans, our harness, 200 dpi:
 
 The CLI and `convert_many` run one single-threaded worker process per usable core, one page per task, so a single long PDF also uses every core. `--cores` limits it.
 
-Pages per second. Every engine ran on the same x86 machine (AMD EPYC, no GPU) on the same 300 OmniParseBench pages, with one single-threaded worker per core, OCR mode and default settings. Indra OCR is the mean of 3 runs. The other engines ran once.
+Pages per second on x86 (AMD EPYC 9004 Genoa, 34 cores, no GPU), on the same 300 OmniParseBench pages, with one single-threaded worker per core, OCR mode and default settings. The other engines ran once on the same machine type and pages.
 
 | engine | 4 cores | 8 cores | 16 cores | 32 cores |
 |---|---|---|---|---|
-| Indra OCR | **7.3** | **14.2** | **27.2** | **49.4** |
-| Indra OCR `--math`† | ~5 | – | – | ~30 |
+| Indra OCR | **6.2** | **11.9** | **23.7** | **43.9** |
 | PaddleOCR PP-OCRv6 small, text models only (RapidOCR) | 0.65 | 1.24 | 2.42 | 4.28 |
 | Tesseract 5 | 0.78 | 1.37 | 2.27 | 2.92 |
 | PaddleOCR PP-StructureV3\* | ≤ 0.022 | ≤ 0.044 | ≤ 0.089 | ≤ 0.18 |
 
-At 32 cores, Indra OCR is 11.5x PaddleOCR's PP-OCR text models, 16.9x Tesseract and about 280x PP-StructureV3 (against its upper bound). \*PP-StructureV3 ran a time-capped subset of the pages, so its numbers are upper bounds. †`--math` ran in a separate container with the same CPU type and the same pages, where it gave 4.8 pages/s on 4 cores and 29.2 on 32, against 6.8 and 44.9 without it (about 30% and 35% lower).
+At 32 cores, Indra OCR is 10x PaddleOCR's PP-OCR text models and 15x Tesseract. \*PP-StructureV3 ran a time-capped subset of other OmniParseBench pages in an earlier run, so its numbers are upper bounds.
+
+Throughput depends on the CPU: on other x86 container types we measured 25 to 51 pages per second at 32 cores.
 
-Model loading and one warm-up page per worker are not timed. A short 300-page job through `convert_many`, model loading included, runs at 7.2 pages/s on 4 cores and 37.7 on 32.
+Model loading and one warm-up page per worker are not timed.
 
 ## Reproducing
 
 ```shell
-pip install 'omni-parse-bench[benchmark]'
+git clone https://github.com/datalab-to/indra.git && cd indra
+pip install indra-ocr 'omni-parse-bench[benchmark]'
 python bench/opb_indra.py --out runs/opb_auto --mode auto --procs 8
 ```
 
-Each page runs in a single-threaded worker process, page headers and footers kept. `--mode ocr` gives the OCR-only row, `--limit N` scores the first N pages, and `--models` points at a local model folder. The run writes `summary.json` (the benchmark's own summary, plus median and p90 ms per page) and `pages.jsonl` (per page: time, source, tests passed).
+Each page runs in a single-threaded worker process, page headers and footers kept. `--mode ocr` gives the OCR-only row, `--math` the `--math` row, `--suites` scores only the listed suites, `--limit N` scores the first N pages, and `--models` points at a local model folder. The run writes `summary.json` (the benchmark's own summary, plus median and p90 ms per page) and `pages.jsonl` (per page: time, source, tests passed). The tables above come from our x86 harness, which gives each page 4 threads. This script gives each page one thread, so its times differ, and its scores can differ by a few tenths of a point.
 
 # Credits
 

config.json

@@ -5,16 +5,21 @@
  "framework": "onnxruntime",
  "files": [
   "det.onnx",
+  "lm.npz",
+  "lm_cjk.npz",
+  "lm_world.npz",
   "math_dec_init.onnx",
   "math_dec_step.onnx",
   "math_enc.onnx",
   "mathcls.onnx",
+  "meta.json",
   "order.onnx",
   "orient.onnx",
   "rec.onnx",
   "rec_cjk.onnx",
-  "script.onnx",
-  "meta.json"
+  "rec_rtl.onnx",
+  "rec_world.onnx",
+  "script.onnx"
  ],
- "note": "Indra OCR runs the .onnx files with onnxruntime (pip install indra-ocr). model.safetensors holds the float weights of rec.onnx, the Latin-script (English) recognizer, for the Hub parameter count; the package does not use it."
+ "note": "Indra OCR runs the .onnx files with onnxruntime (pip install indra-ocr). The .npz files are n-gram language models for unsure lines. model.safetensors holds the float weights of rec.onnx, the Latin-script recognizer, for the Hub parameter count; the package does not use it."
 }

det.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:46b0050ce4c4692f887a1a9c038480223af1c7a91b3fcced2657d9cf00290dc4
+oid sha256:f2bd4cba23e9c328cf7ec824634e423e191a2c6aacbbf35c62bd79dd70f62f59
 size 389948

lm.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c0fb618a363a0acdd05d4f5b0edd9e8146d2d990541b87f6130bbfe17cea58d
+size 15695957

lm_cjk.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d64f13f4f90f4e529bd63340c6df76238d007feaef2abb903d8cd28d92bc2f3
+size 18955160

lm_world.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34df5e74a2fcbb9cf5e7f360a559375ffa2e04d2d2943a42308c177bcb444d5d
+size 11641215

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7df6fa345f7e5a72c4207a7a1934022a2676a5416ceb208e001bbdf6ce129532
-size 4955608
+oid sha256:e9b0b74c12176516548664a46429758ac7c1088dd43524534fc7272e221a6762
+size 5013304

order.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:23635dd2324b4ccc00c408af961273a2dedd2e4f0386bc54dba678c41bcf6b46
+oid sha256:a42db2e8b536ad3d84045a4b7f9b0a72667cf8be4aa02d63f7b38004719fb180
 size 2973138

orient.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8d7bfce5d08bcad55955f41ca494a7f9d9d3ed5d5b6da1f6f276d5c509590729
-size 371414
+oid sha256:20eaf670f55a7cf9facfe1bdd6c7b8e40be75bbf4d48a3df43f66aa3bbd874fd
+size 371802

rec.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e243be069b357e56a0e867a21d7482e498df42fb19678bfb67a25f48b1f06151
-size 4977797
+oid sha256:475972a2710be4a3cbfeb2bc7f3624ffd563de07de42476fc7a290d4e1ece484
+size 5042161

rec_cjk.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4cec840b55e1bb7f375daf30a2975404a867a71ac1a5bc5b1629c4909ce16baa
-size 9255441
+oid sha256:4a035516a17e62cdf33a4fe2d88077654cb8841cff024685cdef4e351694ef50
+size 10176018

assets/examples/rotated_letter.png → rec_rtl.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bfb42c69e9950e123aef7bf879ced11d2f6a70d88bfd79e629f9f37b2e6c918f
-size 698666
+oid sha256:468796bd684486a8388c30c8b4ed2a26e3eeb1f8ff02831c24c2e12c79a2a834
+size 4812710

assets/examples/table_pmc.png → rec_world.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f8b89bdcc25fb9687a05e4bf09992a3f4dd8a852b20c9c694dd9da7a081cd495
-size 412670
+oid sha256:c8d1e59f21b04966f179d2d2d8e22b230d22110b3f89855bbbf2624a58c40043
+size 5627990

script.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5ba37030e817affede0097a7503b6829624104166c6e0b6aacecacf919fc7d11
-size 191005
+oid sha256:b6ce4e926e19c243faaf37bd46880398bf2cb4ae56a29e1177a3b017c1280e36
+size 191630