added watch

app.py

@@ -34,14 +34,18 @@ _sampling_rate = 24000
 
 
 def _normalize_text(s: str, lang_hint: str = "fr") -> str:
-    s = (s or "").strip().lower()
+    s = (s or "").strip()
     try:
         import re
         from num2words import num2words
-
-        def repl(m): return num2words(int(m.group()), lang=lang_hint)
+        def repl(m):
+            try:
+                return num2words(int(m.group()), lang=lang_hint)
+            except Exception:
+                return m.group()
         s = re.sub(r"\d+", repl, s)
     except Exception:
+        # pas de dépendance dure
         pass
     return s
 
@@ -50,22 +54,49 @@ def _load_model(device: str = "cuda"):
     global _pardi, _sampling_rate
     if _pardi is None:
         _pardi = PardiSpeech.from_pretrained(MODEL_REPO_ID, map_location=device)
+        _pardi.eval()
         _sampling_rate = getattr(_pardi, "sampling_rate", 24000)
-        print(f"✅ PardiSpeech loaded on {device} (sr={_sampling_rate}).")
+        print(f"✅ PardiSpeech loaded on {device} (sr={_sampling_rate}).", flush=True)
     return _pardi
 
 
 def _to_mono_float32(arr: np.ndarray) -> np.ndarray:
-    arr = arr.astype(np.float32)
+    arr = np.asarray(arr)
     if arr.ndim == 2:
         arr = arr.mean(axis=1)
-    return arr
+    return arr.astype(np.float32)
 
 
-@spaces.GPU(duration=200)  # 200s pour les autres users (peut être augmenté si besoin)
+def _env_diag() -> str:
+    parts = []
+    try:
+        parts.append(f"torch: {torch.__version__}")
+        try:
+            import triton  # type: ignore
+            parts.append(f"triton: {getattr(triton, '__version__', 'unknown')}")
+        except Exception as _e:
+            parts.append("triton: not importable")
+        parts.append(f"cuda.is_available: {torch.cuda.is_available()}")
+        if torch.cuda.is_available():
+            parts.append(f"cuda.device_count: {torch.cuda.device_count()}")
+            parts.append(f"cuda.current_device: {torch.cuda.current_device()}")
+            parts.append(f"cuda.get_device_name: {torch.cuda.get_device_name(torch.cuda.current_device())}")
+            parts.append(f"cuda.version: {torch.version.cuda}")
+            try:
+                free, total = torch.cuda.mem_get_info()
+                parts.append(f"cuda.mem_free: {free/1e9:.2f} GB / total: {total/1e9:.2f} GB")
+            except Exception:
+                pass
+    except Exception as e:
+        parts.append(f"env_diag error: {e}")
+    return " | ".join(parts)
+
+
+@spaces.GPU(duration=200)  # 200s pour les autres users
 def synthesize(
     text: str,
     debug: bool,
+    adv_sampling: bool,   # toggle "Sampling avancé (Velocity Head)"
     ref_audio,
     ref_text: str,
     steps: int,
@@ -91,17 +122,18 @@ def synthesize(
 
     def maybe_timeout_checkpoint(stage: str):
         dur = time.perf_counter() - t0
-        print(f"[debug] stage={stage} t={dur:.2f}s")
+        print(f"[debug] stage={stage} t={dur:.2f}s", flush=True)
         if dur > MAX_WALLTIME_S:
             raise TimeoutError(f"Watchdog: dépassement {dur:.1f}s avant kill ZeroGPU (étape: {stage})")
 
     with redirect_stdout(logbuf), redirect_stderr(logbuf):
         try:
+            print("[env]", _env_diag(), flush=True)
             progress(0.02, desc="Init")
             device = "cuda" if torch.cuda.is_available() else "cpu"
             torch.manual_seed(int(seed))
 
-            # Pour des traces CUDA synchrones (erreurs au bon endroit)
+            # Traces CUDA synchrones (erreurs au bon endroit)
             os.environ.setdefault("CUDA_LAUNCH_BLOCKING", "1")
 
             maybe_timeout_checkpoint("load_model")
@@ -114,26 +146,10 @@ def synthesize(
             progress(0.12, desc="Préparation du texte")
             txt = _normalize_text(text, lang_hint=lang_hint)
 
-            # Clamp pour limiter la durée
+            # Clamp pour limiter la durée (démo)
             steps = int(min(max(1, steps), 16))
             max_seq_len = int(min(max(50, max_seq_len), 600))
 
-            progress(0.16, desc="Paramètres sampling")
-            # IMPORTANT : signature de VelocityHeadSamplingParams
-            try:
-                vel_params = VelocityHeadSamplingParams(
-                    cfg_ref=float(cfg_ref),
-                    cfg=float(cfg),
-                    num_steps=int(steps)
-                )
-            except TypeError:
-                vel_params = VelocityHeadSamplingParams(
-                    cfg_ref=float(cfg_ref),
-                    cfg=float(cfg),
-                    num_steps=int(steps),
-                    temperature=float(temperature)
-                )
-
             # Prefix optionnel
             maybe_timeout_checkpoint("prefix")
             progress(0.22, desc="Prefix (optionnel)")
@@ -143,63 +159,84 @@ def synthesize(
                     wav, sr = sf.read(ref_audio)
                 else:
                     sr, wav = ref_audio
-                wav = _to_mono_float32(np.array(wav))
+                wav = _to_mono_float32(wav)
                 wav_t = torch.from_numpy(wav).to(device)
-                import torchaudio
-                if sr != pardi.sampling_rate:
-                    wav_t = torchaudio.functional.resample(wav_t, sr, pardi.sampling_rate)
+                try:
+                    import torchaudio
+                    if sr != pardi.sampling_rate:
+                        wav_t = torchaudio.functional.resample(wav_t, sr, pardi.sampling_rate)
+                except Exception as _e:
+                    print("⚠️ torchaudio not available for resample; using original SR:", sr, flush=True)
                 wav_t = wav_t.unsqueeze(0)
                 with torch.inference_mode():
                     prefix_tokens = pardi.patchvae.encode(wav_t)
                 prefix = (ref_text or "", prefix_tokens[0])
 
-            print(f"[debug] has_prefix={prefix is not None}, steps={steps}, cfg={cfg}, cfg_ref={cfg_ref}, T={temperature}, max_seq_len={max_seq_len}, seed={seed}")
+            print(f"[debug] has_prefix={prefix is not None}, steps={steps}, cfg={cfg}, cfg_ref={cfg_ref}, T={temperature}, max_seq_len={max_seq_len}, seed={seed}, adv_sampling={adv_sampling}", flush=True)
             maybe_timeout_checkpoint("tts_start")
             progress(0.28, desc="Synthèse…")
 
             if device == "cuda":
                 torch.cuda.synchronize()
 
+            # ---- FAST PATH (comme le notebook): sans VelocityHead par défaut ----
             with torch.inference_mode():
-                # Pas de cache envoyé (GLA “safe” côté modèle)
-                wavs, _ = pardi.text_to_speech(
-                    [txt],
-                    prefix,
-                    max_seq_len=int(max_seq_len),
-                    velocity_head_sampling_params=vel_params,
-                )
+                if adv_sampling:
+                    # Mode avancé: on passe VelocityHeadSamplingParams
+                    try:
+                        vel_params = VelocityHeadSamplingParams(
+                            cfg_ref=float(cfg_ref),
+                            cfg=float(cfg),
+                            num_steps=int(steps)
+                        )
+                    except TypeError:
+                        vel_params = VelocityHeadSamplingParams(
+                            cfg_ref=float(cfg_ref),
+                            cfg=float(cfg),
+                            num_steps=int(steps),
+                            temperature=float(temperature)
+                        )
+                    wavs, _ = pardi.text_to_speech(
+                        [txt], prefix, max_seq_len=int(max_seq_len),
+                        velocity_head_sampling_params=vel_params
+                    )
+                else:
+                    # Fast path (notebook)
+                    wavs, _ = pardi.text_to_speech(
+                        [txt], prefix, max_seq_len=int(max_seq_len)
+                    )
+            # --------------------------------------------------------------------
 
             if device == "cuda":
                 torch.cuda.synchronize()
             progress(0.96, desc="Finalisation")
 
-            wav = wavs[0].detach().cpu().numpy()
+            wav = wavs[0].detach().cpu().numpy().astype(np.float32)
             logs = logbuf.getvalue() if debug else ""
-            print(f"[debug] synthesize walltime = {time.perf_counter()-t0:.2f}s")
+            print(f"[debug] synthesize walltime = {time.perf_counter()-t0:.2f}s", flush=True)
             return (_sampling_rate, wav), logs
 
         except Exception as e:
-            import traceback as _tb
             dur = time.perf_counter() - t0
-            msg = f"{type(e).__name__}: {e}\\n\\n[walltime={dur:.1f}s]\\n"
-            logs = msg + logbuf.getvalue() + "\\n" + _tb.format_exc()
-            if debug:
-                # On retourne la trace dans l’UI (textbox), sans lever d’exception Gradio
-                return None, logs
-            raise gr.Error(msg)
+            msg = f"{type(e).__name__}: {e}\n\n[walltime={dur:.1f}s]\n"
+            logs = msg + logbuf.getvalue() + "\n" + traceback.format_exc()
+            # 👉 Toujours renvoyer les logs dans l'UI, même si debug = False
+            return None, logs
 
 
 def build_demo():
     with gr.Blocks(title="Lina-speech / pardi-speech Demo") as demo:
         gr.Markdown(
-            "## Lina-speech (pardi-speech) – Démo TTS\\n"
-            "Génère de l'audio à partir de texte, avec ou sans *prefix* (audio de référence).\\n"
-            "Paramètres avancés: *num_steps*, *CFG*, *température*, *max_seq_len*, *seed*."
+            "## Lina-speech (pardi-speech) – Démo TTS\n"
+            "Génère de l'audio à partir de texte, avec ou sans *prefix* (audio de référence).\n"
+            "Par défaut, le chemin **rapide** (comme dans le notebook) est utilisé. "
+            "Active **Sampling avancé** pour passer par Velocity Head."
         )
 
         with gr.Row():
             text = gr.Textbox(label="Texte à synthétiser", lines=4, placeholder="Tape ton texte ici…")
         debug = gr.Checkbox(value=False, label="Mode debug (afficher la stacktrace)")
+        adv_sampling = gr.Checkbox(value=False, label="Sampling avancé (Velocity Head)")
 
         with gr.Accordion("Prefix (optionnel)", open=False):
             ref_audio = gr.Audio(sources=["upload", "microphone"], type="numpy", label="Audio de référence")
@@ -218,13 +255,13 @@ def build_demo():
 
         btn = gr.Button("Synthétiser")
         out_audio = gr.Audio(label="Sortie audio", type="numpy")
-        logs_box = gr.Textbox(label="Logs (debug)", lines=10)
+        logs_box = gr.Textbox(label="Logs (debug)", lines=14)
 
         demo.queue(default_concurrency_limit=1, max_size=32)
 
         btn.click(
             fn=synthesize,
-            inputs=[text, debug, ref_audio, ref_text, steps, cfg, cfg_ref, temperature, max_seq_len, seed, lang_hint],
+            inputs=[text, debug, adv_sampling, ref_audio, ref_text, steps, cfg, cfg_ref, temperature, max_seq_len, seed, lang_hint],
             outputs=[out_audio, logs_box],
         )
     return demo