Module L29 · Partie K · Ingénierie de l’IA

OCR : lire une image, du pixel au texte structuré.

Lire un document scanné, une plaque, un compteur, un ticket : l’OCR est un pipeline — acquisition, prétraitement (binarisation, redressement), détection des zones de texte, reconnaissance (des caractères isolés aux lignes entières par CTC ou par transformer), post-traitement (dictionnaire, modèle de langue) et compréhension du document (tableaux, formulaires, mise en page). Ce chapitre implémente les briques classiques en NumPy, explique la perte CTC et les modèles modernes (CRNN, TrOCR, LayoutLM, modèles vision-langage), et donne les métriques (CER, WER) et les articles.

Durée : 3 séances · Prérequis : L10, L14, L19, L25. Objectifs : prétraiter une image (Otsu, morphologie, redressement par Hough) ; segmenter en lignes et caractères ; comprendre CTC et l’implémenter ; évaluer par CER/WER ; choisir entre Tesseract, PaddleOCR, TrOCR, un VLM ; lire les articles.

Ce que vous saurez faire à la fin

Binariser (Otsu), redresser, segmenter des lignes et des caractères par projections et composantes connexes.
Expliquer la perte CTC (alignement sans segmentation) et calculer sa programmation dynamique.
Mesurer CER et WER, et lire une matrice de confusion de caractères.
Construire un pipeline OCR sur PC avec Tesseract/PaddleOCR et un modèle vision-langage, et les comparer honnêtement.

Fiche de cours · Définitions

Définitions

Définition (OCR, HTR, détection, reconnaissance). OCR : texte imprimé ; HTR (handwritten text recognition) : manuscrit. Détection : localiser les zones de texte (boîtes, polygones). Reconnaissance : transcrire une zone en chaîne. Compréhension de document : structure (titres, tableaux, champs de formulaire), relations clé-valeur.

Définition (binarisation, seuil d’Otsu). Transformer une image en niveaux de gris en noir/blanc. Otsu choisit le seuil qui minimise la variance intra-classe (équivalent : maximise la variance inter-classe) de l’histogramme. Seuillage adaptatif (Sauvola) : seuil local, robuste aux éclairages inégaux.

Définition (morphologie mathématique). Érosion (min sur un voisinage), dilatation (max), ouverture (érosion puis dilatation : supprime les petits objets), fermeture (dilatation puis érosion : bouche les trous). Sur des images binaires : opérations ensemblistes avec un élément structurant.

Définition (redressement, transformée de Hough). Estimer l’angle d’inclinaison (skew) : chaque point de contour vote pour les droites (ρ, θ) qui passent par lui ; les lignes de texte produisent un pic à l’angle dominant. Variante : maximiser la variance du profil de projection horizontale sur les angles candidats.

Définition (segmentation par projection, composantes connexes). Profil de projection horizontale = somme des pixels noirs par ligne : les creux séparent les lignes de texte. Composantes connexes (4- ou 8-connexité) : caractères ou fragments (les lettres accentuées, le i, sont en plusieurs composantes).

Définition (CTC). Connectionist Temporal Classification : perte pour prédire une séquence de caractères à partir d’une séquence de T trames (colonnes de l’image) sans alignement connu, via un symbole « blanc » et une fonction de réduction (fusionner les répétitions, supprimer les blancs).

Définition (CER, WER). Character Error Rate = (substitutions + insertions + suppressions)/longueur de référence, calculé par distance de Levenshtein ; WER : idem sur les mots. Peuvent dépasser 100 %.

Définition (modèles). Tesseract (LSTM, classique) ; CRNN (CNN + BiLSTM + CTC) ; PaddleOCR (détection DB + reconnaissance SVTR) ; TrOCR (encodeur ViT + décodeur texte) ; LayoutLM/Donut (compréhension de document) ; VLM généralistes (GPT-4V, Qwen-VL, PaliGemma) qui « lisent » sans pipeline explicite.

Fiche de cours · Formules

Formules à connaître

Otsu : σ²_inter(t) = ω₀(t)ω₁(t)[μ₀(t) − μ₁(t)]² ; t* = argmax_t σ²_inter ; ω = proportions, μ = moyennes des deux classes

Sauvola : T(x, y) = m(x, y)·[1 + k(s(x, y)/R − 1)], m et s moyenne et écart-type locaux, k ≈ 0,2–0,5, R = 128

Hough : un point (x, y) vote pour ρ = x cos θ + y sin θ, θ ∈ [−π/2, π/2] ; accumulateur (ρ, θ) ; angle de skew = θ du pic − 90°

CTC : p(y | X) = Σ_{π ∈ B⁻¹(y)} Π_t p(π_t | X) ; calcul par programmation dynamique avant-arrière sur la séquence augmentée y′ = (ε, y₁, ε, y₂, …, ε) en O(T·|y|)

Récurrence CTC : α_t(s) = [α_t−1(s) + α_t−1(s−1) + α_t−1(s−2)·1_{y′_s ≠ ε, y′_s ≠ y′_s−2}]·p_t(y′_s)

Levenshtein : D[i][j] = min(D[i−1][j] + 1, D[i][j−1] + 1, D[i−1][j−1] + 1_{a_i ≠ b_j}) ; CER = D[n][m]/n

Résolution nécessaire : ≈ 20–30 pixels de hauteur de x pour l’imprimé (300 dpi pour du 10 pt) ; en dessous, le CER explose

Décodage CTC glouton : argmax par trame puis B(·) ; par faisceau avec modèle de langue : score = log p_CTC + α log p_LM + β·|mots|

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire

Théorème 1 (Otsu : minimiser l’intra-classe = maximiser l’inter-classe). Pour un seuil t, σ²_totale = σ²_intra(t) + σ²_inter(t), avec σ²_intra = ω₀σ₀² + ω₁σ₁² et σ²_inter = ω₀ω₁(μ₀ − μ₁)².

C’est la décomposition de la variance (L11) : Var(X) = E[Var(X | classe)] + Var(E[X | classe]). Le premier terme est ω₀σ₀² + ω₁σ₁². Le second : la moyenne globale est μ = ω₀μ₀ + ω₁μ₁ ; Var(E[X|classe]) = ω₀(μ₀ − μ)² + ω₁(μ₁ − μ)² ; avec μ₀ − μ = ω₁(μ₀ − μ₁) et μ₁ − μ = −ω₀(μ₀ − μ₁), on obtient ω₀ω₁²(μ₀ − μ₁)² + ω₁ω₀²(μ₀ − μ₁)² = ω₀ω₁(μ₀ − μ₁)². Comme σ²_totale ne dépend pas de t, minimiser l’un revient à maximiser l’autre ; σ²_inter se calcule en O(1) par seuil à partir de sommes cumulées de l’histogramme : Otsu est O(256) après l’histogramme.

Théorème 2 (CTC : la somme sur les alignements se calcule en O(T·|y|)). Le nombre d’alignements π de longueur T qui se réduisent à y est exponentiel, mais p(y | X) = Σ_s α_T(s) pour s ∈ {|y′|, |y′| − 1}, avec α calculé par la récurrence ci-dessus.

Définissons α_t(s) = probabilité totale des préfixes d’alignement de longueur t qui se réduisent au préfixe y′_1..s (dans la séquence augmentée de blancs). Un alignement qui est en s à l’instant t était, à t − 1, en s (répétition du même symbole, fusionnée par B), en s − 1 (passage du blanc au caractère ou du caractère au blanc), ou en s − 2 (sauter un blanc, autorisé seulement si y′_s est un caractère différent de y′_s−2 — sinon deux caractères identiques consécutifs seraient fusionnés). Les trois cas sont disjoints et exhaustifs, d’où la récurrence, chaque terme multiplié par la probabilité d’émettre y′_s à t. Initialisation : α₁(1) = p₁(ε), α₁(2) = p₁(y₁). Un alignement complet finit sur le dernier caractère ou sur le blanc final. Coût : T × (2|y| + 1) cellules, chacune O(1). Le gradient s’obtient par la passe arrière β symétrique (Graves et al. 2006) — c’est le même schéma que l’algorithme avant-arrière des HMM.

Théorème 3 (CER par Levenshtein est une distance et se calcule en O(nm)).

La récurrence D[i][j] considère la dernière opération d’une transformation optimale de a_1..i en b_1..j : suppression de a_i (D[i−1][j] + 1), insertion de b_j (D[i][j−1] + 1), ou substitution/correspondance (D[i−1][j−1] + 1_{a_i≠b_j}) ; sous-structure optimale (L04). Propriétés de distance : symétrie (inverser les opérations), inégalité triangulaire (concaténer deux suites d’opérations). Deux lignes de mémoire suffisent. Remarque : CER n’est pas borné par 1 (insertions) et dépend de la normalisation (casse, accents, espaces) : la fixer avant toute comparaison.

Théorème 4 (un modèle de langue améliore l’OCR : argument bayésien). Décoder ŷ = argmax_y p(y | X) ∝ p(X | y)p(y) : le modèle de langue p(y) corrige les confusions visuelles (« rn » ↔ « m », « 0 » ↔ « O ») là où le modèle visuel est incertain.

Bayes (L11). Si le reconnaisseur donne p(X | « modem ») ≈ p(X | « rnodem ») (visuellement identiques), le terme p(y) tranche (« rnodem » n’existe pas). En pratique, le score de faisceau log p_CTC(y|X) + α log p_LM(y) réalise cette combinaison, α réglé sur un jeu de validation. Limite : sur des chaînes sans structure linguistique (numéros de série, plaques), p(y) doit être une grammaire (format) et non un modèle de langue général — sinon il « corrige » des codes valides en mots.

01 / Prétraiter

Une image de texte synthétique, Otsu, morphologie, redressement par projection

import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(0)
# Glyphes 7×5 (police bitmap) pour fabriquer des images de texte contrôlées
GLYPHES = {
 "A": ["01110","10001","10001","11111","10001","10001","10001"], "B": ["11110","10001","11110","10001","10001","10001","11110"],
 "C": ["01111","10000","10000","10000","10000","10000","01111"], "O": ["01110","10001","10001","10001","10001","10001","01110"],
 "E": ["11111","10000","10000","11110","10000","10000","11111"],
 "R": ["11110","10001","11110","10100","10010","10001","10001"], "T": ["11111","00100","00100","00100","00100","00100","00100"],
 "1": ["00100","01100","00100","00100","00100","00100","01110"], "2": ["01110","10001","00001","00110","01000","10000","11111"],
 " ": ["00000"] * 7,
}
def rendre(lignes, echelle=3, marge=12):
    H = len(lignes) * (7 * echelle + 10) + 2 * marge; W = max(len(l) for l in lignes) * 6 * echelle + 2 * marge
    img = np.zeros((H, W))
    for r, texte in enumerate(lignes):
        for c, ch in enumerate(texte):
            g = np.array([[int(b) for b in row] for row in GLYPHES[ch]]); g = np.kron(g, np.ones((echelle, echelle)))
            y, x = marge + r * (7 * echelle + 10), marge + c * 6 * echelle; img[y:y + g.shape[0], x:x + g.shape[1]] = g
    return img
def rotation(img, deg):                                     # rotation par plus proche voisin (suffisant ici)
    H, W = img.shape; t = np.deg2rad(deg); cy, cx = H / 2, W / 2; ys, xs = np.mgrid[0:H, 0:W]
    xr = np.cos(t) * (xs - cx) + np.sin(t) * (ys - cy) + cx; yr = -np.sin(t) * (xs - cx) + np.cos(t) * (ys - cy) + cy
    xi, yi = np.rint(xr).astype(int), np.rint(yr).astype(int); ok = (xi >= 0) & (xi < W) & (yi >= 0) & (yi < H)
    out = np.zeros_like(img); out[ok] = img[yi[ok], xi[ok]]; return out
propre = rendre(["ROBOT 12", "CARTE A"]); scan = rotation(propre, 4)
scan = 0.75 * scan + 0.15 + rng.normal(0, 0.12, scan.shape) + np.linspace(0, 0.25, scan.shape[1])[None, :]   # contraste faible, bruit, éclairage
def otsu(g):
    h, _ = np.histogram(g, 256, (g.min(), g.max() + 1e-9)); p = h / h.sum(); w0 = np.cumsum(p); mu = np.cumsum(p * np.arange(256))
    inter = (mu[-1] * w0 - mu) ** 2 / (w0 * (1 - w0) + 1e-12); t = inter.argmax()
    return g.min() + (t + 0.5) / 256 * (g.max() - g.min())
def sauvola(g, fen=25, k=0.3):
    from numpy.lib.stride_tricks import sliding_window_view
    p = fen // 2; gp = np.pad(g, p, mode="reflect"); w = sliding_window_view(gp, (fen, fen))
    m, s = w.mean((-1, -2)), w.std((-1, -2)); return g > m * (1 + k * (s / 0.5 - 1))
def erosion(b, r=1): from numpy.lib.stride_tricks import sliding_window_view as s; return s(np.pad(b, r, constant_values=True), (2*r+1, 2*r+1)).all((-1, -2))
def dilatation(b, r=1): from numpy.lib.stride_tricks import sliding_window_view as s; return s(np.pad(b, r, constant_values=False), (2*r+1, 2*r+1)).any((-1, -2))
bin_otsu = scan > otsu(scan); bin_sauv = sauvola(scan); ouvert = dilatation(erosion(bin_sauv))
def skew(b, angles=np.arange(-8, 8.1, 0.5)):               # angle qui maximise la variance du profil de projection horizontale
    return angles[np.argmax([rotation(b.astype(float), a).sum(1).var() for a in angles])]
a = skew(ouvert); redresse = rotation(ouvert.astype(float), -a) > 0.5
fig, ax = plt.subplots(2, 3, figsize=(12, 5.5))
for axe, im, t in zip(ax.ravel(), [scan, bin_otsu, bin_sauv, ouvert, redresse, redresse.sum(1)[:, None] * np.ones((1, 40))], ["scan (bruit, éclairage, 4°)", "Otsu (global) : le gradient d'éclairage gêne", "Sauvola (local)", "ouverture (bruit ôté)", f"redressé (skew estimé {-a:+.1f}°)", "profil de projection"]):
    axe.imshow(im, cmap="gray"); axe.set_title(t, fontsize=9); axe.axis("off")
plt.tight_layout(); plt.show()

01 / Prétraiter

Segmenter : lignes par projection, caractères par composantes connexes, puis reconnaître par gabarits

import numpy as np
def lignes_par_projection(b):
    prof = b.sum(1); dedans, out, deb = False, [], 0
    for i, v in enumerate(prof):
        if v > 0 and not dedans: dedans, deb = True, i
        elif v == 0 and dedans: dedans = False; out.append((deb, i))
    if dedans: out.append((deb, len(prof)))
    return out
def composantes(b):                                           # étiquetage 8-connexe par parcours (L05) ; renvoie les boîtes
    H, W = b.shape; vu = np.zeros_like(b, bool); boites = []
    for y in range(H):
        for x in range(W):
            if b[y, x] and not vu[y, x]:
                pile = [(y, x)]; vu[y, x] = True; ys, xs = [], []
                while pile:
                    cy, cx = pile.pop(); ys.append(cy); xs.append(cx)
                    for dy in (-1, 0, 1):
                        for dx in (-1, 0, 1):
                            ny, nx = cy + dy, cx + dx
                            if 0 <= ny < H and 0 <= nx < W and b[ny, nx] and not vu[ny, nx]: vu[ny, nx] = True; pile.append((ny, nx))
                boites.append((min(ys), max(ys) + 1, min(xs), max(xs) + 1))
    return boites
def normaliser(patch, h=7, w=5):                              # redimensionner un glyphe à 7×5 par moyenne par blocs
    H, W = patch.shape; ys = (np.arange(h + 1) * H / h).astype(int); xs = (np.arange(w + 1) * W / w).astype(int)
    return np.array([[patch[ys[i]:max(ys[i+1], ys[i]+1), xs[j]:max(xs[j+1], xs[j]+1)].mean() for j in range(w)] for i in range(h)])
gabarits = {ch: np.array([[int(c) for c in r] for r in rows], float) for ch, rows in GLYPHES.items() if ch != " "}
def reconnaitre(patch):
    v = normaliser(patch); return max(gabarits, key=lambda ch: -np.abs(gabarits[ch] - v).sum())   # plus proche gabarit (distance L1)
texte_lu = []
for (y0, y1) in lignes_par_projection(redresse):
    ligne = redresse[y0:y1]; boites = sorted(composantes(ligne), key=lambda b: b[2]); boites = [b for b in boites if (b[1]-b[0]) * (b[3]-b[2]) > 15]
    mots, prev_x1 = [], None
    for (a, b, c, d) in boites:
        if prev_x1 is not None and c - prev_x1 > 8: mots.append(" ")                  # grand espace = séparateur de mots
        mots.append(reconnaitre(ligne[a:b, c:d])); prev_x1 = d
    texte_lu.append("".join(mots))
print("texte reconnu :", texte_lu, "| attendu : ['ROBOT 12', 'CARTE A']")
def levenshtein(a, b):
    D = np.arange(len(b) + 1)
    for i, ca in enumerate(a, 1):
        prev, D[0] = D[0], i
        for j, cb in enumerate(b, 1): prev, D[j] = D[j], min(D[j] + 1, D[j - 1] + 1, prev + (ca != cb))
    return int(D[-1])
ref = "ROBOT 12\nCARTE A"; hyp = "\n".join(texte_lu); print(f"CER = {levenshtein(hyp, ref) / len(ref):.3f}")

Ce pipeline « classique » (années 1990) marche sur du texte propre et une police connue ; il casse dès que la police, la taille ou le fond changent. C’est exactement pourquoi la reconnaissance est passée aux modèles appris sur des lignes entières — mais le prétraitement, lui, reste utile.

02 / Apprendre

La perte CTC, implémentée : alignement sans segmentation

import numpy as np
def ctc_log_vraisemblance(logp, y, blanc=0):
    """logp : (T, C) log-probabilités par trame ; y : liste d'indices de caractères (sans blanc). Retourne log p(y | X)."""
    yp = [blanc];
    for c in y: yp += [c, blanc]                                      # séquence augmentée ε y1 ε y2 … ε
    S, T = len(yp), len(logp); NEG = -1e30
    alpha = np.full((T, S), NEG); alpha[0, 0] = logp[0, blanc]
    if S > 1: alpha[0, 1] = logp[0, yp[1]]
    def lse(*v): m = max(v); return m + np.log(sum(np.exp(x - m) for x in v)) if m > NEG / 2 else NEG
    for t in range(1, T):
        for s in range(S):
            cands = [alpha[t - 1, s]]
            if s >= 1: cands.append(alpha[t - 1, s - 1])
            if s >= 2 and yp[s] != blanc and yp[s] != yp[s - 2]: cands.append(alpha[t - 1, s - 2])
            alpha[t, s] = lse(*cands) + logp[t, yp[s]]
    return lse(alpha[T - 1, S - 1], alpha[T - 1, S - 2]) if S > 1 else alpha[T - 1, 0]
def reduire(chemin, blanc=0):
    out, prev = [], None
    for c in chemin:
        if c != prev and c != blanc: out.append(c)
        prev = c
    return out
# Vérification par force brute : somme sur tous les alignements de longueur T dont la réduction est y
rng = np.random.default_rng(0); T, C = 6, 4; logits = rng.normal(0, 1, (T, C)); logp = logits - np.log(np.exp(logits).sum(1, keepdims=True))
import itertools
def brute(y):
    return np.log(sum(np.exp(sum(logp[t, c] for t, c in enumerate(pi))) for pi in itertools.product(range(C), repeat=T) if reduire(pi) == list(y)))
for y in ([1], [1, 2], [2, 2], [3, 1, 3]):
    print(f"y = {y} : CTC {ctc_log_vraisemblance(logp, y):9.4f}   force brute {brute(y):9.4f}")
# Décodage glouton et son piège
chemin = logp.argmax(1); print("\nargmax par trame :", chemin.tolist(), "→ réduit :", reduire(chemin))
print("Le glouton choisit le meilleur ALIGNEMENT, pas la meilleure SÉQUENCE (plusieurs alignements se cumulent sur une même sortie) : la recherche en faisceau corrige cela.")

CTC est ce qui a rendu possible l’OCR de lignes (CRNN, Tesseract 4) et la reconnaissance vocale de bout en bout (L30) : le réseau émet une distribution par colonne d’image ou par trame audio, et la perte somme sur tous les alignements compatibles avec la transcription — aucune annotation de position n’est nécessaire.

03 / Modèles

Vue informatique : les architectures d’OCR, du CRNN aux modèles vision-langage

Modèle	Architecture	Forces	Limites	Coût
Tesseract 4/5	LSTM + CTC sur lignes, segmentation classique	Libre, 100+ langues, rapide CPU, sortie hOCR/positions	Fragile sur photos, mises en page complexes, manuscrit	~0,5 s/page CPU
CRNN (Shi 2015)	CNN → BiLSTM → CTC	Simple, entraînable sur ses données	Lignes seulement ; détection à part	ms/ligne GPU
PaddleOCR / EasyOCR	Détection (DBNet) + reconnaissance (SVTR/CRNN)	Photos, scènes, multilingue, open source	Compréhension de structure limitée	~50 ms/image GPU
TrOCR (Li 2021)	Encodeur ViT + décodeur texte (BART/RoBERTa) pré-entraînés	Manuscrit, imprimé ; SOTA sur IAM, SROIE	Lignes ; lourd ; pas de détection	~100 ms/ligne GPU
LayoutLMv3, Donut, Nougat	Multimodal texte+position+image ; Donut/Nougat sans OCR (image → JSON/Markdown)	Formulaires, tableaux, articles scientifiques	Domaine d’entraînement ; hallucinations de champs	s/page GPU
VLM (GPT-4V, Claude, Qwen-VL, PaliGemma)	Encodeur image + LLM	Lecture + raisonnement + structure en un prompt ; zero-shot	Coût, latence, hallucinations sur les chiffres, pas de positions précises, données qui sortent	1–10 s/page, ¢ par page

Choisir (L34) : documents propres et volumineux → Tesseract/Paddle (coût ~0) ; photos et scènes → Paddle/EasyOCR ; manuscrit → TrOCR affiné ; formulaires et tableaux avec structure → LayoutLM/Donut ou VLM ; besoin de raisonner sur le contenu → VLM, avec vérification des nombres par un OCR classique (deux systèmes qui s’accordent = confiance).

04 / Évaluer

CER, WER, matrice de confusion, et les pièges de normalisation

import numpy as np, re, unicodedata
from collections import Counter
def levenshtein_ops(a, b):
    """Distance + liste des opérations (pour la matrice de confusion)."""
    n, m = len(a), len(b); D = np.zeros((n + 1, m + 1), int); D[:, 0] = np.arange(n + 1); D[0, :] = np.arange(m + 1)
    for i in range(1, n + 1):
        for j in range(1, m + 1): D[i, j] = min(D[i-1, j] + 1, D[i, j-1] + 1, D[i-1, j-1] + (a[i-1] != b[j-1]))
    ops, i, j = [], n, m
    while i > 0 or j > 0:
        if i > 0 and j > 0 and D[i, j] == D[i-1, j-1] + (a[i-1] != b[j-1]):
            if a[i-1] != b[j-1]: ops.append(("sub", a[i-1], b[j-1]))
            i, j = i - 1, j - 1
        elif i > 0 and D[i, j] == D[i-1, j] + 1: ops.append(("del", a[i-1], "")); i -= 1
        else: ops.append(("ins", "", b[j-1])); j -= 1
    return D[n, m], ops
def cer(hyp, ref): return levenshtein_ops(ref, hyp)[0] / max(1, len(ref))
def wer(hyp, ref): return levenshtein_ops(ref.split(), hyp.split())[0] / max(1, len(ref.split()))
def normaliser(s, casse=True, accents=True, espaces=True):
    if accents: s = "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
    if casse: s = s.lower()
    if espaces: s = re.sub(r"\s+", " ", s).strip()
    return s
ref = "Le robot R2 mesure 3,20 m. Tension : 12 V ; courant 2,7 A."
hyps = {"OCR A": "Le robot R2 mesure 3,20 m. Tension : 12 V ; courant 2,7 A.", "OCR B": "Le rob0t R2 mesure 3.20 rn. Tension: 12 V; courant 2,7 A", "OCR C": "LE ROBOT R2 MESURE 3,20 M. TENSION : 12 V ; COURANT 2,7 A."}
print(f"{'système':8s} {'CER brut':>9s} {'WER brut':>9s} {'CER norm.':>10s} {'WER norm.':>10s}")
for nom, h in hyps.items(): print(f"{nom:8s} {cer(h, ref):9.3f} {wer(h, ref):9.3f} {cer(normaliser(h), normaliser(ref)):10.3f} {wer(normaliser(h), normaliser(ref)):10.3f}")
_, ops = levenshtein_ops(ref, hyps["OCR B"]); conf = Counter((a, b) for op, a, b in ops if op == "sub")
print("\nconfusions d'OCR B :", dict(conf), "| insertions/suppressions :", sum(1 for o in ops if o[0] != "sub"))
print("OCR C est « parfait » après normalisation de casse : la normalisation fait partie de la définition de la métrique — la déclarer.")

Sur des documents à valeur (factures, relevés), le CER moyen cache l’essentiel : une erreur sur un chiffre d’un montant est grave, une sur une lettre d’un mot ne l’est pas. Mesurer aussi l’exactitude par champ (montant exact ? date exacte ?) et le taux de documents entièrement corrects — c’est ce que le métier verra.

05 / Articles

Les articles à lire

Article	Contribution	À retenir
Otsu, A Threshold Selection Method from Gray-Level Histograms, IEEE SMC 1979	Seuil optimal par variance inter-classe	Théorème 1 ; global, donc sensible à l’éclairage → Sauvola (2000)
Graves et al., Connectionist Temporal Classification, ICML 2006	Perte CTC pour séquences non alignées	Théorème 2 ; base de l’OCR et de l’ASR de bout en bout
Shi et al., An End-to-End Trainable Neural Network for Image-based Sequence Recognition (CRNN), 2015 — 1507.05717	CNN + BiLSTM + CTC sur lignes	L’architecture de référence pendant 5 ans
Smith, An Overview of the Tesseract OCR Engine, ICDAR 2007 ; Tesseract 4 (LSTM) 2018	Pipeline complet libre	Lire pour comprendre ce qu’un pipeline « classique » contient
Baek et al., What Is Wrong With Scene Text Recognition Model Comparisons?, ICCV 2019 — 1904.01906	Comparaison honnête : mêmes données, mêmes protocoles	Les écarts publiés venaient souvent des données d’entraînement, pas des modèles (L24)
Liao et al., Real-time Scene Text Detection with Differentiable Binarization (DBNet), AAAI 2020 — 1911.08947	Détection de texte par segmentation + binarisation apprise	Détecteur de PaddleOCR
Li et al., TrOCR, 2021 — 2109.10282	Transformer image→texte pré-entraîné, sans CNN ni CTC	Le pré-entraînement (synthétique + réel) fait la différence
Xu et al., LayoutLM, KDD 2020 — 1912.13318 ; Huang et al., LayoutLMv3, 2022 — 2204.08387	Texte + position 2D + image pour la compréhension de documents	Extraction clé-valeur, classification de documents
Kim et al., Donut: OCR-free Document Understanding, ECCV 2022 — 2111.15664	Image → JSON directement	Pas d’erreurs d’OCR en cascade, mais hallucinations possibles
Blecher et al., Nougat, 2023 — 2308.13418	PDF scientifique → Markdown avec formules	Utile pour alimenter un RAG (L26)
Liu et al., OCRBench, 2023 — 2305.07895	Benchmark des VLM sur l’OCR	Les VLM lisent bien mais comptent et alignent mal (tableaux, chiffres)

TP guidé

TP — Trois OCR sur vos documents, comparés (5 h)

Corpus. 30 pages variées (scan propre, photo de smartphone, ticket, tableau, manuscrit) avec transcription de référence (tapée à la main, normalisation fixée). 10 avec des champs à extraire (date, montant, référence).
Prétraitement. OpenCV : niveaux de gris, Sauvola (cv2.ximgproc.niBlackThreshold ou implémentation), redressement (Hough cv2.HoughLines), déformation de perspective pour les photos (getPerspectiveTransform). Mesurer le CER avec/sans.
Trois moteurs. Tesseract (pytesseract, --psm adapté), PaddleOCR, et un VLM (API ou Qwen2-VL local). Même prompt de normalisation. Tableau : CER, WER, exactitude par champ, taux de pages parfaites, temps, coût.
Analyse d’erreurs. Matrice de confusion des caractères par moteur ; les 10 pires pages : pourquoi ? (résolution, police, fond, mise en page). Une figure « CER en fonction de la hauteur de texte en pixels ».
Post-traitement. Correction par dictionnaire (SymSpell) et par grammaire de champs (regex de date/montant) ; accord entre deux moteurs comme score de confiance ; mesurer le gain.
Livrable. Dépôt (pipeline, évaluation, jeu annoté), rapport, et une recommandation : quel moteur pour quel type de document, avec les chiffres.

Exercices

Exercices auto-corrigés

Exercice 1 — Otsu et sa propriété

Réimplémentez otsu_seuil(pixels) sur des valeurs entières 0–255 (histogramme, sommes cumulées, argmax de la variance inter-classe) et vérifiez le Théorème 1 : σ²_intra + σ²_inter = σ²_totale pour tout seuil, et le seuil sépare deux modes.

Correction

def otsu_seuil(pixels):
    h = np.bincount(pixels, minlength=256).astype(float); p = h / h.sum(); w0 = np.cumsum(p); m = np.cumsum(p * np.arange(256))
    mt = m[-1]; inter = (mt * w0 - m) ** 2 / (w0 * (1 - w0) + 1e-12)
    return int(np.argmax(inter))

Exercice 2 — Décodage CTC par faisceau (préfixes)

Implémentez ctc_faisceau(logp, largeur, blanc=0) : recherche en faisceau sur les préfixes réduits, en maintenant pour chaque préfixe deux probabilités (se terminant par blanc / par non-blanc) — l’algorithme de Graves. Vérifiez qu’il trouve la séquence de probabilité totale maximale sur un petit cas où le glouton se trompe.

import numpy as np, itertools
def ctc_faisceau(logp, largeur=4, blanc=0):
    ...   # à vous → liste d'indices (meilleure séquence)

# Cas où le glouton échoue : deux alignements différents produisent [1], un seul produit [2] mais il est le plus probable individuellement
p = np.array([[0.4, 0.35, 0.25], [0.4, 0.35, 0.25]]); logp = np.log(p)     # trames : (ε, 1, 2)
def reduire(ch, b=0):
    out, prev = [], None
    for c in ch:
        if c != prev and c != b: out.append(c)
        prev = c
    return out
tot = {}
for pi in itertools.product(range(3), repeat=2): tot.setdefault(tuple(reduire(pi)), 0); tot[tuple(reduire(pi))] += np.exp(logp[0, pi[0]] + logp[1, pi[1]])
best = max(tot, key=tot.get); print("probabilités totales par séquence :", {k: round(v, 3) for k, v in tot.items()}, "→ meilleure :", best)
assert list(best) == ctc_faisceau(logp, 4), ctc_faisceau(logp, 4)
assert reduire(logp.argmax(1)) != list(best)                    # le glouton donne [] (ε ε) ici
print("✔ exercice 2 réussi")

Correction

def ctc_faisceau(logp, largeur=4, blanc=0):
    from collections import defaultdict
    T, C = logp.shape; P = np.exp(logp)
    faisceau = {(): (1.0, 0.0)}                     # préfixe → (p_blanc, p_nonblanc)
    for t in range(T):
        nouveau = defaultdict(lambda: [0.0, 0.0])
        for pref, (pb, pnb) in faisceau.items():
            nouveau[pref][0] += (pb + pnb) * P[t, blanc]                       # émettre un blanc
            if pref: nouveau[pref][1] += pnb * P[t, pref[-1]]                  # répéter le dernier caractère (fusionné)
            for c in range(C):
                if c == blanc: continue
                ext = pref + (c,)
                if pref and c == pref[-1]: nouveau[ext][1] += pb * P[t, c]      # même caractère : seulement après un blanc
                else: nouveau[ext][1] += (pb + pnb) * P[t, c]
        faisceau = dict(sorted(nouveau.items(), key=lambda kv: -(kv[1][0] + kv[1][1]))[:largeur])
        faisceau = {k: (v[0], v[1]) for k, v in faisceau.items()}
    return list(max(faisceau, key=lambda k: sum(faisceau[k])))

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Exactitude par champ et taux de documents parfaits

Écrivez evaluer_champs(refs, hyps) : listes de dicts {champ: valeur} ; renvoyer (exactitude par champ : dict champ → fraction exacte après normalisation espaces/casse, taux de documents entièrement corrects, CER moyen sur les valeurs concaténées).

import numpy as np, re
def levenshtein(a, b):
    D = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        prev, D[0] = D[0], i
        for j, cb in enumerate(b, 1): prev, D[j] = D[j], min(D[j] + 1, D[j - 1] + 1, prev + (ca != cb))
    return D[-1]
def evaluer_champs(refs, hyps):
    ...   # à vous

refs = [{"date": "12/03/2026", "montant": "48,90", "ref": "F-2291"}, {"date": "01/04/2026", "montant": "1200,00", "ref": "F-2302"}, {"date": "15/04/2026", "montant": "7,50", "ref": "F-2310"}]
hyps = [{"date": "12/03/2026", "montant": "48,90", "ref": "F-2291"}, {"date": "01/04/2026", "montant": "1200,00", "ref": "f-2302 "}, {"date": "15/04/2026", "montant": "7,5O", "ref": "F-2310"}]
par_champ, parfaits, cer_moy = evaluer_champs(refs, hyps)
assert par_champ == {"date": 1.0, "montant": 2/3, "ref": 1.0} and abs(parfaits - 2/3) < 1e-9
assert 0 < cer_moy < 0.05
print(f"✔ exercice 3 réussi : {par_champ}, documents parfaits {parfaits:.2f}, CER {cer_moy:.3f} — un CER de 1 % cache 33 % de documents faux")

Correction

def evaluer_champs(refs, hyps):
    norm = lambda s: re.sub(r"\s+", " ", str(s)).strip().lower()
    champs = list(refs[0]); exact = {c: np.mean([norm(r[c]) == norm(h.get(c, "")) for r, h in zip(refs, hyps)]) for c in champs}
    parfaits = np.mean([all(norm(r[c]) == norm(h.get(c, "")) for c in champs) for r, h in zip(refs, hyps)])
    cers = [levenshtein(norm("|".join(h.get(c, "") for c in champs)), norm("|".join(r[c] for c in champs))) / len("|".join(r[c] for c in champs)) for r, h in zip(refs, hyps)]
    return exact, float(parfaits), float(np.mean(cers))

Exercice 4 — Correction par grammaire de champ

Écrivez corriger_montant(s) qui applique les confusions OCR classiques dans un contexte numérique (O→0, l/I→1, S→5, B→8, « . » ou « , » décimal → « , »), et corriger_date(s) (même idée + format JJ/MM/AAAA avec validation : mois 1–12, jour 1–31). Les chaînes déjà valides ne changent pas ; une chaîne irrécupérable renvoie None.

Correction

TABLE = str.maketrans({"O": "0", "o": "0", "l": "1", "I": "1", "S": "5", "B": "8"})
def corriger_montant(s):
    t = s.strip().translate(TABLE).replace(".", ",")
    return t if re.fullmatch(r"\d+(,\d{2})?", t) else None
def corriger_date(s):
    t = s.strip().translate(TABLE); m = re.fullmatch(r"(\d{2})/(\d{2})/(\d{4})", t)
    if not m: return None
    j, mo, a = map(int, m.groups()); return t if 1 <= j <= 31 and 1 <= mo <= 12 else None

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Un OCR donne un CER de 2 % sur des factures. Le métier constate que 30 % des montants sont faux. Expliquer et proposer une évaluation.

Correction. Le CER moyen est dominé par le texte courant (adresses, libellés), abondant et facile ; les montants sont rares (quelques caractères par page) et difficiles (chiffres sans contexte linguistique, polices variées, alignements de colonnes). 2 % de CER global peut donc coexister avec 30 % de montants faux (exercice 3). Évaluation : exactitude par champ, taux de documents parfaits, matrice de confusion restreinte aux chiffres, CER sur les zones numériques ; et un post-traitement par grammaire (exercice 4) + vérification arithmétique (somme des lignes = total) qui détecte la plupart des erreurs restantes.

Exercice 2. Pourquoi CTC impose-t-il un blanc entre deux caractères identiques (« ll » dans « balle ») ? Que se passerait-il sans ?

Correction. La fonction de réduction B fusionne les répétitions consécutives : sans blanc, l’alignement « b a l l e » se réduirait en « bale ». Le blanc sépare : « b a l ε l e » → « balle ». C’est pourquoi la récurrence interdit le saut s−2 quand y′_s = y′_s−2 (Théorème 2), et pourquoi T doit être ≥ |y| + nombre de doublons consécutifs : une image trop étroite (peu de colonnes) rend certaines transcriptions impossibles — d’où le sous-échantillonnage horizontal limité (facteur 4) dans les CRNN.

Exercice 3. Un VLM lit correctement un tableau de 8 colonnes mais décale parfois les valeurs d’une colonne. Diagnostic et remède.

Correction. Un VLM produit du texte token par token à partir de patchs d’image ; il n’a pas de notion de coordonnées exactes et « devine » l’alignement des colonnes à partir de régularités apprises — il peut donc décaler des cellules de façon plausible (hallucination structurelle), ce que le CER ne mesure pas. Remèdes : (1) détecter la structure du tableau avec un modèle dédié (Table Transformer, PaddleOCR-structure) qui donne les cellules avec positions, puis reconnaître cellule par cellule ; (2) demander au VLM une sortie JSON par ligne avec l’en-tête répété, et vérifier les contraintes (types, sommes) ; (3) évaluer par cellule (exactitude de position + valeur), pas par CER ; (4) accord entre deux systèmes comme confiance, revue humaine sur les désaccords.

Vérification

Quel est l’apport principal de la perte CTC pour l’OCR de lignes ?

Deux questions supplémentaires

1. Pourquoi Otsu échoue-t-il sur un scan mal éclairé ? Le seuil est global ; un gradient d’éclairage mélange les deux modes → seuil local (Sauvola).

2. Pourquoi mesurer l’exactitude par champ en plus du CER ? Le CER est dominé par le texte facile ; les champs critiques (montants) sont rares et durs.

Référence

Les mots à retenir

Mot	Définition
Binarisation (Otsu, Sauvola)	Seuil global par variance inter-classe / seuil local par moyenne et écart-type.
Morphologie	Érosion, dilatation, ouverture, fermeture sur images binaires.
Skew	Inclinaison du document ; Hough ou variance de projection.
CTC	Perte de séquence sans alignement, avec blanc et réduction.
CER / WER	Taux d’erreur par Levenshtein ; dépend de la normalisation.
CRNN / TrOCR	CNN+LSTM+CTC / ViT+décodeur : reconnaissance de lignes.
LayoutLM / Donut	Compréhension de documents : structure et champs.
VLM	Lecture et raisonnement zero-shot ; vérifier chiffres et structure.

Suite

Après l’image, le son.

La reconnaissance vocale partage avec l’OCR la perte CTC et les encodeurs-décodeurs — mais le signal est une onde. Chapitre suivant : du spectrogramme à Whisper.

← L28 Sommaire L30 : ASR →