Adaptation ZeroGPU : evaluation par creneaux GPU, reprise sur quota epuise

README.md

@@ -17,8 +17,12 @@ 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.
+automatiquement sur le GPU partagé de ce Space (ZeroGPU), puis ajouté au
+classement. Aucun compte n'est nécessaire.
+
+L'évaluation avance par tranches, chacune tenant dans un créneau GPU. Quand
+le quota quotidien s'épuise, elle se met en pause et reprend d'elle-même à
+la tranche suivante — un redémarrage du Space ne fait rien perdre non plus.
 
 ## Métriques
 

app.py

@@ -172,9 +172,9 @@ Pour toutes ces mesures sauf le RTFx, **plus bas vaut mieux**.
 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.
+⏱️ **Vitesse.** Le RTFx dépend du matériel, indiqué pour chaque score. Un
+modèle mesuré sur le GPU partagé du Space n'est pas directement comparable à
+un modèle mesuré sur L4 dédiée : ne comparez les vitesses qu'à matériel égal.
 """
 
 
@@ -251,10 +251,10 @@ def submit(model_id: str, hf_username: str, contact: str, note: str,
     _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**."
+        "L'évaluation tourne par tranches sur le GPU partagé du Space. Selon "
+        "le quota disponible, comptez de quelques minutes à quelques heures. "
+        "Le score apparaîtra au classement une fois calculé — suivez "
+        "l'avancement dans l'onglet **File d'attente**."
     )
 
 
@@ -358,11 +358,12 @@ def build_ui() -> gr.Blocks:
                 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.",
+                    "L'évaluation tourne par tranches sur le GPU partagé du "
+                    "Space (ZeroGPU). Le calcul lui-même est rapide — quelques "
+                    "minutes pour un modèle CTC — mais le quota GPU quotidien "
+                    "est limité : une évaluation peut s'étaler sur plusieurs "
+                    "heures, en pause entre deux tranches. Une évaluation "
+                    "interrompue reprend exactement là où elle s'était arrêtée.",
                     elem_classes="fb-note")
                 demo.load(build_queue, None, [q_table, etat_line])
 

evaluator.py

@@ -37,6 +37,21 @@ import requests
 
 import fonbench_eval as fe
 
+# ZeroGPU : le GPU n'est attaché que le temps d'une fonction décorée. En
+# dehors d'un Space ZeroGPU (tests locaux), le décorateur devient neutre.
+try:
+    import spaces
+
+    GPU = spaces.GPU
+    ON_ZEROGPU = True
+except Exception:  # noqa: BLE001
+    ON_ZEROGPU = False
+
+    def GPU(*args, **kwargs):  # noqa: D103
+        def deco(fn):
+            return fn
+        return deco(args[0]) if args and callable(args[0]) else deco
+
 # --- configuration ------------------------------------------------------
 
 SUPABASE_URL = os.environ.get(
@@ -59,9 +74,18 @@ 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
+
+# Une tranche = un créneau GPU. ZeroGPU plafonne la durée d'un créneau, et
+# plus on en demande, plus on attend : on vise ~10 s de calcul réel.
+# Sur A10G, un CTC tourne autour de 100× temps réel (100 énoncés ≈ 700 s
+# d'audio ≈ 7 s), un Whisper autour de 5× (20 énoncés ≈ 140 s ≈ 30 s).
+GPU_DURATION = 120
+CHUNK_CTC = 100
+CHUNK_SEQ2SEQ = 20
+BATCH_CTC = 8
+# Quota journalier épuisé : on attend au lieu d'abandonner. Le point de
+# reprise est déjà enregistré, rien n'est perdu.
+QUOTA_WAIT_SECONDS = 1800
 
 # Architectures autorégressives : pipeline + découpage à 30 s, sinon les
 # énoncés longs font échouer Whisper.
@@ -203,7 +227,6 @@ class Transcriber:
         )
         self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
             model_id, revision=revision, trust_remote_code=False,
-            dtype=self.torch.float32,
         ).eval()
         self.pipe = pipeline(
             "automatic-speech-recognition",
@@ -236,23 +259,57 @@ class Transcriber:
         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]:
+    def transcribe(self, arrays: list) -> list[str]:
+        """Transcrit une tranche. À n'appeler que depuis un créneau GPU."""
+        torch = self.torch
+        dev = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(dev)
+        if self.pipe is not None:
+            self.pipe.device = torch.device(dev)
+
         if self.seq2seq:
-            return [
-                (self.pipe(a)["text"] or "").strip() for a in arrays
-            ]
+            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():
+            inputs = {k: v.to(dev) for k, v in inputs.items()}
+            with torch.inference_mode():
                 logits = self.model(**inputs).logits
-            ids = self.torch.argmax(logits, dim=-1)
+            ids = torch.argmax(logits, dim=-1).cpu()
             out.extend(t.strip() for t in self.processor.batch_decode(ids))
         return out
 
+    def hardware(self) -> str:
+        try:
+            if self.torch.cuda.is_available():
+                return f"HF Space ZeroGPU ({self.torch.cuda.get_device_name(0)})"
+        except Exception:  # noqa: BLE001
+            pass
+        return "HF Space CPU"
+
+
+# Le modèle reste une variable de module : ZeroGPU exécute la fonction
+# décorée dans un processus dérivé, qui hérite de la mémoire sans rien
+# sérialiser. Le passer en argument recopierait tout le modèle à chaque appel.
+_CURRENT: Transcriber | None = None
+
+
+@GPU(duration=GPU_DURATION)
+def gpu_transcribe(arrays: list) -> list[str]:
+    return _CURRENT.transcribe(arrays)
+
+
+def _is_quota_error(exc: Exception) -> bool:
+    """Le quota ZeroGPU est-il épuisé (par opposition à une vraie panne) ?"""
+    texte = f"{type(exc).__name__} {exc}".lower()
+    return any(m in texte for m in ("quota", "gpu task aborted",
+                                    "no gpu is currently available",
+                                    "exceeded your"))
+
 
 # --- une évaluation -----------------------------------------------------
 
@@ -304,7 +361,8 @@ def run_job(job: dict) -> None:
         _state.update(message="doublon ignoré", model=None)
         return
 
-    tr = Transcriber(model_id, revision)
+    global _CURRENT
+    tr = _CURRENT = Transcriber(model_id, revision)
     chunk = tr.chunk_size
 
     saved = job.get("progress") or {}
@@ -316,14 +374,14 @@ def run_job(job: dict) -> None:
     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.
+    # Chaque tranche tient dans un créneau GPU et vaut battement de cœur :
+    # elle reste bien en deçà des 20 min au-delà desquelles la base
+    # considère la tâche abandonnée et la redonne.
     n_chunks = (total + chunk - 1) // chunk
     skipped = 0
 
-    for ci in range(next_chunk, n_chunks):
+    ci = next_chunk
+    while ci < n_chunks:
         rows = ds.select(range(ci * chunk, min((ci + 1) * chunk, total)))
         arrays, refs = [], []
         for row in rows:
@@ -335,7 +393,19 @@ def run_job(job: dict) -> None:
 
         if arrays:
             t0 = time.time()
-            hyps = tr(arrays)
+            try:
+                hyps = gpu_transcribe(arrays)
+            except Exception as exc:  # noqa: BLE001
+                if not _is_quota_error(exc):
+                    raise
+                # Quota ZeroGPU épuisé : on patiente et on refait la même
+                # tranche. Le point de reprise est déjà en base, rien n'est
+                # perdu — c'est précisément ce que le découpage permet.
+                log(f"⏸ quota GPU épuisé ({exc}) — reprise dans "
+                    f"{QUOTA_WAIT_SECONDS // 60} min à la tranche {ci}")
+                _state.update(message="quota GPU épuisé — en attente")
+                time.sleep(QUOTA_WAIT_SECONDS)
+                continue
             compute_s += time.time() - t0
             audio_s += sum(len(a) for a in arrays) / 16000.0
             fe.accumulate(counters, refs, hyps)
@@ -349,6 +419,7 @@ def run_job(job: dict) -> None:
         })
         rtfx = audio_s / compute_s if compute_s else 0
         log(f"  {done}/{total} — RTFx {rtfx:.2f}")
+        ci += 1
 
     if skipped:
         log(f"⚠ {skipped} énoncés illisibles écartés")
@@ -369,7 +440,7 @@ def run_job(job: dict) -> None:
             "rtfx": rtfx,
             "rtf": round(1 / rtfx, 4) if rtfx else None,
             "eval_seconds": round(compute_s, 1),
-            "hardware": "HF Space CPU",
+            "hardware": tr.hardware(),
             "worker_version": WORKER_VERSION,
         },
         "p_error": None,

requirements.txt

@@ -1,8 +1,9 @@
-# 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
+# ZeroGPU : ne PAS forcer les roues CPU de PyTorch (pas d'index /whl/cpu),
+# sinon le GPU alloué reste inutilisable. Et la version doit figurer dans la
+# liste acceptée par ZeroGPU : 2.8.0, 2.9.1, 2.10.0, 2.11.0.
+torch==2.8.0
+spaces
 
-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)).