Nart/abkhaz-ocr-line-reader

Abkhaz OCR — the four-alphabet line reader

From the Bagrat Shinkuba Foundation. One line reader (CRNN + CTC) for all the alphabets Abkhaz has been printed in:

• modern Abkhaz Cyrillic;
• the Georgian-based alphabet of 1938–54;
• the Latin alphabet of 1928–38, and Marr's analytic alphabet of 1926–28;
• pre-1926 Abkhaz Cyrillic.

This repository holds the trained reader (model/), the code that runs it (code/), and the exact training set it was trained on with the weights it started from, so the training can be run again. It is the reader behind the Foundation's OCR app «Аԥхьаҩ».

Credits

Human-checked lines in the Georgian-based alphabet come from Marat Ionov's Abkhaz Mkhedruli Dataset for PaddleOCR (made with the Bagrat Shinkuba Foundation; CC BY-NC-SA 4.0). They are used in two ways: lines from 12 of his source books are in the training set (ionov-train), and the lines from his other 6 books were kept out of training and are the human-checked test in the results below.

Results

Every figure below is the same measure: the character error rate of single text lines — the letters the reader got wrong (substituted, missed or added), divided by the number of letters in the correct line — on real printed lines from pages the reader never saw in training. Lower is better.

alphabet	test lines	error rate
Modern Abkhaz Cyrillic	24,704 lines from held-out pages of books, journals and newspapers	0.54 %
Georgian-based alphabet, 1938–54	95 lines from 21 books	2.38 %
Georgian-based alphabet, human-checked	1,066 lines from Marat Ionov's 6 checked books, held out of training	2.96 %
Latin alphabet, 1929–38 print	83 lines from 17 books	1.96 %
Pre-1926 Cyrillic	109 lines from 22 books (1866–1926)	4.69 %
Marr's analytic alphabet, 1926–28 print	19 lines from 4 books	17.93 % — the hardest: this alphabet is learned from synthetic lines only so far

The historical test lines (one page per book) were transcribed by Claude agents and spot-checked by a native speaker; the Marr lines were transcribed letter for letter by Gemini against Marr's own printed letter table; Marat Ionov's lines were checked by hand.

Use the reader

hf download Nart/abkhaz-ocr-line-reader --repo-type dataset --include "model/*" "code/*" --local-dir reader
cd reader
pip install torch numpy pillow
python code/read_lines.py model line1.png line2.png              # each image is one printed line
python code/read_lines.py model --block line1.png line2.png      # the lines of one text block, read in one alphabet

code/ocr_nets.py is the network itself and the alphabet lock; code/read_lines.py shows the whole path from a line image to text (grey, 48 px high, ink high, greedy CTC). With --block the lines are treated as one text block and read in one alphabet, chosen from what the block's words show — the way the app reads a column. A single old-alphabet line is better read without it.

Contents

path	what
model/	the trained reader: best.pt, charset.json (396 symbols), scripts.json (the per-alphabet masks used to lock a text block to one alphabet), metrics.json, train.log
code/	ocr_nets.py (the model class, the CTC decoders and the alphabet lock) and read_lines.py (how to read lines with it)
labels/<set>.tsv	the 8 label files used in training: image path<TAB>text, paths relative to data/<set>/
shards/<source>-NN.tar	all 565,732 line images those files point at, stored under data/<source>/… (7.3 GB)
init/	the weights training started from: the previous reader, trained on the same sets without synth-marr
manifest.json	image counts per source

The 14 letters of the 1928 Latin alphabet that have no Unicode code point are written in the labels as ‹cyrillic› (for example ‹шә›). Marr's letters are written in Unicode with combining marks (ring below = labialised, comma below = palatalised, NFC); stress marks are left out.

label set	lines	what it is
modern-lines	248,601	real modern Abkhaz line crops from books, journals and newspapers
mix4-modern	124,567	half of modern-lines again (modern weighted 1.5×)
mix4-synth	185,028	synthetic lines in the Georgian-based, Latin and pre-1926 Cyrillic alphabets
synth-marr	80,000	synthetic lines in Marr's analytic alphabet: real Abkhaz text converted into Marr's letters and printed in four typefaces
pseudo-old2	105,200	real old-alphabet print, labelled by an earlier version of the reader where it was sure
gemini-old	2,052	Latin / pre-1926 Cyrillic lines the reader was unsure of, read by Gemini from the image
ionov-train	8,340	Marat Ionov's human-checked Abkhaz lines in the Georgian-based alphabet (from Grundik/abkhaz-mkhedruli-dataset-paddle), the 6 books in our test held out
georgian-real	22,510	real Georgian-language print of 1935–50 (8 books from the National Parliamentary Library of Georgia), labelled by matching the reading to Wikisource text letter by letter

Train it again

cd services/ocr-lab
hf download Nart/abkhaz-ocr-line-reader --repo-type dataset --local-dir /tmp/r
mkdir -p data && for t in /tmp/r/shards/*.tar; do tar -xf "$t"; done      # → data/<source>/…
for f in /tmp/r/labels/*.tsv; do d=data/$(basename "$f" .tsv); mkdir -p "$d"; cp "$f" "$d/labels.tsv"; done
R=runs/reader; mkdir -p $R
cp /tmp/r/init/best.pt $R/init.pt && cp /tmp/r/init/charset.json $R/charset.json
D=data
venv/bin/python -u scripts/train_rec.py \
    --pages $D/modern-lines,$D/mix4-modern,$D/mix4-synth,$D/pseudo-old2,$D/gemini-old,$D/ionov-train,$D/georgian-real,$D/synth-marr \
    --tight-lines mix4-synth,synth-marr --resume $R/init.pt --extend-charset \
    --out $R --epochs 1 --workers 8 --eval-lines 0
venv/bin/python scripts/script_masks.py $R          # writes scripts.json

--extend-charset adds Marr's letters to the reader's output. One epoch, about an hour and a half on one 8 GB laptop GPU. How each label set was built is written up in services/ocr-lab/docs/four-alphabet-reader.md in the bagrat-fund repository, with the scripts in services/ocr-lab/scripts/rounds/.