FonBench : leaderboard + evaluateur CPU autonome

README.md

@@ -1,15 +1,61 @@
----
-title: FonBench
-emoji: 🏆
-colorFrom: red
-colorTo: red
-sdk: gradio
-sdk_version: 6.24.0
-python_version: '3.12'
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: 'Classement public des modèles de reconnaissance vocale pour '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: FonBench
+emoji: 🗣️
+colorFrom: indigo
+colorTo: yellow
+sdk: gradio
+sdk_version: 6.24.0
+app_file: app.py
+pinned: true
+license: apache-2.0
+short_description: Classement public des modèles ASR pour le fongbe
+---
+
+# FonBench
+
+Classement public des modèles de reconnaissance vocale pour le **fongbe**,
+langue tonale parlée par environ 2,3 millions de personnes au Bénin.
+
+N'importe qui peut proposer un modèle du Hub : il est évalué
+automatiquement sur le CPU de ce Space, puis ajouté au classement. Aucun
+compte n'est nécessaire.
+
+## Métriques
+
+Le fongbe s'écrit avec des tons (á, ɔ́, ě…) qui changent le sens des mots,
+mais les corpus ne suivent pas tous la même convention — certains n'en
+notent aucun. Un WER brut n'est donc pas comparable d'un corpus à l'autre.
+D'où :
+
+- **WER_seg** — erreurs sur les mots, tons retirés. Justesse phonétique,
+  comparable partout. C'est le classement par défaut.
+- **WER_ton** — erreurs sur les seules marques tonales. Non calculé quand
+  le corpus n'annote pas les tons, pour ne pas fausser la mesure.
+- **T-WER** = `WER_seg + 2 × WER_ton` — métrique phare, double pénalité
+  tonale.
+- **RTFx** — durée d'audio traitée par seconde de calcul. Plus haut = plus
+  rapide. Dépend du matériel : ne comparez qu'à matériel égal.
+
+Le calcul est ouvert et reproductible : `fonbench_eval.py`.
+
+## Corpus de test
+
+Le jeu de test principal (2 555 énoncés, 4,98 h, 45 locuteurs) **n'est pas
+publié**. Les corpus fongbe publics circulent depuis 2016 et plusieurs
+modèles s'y sont entraînés, ce qui gonfle artificiellement leurs scores.
+Ses locuteurs sont disjoints de ceux de l'entraînement. Seuls les scores
+agrégés sont rendus publics — ni l'audio ni les transcriptions ne sont
+accessibles depuis ce Space.
+
+## Protocole
+
+- Révision de modèle figée : chaque score est rattaché au hash du dépôt.
+- Normalisation de texte identique pour tous les modèles.
+- `trust_remote_code=False` : aucun code arbitraire n'est exécuté. Les
+  poids `.bin` sont lus en mode `weights_only`.
+- Un couple (modèle, révision, corpus) n'est jamais réévalué.
+
+## Soumettre un modèle
+
+Dépôt **public** sur le Hub. Architectures reconnues : wav2vec2,
+wav2vec2-BERT, HuBERT, MMS, Whisper.

app.py

@@ -0,0 +1,398 @@
+"""FonBench — leaderboard ASR pour le fongbe.
+
+Vitrine publique du classement, formulaire de soumission, et lancement de
+l'évaluateur de fond (voir evaluator.py). Cette interface ne lit que des
+scores agrégés : ni l'audio ni les transcriptions du corpus de test n'y
+transitent jamais.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+
+import gradio as gr
+import pandas as pd
+import requests
+
+import evaluator
+
+SUPABASE_URL = os.environ.get(
+    "SUPABASE_URL", "https://cqdimvcnmhrsdcoobkmd.supabase.co"
+).rstrip("/")
+ANON_KEY = os.environ.get(
+    "SUPABASE_ANON_KEY", "sb_publishable_MapYll-_Y0hNoLYOfaDR3w_tsTEHyiz"
+)
+REST = f"{SUPABASE_URL}/rest/v1"
+HEADERS = {"apikey": ANON_KEY}
+
+CACHE_SECONDS = 60
+_cache: dict = {}
+
+# Indigo profond et ocre — les couleurs des tentures appliquées d'Abomey.
+CSS = """
+:root { --fb-indigo:#2a2a5e; --fb-ocre:#c8873b; }
+.fb-title { font-size:2.1rem; font-weight:700; color:var(--fb-indigo);
+            margin-bottom:.15rem; letter-spacing:-.02em; }
+.dark .fb-title { color:#b9b9ee; }
+.fb-sub { color:#6b6b7b; margin-bottom:1rem; }
+.fb-note { font-size:.9rem; line-height:1.55; }
+.fb-badge { display:inline-block; padding:.1rem .5rem; border-radius:999px;
+            font-size:.75rem; font-weight:600; background:var(--fb-ocre);
+            color:#fff; }
+footer { display:none !important; }
+"""
+
+
+# --- lecture de la base -------------------------------------------------
+
+def fetch(path: str, params: dict, ttl: int = CACHE_SECONDS):
+    key = (path, tuple(sorted(params.items())))
+    hit = _cache.get(key)
+    if hit and time.time() - hit[0] < ttl:
+        return hit[1]
+    r = requests.get(f"{REST}/{path}", headers=HEADERS, params=params, timeout=30)
+    r.raise_for_status()
+    data = r.json()
+    _cache[key] = (time.time(), data)
+    return data
+
+
+def get_benchmarks() -> list[dict]:
+    return fetch("benchmarks", {"is_active": "eq.true", "select": "*",
+                                "order": "id"}, ttl=600)
+
+
+def get_results(benchmark_id: str) -> list[dict]:
+    return fetch("results", {"is_hidden": "eq.false",
+                             "benchmark_id": f"eq.{benchmark_id}",
+                             "select": "*"})
+
+
+# --- mise en forme ------------------------------------------------------
+
+def pct(x) -> str:
+    return "—" if x is None else f"{float(x) * 100:.1f} %"
+
+
+def params_txt(n) -> str:
+    if not n:
+        return "—"
+    n = int(n)
+    return f"{n / 1e9:.1f} Md".replace(".", ",") if n >= 1e9 else f"{n / 1e6:.0f} M"
+
+
+def build_table(benchmark_id: str, archs: list[str], decoders: list[str],
+                hide_contaminated: bool, sort_by: str):
+    try:
+        rows = get_results(benchmark_id)
+    except Exception as exc:  # noqa: BLE001
+        return (pd.DataFrame({"Erreur": [f"Base injoignable : {exc}"]}),
+                "", gr.update(), gr.update())
+
+    all_archs = sorted({r["architecture"] for r in rows if r.get("architecture")})
+    all_decs = sorted({r["decoder_type"] for r in rows if r.get("decoder_type")})
+
+    sel = rows
+    if archs:
+        sel = [r for r in sel if r.get("architecture") in archs]
+    if decoders:
+        sel = [r for r in sel if r.get("decoder_type") in decoders]
+    if hide_contaminated:
+        sel = [r for r in sel if not r.get("contamination_flag")]
+
+    # Le corpus annote-t-il les tons ? Si oui le T-WER fait foi, sinon on
+    # classe sur le WER_seg — comparer des WER bruts entre corpus dont les
+    # conventions tonales diffèrent n'aurait aucun sens.
+    tonal = any(r.get("twer") is not None for r in rows)
+    metric = "twer" if tonal else "wer_notone"
+    if sort_by == "Vitesse (RTFx)":
+        sel.sort(key=lambda r: -(r.get("rtfx") or 0))
+    elif sort_by == "Taille du modèle":
+        sel.sort(key=lambda r: (r.get("model_params") or 0))
+    else:
+        sel.sort(key=lambda r: (r.get(metric) is None, r.get(metric) or 9e9))
+
+    data = []
+    for i, r in enumerate(sel, 1):
+        medaille = {1: "🥇", 2: "🥈", 3: "🥉"}.get(i, "")
+        nom = f"[{r['model_id']}](https://huggingface.co/{r['model_id']})"
+        if r.get("contamination_flag"):
+            nom += " ⚠️"
+        data.append({
+            "#": f"{i} {medaille}".strip(),
+            "Modèle": nom,
+            "T-WER": pct(r.get("twer")),
+            "WER_seg": pct(r.get("wer_notone")),
+            "WER_ton": pct(r.get("wer_ton")),
+            "WER": pct(r.get("wer")),
+            "CER": pct(r.get("cer")),
+            "MER": pct(r.get("mer")),
+            "WIL": pct(r.get("wil")),
+            "RTFx": "—" if not r.get("rtfx") else f"{float(r['rtfx']):.1f}×",
+            "Taille": params_txt(r.get("model_params")),
+            "Architecture": r.get("architecture") or "—",
+            "Décodage": r.get("decoder_type") or "—",
+        })
+
+    bench = next((b for b in get_benchmarks() if b["id"] == benchmark_id), {})
+    entete = (
+        f"**{bench.get('name', benchmark_id)}** — "
+        f"{bench.get('num_utterances', '?')} énoncés · "
+        f"{bench.get('duration_hours', '?')} h"
+        + ("  ·  <span class='fb-badge'>corpus privé</span>"
+           if bench.get("is_private") else "")
+        + f"  ·  classement par **{'T-WER' if tonal else 'WER_seg'}**"
+        + f"  ·  {len(sel)} modèle(s) affiché(s) sur {len(rows)}"
+    )
+    return (pd.DataFrame(data), entete,
+            gr.update(choices=all_archs), gr.update(choices=all_decs))
+
+
+NOTE_METRIQUES = """
+### Lire ce tableau
+
+Le fongbe est une langue **tonale** : les tons s'écrivent avec des accents
+(á, ɔ́, ě…) et changent le sens des mots. Or les corpus fongbe ne suivent pas
+la même convention — certains ne notent aucun ton. Comparer un WER brut d'un
+corpus à l'autre n'aurait donc pas de sens. D'où trois familles de mesures.
+
+| Mesure | Ce qu'elle dit |
+|---|---|
+| **WER_seg** | erreurs sur les mots, **tons retirés**. Mesure la justesse phonétique et reste comparable entre tous les corpus. |
+| **WER_ton** | erreurs portant sur les seules marques tonales. Vaut « — » quand le corpus n'annote pas les tons, pour ne pas fausser la mesure. |
+| **T-WER** | `WER_seg + 2 × WER_ton`. Métrique phare : elle pénalise doublement les fautes de ton. |
+| WER, CER | erreurs de mots et de caractères, tons compris. Repères classiques. |
+| MER, WIL | *match error rate* et *word information lost* : plus robustes quand un modèle produit beaucoup d'insertions. |
+| RTFx | durée d'audio traitée par seconde de calcul. **Plus haut = plus rapide.** |
+
+Pour toutes ces mesures sauf le RTFx, **plus bas vaut mieux**.
+
+⚠️ **Contamination.** Un modèle marqué ⚠️ a probablement été entraîné sur ce
+jeu de test : son score paraît excellent sans rien prouver. Il reste affiché
+par transparence, mais n'est pas comparable aux autres.
+
+⏱️ **Vitesse.** Le RTFx dépend du matériel. Les modèles évalués sur le CPU du
+Space sont bien plus lents que ceux mesurés sur GPU L4 : ne comparez les
+vitesses qu'entre modèles évalués sur le même matériel.
+"""
+
+
+# --- file d'attente -----------------------------------------------------
+
+def build_queue():
+    try:
+        rows = fetch("public_queue", {"select": "*", "order": "created_at.desc",
+                                      "limit": "50"}, ttl=15)
+    except Exception as exc:  # noqa: BLE001
+        return pd.DataFrame({"Erreur": [f"Base injoignable : {exc}"]}), ""
+
+    etats = {"pending": "⏳ en attente", "running": "⚙️ en cours",
+             "done": "✅ terminé", "failed": "❌ échec",
+             "rejected": "🚫 refusé"}
+    data = []
+    for r in rows:
+        total = r.get("progress_total") or 0
+        done = r.get("progress_done") or 0
+        avance = f"{done}/{total}" if total else "—"
+        if total and r["status"] == "running":
+            avance += f"  ({done * 100 // total} %)"
+        data.append({
+            "Modèle": r["model_id"],
+            "État": etats.get(r["status"], r["status"]),
+            "Avancement": avance,
+            "Détail": (r.get("error_message") or "")[:120],
+            "Déposé le": (r.get("created_at") or "")[:10],
+        })
+
+    etat = evaluator.status()
+    ligne = f"**Évaluateur :** {etat['message']}"
+    if etat.get("model"):
+        ligne += f" — {etat['model']} ({etat['done']}/{etat['total']})"
+    return pd.DataFrame(data), ligne
+
+
+# --- soumission ---------------------------------------------------------
+
+def submit(model_id: str, hf_username: str, contact: str, note: str,
+           benchmark_id: str):
+    model_id = (model_id or "").strip()
+    if "/" not in model_id or len(model_id.split("/")) != 2 or \
+            not all(model_id.split("/")):
+        return ("### ❌ Format invalide\n"
+                "L'identifiant doit être de la forme `organisation/nom`, "
+                "tel qu'il apparaît dans l'URL du modèle sur Hugging Face.")
+
+    payload = {"model_id": model_id, "benchmark_id": benchmark_id}
+    for champ, valeur in (("hf_username", hf_username), ("contact", contact),
+                          ("note", note)):
+        if (valeur or "").strip():
+            payload[champ] = valeur.strip()
+
+    try:
+        r = requests.post(
+            f"{REST}/public_requests",
+            headers={**HEADERS, "Content-Type": "application/json",
+                     "Prefer": "return=minimal"},
+            json=payload, timeout=30,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return f"### ❌ Envoi impossible\nBase injoignable : {exc}"
+
+    if r.status_code >= 400:
+        # La base applique elle-même les garde-fous (doublon, débit, file
+        # pleine) et renvoie un message déjà rédigé en français.
+        try:
+            detail = r.json().get("message") or r.text
+        except Exception:  # noqa: BLE001
+            detail = r.text
+        return f"### ❌ Demande refusée\n{detail}"
+
+    _cache.clear()
+    return (
+        f"### ✅ `{model_id}` est en file d'attente\n\n"
+        "L'évaluation tourne sur le CPU du Space : comptez une à deux heures "
+        "pour un modèle CTC de taille moyenne, bien davantage pour un gros "
+        "modèle autorégressif. Le score apparaîtra au classement une fois "
+        "calculé — suivez l'avancement dans l'onglet **File d'attente**."
+    )
+
+
+A_PROPOS = """
+## FonBench
+
+Premier classement public de reconnaissance vocale pour le **fongbe**, langue
+tonale parlée par environ 2,3 millions de personnes au Bénin. Le projet
+répond à une difficulté concrète : jusqu'ici, les scores publiés sur le
+fongbe n'étaient pas comparables entre eux, faute d'un protocole et d'un jeu
+de test communs.
+
+### Pourquoi le corpus de test n'est pas publié
+
+Les corpus fongbe publics circulent depuis 2016, et plusieurs modèles
+diffusés se sont entraînés dessus. Leur WER sur ces données paraît alors
+remarquable — sans rien dire de leur capacité réelle à transcrire une voix
+nouvelle. Nous l'avons mesuré : l'un des jeux de test que nous utilisions
+partageait **83 % de ses énoncés** avec les données d'entraînement d'un split
+public.
+
+Le jeu de test principal (**2 555 énoncés, 4,98 h, 45 locuteurs**) n'est donc
+pas diffusé. Ses locuteurs sont disjoints de ceux de l'entraînement, et une
+coupure temporelle sépare les textes. Seuls les scores agrégés sont rendus
+publics : personne — pas même via ce Space — ne peut en télécharger l'audio
+ou les transcriptions.
+
+### Le protocole
+
+- **Révision figée.** Chaque score est rattaché au hash exact du dépôt évalué.
+  Republier un modèle sous le même nom ne change pas le score déjà obtenu.
+- **Normalisation commune.** Même code de normalisation et de calcul pour
+  tous les modèles, tons compris. Il est ouvert : `fonbench_eval.py`.
+- **Aucun code arbitraire.** Les modèles sont chargés avec
+  `trust_remote_code=False` : le code personnalisé éventuellement présent
+  dans un dépôt n'est jamais exécuté. Les poids `.bin`, encore majoritaires
+  sur les modèles fongbe, sont lus en mode `weights_only`.
+- **Pas de calcul en double.** Un couple (modèle, révision, corpus) n'est
+  jamais réévalué : le score existant est réutilisé.
+
+### Soumettre un modèle
+
+Le dépôt doit être **public** sur le Hub. Architectures reconnues :
+wav2vec2, wav2vec2-BERT, HuBERT, MMS, Whisper. Aucun compte n'est requis.
+"""
+
+
+# --- interface ----------------------------------------------------------
+
+def build_ui() -> gr.Blocks:
+    try:
+        benchs = get_benchmarks()
+    except Exception:  # noqa: BLE001 — l'interface doit s'afficher malgré tout
+        benchs = []
+    choix = [(f"{b['name']} ({b.get('num_utterances', '?')} énoncés)", b["id"])
+             for b in benchs]
+    defaut = "jml-test-v1" if any(b["id"] == "jml-test-v1" for b in benchs) \
+        else (benchs[0]["id"] if benchs else "")
+
+    # Gradio 6 : `theme` et `css` se passent à launch(), plus au constructeur.
+    with gr.Blocks(title="FonBench — leaderboard ASR fongbe") as demo:
+        gr.HTML("<div class='fb-title'>FonBench</div>"
+                "<div class='fb-sub'>Classement public des modèles de "
+                "reconnaissance vocale pour le fongbe</div>")
+
+        with gr.Tabs():
+            with gr.Tab("Classement"):
+                with gr.Row():
+                    b_sel = gr.Dropdown(choix, value=defaut, label="Corpus",
+                                        scale=3)
+                    tri = gr.Dropdown(
+                        ["Qualité (métrique de classement)", "Vitesse (RTFx)",
+                         "Taille du modèle"],
+                        value="Qualité (métrique de classement)",
+                        label="Trier par", scale=2)
+                with gr.Row():
+                    f_arch = gr.Dropdown([], multiselect=True,
+                                         label="Architecture", scale=2)
+                    f_dec = gr.Dropdown([], multiselect=True,
+                                        label="Décodage", scale=2)
+                    f_cont = gr.Checkbox(label="Masquer les modèles contaminés",
+                                         scale=2)
+                    rafraichir = gr.Button("Rafraîchir", scale=1)
+
+                entete = gr.Markdown()
+                table = gr.Dataframe(interactive=False, wrap=True,
+                                     datatype=["str", "markdown"] + ["str"] * 11)
+                gr.Markdown(NOTE_METRIQUES, elem_classes="fb-note")
+
+                entrees = [b_sel, f_arch, f_dec, f_cont, tri]
+                sorties = [table, entete, f_arch, f_dec]
+                for widget in (b_sel, tri, f_arch, f_dec, f_cont):
+                    widget.change(build_table, entrees, sorties)
+                rafraichir.click(lambda: _cache.clear(), None, None).then(
+                    build_table, entrees, sorties)
+                demo.load(build_table, entrees, sorties)
+
+            with gr.Tab("File d'attente"):
+                etat_line = gr.Markdown()
+                q_table = gr.Dataframe(interactive=False, wrap=True)
+                gr.Button("Rafraîchir").click(build_queue, None,
+                                              [q_table, etat_line])
+                gr.Markdown(
+                    "L'évaluation tourne sur le CPU partagé du Space : comptez "
+                    "**1 à 2 h** pour un modèle CTC de 300 M paramètres, et "
+                    "**plusieurs jours** pour un gros modèle autorégressif de "
+                    "type Whisper. Une évaluation interrompue par un "
+                    "redémarrage reprend là où elle s'était arrêtée.",
+                    elem_classes="fb-note")
+                demo.load(build_queue, None, [q_table, etat_line])
+
+            with gr.Tab("Soumettre un modèle"):
+                gr.Markdown(
+                    "Le dépôt doit être **public** et ne pas dépendre de code "
+                    "personnalisé : `trust_remote_code` est désactivé. Les "
+                    "poids `safetensors` comme `.bin` sont acceptés. "
+                    "Aucun compte requis.")
+                s_model = gr.Textbox(label="Identifiant Hugging Face",
+                                     placeholder="organisation/nom-du-modele")
+                with gr.Row():
+                    s_user = gr.Textbox(label="Votre pseudo HF (facultatif)")
+                    s_contact = gr.Textbox(label="Contact (facultatif)")
+                s_note = gr.Textbox(label="Note (facultatif)", lines=2,
+                                    placeholder="Base, données d'entraînement…")
+                s_bench = gr.Dropdown(choix, value=defaut, label="Corpus")
+                s_out = gr.Markdown()
+                gr.Button("Soumettre", variant="primary").click(
+                    submit, [s_model, s_user, s_contact, s_note, s_bench], s_out)
+
+            with gr.Tab("À propos"):
+                gr.Markdown(A_PROPOS, elem_classes="fb-note")
+
+    return demo
+
+
+if __name__ == "__main__":
+    evaluator.start()
+    build_ui().launch(
+        css=CSS,
+        theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="amber"),
+    )

evaluator.py

@@ -0,0 +1,429 @@
+"""FonBench — évaluateur de fond du Space.
+
+Un unique thread démon : il prend une demande dans la file Supabase,
+charge le corpus de test PRIVÉ, transcrit par tranches et republie les
+scores. Aucun GPU : tout se fait sur le CPU du Space.
+
+Trois précautions valent d'être expliquées, parce qu'elles dictent la
+structure du fichier.
+
+1. Le corpus est chargé AVANT le modèle, et le token qui y donne accès est
+   retiré de l'environnement dès l'import. Le Space charge des modèles
+   écrits par des inconnus : aucun ne doit tourner dans un processus où
+   traîne encore de quoi lire le corpus. S'y ajoute `trust_remote_code=False`
+   sans exception — c'est ce qui empêche le code personnalisé d'un dépôt de
+   s'exécuter.
+
+2. On reprend après redémarrage. Un Space gratuit redémarre souvent et une
+   évaluation dure des heures : sans reprise, les gros modèles ne
+   finiraient jamais. Ce qu'on sauvegarde à chaque tranche, ce sont des
+   COMPTEURS d'erreurs, jamais des transcriptions — sinon on recopierait le
+   corpus privé dans la base. La somme des compteurs redonne exactement les
+   mêmes scores (voir fonbench_eval).
+
+3. Le Space n'a pas la clé service de la base. Il écrit via quatre
+   procédures protégées par un jeton dédié : au pire, un jeton volé permet
+   de polluer la file publique, pas de toucher aux comptes ni aux scores.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+import traceback
+
+import requests
+
+import fonbench_eval as fe
+
+# --- configuration ------------------------------------------------------
+
+SUPABASE_URL = os.environ.get(
+    "SUPABASE_URL", "https://cqdimvcnmhrsdcoobkmd.supabase.co"
+).rstrip("/")
+# Publique par conception : la Row Level Security fait le tri, pas le secret.
+ANON_KEY = os.environ.get(
+    "SUPABASE_ANON_KEY", "sb_publishable_MapYll-_Y0hNoLYOfaDR3w_tsTEHyiz"
+)
+SPACE_TOKEN = os.environ.get("SPACE_TOKEN", "")
+
+# Sorti de l'environnement immédiatement : un modèle inconnu chargé plus
+# tard ne doit pas pouvoir le lire dans os.environ.
+_DATA_TOKEN = os.environ.pop("HF_DATA_TOKEN", None) or os.environ.pop(
+    "HF_TOKEN", None
+)
+
+REST = f"{SUPABASE_URL}/rest/v1"
+HEADERS = {"apikey": ANON_KEY, "Content-Type": "application/json"}
+
+WORKER_VERSION = "space-1.0"
+POLL_SECONDS = 60
+CHUNK_CTC = 50
+CHUNK_SEQ2SEQ = 10           # un Whisper met des minutes par énoncé sur CPU
+BATCH_CTC = 4
+
+# Architectures autorégressives : pipeline + découpage à 30 s, sinon les
+# énoncés longs font échouer Whisper.
+SEQ2SEQ_TYPES = {
+    "whisper", "speech_to_text", "speech-encoder-decoder",
+    "speech_encoder_decoder", "seamless_m4t", "seamless_m4t_v2",
+}
+
+_state = {"message": "démarrage…", "model": None, "done": 0, "total": 0}
+
+
+def log(msg: str) -> None:
+    print(f"[evaluator] {msg}", flush=True)
+
+
+def status() -> dict:
+    return dict(_state)
+
+
+# --- accès à la file ----------------------------------------------------
+
+def rpc(name: str, payload: dict):
+    r = requests.post(
+        f"{REST}/rpc/{name}", headers=HEADERS, json=payload, timeout=60
+    )
+    if r.status_code >= 400:
+        raise RuntimeError(f"{name}: {r.status_code} {r.text[:200]}")
+    return r.json() if r.text.strip() else None
+
+
+# --- audio --------------------------------------------------------------
+
+def decode_audio(cell, target_sr: int = 16000):
+    """Décode un audio (WAV/FLAC/OGG/Opus/WebM/MP3…) en mono float32 16 kHz.
+
+    PyAV plutôt que soundfile : le corpus contient des conteneurs que
+    libsndfile ne sait pas ouvrir (WebM, Opus) et des fichiers dont
+    l'en-tête le fait échouer (« array is too big »).
+    """
+    import io
+
+    import av
+    import numpy as np
+
+    raw = cell["bytes"] if isinstance(cell, dict) else cell
+    if raw is None and isinstance(cell, dict) and cell.get("path"):
+        with open(cell["path"], "rb") as f:
+            raw = f.read()
+
+    with av.open(io.BytesIO(raw)) as container:
+        stream = container.streams.audio[0]
+        resampler = av.audio.resampler.AudioResampler(
+            format="flt", layout="mono", rate=target_sr
+        )
+        chunks: list = []
+
+        def _emit(frame):
+            res = resampler.resample(frame)
+            for rf in res if isinstance(res, list) else ([res] if res else []):
+                chunks.append(rf.to_ndarray().reshape(-1))
+
+        for frame in container.decode(stream):
+            _emit(frame)
+        _emit(None)  # flush du resampler
+
+    if not chunks:
+        return np.zeros(1, dtype="float32")
+    return np.concatenate(chunks).astype("float32")
+
+
+# --- corpus -------------------------------------------------------------
+
+_dataset_cache: dict = {}
+
+
+def load_corpus(bench: dict):
+    """Charge le corpus de test. Gardé en mémoire entre deux évaluations."""
+    from datasets import Audio, load_dataset
+
+    key = (bench["hf_dataset_id"], bench.get("hf_revision"), bench["hf_split"])
+    if key in _dataset_cache:
+        return _dataset_cache[key]
+
+    ds = load_dataset(
+        bench["hf_dataset_id"],
+        split=bench["hf_split"],
+        revision=bench.get("hf_revision") or None,
+        token=_DATA_TOKEN,
+    )
+    if bench.get("sample_size"):
+        ds = ds.shuffle(seed=bench.get("sample_seed") or 42)
+        ds = ds.select(range(min(bench["sample_size"], len(ds))))
+    ds = ds.cast_column("audio", Audio(decode=False))
+    _dataset_cache.clear()          # 16 Go de RAM : un seul corpus à la fois
+    _dataset_cache[key] = ds
+    return ds
+
+
+# --- modèle -------------------------------------------------------------
+
+class Transcriber:
+    """Charge un modèle du Hub et transcrit des tableaux 16 kHz."""
+
+    def __init__(self, model_id: str, revision: str):
+        import torch
+        from transformers import AutoConfig
+
+        torch.set_num_threads(max(1, (os.cpu_count() or 2)))
+        self.torch = torch
+        self.model_id = model_id
+
+        cfg = AutoConfig.from_pretrained(
+            model_id, revision=revision, trust_remote_code=False
+        )
+        self.architecture = cfg.model_type
+        self.seq2seq = cfg.model_type in SEQ2SEQ_TYPES or any(
+            "ConditionalGeneration" in a or "Seq2Seq" in a
+            for a in (getattr(cfg, "architectures", None) or [])
+        )
+        self.chunk_size = CHUNK_SEQ2SEQ if self.seq2seq else CHUNK_CTC
+        self.decoder_type = "encoder-decoder" if self.seq2seq else "ctc"
+
+        if self.seq2seq:
+            self._load_seq2seq(model_id, revision)
+        else:
+            self._load_ctc(model_id, revision)
+
+        self.model_params = sum(p.numel() for p in self.model.parameters())
+
+    def _load_seq2seq(self, model_id, revision):
+        from transformers import (
+            AutoModelForSpeechSeq2Seq,
+            AutoProcessor,
+            pipeline,
+        )
+
+        self.processor = AutoProcessor.from_pretrained(
+            model_id, revision=revision, trust_remote_code=False
+        )
+        self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
+            model_id, revision=revision, trust_remote_code=False,
+            dtype=self.torch.float32,
+        ).eval()
+        self.pipe = pipeline(
+            "automatic-speech-recognition",
+            model=self.model,
+            tokenizer=self.processor.tokenizer,
+            feature_extractor=self.processor.feature_extractor,
+            # Sans ce découpage, tout énoncé de plus de 30 s fait échouer
+            # Whisper sur une incompatibilité de dimensions.
+            chunk_length_s=30,
+        )
+
+    def _load_ctc(self, model_id, revision):
+        from transformers import AutoModelForCTC, AutoProcessor
+
+        self.processor = AutoProcessor.from_pretrained(
+            model_id, revision=revision, trust_remote_code=False
+        )
+        self.model = AutoModelForCTC.from_pretrained(
+            model_id, revision=revision, trust_remote_code=False,
+        ).eval()
+        self.pipe = None
+
+        # MMS multilingue : les poids fongbe vivent dans un adaptateur séparé,
+        # sans quoi le modèle transcrit dans une tout autre langue.
+        try:
+            if getattr(self.model.config, "adapter_attn_dim", None):
+                self.model.load_adapter("fon")
+                self.processor.tokenizer.set_target_lang("fon")
+                log("adaptateur MMS « fon » chargé")
+        except Exception as exc:  # noqa: BLE001 — modèle déjà spécialisé
+            log(f"pas d'adaptateur fon ({type(exc).__name__}) — poids tels quels")
+
+    def __call__(self, arrays: list) -> list[str]:
+        if self.seq2seq:
+            return [
+                (self.pipe(a)["text"] or "").strip() for a in arrays
+            ]
+        out: list[str] = []
+        for i in range(0, len(arrays), BATCH_CTC):
+            batch = arrays[i:i + BATCH_CTC]
+            inputs = self.processor(
+                batch, sampling_rate=16000, return_tensors="pt", padding=True
+            )
+            with self.torch.inference_mode():
+                logits = self.model(**inputs).logits
+            ids = self.torch.argmax(logits, dim=-1)
+            out.extend(t.strip() for t in self.processor.batch_decode(ids))
+        return out
+
+
+# --- une évaluation -----------------------------------------------------
+
+def check_model(model_id: str) -> str:
+    """Révision figée du modèle. Lève si le dépôt est inutilisable."""
+    from huggingface_hub import HfApi
+
+    # Sans token : un modèle soumis doit être public pour être vérifiable.
+    api = HfApi(token=False)
+    try:
+        info = api.model_info(model_id, files_metadata=False)
+    except Exception:  # noqa: BLE001
+        raise RuntimeError("Modèle introuvable ou privé sur le Hub.")
+
+    # On accepte aussi les poids `.bin` : la moitié des modèles fongbe
+    # publics datent d'avant safetensors, les exclure viderait le classement.
+    # Le risque du pickle est couvert ailleurs — transformers charge les .bin
+    # avec `weights_only=True` (donc sans exécution de code) depuis la 4.36,
+    # et `trust_remote_code=False` bloque le code personnalisé du dépôt.
+    names = [s.rfilename for s in (info.siblings or [])]
+    if not any(n.endswith((".safetensors", ".bin", ".ckpt", ".pt"))
+               for n in names):
+        raise RuntimeError(
+            "Aucun fichier de poids trouvé dans le dépôt "
+            "(.safetensors ou .bin attendu)."
+        )
+    return info.sha
+
+
+def run_job(job: dict) -> None:
+    request, bench = job["request"], job["benchmark"]
+    rid, model_id = request["id"], request["model_id"]
+    _state.update(model=model_id, message="préparation", done=0, total=0)
+    log(f"▶ {model_id} sur {bench['id']}")
+
+    revision = check_model(model_id)
+
+    # Corpus d'abord : le token de lecture ne doit jamais coexister avec un
+    # modèle inconnu déjà chargé en mémoire.
+    ds = load_corpus(bench)
+    total = len(ds)
+
+    verdict = rpc("space_begin", {
+        "p_token": SPACE_TOKEN, "p_id": rid,
+        "p_revision": revision, "p_total": total,
+    })
+    if verdict == "duplicate":
+        log(f"↷ {model_id} : déjà évalué à cette révision")
+        _state.update(message="doublon ignoré", model=None)
+        return
+
+    tr = Transcriber(model_id, revision)
+    chunk = tr.chunk_size
+
+    saved = job.get("progress") or {}
+    counters = saved.get("counters") or fe.new_counters()
+    counters = {k: int(counters.get(k, 0)) for k in fe.COUNTER_KEYS}
+    next_chunk = int(saved.get("next_chunk") or 0)
+    audio_s = float(saved.get("audio_seconds") or 0.0)
+    compute_s = float(saved.get("compute_seconds") or 0.0)
+    if next_chunk:
+        log(f"↻ reprise à la tranche {next_chunk} ({next_chunk * chunk} énoncés)")
+
+    # Les tailles de tranche sont calibrées pour qu'une tranche reste sous
+    # les 20 min au-delà desquelles la base considère la tâche abandonnée :
+    # 50 énoncés en CTC (~2 min), 10 seulement pour un Whisper sur CPU
+    # (~13 min dans le pire cas). Chaque tranche vaut donc battement de cœur.
+    n_chunks = (total + chunk - 1) // chunk
+    skipped = 0
+
+    for ci in range(next_chunk, n_chunks):
+        rows = ds.select(range(ci * chunk, min((ci + 1) * chunk, total)))
+        arrays, refs = [], []
+        for row in rows:
+            try:
+                arrays.append(decode_audio(row["audio"]))
+                refs.append(row["transcription"])
+            except Exception:  # noqa: BLE001 — énoncé illisible : pas la faute du modèle
+                skipped += 1
+
+        if arrays:
+            t0 = time.time()
+            hyps = tr(arrays)
+            compute_s += time.time() - t0
+            audio_s += sum(len(a) for a in arrays) / 16000.0
+            fe.accumulate(counters, refs, hyps)
+
+        done = min((ci + 1) * chunk, total)
+        _state.update(message="évaluation", done=done, total=total)
+        rpc("space_checkpoint", {
+            "p_token": SPACE_TOKEN, "p_id": rid, "p_next_chunk": ci + 1,
+            "p_done": done, "p_counters": counters,
+            "p_audio": round(audio_s, 2), "p_compute": round(compute_s, 2),
+        })
+        rtfx = audio_s / compute_s if compute_s else 0
+        log(f"  {done}/{total} — RTFx {rtfx:.2f}")
+
+    if skipped:
+        log(f"⚠ {skipped} énoncés illisibles écartés")
+    if not counters["n_scored"]:
+        raise RuntimeError("Aucune transcription exploitable produite.")
+
+    metrics = fe.finalize(counters)
+    rtfx = round(audio_s / compute_s, 3) if compute_s else None
+    rpc("space_finish", {
+        "p_token": SPACE_TOKEN, "p_id": rid, "p_status": "done",
+        "p_metrics": {k: metrics[k] for k in (
+            "wer", "cer", "mer", "wil", "wer_seg", "cer_seg", "wer_ton", "twer"
+        )},
+        "p_meta": {
+            "architecture": tr.architecture,
+            "decoder_type": tr.decoder_type,
+            "model_params": tr.model_params,
+            "rtfx": rtfx,
+            "rtf": round(1 / rtfx, 4) if rtfx else None,
+            "eval_seconds": round(compute_s, 1),
+            "hardware": "HF Space CPU",
+            "worker_version": WORKER_VERSION,
+        },
+        "p_error": None,
+    })
+    log(f"✔ {model_id} — WER_seg {metrics['wer_seg']:.1%} "
+        f"T-WER {metrics['twer']} RTFx {rtfx}")
+    _state.update(message="terminé", model=None, done=0, total=0)
+
+
+def loop() -> None:
+    if not SPACE_TOKEN:
+        _state["message"] = "SPACE_TOKEN absent — évaluateur à l'arrêt"
+        log("SPACE_TOKEN absent : aucune évaluation ne sera lancée.")
+        return
+    if not _DATA_TOKEN:
+        _state["message"] = "HF_DATA_TOKEN absent — évaluateur à l'arrêt"
+        log("HF_DATA_TOKEN absent : le corpus privé est illisible.")
+        return
+
+    log("évaluateur démarré")
+    while True:
+        job = None
+        try:
+            job = rpc("space_claim", {"p_token": SPACE_TOKEN})
+        except Exception as exc:  # noqa: BLE001 — réseau : on réessaie
+            log(f"⚠ space_claim : {exc}")
+
+        if not job:
+            _state.update(message="aucune tâche en attente", model=None)
+            time.sleep(POLL_SECONDS)
+            continue
+
+        try:
+            run_job(job)
+        except Exception as exc:  # noqa: BLE001 — tout échec doit être publié
+            log(f"✘ échec : {exc}")
+            traceback.print_exc()
+            _state.update(message=f"échec : {exc}", model=None)
+            try:
+                rpc("space_finish", {
+                    "p_token": SPACE_TOKEN, "p_id": job["request"]["id"],
+                    "p_status": "failed", "p_metrics": None, "p_meta": None,
+                    # Message court et sans extrait du corpus.
+                    "p_error": f"{type(exc).__name__}: {exc}"[:300],
+                })
+            except Exception:  # noqa: BLE001
+                traceback.print_exc()
+        finally:
+            import gc
+
+            gc.collect()
+
+
+def start() -> threading.Thread:
+    t = threading.Thread(target=loop, name="fonbench-eval", daemon=True)
+    t.start()
+    return t

fonbench_eval.py

@@ -0,0 +1,264 @@
+"""FonBench — normalisation du texte fongbe et métriques ASR.
+
+Copie conforme du module de référence utilisé par le worker GPU : les
+scores publiés par le Space doivent être comparables au chiffre près à
+ceux déjà au classement.
+
+Métriques (un seul passage) :
+  · Qualité      : WER, CER, MER, WIL (jiwer)
+  · Segmentale   : WER_seg / CER_seg — texte dé-tonalisé (accents retirés).
+                   Non biaisée : comparable même entre corpus qui ne marquent
+                   pas les tons (ALFFA n'en met aucune, JML les met toutes).
+  · Tonale       : WER_ton — taux d'erreur sur les seules marques tonales.
+                   None si le corpus n'annote pas les tons (sinon biaisé).
+  · Phare        : T-WER = WER_seg + 2·WER_ton (double pénalité tonale).
+
+S'y ajoute ici, par rapport au module du worker, une variante **par
+tranches** (`accumulate` / `finalize`). Une évaluation sur CPU dure des
+heures et le Space redémarre : il faut pouvoir reprendre. Mais stocker les
+transcriptions déjà produites reviendrait à recopier le corpus privé hors
+du Space. On ne garde donc que des compteurs d'erreurs, dont la somme
+redonne *exactement* les mêmes scores — les alignements jiwer étant
+indépendants d'un énoncé à l'autre, c'est une identité, pas une
+approximation. `test_accumulation.py` le vérifie.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+import jiwer
+
+FONBENCH_EVAL_VERSION = "0.3.0"
+
+_WHITESPACE = re.compile(r"\s+")
+
+# Voyelles fongbe (base, après minuscules/NFD).
+_VOWELS = set("aeiouɛɔ")
+
+# Marques tonales combinantes → symbole de ton.
+_TONE_MARKS = {
+    "́": "H",  # accent aigu — ton haut
+    "̀": "L",  # accent grave — ton bas
+    "̌": "R",  # caron — ton montant
+    "̂": "F",  # circonflexe — ton descendant
+    "̄": "M",  # macron — ton moyen
+}
+# Seuil : en dessous, le corpus n'annote pas vraiment les tons → WER_ton biaisé.
+_TONE_ANNOTATION_THRESHOLD = 0.10
+
+
+def normalize_fon(text: str) -> str:
+    """Normalise un texte fongbe avant le calcul des métriques."""
+    text = unicodedata.normalize("NFC", text)
+    text = text.lower()
+    text = "".join(
+        ch
+        for ch in text
+        if unicodedata.category(ch)[0] in ("L", "M", "N") or ch.isspace()
+    )
+    return _WHITESPACE.sub(" ", text).strip()
+
+
+def strip_tones(text: str) -> str:
+    """Retire les marques tonales, garde les lettres fongbe.
+
+    ɖ, ɛ, ɔ, ŋ… sont des caractères atomiques (non décomposables) et restent ;
+    seuls les accents combinants (á→a, ɔ́→ɔ, ě→e) tombent.
+    """
+    decomposed = unicodedata.normalize("NFD", text)
+    without_marks = "".join(
+        ch for ch in decomposed if unicodedata.category(ch) != "Mn"
+    )
+    return unicodedata.normalize("NFC", without_marks)
+
+
+def tone_sequence(text: str) -> tuple[list[str], int]:
+    """Séquence de tons (un par voyelle) + nombre de voyelles marquées."""
+    d = unicodedata.normalize("NFD", text)
+    seq: list[str] = []
+    marked = 0
+    i = 0
+    while i < len(d):
+        ch = d[i]
+        if ch in _VOWELS:
+            tone = "."
+            j = i + 1
+            while j < len(d) and unicodedata.category(d[j]) == "Mn":
+                if d[j] in _TONE_MARKS:
+                    tone = _TONE_MARKS[d[j]]
+                j += 1
+            if tone != ".":
+                marked += 1
+            seq.append(tone)
+            i = j
+        else:
+            i += 1
+    return seq, marked
+
+
+def levenshtein(a: list[str], b: list[str]) -> int:
+    """Distance d'édition entre deux séquences (espace linéaire)."""
+    if not a:
+        return len(b)
+    if not b:
+        return len(a)
+    prev = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        cur = [i]
+        for j, cb in enumerate(b, 1):
+            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
+        prev = cur
+    return prev[-1]
+
+
+# --- calcul en un passage (référence) ----------------------------------
+
+def compute_metrics(references: list[str], hypotheses: list[str]) -> dict:
+    """Toutes les métriques FonBench, sur des listes parallèles réf/hyp."""
+    counters = new_counters()
+    accumulate(counters, references, hypotheses)
+    if not counters["n_scored"]:
+        raise ValueError("aucune référence non vide après normalisation")
+    return finalize(counters)
+
+
+# --- calcul par tranches (reprise après redémarrage) --------------------
+
+COUNTER_KEYS = (
+    "w_s", "w_d", "w_i", "w_h",        # mots, tons compris
+    "c_s", "c_d", "c_i", "c_h",        # caractères, tons compris
+    "ws_s", "ws_d", "ws_i", "ws_h",    # mots dé-tonalisés
+    "cs_s", "cs_d", "cs_i", "cs_h",    # caractères dé-tonalisés
+    "tone_dist", "tone_units", "tone_marked",
+    "n_scored",
+)
+
+
+def new_counters() -> dict:
+    return {k: 0 for k in COUNTER_KEYS}
+
+
+def accumulate(counters: dict, references: list[str], hypotheses: list[str]) -> dict:
+    """Ajoute une tranche aux compteurs. Modifie et renvoie `counters`."""
+    if len(references) != len(hypotheses):
+        raise ValueError(
+            f"références ({len(references)}) et hypothèses ({len(hypotheses)}) "
+            "doivent avoir la même longueur"
+        )
+
+    pairs = [
+        (normalize_fon(ref), normalize_fon(hyp))
+        for ref, hyp in zip(references, hypotheses)
+    ]
+    # Une référence vide rendrait le WER indéfini : on écarte la paire.
+    pairs = [(r, h) for r, h in pairs if r]
+    if not pairs:
+        return counters
+
+    refs = [r for r, _ in pairs]
+    hyps = [h for _, h in pairs]
+    refs_seg = [strip_tones(r) for r in refs]
+    hyps_seg = [strip_tones(h) for h in hyps]
+
+    for prefix, out in (
+        ("w", jiwer.process_words(refs, hyps)),
+        ("c", jiwer.process_characters(refs, hyps)),
+        ("ws", jiwer.process_words(refs_seg, hyps_seg)),
+        ("cs", jiwer.process_characters(refs_seg, hyps_seg)),
+    ):
+        counters[f"{prefix}_s"] += out.substitutions
+        counters[f"{prefix}_d"] += out.deletions
+        counters[f"{prefix}_i"] += out.insertions
+        counters[f"{prefix}_h"] += out.hits
+
+    for r, h in zip(refs, hyps):
+        rs, rm = tone_sequence(r)
+        hs, _ = tone_sequence(h)
+        counters["tone_dist"] += levenshtein(rs, hs)
+        counters["tone_units"] += len(rs)
+        counters["tone_marked"] += rm
+
+    counters["n_scored"] += len(refs)
+    return counters
+
+
+def _rate(errors: int, total: int) -> float | None:
+    return round(errors / total, 4) if total else None
+
+
+def finalize(counters: dict) -> dict:
+    """Métriques finales à partir des compteurs cumulés."""
+    c = {k: int(counters.get(k, 0)) for k in COUNTER_KEYS}
+
+    ref_words = c["w_h"] + c["w_s"] + c["w_d"]
+    hyp_words = c["w_h"] + c["w_s"] + c["w_i"]
+    wer_errors = c["w_s"] + c["w_d"] + c["w_i"]
+
+    wer = _rate(wer_errors, ref_words)
+    mer = _rate(wer_errors, wer_errors + c["w_h"])
+    if not ref_words:
+        wil = None
+    elif not hyp_words:
+        # Modèle muet : plus aucune information transmise (jiwer pose wip = 0).
+        wil = 1.0
+    else:
+        wil = round(1 - (c["w_h"] / ref_words) * (c["w_h"] / hyp_words), 4)
+
+    cer = _rate(c["c_s"] + c["c_d"] + c["c_i"], c["c_h"] + c["c_s"] + c["c_d"])
+    wer_seg = _rate(
+        c["ws_s"] + c["ws_d"] + c["ws_i"], c["ws_h"] + c["ws_s"] + c["ws_d"]
+    )
+    cer_seg = _rate(
+        c["cs_s"] + c["cs_d"] + c["cs_i"], c["cs_h"] + c["cs_s"] + c["cs_d"]
+    )
+
+    units, marked = c["tone_units"], c["tone_marked"]
+    annotated = units > 0 and (marked / units) >= _TONE_ANNOTATION_THRESHOLD
+    wer_ton = round(c["tone_dist"] / units, 4) if annotated else None
+    twer = (
+        round(wer_seg + 2 * wer_ton, 4)
+        if wer_ton is not None and wer_seg is not None
+        else None
+    )
+
+    return {
+        "wer": wer,
+        "cer": cer,
+        "mer": mer,
+        "wil": wil,
+        "wer_seg": wer_seg,
+        "cer_seg": cer_seg,
+        "wer_ton": wer_ton,
+        "twer": twer,
+        "tone_annotated": annotated,
+        "num_utterances_scored": c["n_scored"],
+        "version": FONBENCH_EVAL_VERSION,
+    }
+
+
+if __name__ == "__main__":
+    # Auto-tests : python fonbench_eval.py
+    assert normalize_fon("Ɖò xwégbè,  é ɖù nǔ!") == "ɖò xwégbè é ɖù nǔ"
+    assert strip_tones("étɛ́ ká ɖíe") == "etɛ ka ɖie", strip_tones("étɛ́ ká ɖíe")
+
+    seq, marked = tone_sequence("étɛ́ ká ɖíe")  # é=H, ɛ́=H, á=H, í=H, e=.
+    assert seq == ["H", "H", "H", "H", "."], seq
+    assert marked == 4, marked
+
+    # Erreur purement tonale : segmental parfait, tonal fautif
+    m = compute_metrics(["étɛ́ ká ɖíe"], ["etɛ ka ɖie"])
+    assert m["wer_seg"] == 0.0, m
+    assert m["wer_ton"] and m["wer_ton"] > 0, m
+    assert m["twer"] == round(0 + 2 * m["wer_ton"], 4), m
+
+    # Corpus sans tons (type ALFFA) : wer_ton doit être None (non biaisé)
+    m2 = compute_metrics(["un yi axi me"], ["un yi axi me"])
+    assert m2["wer_ton"] is None and m2["twer"] is None, m2
+
+    # Modèle muet : WIL saturé, pas de division par zéro
+    m3 = compute_metrics(["étɛ́ ká ɖíe"], [""])
+    assert m3["wil"] == 1.0, m3
+
+    print("fonbench_eval OK —", compute_metrics(["étɛ́ ká ɖíe"], ["etɛ ka die"]))

requirements.txt

@@ -0,0 +1,15 @@
+# Roues CPU : la roue torch par défaut embarque CUDA (~2,5 Go) pour rien
+# sur un Space CPU basic, et fait dépasser la limite de build.
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+torch==2.5.1
+transformers>=4.46,<5
+# <4.0 : les versions 4.x imposent torchcodec pour décoder l'audio, alors
+# qu'on décode nous-mêmes avec PyAV (Audio(decode=False)).
+datasets>=2.20,<4.0
+huggingface_hub>=0.25
+av>=12.0
+jiwer>=3.0
+numpy<2
+pandas
+requests