Kuzushiji OCR

Kuzushiji is the cursive script most pre-modern Japanese texts were written in, and few people can still read it. Recognising single characters is a solved classroom exercise. Reading a line is not: the model gets an image of several characters with no boundaries marked and has to output them in order, however many there are.

The question was narrow on purpose. Does adding a recurrent layer, which reads the visual features in sequence, help transcribe these lines? And if it does, does the help grow as the lines get longer, where order should matter more?

The notebook composes its own lines at runtime from Kuzushiji-49’s 28 × 28 single-character glyphs: 2 to 5 characters placed left to right on a 32 × 128 canvas, at one common scale.

• No leaks between splitsThe official K49 training glyphs are split into separate pools for training and validation composites, and the official test glyphs are used only for test composites. No single glyph image appears in two splits.
• Balanced12,000 training, 2,000 validation and 3,000 test lines, equal across lengths 2 to 5, with characters drawn uniformly across 49 classes.
• Checked before trustedLabel and blank validation, a check that 16 timesteps can represent every target, and overfitting runs on 64 sequences (98.4% for the CNN, 100% for the CRNN) to prove each model can learn the task at all.

Both share the same convolutional feature extractor, which turns the image into 16 ordered slices from left to right, and both are trained with CTC, which learns to map those 16 slices to a label sequence of any length, using a blank symbol for “nothing here” and to separate repeated characters.

• After the CNN

  CNN-CTC Dense layer, 128 unitsCRNN-CTC Bidirectional LSTM, 64 units each way

• Parameters

  CNN-CTC 164,786CRNN-CTC 263,602

• Training

  CNN-CTC Seed 42, Adam 1e-3, batch 64, up to 30 epochsCRNN-CTC Identical

• Checkpoint

  CNN-CTC Lowest validation CTC lossCRNN-CTC Identical

• Decoding

  CNN-CTC Greedy CTCCRNN-CTC Identical

The test set stayed untouched until both configurations and their checkpoints were frozen.

• 2

  CNN exact 52.1%CRNN exact 56.0%CNN CER 27.3%CRNN CER 24.8%

• 3

  CNN exact 38.0%CRNN exact 41.5%CNN CER 28.2%CRNN CER 25.4%

• 4

  CNN exact 27.5%CRNN exact 31.7%CNN CER 27.9%CRNN CER 24.3%

• 5

  CNN exact 21.6%CRNN exact 24.5%CNN CER 27.6%CRNN CER 25.0%

The CRNN wins at every length, by 2.9 to 4.3 points of exact accuracy, but the largest gain is at length 4, not 5. The error types say more than the totals: the CNN dropped whole characters 442 times, the CRNN 52 times. Recurrence mostly fixed missing characters; wrong characters stayed about as common (2,374 substitutions against 2,522).

• Change exactly one thing

  Same features, data, seed, optimiser, checkpoint rule and decoder; the only difference is the BiLSTM. Anything else and the comparison measures two changes at once.

• Keep glyphs from crossing splits

  Composing lines from a shared pool would let the test set contain glyph images the model trained on in other lines. Splitting the source glyphs first means the test measures reading unseen handwriting, not recognising familiar strokes.

• Prove the pipeline can learn before comparing

  CTC fails quietly when labels, blanks or timesteps are wrong. Overfitting a tiny set to near-perfect accuracy shows each model and its decoder work, so a gap between them reflects the architecture, not a bug.

• Report error types, not just a rate

  A 10% relative drop in character error sounds like general improvement. Splitting it into deletions, substitutions and insertions shows where it came from, and keeps the paper from claiming the CRNN recognises characters better when it mostly stopped skipping them.

• Synthetic lines of clean glyphs with random characters and no linguistic context: this is not document OCR.
• One configuration and one seed per model, so run-to-run variation is unmeasured.
• The CRNN also has more capacity; recurrence isn’t separated from parameter count.
• Greedy decoding only, with no beam search or language model.
• Only 157 test lines had adjacent repeated characters, too few to say anything about repeats.