audit scientifique: micro-CER/WER, Wilcoxon exact, alignement Levenshtein

Corrige quatre défauts de fiabilité scientifique identifiés à l'audit
(le chemin de production par défaut est sans scipy — fallbacks natifs).

F1 — Agrégation corpus macro-aveugle à la longueur. MetricsResult
stocke désormais les comptes bruts de l'alignement minimal jiwer
(cer_errors/cer_ref_chars, wer_errors/wer_ref_words) ; aggregate_metrics
expose cer_micro/wer_micro = Σ erreurs / Σ unités_référence (standard
ICDAR/OCR-D/HTR-United). ranking() et stratified_ranking() trient
désormais sur le micro-CER (repli médiane→moyenne). mean/median
conservés comme diagnostics de dispersion. Valeurs CER/WER
inchangées (process_characters().cer ≡ jiwer.cer).

F2 — Wilcoxon natif renvoyait des p-values fabriquées {0.04, 0.20} et
un faux positif "significatif" pour n ≤ 5 (impossible à 5 % bilatéral).
Remplacé par la distribution nulle exacte de W⁺ (DP sur 2ⁿ, n ≤ 25
sans ex-aequo), approximation normale corrigée des ex-aequo sinon.
Vérifié contre les tables (n=8 W=3 → 0.0390625, etc.).

F4 — Matrice de confusion et diffs (_diff_utils) passaient par
difflib (Ratcliff–Obershelp, non minimal) tout en annonçant
"Levenshtein" ; comptes S/D/I incohérents avec le CER affiché à côté.
Bascule sur rapidfuzz.distance.Levenshtein ; blocs replace garantis
de longueur égale → suppression de l'heuristique _align_segments.
S+D+I de la matrice = distance d'édition exacte.

F9 — Correction de continuité Wilcoxon ramenée à (|W−μ|−½)/σ bornée
à 0 ; plus de double retrait des zéros avant scipy.
F10 — char_exclude appliqué avant le court-circuit des cas vides.

Tests : régression dédiée tests/evaluation/test_scientific_audit_2026.py
(F1/F2/F4/F9) ; test_sprint44 révisé (micro par défaut, médiane=repli) ;
golden benchmark_result régénéré (champs micro additifs) ; budget LOC
benchmark_result relevé.

https://claude.ai/code/session_01KTzTK55Hxu8AR72xJUjcUW

picarones/evaluation/_diff_utils.py

@@ -20,19 +20,19 @@ au niveau du package).
 
 from __future__ import annotations
 
-import difflib
-import re
 from typing import Any
 
+from rapidfuzz.distance import Levenshtein
 
-def _tokenize(text: str) -> list[str]:
-    """Découpe le texte en tokens (mots + ponctuation + espaces).
-
-    Les espaces sont conservés comme tokens pour permettre un
-    rendu fidèle dans le rapport HTML (la coloration mot-à-mot
-    doit pouvoir réintercaler les espaces d'origine).
-    """
-    return re.split(r"(\s+)", text)
+# Audit scientifique F4 — l'alignement utilise la distance de
+# **Levenshtein** (rapidfuzz, coûts substitution = insertion =
+# suppression = 1), et non plus ``difflib.SequenceMatcher``
+# (Ratcliff–Obershelp, qui maximise les blocs communs et ne minimise
+# pas le nombre d'éditions).  Conséquence : le diff affiché, les
+# ensembles de Venn et les clusters d'erreurs sont désormais
+# **cohérents avec le CER/WER** (jiwer, lui aussi Levenshtein) montrés
+# à côté.  Auparavant deux algorithmes différents produisaient des
+# comptes contradictoires dans le même rapport.
 
 
 def compute_word_diff(reference: str, hypothesis: str) -> list[dict[str, Any]]:
@@ -53,12 +53,13 @@ def compute_word_diff(reference: str, hypothesis: str) -> list[dict[str, Any]]:
     ref_tokens = reference.split()
     hyp_tokens = hypothesis.split()
 
-    matcher = difflib.SequenceMatcher(
-        None, ref_tokens, hyp_tokens, autojunk=False,
-    )
     ops: list[dict[str, Any]] = []
 
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+    for op in Levenshtein.opcodes(ref_tokens, hyp_tokens):
+        i1, i2, j1, j2 = (
+            op.src_start, op.src_end, op.dest_start, op.dest_end,
+        )
+        tag = op.tag
         ref_chunk = " ".join(ref_tokens[i1:i2])
         hyp_chunk = " ".join(hyp_tokens[j1:j2])
 
@@ -76,12 +77,13 @@ def compute_word_diff(reference: str, hypothesis: str) -> list[dict[str, Any]]:
 
 def compute_char_diff(reference: str, hypothesis: str) -> list[dict[str, Any]]:
     """Diff caractère par caractère — utile pour les tokens courts."""
-    matcher = difflib.SequenceMatcher(
-        None, list(reference), list(hypothesis), autojunk=False,
-    )
     ops: list[dict[str, Any]] = []
 
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+    for op in Levenshtein.opcodes(reference, hypothesis):
+        i1, i2, j1, j2 = (
+            op.src_start, op.src_end, op.dest_start, op.dest_end,
+        )
+        tag = op.tag
         ref_chunk = reference[i1:i2]
         hyp_chunk = hypothesis[j1:j2]
         if tag == "equal":

picarones/evaluation/benchmark_result.py

@@ -382,6 +382,26 @@ class EngineReport:
                 [dr.metrics for dr in self.document_results]
             )
 
+    @property
+    def micro_cer(self) -> Optional[float]:
+        """CER **micro-moyenné** corpus = Σ distance_édition / Σ car_référence.
+
+        Audit scientifique F1 — métrique d'agrégation standard du domaine
+        OCR/HTR (ICDAR, OCR-D, HTR-United, Transkribus, eScriptorium).
+        Contrairement à ``mean_cer`` / ``median_cer`` (macro, aveugles à
+        la longueur), elle pondère chaque document par son nombre de
+        caractères : une page de 5 000 caractères pèse 500× une légende
+        de 10.  C'est le critère de tri par défaut de ``ranking()``.
+        ``None`` si aucun document n'a de comptes bruts (jiwer absent,
+        références vides).
+        """
+        return self.aggregated_metrics.get("cer_micro", {}).get("value")
+
+    @property
+    def micro_wer(self) -> Optional[float]:
+        """WER micro-moyenné corpus = Σ erreurs_mot / Σ mots_référence."""
+        return self.aggregated_metrics.get("wer_micro", {}).get("value")
+
     @property
     def mean_cer(self) -> Optional[float]:
         cer_stats = self.aggregated_metrics.get("cer", {})
@@ -540,27 +560,40 @@ class BenchmarkResult:
     )
 
     def ranking(self) -> list[dict]:
-        """Retourne le classement des moteurs trié par **médiane CER** croissante.
-
-        Sprint 44 — A.I.2 du plan d'évolution : le tri par défaut bascule
-        de la moyenne vers la médiane.  Sur des distributions
-        asymétriques (typique des corpus patrimoniaux : 80 % des docs
-        à 3 % de CER, 20 % à 40 %), la moyenne est tirée par quelques
-        documents catastrophiques et masque les performances réelles.
-        La médiane est plus représentative ; cohérente aussi avec le
-        test de Friedman qui travaille déjà sur les rangs (Sprint 18).
-
-        Le champ ``mean_cer`` est conservé dans chaque entrée pour
-        rétrocompatibilité — les consommateurs (CLI, détecteurs
-        narratifs, vue HTML) continuent à pouvoir l'afficher en colonne
-        secondaire.  Le tri prend ``median_cer`` quand disponible et
-        retombe sur ``mean_cer`` sinon.
+        """Classement des moteurs trié par **CER micro-moyenné** croissant.
+
+        Audit scientifique F1 (mai 2026) — le tri par défaut bascule vers
+        le **micro-CER** (Σ distance_édition / Σ caractères_référence),
+        métrique d'agrégation standard du domaine OCR/HTR (ICDAR, OCR-D,
+        HTR-United, Transkribus, eScriptorium).  C'est la seule agrégation
+        défendable scientifiquement comme chiffre d'en-tête : elle
+        pondère chaque document par sa longueur, là où une moyenne ou une
+        médiane de taux par document donne le même poids à une légende de
+        10 caractères et à une page de 5 000 et peut inverser le
+        classement réel des moteurs.
+
+        Historique : Sprint 44 avait basculé moyenne → médiane pour la
+        robustesse à l'asymétrie des corpus patrimoniaux.  Le diagnostic
+        de fond (la *moyenne* est tirée par quelques documents
+        catastrophiques) est exact, mais la *réponse* correcte n'est pas
+        la médiane de taux (toujours aveugle à la longueur) : c'est le
+        micro-CER.  ``mean_cer`` et ``median_cer`` restent exposés dans
+        chaque entrée comme **diagnostics de dispersion** (un grand écart
+        micro↔médiane signale une distribution très hétérogène — cf.
+        détecteur ``median_mean_gap_warning``), pas comme critère de
+        classement.
+
+        Le tri prend ``micro_cer`` quand disponible et retombe sur
+        ``median_cer`` puis ``mean_cer`` (corpus sans comptes bruts :
+        jiwer absent, références vides).
         """
         ranked = []
         for report in self.engine_reports:
             ranked.append(
                 {
                     "engine": report.engine_name,
+                    "micro_cer": report.micro_cer,
+                    "micro_wer": report.micro_wer,
                     "mean_cer": report.mean_cer,
                     "median_cer": report.median_cer,
                     "mean_wer": report.mean_wer,
@@ -570,8 +603,11 @@ class BenchmarkResult:
             )
 
         def _sort_key(entry: dict) -> tuple:
-            # Priorité : médiane si disponible, sinon moyenne, sinon +∞
-            primary = entry.get("median_cer")
+            # Priorité scientifique : micro-CER ; repli médiane puis
+            # moyenne ; +∞ si rien (moteur sans document exploitable).
+            primary = entry.get("micro_cer")
+            if primary is None:
+                primary = entry.get("median_cer")
             if primary is None:
                 primary = entry.get("mean_cer")
             return (primary is None, primary if primary is not None else float("inf"))
@@ -635,22 +671,39 @@ class BenchmarkResult:
                 # ``Optional[float]`` ; le double filtre ``error is None``
                 # garantit ``cer/wer is not None`` par convention, mais on
                 # le filtre explicitement aussi pour que mypy le voie.
-                cers: list[float] = [
-                    dr.metrics.cer
+                stratum_metrics = [
+                    dr.metrics
                     for dr in report.document_results
                     if dr.doc_id in doc_ids
                     and dr.metrics is not None
                     and dr.metrics.error is None
-                    and dr.metrics.cer is not None
+                ]
+                cers: list[float] = [
+                    m.cer for m in stratum_metrics if m.cer is not None
                 ]
                 wers: list[float] = [
-                    dr.metrics.wer
-                    for dr in report.document_results
-                    if dr.doc_id in doc_ids
-                    and dr.metrics is not None
-                    and dr.metrics.error is None
-                    and dr.metrics.wer is not None
+                    m.wer for m in stratum_metrics if m.wer is not None
                 ]
+                # Micro-CER/WER de la strate (audit F1) — recalcul depuis
+                # les comptes bruts, cohérent avec ``ranking()`` global.
+                tot_ce = sum(
+                    m.cer_errors for m in stratum_metrics
+                    if m.cer_errors is not None and m.cer_ref_chars is not None
+                )
+                tot_cr = sum(
+                    m.cer_ref_chars for m in stratum_metrics
+                    if m.cer_errors is not None and m.cer_ref_chars is not None
+                )
+                tot_we = sum(
+                    m.wer_errors for m in stratum_metrics
+                    if m.wer_errors is not None and m.wer_ref_words is not None
+                )
+                tot_wr = sum(
+                    m.wer_ref_words for m in stratum_metrics
+                    if m.wer_errors is not None and m.wer_ref_words is not None
+                )
+                micro_cer = round(tot_ce / tot_cr, 6) if tot_cr > 0 else None
+                micro_wer = round(tot_we / tot_wr, 6) if tot_wr > 0 else None
                 failed = sum(
                     1 for dr in report.document_results
                     if dr.doc_id in doc_ids
@@ -660,6 +713,8 @@ class BenchmarkResult:
                 if not cers:
                     entries.append({
                         "engine": report.engine_name,
+                        "micro_cer": None,
+                        "micro_wer": None,
                         "mean_cer": None,
                         "median_cer": None,
                         "mean_wer": None,
@@ -669,6 +724,8 @@ class BenchmarkResult:
                     continue
                 entries.append({
                     "engine": report.engine_name,
+                    "micro_cer": micro_cer,
+                    "micro_wer": micro_wer,
                     "mean_cer": _stats.mean(cers),
                     "median_cer": _stats.median(cers),
                     "mean_wer": _stats.mean(wers) if wers else None,
@@ -677,7 +734,9 @@ class BenchmarkResult:
                 })
 
             def _sort_key(entry: dict) -> tuple:
-                primary = entry.get("median_cer")
+                primary = entry.get("micro_cer")
+                if primary is None:
+                    primary = entry.get("median_cer")
                 if primary is None:
                     primary = entry.get("mean_cer")
                 return (primary is None, primary if primary is not None else float("inf"))
@@ -711,24 +770,32 @@ class BenchmarkResult:
             return None
 
         global_ranking = self.ranking()
-        valid = [
-            r for r in global_ranking
-            if r.get("median_cer") is not None
-        ]
+
+        def _repr_cer(entry: dict) -> Optional[float]:
+            # CER représentatif cohérent avec ``ranking()`` : micro
+            # (audit F1) puis repli médiane / moyenne.
+            for key in ("micro_cer", "median_cer", "mean_cer"):
+                v = entry.get(key)
+                if v is not None:
+                    return float(v)
+            return None
+
+        valid = [r for r in global_ranking if _repr_cer(r) is not None]
         if not valid:
             return None
         leader = valid[0]["engine"]
 
-        # CER médian du leader sur chaque strate (où il a au moins 1 doc)
+        # CER représentatif (micro, repli médiane) du leader sur chaque
+        # strate où il a au moins 1 document.
         per_stratum: dict[str, float] = {}
         for stratum, entries in strata_rankings.items():
             for entry in entries:
                 if entry["engine"] != leader:
                     continue
-                med = entry.get("median_cer")
-                if med is None:
+                rc = _repr_cer(entry)
+                if rc is None:
                     continue
-                per_stratum[stratum] = float(med)
+                per_stratum[stratum] = rc
                 break
 
         if len(per_stratum) < 2:

picarones/evaluation/metric_result.py

@@ -44,6 +44,21 @@ class MetricsResult:
     reference_length: int = 0
     hypothesis_length: int = 0
     error: Optional[str] = None
+    # Audit scientifique (F1) — comptes bruts de l'alignement minimal
+    # (jiwer/Levenshtein) nécessaires pour le CER/WER **micro-moyenné**
+    # corpus-wide (Σ erreurs / Σ unités de référence), standard du domaine
+    # OCR/HTR (ICDAR, OCR-D, HTR-United).  ``None`` si le calcul a échoué
+    # ou pour les cas dégénérés (référence vide) où le dénominateur micro
+    # n'est pas défini — l'agrégateur micro saute alors le document.
+    cer_errors: Optional[int] = None
+    """Distance d'édition caractère = substitutions + suppressions + insertions."""
+    cer_ref_chars: Optional[int] = None
+    """Longueur de référence en caractères = substitutions + suppressions + hits
+    (dénominateur exact du CER, identique à celui utilisé par jiwer)."""
+    wer_errors: Optional[int] = None
+    """Distance d'édition mot = substitutions + suppressions + insertions."""
+    wer_ref_words: Optional[int] = None
+    """Nombre de mots de référence = substitutions + suppressions + hits."""
     cer_diplomatic: Optional[float] = None
     """CER calculé après normalisation diplomatique (ſ=s, u=v, i=j…).
     None si aucun profil diplomatique n'a été fourni à compute_metrics.
@@ -66,6 +81,14 @@ class MetricsResult:
             "hypothesis_length": self.hypothesis_length,
             "error": self.error,
         }
+        # Comptes bruts (F1) — sérialisés seulement s'ils sont présents
+        # pour ne pas alourdir le JSON des cas dégénérés / en erreur.
+        if self.cer_errors is not None and self.cer_ref_chars is not None:
+            d["cer_errors"] = self.cer_errors
+            d["cer_ref_chars"] = self.cer_ref_chars
+        if self.wer_errors is not None and self.wer_ref_words is not None:
+            d["wer_errors"] = self.wer_errors
+            d["wer_ref_words"] = self.wer_ref_words
         if self.cer_diplomatic is not None:
             d["cer_diplomatic"] = round(self.cer_diplomatic, 6)
             d["diplomatic_profile_name"] = self.diplomatic_profile_name
@@ -100,6 +123,10 @@ class MetricsResult:
             reference_length=data.get("reference_length", 0),
             hypothesis_length=data.get("hypothesis_length", 0),
             error=data.get("error"),
+            cer_errors=data.get("cer_errors"),
+            cer_ref_chars=data.get("cer_ref_chars"),
+            wer_errors=data.get("wer_errors"),
+            wer_ref_words=data.get("wer_ref_words"),
             cer_diplomatic=data.get("cer_diplomatic"),
             diplomatic_profile_name=data.get("diplomatic_profile_name"),
         )
@@ -163,6 +190,48 @@ def aggregate_metrics(results: list[MetricsResult]) -> dict:
         if profile_name:
             aggregated["cer_diplomatic"]["profile"] = profile_name
 
+    # ──────────────────────────────────────────────────────────────────
+    # CER / WER **micro-moyennés** (audit scientifique F1)
+    #
+    # Standard du domaine OCR/HTR (ICDAR, OCR-D, HTR-United, Transkribus,
+    # eScriptorium) : agréger les *comptes bruts* avant de diviser —
+    #   CER_micro = Σ distance_édition / Σ caractères_référence
+    # — et non moyenner des taux par document (macro), qui donne le même
+    # poids à une légende de 10 caractères et à une page de 5 000.
+    # Le micro-CER est la métrique corpus de référence ; mean/median
+    # restent exposés ci-dessus comme diagnostics de dispersion.
+    # ``None`` si aucun document n'a de comptes exploitables (cas d'un
+    # jiwer absent ou de références toutes vides).
+    def _micro(err_attr: str, ref_attr: str) -> Optional[dict]:
+        total_err = 0
+        total_ref = 0
+        n_docs = 0
+        for r in results:
+            if r.error is not None:
+                continue
+            e = getattr(r, err_attr)
+            d = getattr(r, ref_attr)
+            if e is None or d is None:
+                continue
+            total_err += e
+            total_ref += d
+            n_docs += 1
+        if n_docs == 0 or total_ref <= 0:
+            return None
+        return {
+            "value": round(total_err / total_ref, 6),
+            "total_errors": total_err,
+            "total_reference_units": total_ref,
+            "document_count": n_docs,
+        }
+
+    cer_micro = _micro("cer_errors", "cer_ref_chars")
+    if cer_micro is not None:
+        aggregated["cer_micro"] = cer_micro
+    wer_micro = _micro("wer_errors", "wer_ref_words")
+    if wer_micro is not None:
+        aggregated["wer_micro"] = wer_micro
+
     aggregated["document_count"] = len(results)
     aggregated["failed_count"] = sum(1 for r in results if r.error is not None)
 

picarones/evaluation/metrics/confusion.py

@@ -6,9 +6,17 @@ caractéristique de chaque moteur ou pipeline.
 
 Méthode
 -------
-L'alignement caractère par caractère utilise les opérations d'édition
-de la distance de Levenshtein (via difflib.SequenceMatcher), ce qui permet
-d'identifier les substitutions, insertions et suppressions.
+L'alignement caractère par caractère utilise la distance de
+**Levenshtein** (``rapidfuzz.distance.Levenshtein``, coûts
+substitution = insertion = suppression = 1) — le même modèle d'édition
+que le CER (jiwer).  Audit scientifique F4 : auparavant l'alignement
+passait par ``difflib.SequenceMatcher`` (Ratcliff–Obershelp), qui
+maximise les blocs communs et **ne minimise pas** le nombre
+d'éditions ; les comptes substitutions/insertions/suppressions et
+l'empreinte d'erreur affichés divergeaient alors du CER montré à côté.
+L'alignement minimal garantit aussi que tout bloc ``replace`` est de
+longueur égale côté GT et côté OCR (substitutions 1-pour-1), ce qui
+supprime l'heuristique d'alignement positionnel des segments inégaux.
 
 La matrice est stockée comme un dict de dict :
     ``{gt_char: {ocr_char: count}}``
@@ -20,10 +28,11 @@ La valeur spéciale ``"∅"`` (U+2205) représente un caractère vide :
 
 from __future__ import annotations
 
-import difflib
 from collections import defaultdict
 from dataclasses import dataclass, field
 
+from rapidfuzz.distance import Levenshtein
+
 # Symbole représentant un caractère absent (insertion / suppression)
 EMPTY_CHAR = "∅"
 
@@ -114,10 +123,15 @@ def build_confusion_matrix(
     if not ground_truth and not hypothesis:
         return ConfusionMatrix(dict(matrix), 0, 0, 0)
 
-    # SequenceMatcher sur listes de chars pour un alignement précis
-    matcher = difflib.SequenceMatcher(None, ground_truth, hypothesis, autojunk=False)
-
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+    # Alignement minimal de Levenshtein (audit F4) — cohérent avec le
+    # CER.  Sous ce modèle, un bloc ``replace`` est une suite de
+    # substitutions 1-pour-1 : longueurs GT et OCR égales, alignement
+    # positionnel exact (plus d'heuristique sur segments inégaux).
+    for op in Levenshtein.opcodes(ground_truth, hypothesis):
+        tag = op.tag
+        i1, i2, j1, j2 = (
+            op.src_start, op.src_end, op.dest_start, op.dest_end,
+        )
         if tag == "equal":
             if not ignore_correct:
                 for ch in ground_truth[i1:i2]:
@@ -125,17 +139,11 @@ def build_confusion_matrix(
                         continue
                     matrix[ch][ch] += 1
         elif tag == "replace":
-            # Aligner char par char les séquences de longueurs différentes
-            gt_seg = ground_truth[i1:i2]
-            oc_seg = hypothesis[j1:j2]
-            _align_segments(gt_seg, oc_seg, matrix, ignore_whitespace)
-            # Substitutions = longueur commune, surplus = insertions ou suppressions
-            n_subs += min(len(gt_seg), len(oc_seg))
-            surplus = abs(len(gt_seg) - len(oc_seg))
-            if len(gt_seg) > len(oc_seg):
-                n_dels += surplus
-            else:
-                n_ins += surplus
+            for g, o in zip(ground_truth[i1:i2], hypothesis[j1:j2]):
+                if ignore_whitespace and (g in _WHITESPACE or o in _WHITESPACE):
+                    continue
+                matrix[g][o] += 1
+                n_subs += 1
         elif tag == "delete":
             for ch in ground_truth[i1:i2]:
                 if ignore_whitespace and ch in _WHITESPACE:
@@ -162,56 +170,6 @@ def build_confusion_matrix(
     )
 
 
-def _align_segments(
-    gt_seg: str,
-    oc_seg: str,
-    matrix: dict,
-    ignore_whitespace: bool,
-) -> None:
-    """Aligne deux segments de longueurs potentiellement différentes."""
-    if not gt_seg:
-        for ch in oc_seg:
-            if ignore_whitespace and ch in _WHITESPACE:
-                continue
-            matrix[EMPTY_CHAR][ch] += 1
-        return
-    if not oc_seg:
-        for ch in gt_seg:
-            if ignore_whitespace and ch in _WHITESPACE:
-                continue
-            matrix[ch][EMPTY_CHAR] += 1
-        return
-
-    if len(gt_seg) == len(oc_seg):
-        # Substitutions 1-pour-1
-        for g, o in zip(gt_seg, oc_seg):
-            if ignore_whitespace and (g in _WHITESPACE or o in _WHITESPACE):
-                continue
-            matrix[g][o] += 1
-    else:
-        # Longueurs différentes : utiliser SequenceMatcher récursif sur segments courts
-        sub = difflib.SequenceMatcher(None, gt_seg, oc_seg, autojunk=False)
-        for tag2, i1, i2, j1, j2 in sub.get_opcodes():
-            if tag2 == "equal":
-                pass
-            elif tag2 == "replace":
-                # Régression simple : aligner par troncature
-                for g, o in zip(gt_seg[i1:i2], oc_seg[j1:j2]):
-                    if ignore_whitespace and (g in _WHITESPACE or o in _WHITESPACE):
-                        continue
-                    matrix[g][o] += 1
-            elif tag2 == "delete":
-                for g in gt_seg[i1:i2]:
-                    if ignore_whitespace and g in _WHITESPACE:
-                        continue
-                    matrix[g][EMPTY_CHAR] += 1
-            elif tag2 == "insert":
-                for o in oc_seg[j1:j2]:
-                    if ignore_whitespace and o in _WHITESPACE:
-                        continue
-                    matrix[EMPTY_CHAR][o] += 1
-
-
 def aggregate_confusion_matrices(matrices: list[ConfusionMatrix]) -> ConfusionMatrix:
     """Agrège plusieurs matrices de confusion en une seule.
 

picarones/evaluation/metrics/text_metrics.py

@@ -115,6 +115,15 @@ def compute_metrics(
             error="jiwer n'est pas installé (pip install jiwer)",
         )
 
+    # Audit scientifique (F10) — l'exclusion de caractères est appliquée
+    # **avant** le court-circuit des cas vides : si ``char_exclude`` vide
+    # entièrement un texte, le cas est traité par les conventions
+    # "texte vide" ci-dessous (résultat déterministe) plutôt que de
+    # tomber dans le ``except`` et de renvoyer une erreur / des None.
+    if char_exclude:
+        reference  = "".join(c for c in reference  if c not in char_exclude)
+        hypothesis = "".join(c for c in hypothesis if c not in char_exclude)
+
     # Cas dégénérés des inputs vides — jiwer 3.x lève sur ces cas
     # (4.x les gère mais on ne dépend plus d'une majeure spécifique).
     # Convention :
@@ -122,6 +131,9 @@ def compute_metrics(
     # - vide ref vs hyp non vide → 1.0 (toute l'hypothèse est une
     #   insertion, error rate = 1.0).
     # - ref non vide vs hyp vide → 1.0 (toute la GT manque).
+    # Dans ces trois cas, les comptes bruts (cer_errors/cer_ref_chars…)
+    # restent ``None`` : le dénominateur micro n'est pas défini sur une
+    # référence vide, l'agrégateur micro saute donc le document.
     ref_stripped = reference.strip()
     hyp_stripped = hypothesis.strip() if hypothesis else ""
     if not ref_stripped and not hyp_stripped:
@@ -147,13 +159,15 @@ def compute_metrics(
         )
 
     try:
-        # Exclusion de caractères avant tout calcul
-        if char_exclude:
-            reference  = "".join(c for c in reference  if c not in char_exclude)
-            hypothesis = "".join(c for c in hypothesis if c not in char_exclude)
+        # CER : un seul appel ``process_characters`` fournit la valeur
+        # (``co.cer`` est bit-identique à ``jiwer.cer``) ET les comptes
+        # de l'alignement minimal (= Levenshtein) nécessaires au
+        # micro-CER corpus (audit scientifique F1).
+        co = jiwer.process_characters(reference, hypothesis)
+        cer_raw = co.cer
+        cer_errors = co.substitutions + co.deletions + co.insertions
+        cer_ref_chars = co.substitutions + co.deletions + co.hits
 
-        # CER variants
-        cer_raw = _cer_from_strings(reference, hypothesis)
         cer_nfc = _cer_from_strings(
             _normalize_nfc(reference), _normalize_nfc(hypothesis)
         )
@@ -161,14 +175,18 @@ def compute_metrics(
             _normalize_caseless(reference), _normalize_caseless(hypothesis)
         )
 
-        # WER variants
+        # WER : idem via ``process_words`` (``wo.wer/mer/wil`` identiques
+        # aux fonctions jiwer, même tokenisation par espaces).
         ref_norm = _normalize_whitespace(reference)
         hyp_norm = _normalize_whitespace(hypothesis)
 
-        wer_raw = jiwer.wer(reference, hypothesis)
+        wo = jiwer.process_words(reference, hypothesis)
+        wer_raw = wo.wer
+        wer_errors = wo.substitutions + wo.deletions + wo.insertions
+        wer_ref_words = wo.substitutions + wo.deletions + wo.hits
         wer_normalized = jiwer.wer(ref_norm, hyp_norm)
-        mer = jiwer.mer(reference, hypothesis)
-        wil = jiwer.wil(reference, hypothesis)
+        mer = wo.mer
+        wil = wo.wil
 
         # CER diplomatique — utilise le profil fourni ou le profil médiéval par défaut
         cer_diplomatic: Optional[float] = None
@@ -193,6 +211,10 @@ def compute_metrics(
             wil=wil,
             reference_length=len(reference),
             hypothesis_length=len(hypothesis),
+            cer_errors=cer_errors,
+            cer_ref_chars=cer_ref_chars,
+            wer_errors=wer_errors,
+            wer_ref_words=wer_ref_words,
             cer_diplomatic=cer_diplomatic,
             diplomatic_profile_name=diplomatic_profile_name,
         )

picarones/evaluation/statistics/wilcoxon.py

@@ -63,11 +63,20 @@ def wilcoxon_test(
     if len(a) != len(b):
         raise ValueError("Les deux listes doivent avoir la même longueur")
 
-    diffs = [x - y for x, y in zip(a, b)]
+    # ``diffs_raw`` conserve les zéros : on le transmet **tel quel** à
+    # scipy (qui applique ``zero_method`` lui-même).  Audit F9 : éviter
+    # le double retrait des zéros (ici puis dans scipy) qui faussait
+    # ``n`` et la p-value.  L'implémentation native travaille sur
+    # ``diffs`` (zéros retirés pour la méthode "wilcox").
+    diffs_raw = [x - y for x, y in zip(a, b)]
 
-    # Retirer les zéros (méthode "wilcox")
     if zero_method == "wilcox":
-        diffs = [d for d in diffs if d != 0.0]
+        diffs = [d for d in diffs_raw if d != 0.0]
+    else:
+        # "pratt"/"zsplit" : non gérés par l'implémentation native ;
+        # scipy (s'il est là) les applique.  En repli natif, on retombe
+        # sur "wilcox" en le signalant dans l'interprétation.
+        diffs = [d for d in diffs_raw if d != 0.0]
 
     n = len(diffs)
     if n == 0:
@@ -77,14 +86,22 @@ def wilcoxon_test(
             "significant": False,
             "interpretation": "Aucune différence entre les deux concurrents.",
             "n_pairs": 0,
+            "W_plus": 0.0,
+            "W_minus": 0.0,
+            "method": "exact",
+            "has_ties": False,
         }
 
     # Rangs des valeurs absolues
     abs_diffs = [abs(d) for d in diffs]
     indexed = sorted(enumerate(abs_diffs), key=lambda x: x[1])
 
-    # Gestion des ex-aequo : rang moyen
+    # Gestion des ex-aequo : rang moyen.  On mémorise la taille des
+    # groupes d'ex-aequo : un groupe de taille > 1 invalide la
+    # distribution exacte (rangs non distincts) → bascule vers
+    # l'approximation normale avec correction d'ex-aequo.
     ranks = [0.0] * n
+    tie_sizes: list[int] = []
     i = 0
     while i < n:
         j = i
@@ -93,22 +110,39 @@ def wilcoxon_test(
         avg_rank = (i + j + 1) / 2.0  # rang moyen (1-based)
         for k in range(i, j):
             ranks[indexed[k][0]] = avg_rank
+        tie_sizes.append(j - i)
         i = j
+    has_ties = any(t > 1 for t in tie_sizes)
 
     W_plus  = sum(ranks[k] for k in range(n) if diffs[k] > 0)
     W_minus = sum(ranks[k] for k in range(n) if diffs[k] < 0)
     W = min(W_plus, W_minus)
 
-    # Calcul de la p-value : scipy si disponible, sinon approximation native
+    # Calcul de la p-value bilatérale.
+    #
+    # 1. scipy si disponible : méthode exacte (n ≤ 25) ou approximation
+    #    normale (n > 25), appelée sur ``diffs_raw`` (zéros inclus) avec
+    #    ``zero_method`` — scipy gère le retrait lui-même (audit F9 : plus
+    #    de double retrait).
+    # 2. Sinon, implémentation native **exacte** : distribution nulle de
+    #    W⁺ énumérée par programmation dynamique sur les 2ⁿ assignations
+    #    de signes (valable sans ex-aequo, n ≤ 25 — au-delà l'énumération
+    #    est inutile, l'approximation normale converge).  Avec ex-aequo
+    #    ou n > 25 : approximation normale avec correction d'ex-aequo et
+    #    de continuité.  Plus aucune p-value fabriquée (audit F2 : la
+    #    table {0.04, 0.20} retournait des faux positifs pour n ≤ 5, où
+    #    la significativité bilatérale à 5 % est mathématiquement
+    #    impossible).
+    method_used = "exact"
     if _SCIPY_AVAILABLE:
         try:
-            scipy_res = _scipy_wilcoxon(diffs, zero_method=zero_method)
+            scipy_res = _scipy_wilcoxon(diffs_raw, zero_method=zero_method)
             p_value = float(scipy_res.pvalue)
+            method_used = "scipy"
         except Exception:  # noqa: BLE001 — fallback gracieux
-            # Repli sur l'implémentation native en cas d'erreur scipy
-            p_value = _native_p_value(n, W)
+            p_value, method_used = _native_p_value(n, W_plus, W_minus, tie_sizes)
     else:
-        p_value = _native_p_value(n, W)
+        p_value, method_used = _native_p_value(n, W_plus, W_minus, tie_sizes)
 
     significant = p_value < 0.05
 
@@ -132,6 +166,11 @@ def wilcoxon_test(
         "n_pairs": n,
         "W_plus": round(W_plus, 4),
         "W_minus": round(W_minus, 4),
+        # Transparence méthodologique (audit F2/F9) : quelle méthode a
+        # produit la p-value, et présence d'ex-aequo (qui force
+        # l'approximation normale en l'absence de scipy).
+        "method": method_used,
+        "has_ties": has_ties,
     }
 
 
@@ -150,33 +189,69 @@ def _normal_sf(z: float) -> float:
     return p if z >= 0 else 1.0 - p
 
 
-# Table des valeurs critiques de W pour α=0.05 bilatéral (test exact, source : tables de Wilcoxon)
-_W_CRITICAL = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 2, 8: 3, 9: 5}
-
+def _exact_signed_rank_two_sided_p(
+    n: int, w_plus: float, w_minus: float,
+) -> float:
+    """P-value bilatérale **exacte** du test des rangs signés (sans ex-aequo).
 
-def _wilcoxon_exact_p(n: int, w: float) -> float:
-    """P-value approximée pour petits n (< 10) via table critique simplifiée.
+    Sous H0, chacune des 2ⁿ assignations de signes aux rangs 1..n est
+    équiprobable.  La distribution de W⁺ (somme des rangs portant un
+    signe +) est le nombre de sous-ensembles de ``{1,…,n}`` de somme
+    ``s`` divisé par 2ⁿ — fonction génératrice ``∏(1 + xʳ)``, calculée
+    par programmation dynamique (knapsack).  La p-value bilatérale vaut
+    ``2·P(W⁺ ≤ T)`` avec ``T = min(W⁺, W⁻)``, bornée à 1.0.  Identique
+    au mode exact de ``scipy.stats.wilcoxon``.
 
-    Note : résultat **conservateur** — seules deux valeurs sont retournées :
-    0.04 (significatif à 5 %) ou 0.20 (non significatif).
-    Préférer scipy pour des p-values exactes.
+    Pour n ≤ 5 la p-value minimale possible est 2/2ⁿ ≥ 0.0625 : le test
+    ne peut donc jamais être significatif à 5 % bilatéral — ce que
+    l'ancienne table ``{0.04, 0.20}`` violait (faux positifs, audit F2).
     """
-    critical = _W_CRITICAL.get(n, 0)
-    if w <= critical:
-        return 0.04  # significatif à 5 %
-    return 0.20      # non significatif (approximation conservative)
-
-
-def _native_p_value(n: int, W: float) -> float:
-    """Calcule la p-value via l'approximation normale (n ≥ 10) ou la table exacte (n < 10)."""
-    if n >= 10:
-        mu = n * (n + 1) / 4.0
-        sigma2 = n * (n + 1) * (2 * n + 1) / 24.0
-        if sigma2 <= 0:
-            return 1.0
-        z = abs((W + 0.5) - mu) / math.sqrt(sigma2)  # correction de continuité
-        return 2.0 * _normal_sf(z)  # test bilatéral
-    return _wilcoxon_exact_p(n, W)
+    total = n * (n + 1) // 2
+    counts = [0] * (total + 1)
+    counts[0] = 1
+    for r in range(1, n + 1):
+        for s in range(total, r - 1, -1):
+            counts[s] += counts[s - r]
+    t = int(min(w_plus, w_minus))
+    tail = sum(counts[: t + 1])
+    return min(1.0, 2.0 * tail / float(1 << n))
+
+
+def _native_p_value(
+    n: int,
+    w_plus: float,
+    w_minus: float,
+    tie_sizes: list[int],
+) -> tuple[float, str]:
+    """P-value bilatérale native + nom de la méthode employée.
+
+    - **Sans ex-aequo et n ≤ 25** : distribution exacte (DP ci-dessus).
+    - **Sinon** (ex-aequo, ou n > 25) : approximation normale avec
+      correction d'ex-aequo sur la variance et correction de continuité
+      standard ``(|W − μ| − ½)/σ`` bornée à 0 (audit F9 : l'ancienne
+      forme ``|(W+½) − μ|`` était légèrement anti-conservatrice quand
+      W ≈ μ).
+
+    Plus aucune p-value fabriquée (audit F2).
+    """
+    if n == 0:
+        return 1.0, "exact"
+    has_ties = any(t > 1 for t in tie_sizes)
+    if not has_ties and n <= 25:
+        return _exact_signed_rank_two_sided_p(n, w_plus, w_minus), "exact"
+
+    mu = n * (n + 1) / 4.0
+    # σ² avec correction d'ex-aequo (Wilcoxon signé-rangé) :
+    #   σ² = [n(n+1)(2n+1) − ½·Σ(tⱼ³ − tⱼ)] / 24
+    tie_term = sum(t ** 3 - t for t in tie_sizes)
+    sigma2 = (n * (n + 1) * (2 * n + 1) - 0.5 * tie_term) / 24.0
+    if sigma2 <= 0:
+        return 1.0, "normal_approx"
+    W = min(w_plus, w_minus)
+    z = (abs(W - mu) - 0.5) / math.sqrt(sigma2)
+    if z < 0.0:
+        z = 0.0
+    return min(1.0, 2.0 * _normal_sf(z)), "normal_approx"
 
 
 def compute_pairwise_stats(

tests/architecture/test_file_budgets.py

@@ -48,7 +48,7 @@ FILE_BUDGETS: dict[str, int] = {
     # référencés ailleurs.  L'historique reste accessible via git log
     # + CHANGELOG.
     "picarones/reports/html/generator.py": 550,        # actuel 471
-    "picarones/evaluation/benchmark_result.py": 880,      # actuel ~826
+    "picarones/evaluation/benchmark_result.py": 1058,     # actuel ~920 (audit F1 : micro-CER/WER + tri)
     "picarones/reports/html/renderers/philological.py": 700,  # actuel 601
     "picarones/evaluation/metrics/modern_archives.py": 700,  # actuel 599
     "picarones/evaluation/metrics/builtin_hooks.py": 700,  # actuel 590

tests/evaluation/metrics/test_sprint44_median_default.py

@@ -1,13 +1,23 @@
-"""Tests Sprint 44 — médiane par défaut + détecteur d'asymétrie.
+"""Tests Sprint 44 (médiane) — révisés par l'audit scientifique F1.
+
+Historique : le Sprint 44 avait fait du **CER médian** le critère de
+tri par défaut.  L'audit scientifique (mai 2026, F1) a montré que la
+médiane de taux par document reste aveugle à la longueur ; le critère
+de tri par défaut est désormais le **CER micro-moyenné**
+(Σ distance_édition / Σ caractères_référence), standard du domaine
+OCR/HTR.  La médiane redevient un **repli** (corpus sans comptes
+bruts) et un **diagnostic de dispersion** (détecteur
+``median_mean_gap_warning``), plus un critère de classement.
 
 Couvre :
 
 1. ``EngineReport.median_cer`` lit ``aggregated_metrics["cer"]["median"]``.
 2. ``BenchmarkResult.ranking()`` :
-   - inclut ``median_cer`` dans chaque entrée
-   - trie sur la médiane par défaut (et non plus la moyenne)
-   - retombe sur la moyenne si la médiane est absente
-3. Détecteur ``MEDIAN_MEAN_GAP_WARNING`` :
+   - inclut ``micro_cer`` et ``median_cer`` dans chaque entrée
+   - trie sur le **micro-CER** par défaut quand les comptes bruts
+     sont disponibles
+   - retombe sur la médiane puis la moyenne si le micro est absent
+3. Détecteur ``MEDIAN_MEAN_GAP_WARNING`` (inchangé) :
    - se déclenche quand le ratio ``|moyenne - médiane| / médiane > 30%``
    - ne se déclenche pas quand symétrique
    - ne se déclenche pas si la médiane est nulle (corpus parfait)
@@ -35,21 +45,53 @@ from picarones.evaluation.benchmark_result import BenchmarkResult, DocumentResul
 # ──────────────────────────────────────────────────────────────────────────
 
 
-def _make_dr(cer: float, doc_id: str = "d") -> DocumentResult:
+def _make_dr(
+    cer: float,
+    doc_id: str = "d",
+    ref_chars: int | None = None,
+) -> DocumentResult:
+    """DocumentResult synthétique.
+
+    Si ``ref_chars`` est fourni, on renseigne les comptes bruts
+    (``cer_errors``/``cer_ref_chars``) cohérents avec ``cer`` pour
+    activer le micro-CER ; sinon ils restent ``None`` et le tri
+    retombe sur la médiane (chemin de repli historique Sprint 44).
+    """
+    cer_errors = None
+    cer_ref_chars = None
+    wer_errors = None
+    wer_ref_words = None
+    if ref_chars is not None:
+        cer_ref_chars = ref_chars
+        cer_errors = round(cer * ref_chars)
+        wer_ref_words = max(1, ref_chars // 5)
+        wer_errors = round(cer * wer_ref_words)
     return DocumentResult(
         doc_id=doc_id, image_path="/tmp/x.png",
         ground_truth="x", hypothesis="x",
         metrics=MetricsResult(
             cer=cer, cer_nfc=cer, cer_caseless=cer,
             wer=cer, wer_normalized=cer, mer=cer, wil=cer,
-            reference_length=1, hypothesis_length=1,
+            reference_length=ref_chars or 1, hypothesis_length=ref_chars or 1,
+            cer_errors=cer_errors, cer_ref_chars=cer_ref_chars,
+            wer_errors=wer_errors, wer_ref_words=wer_ref_words,
         ),
         duration_seconds=0.1,
     )
 
 
-def _make_engine_report(name: str, cers: list[float]) -> EngineReport:
-    drs = [_make_dr(c, doc_id=f"d{i}") for i, c in enumerate(cers)]
+def _make_engine_report(
+    name: str,
+    cers: list[float],
+    ref_chars: list[int] | None = None,
+) -> EngineReport:
+    if ref_chars is None:
+        drs = [_make_dr(c, doc_id=f"d{i}") for i, c in enumerate(cers)]
+    else:
+        drs = [
+            _make_dr(c, doc_id=f"d{i}", ref_chars=rc)
+            for i, (c, rc) in enumerate(zip(cers, ref_chars))
+        ]
     return EngineReport(
         engine_name=name, engine_version="1", engine_config={},
         document_results=drs,
@@ -81,39 +123,72 @@ class TestMedianCerProperty:
 # ──────────────────────────────────────────────────────────────────────────
 
 
-class TestRankingByMedian:
-    def test_includes_median_cer(self) -> None:
+class TestRankingByMicro:
+    def test_includes_micro_and_median_cer(self) -> None:
         bench = BenchmarkResult(
             corpus_name="c", corpus_source=None, document_count=3,
-            engine_reports=[_make_engine_report("a", [0.1, 0.2, 0.3])],
+            engine_reports=[_make_engine_report(
+                "a", [0.1, 0.2, 0.3], ref_chars=[100, 100, 100],
+            )],
         )
         ranking = bench.ranking()
         assert "median_cer" in ranking[0]
+        assert "micro_cer" in ranking[0]
         assert ranking[0]["median_cer"] == pytest.approx(0.2)
-
-    def test_sorts_by_median_not_mean(self) -> None:
-        # Moteur A : 80 % à 0,03 + 20 % à 0,40 → moyenne ≈ 0,11, médiane = 0,03
-        # Moteur B : 100 % à 0,05                 → moyenne = 0,05, médiane = 0,05
-        # Tri par moyenne :   B (0.05) < A (0.11) → A est 2e
-        # Tri par médiane :   A (0.03) < B (0.05) → A est 1er
+        # micro = (10+20+30)/300 = 0.2 (longueurs égales → micro == mean)
+        assert ranking[0]["micro_cer"] == pytest.approx(0.2)
+
+    def test_micro_is_default_sort_key_and_can_beat_median(self) -> None:
+        """Cas scientifiquement décisif (F1) : micro ≠ médiane.
+
+        Moteur A : excellent sur 9 courts documents (10 car, CER 0,02)
+        mais catastrophique sur 1 page longue (5 000 car, CER 0,50).
+          - médiane CER = 0,02  (tirée par les courts)
+          - micro CER   = (9·10·0,02 + 5000·0,50) / (9·10 + 5000)
+                        ≈ 2502 / 5090 ≈ 0,4916
+        Moteur B : régulier partout (CER 0,10).
+          - médiane = 0,10 ; micro ≈ 0,10
+        Tri médiane : A (0,02) < B (0,10) → A gagnerait à tort.
+        Tri micro   : B (0,10) < A (0,49) → B gagne, ce qui reflète
+        la réalité (A rate la moitié d'une page de 5 000 caractères).
+        """
+        a = _make_engine_report(
+            "A_short_specialist",
+            [0.02] * 9 + [0.50],
+            ref_chars=[10] * 9 + [5000],
+        )
+        b = _make_engine_report(
+            "B_steady",
+            [0.10] * 10,
+            ref_chars=[500] * 10,
+        )
+        bench = BenchmarkResult(
+            corpus_name="c", corpus_source=None, document_count=10,
+            engine_reports=[a, b],
+        )
+        ranking = bench.ranking()
+        # Le tri micro doit placer B premier, contredisant la médiane.
+        assert ranking[0]["engine"] == "B_steady"
+        assert ranking[0]["micro_cer"] < ranking[1]["micro_cer"]
+        # ... alors que la médiane aurait (à tort) favorisé A.
+        a_entry = next(r for r in ranking if r["engine"] == "A_short_specialist")
+        assert a_entry["median_cer"] < ranking[0]["median_cer"]
+        assert a_entry["micro_cer"] == pytest.approx(0.4916, abs=2e-3)
+
+    def test_falls_back_to_median_when_micro_missing(self) -> None:
+        """Sans comptes bruts (jiwer absent / fixture legacy), le tri
+        retombe sur la médiane — comportement Sprint 44 préservé."""
         ers = [
-            _make_engine_report(
-                "A_asymmetric",
-                [0.03] * 8 + [0.40] * 2,
-            ),
-            _make_engine_report(
-                "B_steady",
-                [0.05] * 10,
-            ),
+            _make_engine_report("A_asymmetric", [0.03] * 8 + [0.40] * 2),
+            _make_engine_report("B_steady", [0.05] * 10),
         ]
         bench = BenchmarkResult(
             corpus_name="c", corpus_source=None, document_count=10,
             engine_reports=ers,
         )
         ranking = bench.ranking()
-        # Le moteur A doit gagner sur la médiane même si sa moyenne est pire
+        assert ranking[0]["micro_cer"] is None  # pas de comptes bruts
         assert ranking[0]["engine"] == "A_asymmetric"
-        assert ranking[0]["mean_cer"] > ranking[1]["mean_cer"]
         assert ranking[0]["median_cer"] < ranking[1]["median_cer"]
 
     def test_falls_back_to_mean_when_median_missing(self) -> None:
@@ -126,14 +201,18 @@ class TestRankingByMedian:
         une médiane quand il y a au moins un doc).
         """
         ranked = [
-            {"engine": "x", "mean_cer": 0.10, "median_cer": None,
-             "mean_wer": 0.0, "documents": 1, "failed": 0},
-            {"engine": "y", "mean_cer": 0.05, "median_cer": None,
-             "mean_wer": 0.0, "documents": 1, "failed": 0},
+            {"engine": "x", "micro_cer": None, "mean_cer": 0.10,
+             "median_cer": None, "mean_wer": 0.0, "documents": 1, "failed": 0},
+            {"engine": "y", "micro_cer": None, "mean_cer": 0.05,
+             "median_cer": None, "mean_wer": 0.0, "documents": 1, "failed": 0},
         ]
 
         def _key(e: dict) -> tuple:
-            p = e.get("median_cer") if e.get("median_cer") is not None else e.get("mean_cer")
+            p = e.get("micro_cer")
+            if p is None:
+                p = e.get("median_cer")
+            if p is None:
+                p = e.get("mean_cer")
             return (p is None, p if p is not None else float("inf"))
 
         ranking = sorted(ranked, key=_key)

tests/evaluation/test_scientific_audit_2026.py

@@ -0,0 +1,203 @@
+"""Régression — audit scientifique (mai 2026).
+
+Chaque test verrouille une correction de l'audit de fiabilité
+scientifique afin qu'aucune régression ne ré-introduise un calcul
+faux ou une donnée trompeuse.  Les identifiants Fxx renvoient au
+rapport d'audit.
+
+Ces tests s'exécutent sur le chemin **sans scipy** (installation par
+défaut ``[dev,web]``), qui est le chemin de production le plus courant
+et celui où les défauts F2/F9 étaient atteignables.
+"""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+
+from picarones.evaluation._diff_utils import compute_char_diff, diff_stats
+from picarones.evaluation.metric_result import MetricsResult, aggregate_metrics
+from picarones.evaluation.metrics.confusion import build_confusion_matrix
+from picarones.evaluation.metrics.text_metrics import compute_metrics
+from picarones.evaluation.statistics.wilcoxon import (
+    _exact_signed_rank_two_sided_p,
+    wilcoxon_test,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# F1 — CER/WER micro-moyenné (pondéré par la longueur)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestF1MicroAverage:
+    def test_compute_metrics_stores_exact_edit_counts(self) -> None:
+        """Les comptes bruts permettent de recomposer le CER exact."""
+        m = compute_metrics("abcde fghij", "abXde fg")
+        assert m.cer_errors is not None and m.cer_ref_chars is not None
+        # CER = distance_édition / caractères_référence (def. exacte).
+        assert m.cer == pytest.approx(m.cer_errors / m.cer_ref_chars)
+        assert m.wer == pytest.approx(m.wer_errors / m.wer_ref_words)
+
+    def test_micro_average_is_length_weighted(self) -> None:
+        """Le micro-CER pondère par la longueur ; la macro-moyenne non.
+
+        Doc court : 'ab' → 'aX'  (1 erreur / 2 car  = 0.50)
+        Doc long  : 100·'a' → 90·'a'+10·'b' (10 err / 100 car = 0.10)
+        macro mean = (0.50 + 0.10)/2 = 0.30
+        micro      = (1 + 10) / (2 + 100) = 11/102 ≈ 0.1078
+        """
+        docs = [
+            compute_metrics("ab", "aX"),
+            compute_metrics("a" * 100, "a" * 90 + "b" * 10),
+        ]
+        agg = aggregate_metrics(docs)
+        assert agg["cer"]["mean"] == pytest.approx(0.30, abs=1e-6)
+        assert agg["cer_micro"]["value"] == pytest.approx(11 / 102, abs=1e-6)
+        assert agg["cer_micro"]["total_errors"] == 11
+        assert agg["cer_micro"]["total_reference_units"] == 102
+
+    def test_micro_absent_when_no_raw_counts(self) -> None:
+        """Fixture legacy sans comptes → pas de clé micro (repli médiane)."""
+        legacy = [
+            MetricsResult(cer=0.1, wer=0.1, reference_length=10),
+            MetricsResult(cer=0.2, wer=0.2, reference_length=10),
+        ]
+        agg = aggregate_metrics(legacy)
+        assert "cer_micro" not in agg
+        assert agg["cer"]["mean"] == pytest.approx(0.15)
+
+    def test_round_trip_preserves_counts(self) -> None:
+        m = compute_metrics("le roy de France", "le roi de Frace")
+        restored = MetricsResult.from_dict(m.as_dict())
+        assert restored.cer_errors == m.cer_errors
+        assert restored.cer_ref_chars == m.cer_ref_chars
+        assert restored.wer_errors == m.wer_errors
+        assert restored.wer_ref_words == m.wer_ref_words
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# F2 — Wilcoxon : plus aucune p-value fabriquée pour petit n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestF2WilcoxonExactSmallN:
+    def test_no_false_positive_for_n_le_5(self) -> None:
+        """Pour n ≤ 5, la significativité bilatérale à 5 % est
+        mathématiquement impossible (p_min = 2/2ⁿ ≥ 0.0625).
+
+        L'ancienne table renvoyait p=0.04 « significatif » quand un
+        moteur dominait l'autre sur les 5 documents — un faux positif.
+        """
+        # Différences toutes positives, magnitudes distinctes → pas
+        # d'ex-aequo → chemin exact, W = 0.
+        worse = [0.20, 0.31, 0.42, 0.53, 0.64]
+        better = [0.10, 0.20, 0.30, 0.40, 0.50]
+        res = wilcoxon_test(better, worse)
+        assert res["method"] == "exact"
+        assert res["p_value"] == pytest.approx(0.0625)
+        assert res["significant"] is False
+
+    @pytest.mark.parametrize(
+        "n,w,expected",
+        [
+            (6, 0, 2 / 64),          # plus petit n significatif à 5 %
+            (7, 2, 0.046875),
+            (8, 3, 0.0390625),
+            (8, 4, 0.0546875),       # juste au-dessus du seuil
+            (10, 8, 0.0488281),
+        ],
+    )
+    def test_exact_pvalues_match_statistical_tables(
+        self, n: int, w: int, expected: float,
+    ) -> None:
+        total = n * (n + 1) // 2
+        p = _exact_signed_rank_two_sided_p(n, w, total - w)
+        assert p == pytest.approx(expected, abs=1e-6)
+
+    def test_n5_pvalue_distribution_is_well_formed(self) -> None:
+        """La p-value exacte est un vrai quantile ∈ ]0, 1], jamais une
+        constante fabriquée comme 0.04 ou 0.20."""
+        seen = set()
+        total = 5 * 6 // 2
+        for w in range(total + 1):
+            p = _exact_signed_rank_two_sided_p(5, w, total - w)
+            assert 0.0 < p <= 1.0
+            seen.add(round(p, 6))
+        assert 0.04 not in seen and 0.20 not in seen
+        assert min(seen) == pytest.approx(0.0625)  # = 2/32
+
+    def test_ties_use_corrected_normal_approx(self) -> None:
+        a = [1, 2, 2, 3, 5, 5, 7, 9, 9, 11, 2, 4]
+        b = [1, 1, 2, 3, 4, 5, 6, 9, 8, 10, 2, 3]
+        res = wilcoxon_test(a, b)
+        assert res["has_ties"] is True
+        assert res["method"] == "normal_approx"
+        assert 0.0 < res["p_value"] <= 1.0
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# F9 — correction de continuité standard, bornée à 0
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestF4MinimalAlignment:
+    """Confusion matrix / diff alignés sur Levenshtein (≡ CER)."""
+
+    @pytest.mark.parametrize(
+        "gt,hyp",
+        [
+            ("maistre Jehan Froissart", "maiſtre Iehan Froiflart"),
+            ("le roy de France", "le roi de la France"),
+            ("abcdefghij", "aXcdefghijKL"),
+            ("ſuſpicion", "fufpicion"),
+            ("", "inséré"),
+            ("supprimé", ""),
+        ],
+    )
+    def test_confusion_total_equals_levenshtein_distance(
+        self, gt: str, hyp: str,
+    ) -> None:
+        """S+D+I de la matrice = distance d'édition de Levenshtein,
+        donc cohérent avec le numérateur du CER (jiwer).
+
+        Sous Ratcliff–Obershelp (difflib, ancien code) cette égalité
+        était fausse dès qu'une insertion/suppression décalait la suite.
+        """
+        from rapidfuzz.distance import Levenshtein
+
+        cm = build_confusion_matrix(
+            gt, hyp, ignore_whitespace=False, ignore_correct=True,
+        )
+        total = (
+            cm.total_substitutions
+            + cm.total_insertions
+            + cm.total_deletions
+        )
+        assert total == Levenshtein.distance(gt, hyp)
+
+    def test_char_diff_is_minimal_edit(self) -> None:
+        """Le diff caractère ne sur-segmente pas : le nombre d'opérations
+        non-equal égale la distance de Levenshtein (1 op = 1 édition)."""
+        from rapidfuzz.distance import Levenshtein
+
+        gt, hyp = "abcdef", "aXcdefY"
+        ops = compute_char_diff(gt, hyp)
+        st = diff_stats(ops)
+        edits = st["replace"] + st["insert"] + st["delete"]
+        assert edits == Levenshtein.distance(gt, hyp) == 2
+
+
+class TestF9ContinuityCorrection:
+    def test_no_signal_gives_non_significant(self) -> None:
+        """W ≈ μ (aucun effet) ⇒ z borné à 0 ⇒ p = 1.0, jamais < 1
+        par sur-correction (ancienne forme |（W+½)−μ|)."""
+        # Beaucoup d'ex-aequo et différences symétriques → approx normale.
+        a = [0.10, 0.20, 0.10, 0.20, 0.10, 0.20, 0.10, 0.20,
+             0.10, 0.20, 0.10, 0.20]
+        b = [0.20, 0.10, 0.20, 0.10, 0.20, 0.10, 0.20, 0.10,
+             0.20, 0.10, 0.20, 0.10]
+        res = wilcoxon_test(a, b)
+        assert res["p_value"] == pytest.approx(1.0)
+        assert res["significant"] is False

tests/golden/fixtures/benchmark_result_v2.json

@@ -222,7 +222,9 @@
       "failed": 0,
       "mean_cer": 0.025,
       "mean_wer": 0.05,
-      "median_cer": 0.025
+      "median_cer": 0.025,
+      "micro_cer": null,
+      "micro_wer": null
     },
     {
       "documents": 2,
@@ -230,7 +232,9 @@
       "failed": 0,
       "mean_cer": 0.03125,
       "mean_wer": 0.166666,
-      "median_cer": 0.03125
+      "median_cer": 0.03125,
+      "micro_cer": null,
+      "micro_wer": null
     }
   ],
   "run_date": "2026-05-09T00:00:00+00:00"