anaksor-ocr

អានអក្សរ: Khmer OCR for photos, scans and PDFs. It finds the text lines, reads them, puts them in reading order (columns, receipts, paragraphs) and exports plain text, JSON, a searchable PDF or a Word file.

Try it in your browser →: drop a photo or PDF and see every line it finds. The documentation is in Khmer and English.

pip install anaksor-ocr
anaksor photo.jpg

What it reads

These are real pages read by the released models. Each box is one detected line, and red marks a line read with low confidence.

A scanned letter: 35 lines, in reading order	A receipt photo: 38 lines; printed text reads well, handwriting less so	A road sign: 7 lines, in Khmer and English

_{Image credits: the letter is a public Cambodian government document from an open documents site; the receipt and road sign photos were found through web search and belong to their owners. They are shown only to illustrate the OCR output and are not covered by this project's licence. If one of them is yours and you want it credited or removed, please open an issue.}

The sign, as text:

$ anaksor sign.jpg
បន្ទាយស្រី

BANTEAY SREI

ភ្នំពេញ

PHNOM PENH

67 អន្លង់វែង

ANLONG VENG

ចំការឫស្សី ផាយ សុខុម

Accuracy, speed and limitations

All accuracy numbers were measured on an NVIDIA GeForce RTX 5090 (32 GB).

Speed was measured on an Apple M4 Max, once the models were loaded; your machine will differ.

KhmerST labels only some of the text in each photo. When detection is scored, text that has no label but was found by another detector is ignored ("don't care"), which makes precision look slightly better than it is.

• Printed Khmer reads best: documents, receipts and signs.
• English and other Latin text on photos is weaker: the detector can miss it on signs, and the recogniser saw little real English during training.
• Handwriting and decorative lettering are weak. Check each line's rec_score, or use --highlight-low for Word output.

Training data and its licences are listed in the model card on Hugging Face.

How it works

Install

pip install anaksor-ocr             # images, ONNX Runtime backend (no PyTorch)
pip install "anaksor-ocr[torch]"    # + PyTorch backend: CUDA / Apple MPS, SMTR head, .pth weights
pip install "anaksor-ocr[all]"      # PyTorch + PDF input + Word export

Python 3.11+. For a specific CUDA build of PyTorch, install torch from pytorch.org first; for ONNX Runtime on CUDA, pip install onnxruntime-gpu. The weights (about 95 MB for ONNX Runtime, 113 MB for PyTorch) download to ~/.cache/anaksor on first use.

Backends

anaksor runs on one of two backends. Both give the same boxes and the same text.

anaksor uses PyTorch if it is installed, and ONNX Runtime otherwise. To choose, pass backend="onnx" or backend="torch" (--backend on the command line). An .onnx weights file always runs in ONNX Runtime.

Command line

anaksor photo.jpg                       # text to stdout
anaksor scan.pdf -o scan.docx           # Word, layout rebuilt
anaksor scan.pdf -o scan-searchable.pdf # page images + selectable text
anaksor *.jpg -o out/ -f json           # one JSON per image
anaksor scan.pdf --pages 1-3,7 --device cuda
anaksor --fetch-models                  # download the weights ahead of time

Python

import anaksor

ocr = anaksor.OCR()                       # backend and device picked automatically, see Backends
result = ocr("page.jpg")
print(result["text"])                     # reading order; paragraphs split by blank lines

for line in result["lines"]:              # text, box, quads, parts, rec_score, det_score, block
    print(line["rec_score"], line["text"])

pages = ocr.read("scan.pdf", keep_images=True)        # one result per page
open("scan.pdf", "wb").write(anaksor.export.to_pdf(pages))
open("scan.docx", "wb").write(anaksor.export.to_docx(pages))

ocr(image) takes a path, bytes, a PIL image or an RGB NumPy array. Useful options:

The detector and recogniser can be used on their own: anaksor.Detector().detect(img) and anaksor.Recognizer().recognize([crop, ...]).

Weights

Each model comes as two files. Only the one for your backend is downloaded:

anaksor looks for them in this order and uses the first it finds:

1. a path you pass: det_weights= / rec_weights= (or --det-weights / --rec-weights);
2. the folder in $ANAKSOR_WEIGHTS_DIR;
3. the cache, ~/.cache/anaksor (or $ANAKSOR_HOME), filled on first use from the Hugging Face repo Sokheng/anaksor-ocr.

Downloads are safe and repeatable:

• each file is checked against the SHA-256 in its model spec before it is used, and a file without one is never downloaded;
• neither format can run code when it is loaded;
• files come from the Hub commit this release was built for (rec v4 + det v3, 5c9f76c), so a later upload never changes your results. ANAKSOR_HF_REVISION picks another commit.

Offline machines: run anaksor --fetch-models on a machine with internet, then copy the two files for your backend into $ANAKSOR_WEIGHTS_DIR on the offline one.

Other models

You can also run your own models trained with OpenOCR-style configs, the format used to train these models. Make a spec from the training config. The tools are in the repository, not the installed package, so run them from a clone:

git clone https://github.com/SokhengDin/anaksor-ocr && cd anaksor-ocr
python tools/spec_from_config.py path/to/svtrv2_cppd_khmer.yml --out specs/

rec = anaksor.Recognizer("specs/rec-svtrv2-cppd-khmer.yml", weights="best.pth")
ocr = anaksor.OCR(recognizer=rec)

For the onnx backend, export the weights (needs [export]); the spec already names the .onnx file, so only the printed SHA-256 goes into weights.onnx_sha256:

python tools/export_onnx.py --rec best.pth --rec-spec specs/rec-svtrv2-cppd-khmer.yml --out onnx/

Supported: detection RepViT + DBNet; recognition SVTRv2 (any size) with RCTC + SMTR heads (GTCDecoder, also with the training-only count head), RCTC alone, or CPPD. The .pth checkpoints load as they are, with weights_only, so no code runs; tools/convert_weights.py turns them into .safetensors. A CPPD head has no per-column output, so lines wider than its input are read in overlapping windows joined where their texts overlap, instead of by CTC character positions.

Security

Image inputs are decoded only as JPEG, PNG, WEBP, BMP or TIFF, weights are loaded without running code, and dependency floors exclude versions with known vulnerabilities (checked with pip-audit in CI). See SECURITY.md.

Development

uv venv && uv pip install torch --index-url https://download.pytorch.org/whl/cpu
uv pip install -e ".[all]" pytest ruff pip-audit onnx onnxscript
pytest                                    # no weights or network needed
ANAKSOR_TEST_WEIGHTS=/path/to/weights pytest -m weights
ruff check src tests tools && ruff format --check src tests tools

The website (landing page, demo, documentation) is a Next.js app in web/; see web/README.md.

Layout of the package:

Releasing a new version: see RELEASING.md.

Credits and licence

Apache-2.0. The networks are implemented from their papers, with the layer layout and tensor names of the OpenOCR implementations the models were trained with (see NOTICE).

• DBNet: Liao et al., Real-time Scene Text Detection with Differentiable Binarization, AAAI 2020
• RepViT: Wang et al., RepViT: Revisiting Mobile CNN From ViT Perspective, CVPR 2024
• SVTRv2: Du et al., SVTRv2: CTC Beats Encoder-Decoder Models in Scene Text Recognition, ICCV 2025
• SMTR: Du et al., Out of Length Text Recognition with Sub-String Matching, AAAI 2025
• CPPD: Du et al., Context Perception Parallel Decoder for Scene Text Recognition, TPAMI 2025