💬 NLP

Pre-Editorial Normalization for Automatically Transcribed Medieval Manuscripts in Old French and Latin

This paper introduces the task of Pre-Editorial Normalization (PEN) to bridge the gap between palaeographically accurate and normalized digital editions of Old French and Latin manuscripts, presenting a new dataset and a ByT5-based model that achieves state-of-the-art performance in converting raw Automatic Text Recognition outputs into usable, normalized text.

Original authors: Thibault Clérice, Rachel Bawden, Anthony Glaise, Ariane Pinche, David Smith

Published 2026-02-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Thibault Clérice, Rachel Bawden, Anthony Glaise, Ariane Pinche, David Smith

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a time machine that can take a photo of a handwritten page from a medieval manuscript (like a book from 800 years ago) and turn it into digital text. This is what Automatic Text Recognition (ATR) does. It's amazing, but it's like having a very literal, slightly confused robot assistant.

Here is the problem: The robot assistant sees the page exactly as it is written.

It sees a scribbled "m" and writes "m".
It sees a tiny squiggle meaning "and" and writes "and" (or sometimes just a weird symbol).
It sees a word split across a line break and writes it with a hyphen in the middle.
It sees a fancy "u" that looks like a "v" and writes "v" because that's what the ink looks like, even if it should be a "u".

If you try to use this raw text with modern computer tools (like a spell-checker, a translator, or a search engine), the tools get confused and crash. They expect clean, modern English or French.

On the other hand, if you ask a human scholar to fix it all at once, they might "over-correct." They might change a word just because they think it should be spelled a certain way, accidentally inventing words that were never there (hallucinations) or erasing historical quirks that are actually important.

The Solution: The "Pre-Editorial Normalization" (PEN) Sandwich

The authors of this paper propose a new middle-ground step called Pre-Editorial Normalization (PEN). Think of it as a specialized "translator" or "clean-up crew" that sits between the raw robot scan and the final polished book.

Here is how the process works, using a Restaurant Analogy:

The Raw Ingredients (Graphemic ATR):
Imagine the robot scanner is a chef who just dumped a pile of raw, unpeeled, muddy vegetables onto the counter. Some are whole, some are chopped weirdly, and some have dirt (recognition errors) on them. This is the "graphemic" output. It's accurate to the image, but it's not ready to eat.
The Old Way (The "All-in-One" Chef):
Previously, scholars tried to hire one chef to wash, peel, chop, cook, and plate the food all at once. The problem? This chef often got tired, guessed wrong about what the vegetable was, and sometimes added ingredients that weren't in the original recipe (hallucinations).
The New Way (The PEN Sandwich):
The authors introduce a new step: The Prep Station.
- Step 1: The robot scanner dumps the raw veggies (the manuscript text).
- Step 2 (The PEN Model): A specialized AI (trained on millions of examples) comes in. It doesn't try to cook the meal yet. It just does the prep work:
  - It washes off the mud (fixes robot reading errors).
  - It peels the skins (expands abbreviations like turning "q̃" into "qui").
  - It separates the mixed-up piles (fixes spacing).
  - It standardizes the shapes (changes "u" to "v" where it's a consonant, but keeps the original spelling of words like "philosophia" if that's how it was written).
- Step 3: Now, the text is clean and normalized. It's ready for the final "plating" (editing) or for modern computers to analyze.

Why is this a big deal?

The authors built a massive training dataset (a library of 4.6 million pairs of "dirty" robot text and "clean" human text) to teach their AI how to do this prep work.

The Result: Their AI model is like a master prep chef. It cleaned up the text with 93% accuracy (only 6.7% errors), which is much better than previous attempts.
The Benefit: Because this AI separates the "cleaning" from the "cooking," we can now trust the computer analysis more. If the computer makes a mistake later, we know it's because of the recipe (the analysis), not because the ingredients were muddy.

The Catch (The "Over-Correction" Risk)

The paper also warns that even this new chef has a bias.

For Latin: The chef tends to make everything look like "Classical Latin" (the fancy, perfect version from ancient Rome), sometimes erasing the unique, messy medieval spelling that historians actually want to study.
For Old French: The chef tends to pick the most common way to spell a word, ignoring rare, local dialects.

The Bottom Line

This paper is about building a smart, middle-layer filter for historical texts. Instead of trying to turn a muddy, ancient manuscript directly into a modern book in one giant leap, they break it down. They first turn the muddy text into "clean, standardized text" using a specialized AI. This makes it possible for computers to read, search, and analyze medieval history without getting lost in the mud, while still keeping enough of the original flavor to be historically accurate.

It's the difference between trying to read a handwritten note through a foggy window versus cleaning the glass first so you can see the words clearly.

1. Problem Statement

The paper addresses a critical methodological divide in the digital humanities regarding the transcription of historical manuscripts:

The Graphetic/Graphemic Approach: Produces raw, faithful transcriptions of manuscript features (preserving abbreviations, variable spacing, and character variants like u/v and i/j). While accurate to the physical source, these outputs are incompatible with standard Natural Language Processing (NLP) tools (lemmatizers, POS taggers) and difficult for modern readers.
The Normalized Approach: Produces "clean" text by expanding abbreviations, standardizing spelling, and adding modern punctuation. However, models trained to produce normalized outputs directly often struggle to generalize to new domains, tend to "hallucinate" content, and fail to distinguish between transcription errors (e.g., rn vs. m) and normalization errors.

The Gap: There is a lack of a robust intermediate step that converts raw Automatic Text Recognition (ATR) output into a normalized version while preserving the ability to trace errors back to the transcription stage.

2. Methodology

Task Definition: Pre-Editorial Normalization (PEN)

The authors define Pre-Editorial Normalization (PEN) as a sequence-to-sequence task that takes graphemic ATR output as input and produces normalized text as output. The specific goals of PEN are:

Allograph Normalization: Merging character variants (e.g., u/v, i/j) based on their phonetic function (vowel vs. consonant).
Abbreviation Expansion: Context-sensitive expansion of scribal abbreviations (e.g., qͥ $\to$ qui), respecting morphosyntactic features.
Error Correction: Addressing common ATR recognition errors (e.g., rn $\to$ m).
Capitalization: Standardizing capitalization around punctuation and proper names.
Preservation: Keeping original punctuation and historical spelling variants (e.g., f for ph) that are not merely graphical variants.

Dataset Construction

The authors created a large-scale dataset by aligning two distinct corpora:

Source (Input): The CoMMA corpus, containing 33,000 manuscript pages with graphemic ATR transcriptions (3.3B tokens).
Target (Output): Digitized and born-digital editions of Old French and Latin texts (e.g., Patrologia Latina, Cartae Europae Medii Aevi).

Alignment Process:

Used passim 2.0 (Smith et al., 2023) to align raw ATR pages with normalized editions.
Employed character-level Hidden Markov Model (HMM) alignment to handle rearrangements caused by page layout analysis errors in ATR.
Applied Unicode decomposition normalization to handle diacritics.
Silver Corpus: Generated 4.66 million aligned pairs (silver standard) automatically.
Gold Standard: Manually corrected a subset of 1,800 samples (588 unique samples from 316 manuscripts) by a philologist to create a high-quality evaluation set. This set includes diverse genres (administrative, medical, literary) and handles edge cases like mathematical notation.

Model Architecture

Base Model: ByT5 (Byte-to-Text 5), a transformer model operating at the byte level.
Rationale: ByT5 handles Unicode-decomposed forms and high spelling variation better than subword tokenizers, which is crucial for medieval texts with inconsistent orthography.
Training Strategy: The model was trained on the bilingual silver corpus. Due to the 100:1 imbalance between Latin and Old French, the French portion was upsampled by a factor of 10 to ensure adequate exposure.

3. Key Contributions

Formal Definition of PEN: A clear task definition separating transcription (graphemic) from normalization, allowing for error attribution.
Large-Scale Resource:
- A 4.66M-sample silver training corpus derived from CoMMA and aligned editions.
- A 1.8k-sample gold evaluation set with manual corrections.
State-of-the-Art Model: A ByT5-based normalization model that significantly outperforms existing baselines.
Downstream Impact Analysis: Demonstration that PEN improves performance in downstream tasks like lemmatization and Part-of-Speech (POS) tagging compared to raw ATR or previous pipelines.

4. Results

Normalization Performance

Evaluated on the Gold Standard dataset using Character Error Rate (CER) and Word Error Rate (WER):

Proposed Model (ByT5): Achieved a 6.7% CER (7.6% for Old French, 6.3% for Latin).
Baselines:
- Zero-shot Llama 3 8B: 139.9% CER (failed to handle the task).
- Schonhardt (2025) ByT5: 64.8% CER (performed poorly on Old French due to domain constraints).
Conclusion: The proposed model outperformed baselines by a significant margin, demonstrating the effectiveness of the PEN task definition and the silver dataset.

Qualitative Analysis

Strengths: The model effectively corrects ATR noise (e.g., rn $\to$ m) and expands abbreviations.
Weaknesses:
- Classical Bias (Latin): Tendency to revert to classical spellings (e.g., ph instead of f, -tio instead of -cio) rather than preserving medieval variants.
- Scripta Erasure (Old French): Tendency to normalize to dominant variants (e.g., pople instead of pueple), erasing local scribal traditions.
- Hallucination: Occasional semantic failures (e.g., iterum $\to$ iustum) when context is ambiguous.

Downstream Task Impact

The authors tested the PEN model on a stylometric analysis of Vie de Saint Lambert:

Lemmatization & POS Tagging: The PEN pipeline achieved higher Precision (90.9%) and F1 (89.9%) compared to the previous "Lambert pipeline" (88.8% F1).
Trade-off: While the Lambert pipeline had slightly higher recall, the PEN pipeline introduced less noise and simplified the processing chain by removing the need for ad-hoc space-correction models.

5. Significance and Future Work

Methodological Shift: PEN establishes a necessary intermediate layer in the digital humanities workflow. It allows researchers to use normalized text for NLP tools while retaining the ability to audit errors against the original graphemic transcription.
Scalability: The use of automatic alignment (passim) allows for the creation of massive training datasets without the prohibitive cost of manual annotation for every pair.
Future Directions:
- Expanding the dataset to include more diverse genres (e.g., administrative archives).
- Modeling uncertainty in normalization (producing a distribution of possible outputs rather than a single deterministic string) to handle ambiguous abbreviations.
- Implementing document-level context windows to improve consistency across a whole manuscript.

In summary, this paper provides a robust solution to the "usability gap" in medieval manuscript processing, offering a scalable, high-accuracy method to convert raw OCR outputs into usable, normalized text while maintaining philological rigor.