t-rsi-ocr

T-RSI Fast Reflex OCR

A 1.58-bit ternary BitNet text-line recognizer in 380 KB

[!WARNING] Experimental research release. Every number below was measured on one Apple Silicon machine against ground truth this project generated. It has not been independently replicated. Treat the figures as reproducible-by-you, not as verified.

Every weight is -1, 0 or +1, packed four to a byte. The model reads a 32-pixel-tall text strip and emits characters through CTC, decoded with a prefix beam search over a 27 KB character language model.

It is more accurate than Tesseract 5 on degraded text and on fonts, ties on clean documents, and returns noticeably fewer perfect lines. Full numbers and the reasons are below, including where it loses.

Measured results

Reproduce with python3 benchmark_vs_tesseract.py. Ground truth needs no hand labelling: a digital PDF already contains its own exact text, so rasterizing a page and cropping each line at the bbox the PDF reports gives pixels whose correct answer is known. Training and test documents are split by file and deduplicated by content fingerprint.

Character accuracy

Exact-line match — where it loses

Tesseract's errors cluster onto a few hard lines and leave the rest clean. This model's scatter — single characters across many otherwise-good lines — and one stray character ruins a line as thoroughly as ten. That is the documented weakness of CTC, which treats every timestep as conditionally independent given the image and so cannot notice that the letters it just emitted do not form a word.

Multi-hypothesis voting closes most of that gap at the cost of extra passes:

By content type (real documents)

Alphanumeric identifiers are the weakest content for both engines. Random codes carry no language structure, so no language model can rescue a misread glyph.

Size, memory and speed

129× smaller on disk, 5× faster, 5× faster to cold start — and it uses more total memory than Tesseract. The model is only ~9 MB of that; Python with numpy and pillow costs 31.8 MB before a single weight loads. A C or Rust port would remove that, but no such port has been measured, so it is not a claim.

Position encoding is fixed sinusoidal, computed at load and stored as zero bytes. A learned embedding at 1024×192 float32 would cost 768 KB — more than twice all the ternary weights combined.

Architecture

Inference is engine.py, NumPy only, no framework. Weights are ternary, so an integer SIMD or microcontroller port needs only additions and subtractions. On a CPU the same arithmetic runs through BLAS, which is not literally multiplication-free — the property belongs to the weights, not to this runtime.

engine.py is checked against the PyTorch training module on shared weights and must agree to float32 precision. That test exists because the two once silently computed different functions.

Quickstart

from PIL import Image
from engine import FastReflexOCREngine

engine = FastReflexOCREngine.from_pretrained(
    "psikosen/t-rsi-ocr",
    lm_name="char_lm_3gram.npz",   # omit for greedy CTC
    beam_width=4,
)

text, latency_us, ram_kb = engine.recognize(Image.open("line.png"))
print(f"{text!r}  ({latency_us:.0f} us)")

Higher accuracy, more passes:

from data_generator_v2 import stretch_width
from vote import rover

engine.input_stretch = 1.0        # variants carry their own stretch
factors = [1.05, 1.15, 1.25, 1.35, 1.45]
weights = [0.8, 1.2, 1.6, 1.4, 0.8]
hyps = [engine.recognize(stretch_width(img, f))[0] for f in factors]
text = rover(hyps, weights=weights, null_penalty=0.85)

Two things that matter more than the model

1. Most documents need no OCR at all. DOCX files and digital PDFs already contain their exact text. Reading it takes 4.8 ms per page against Tesseract's 2,038 ms for the same page — 425× faster and exact rather than 97% accurate. Rasterizing a text layer and guessing it back loses table structure and turns 1999.00 into 999.00. Check for a text layer before reaching for any recognizer.

2. This is a line recognizer, not a page reader. It needs pre-cropped lines. Tesseract does layout analysis and recognition in one pass; this does not, and no line detector ships with it. A per-line speed comparison assumes the crops already exist.

Training

python3 train_v2.py --epochs 70 --pool 50000 --real 25000 \
    --layers 4 --hidden 192 --heads 6 --guide-weight 0.5 --out model_v4

49,022 synthetic lines across 111 screened system fonts, mixed with 19,816 real lines cropped from PDFs. Both matter: a synthetic-only model scored 81% on held-out fonts and 16% on real documents — it had learned the renderer.

Augmentation covers blur, sensor speckle, non-uniform lighting, ±5° skew, exposure drift, and horizontal scale jitter (1.0–1.4×). That last one is what makes input_stretch work at inference: CTC cannot emit more characters than it has frames, real lines average 1.29 frames per character, and stretching to 1.69 is worth +14.9 points of exact-line match. Applied to a model trained without the jitter, the same trick is a net loss.

Training uses an attention decoder as an auxiliary teacher (GTC, arXiv:2002.01276), discarded at export — it costs zero bytes and zero milliseconds at inference.

Limitations

• Line recognizer only. No page layout, no line segmentation, no table structure.
• 95 printable ASCII characters. No accents, no CJK, no mathematical notation, no typographic quotes.
• Exact-line match trails Tesseract on clean documents, 73.7% against 85.7% single-pass. Voting narrows it to 86.5% against 87.9% at equal speed.
• Uses more total RAM than Tesseract (41.5 MB against 35.4 MB), because of the Python runtime rather than the model.
• Alphanumeric identifiers are weak (80.0%), as they are for every engine measured.
• Evaluated on one machine. Independent replication welcome.

What was tried and did not work

Recorded so it is not rebuilt from the same reasoning.

Team C · experimental research release