Fix ZeroGPU model re-download loop causing browser freeze

Root cause: indic_text.py and indic_tts.py called .to("cuda").eval() as
part of the module-scope assignment (e.g. _model = Model.from_pretrained().to("cuda")).
On ZeroGPU, after startup the runtime deletes 17GB of raw HF cache blobs and
keeps only its packed tensor format. When these assignments failed (because
the .to("cuda") chain prevents the variable from being set), _model/_mms_model
stayed None. At inference time, from_pretrained() tried to load from the
deleted HF cache, triggering a full re-download inside the GPU window -> hang.

Fix: load both NLLB-200 and MMS-TTS-Kan to CPU at module scope (no .to("cuda")),
so ZeroGPU packs their tensors along with the main models. Inside @spaces.GPU
functions, call model.to("cuda") so ZeroGPU transfers the pre-packed tensors
to GPU without any re-download.

Also reduce voice-cloning sentence cap from 10 to 6 (6 x ~15s = 90s, well
within the 180s GPU budget).

Co-Authored-By: Codex <noreply@codex.ai>

app.py

@@ -1151,9 +1151,9 @@ def generate_tts_cloned_gpu(text: str, ref_wav: str | None, mood: str = "calming
         sentences = [text.strip() or "Sweet dreams."]
 
     has_ref = bool(ref_wav and os.path.exists(str(ref_wav)))
-    # Voice cloning is slower per sentence — cap at 10 to stay within GPU budget
+    # Voice cloning is ~10-15s per sentence — cap at 6 to stay within 180s budget
     if has_ref:
-        sentences = sentences[:10]
+        sentences = sentences[:6]
 
     silence = np.zeros(int(0.65 * sr), dtype=np.float32)
     pieces  = []

indic_text.py

@@ -1,4 +1,9 @@
-"""English → Kannada translation via facebook/nllb-200-distilled-600M (non-gated)."""
+"""English → Kannada translation via facebook/nllb-200-distilled-600M (non-gated).
+
+ZeroGPU pattern: model loaded to CPU at module scope so ZeroGPU can pack its
+tensors. Inside @spaces.GPU functions, .to("cuda") is called and ZeroGPU
+transfers the packed tensors efficiently — no re-download needed.
+"""
 from __future__ import annotations
 import re
 import torch
@@ -15,10 +20,14 @@ def _get_model():
     if _model is None:
         from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
         _tok   = AutoTokenizer.from_pretrained(_HUB_ID, src_lang=_SRC)
-        _model = AutoModelForSeq2SeqLM.from_pretrained(_HUB_ID).to("cuda").eval()
+        # Load to CPU only — ZeroGPU packs these tensors at startup.
+        # .to("cuda") is called inside translate_to_kannada() which runs
+        # inside @spaces.GPU, where ZeroGPU intercepts the call.
+        _model = AutoModelForSeq2SeqLM.from_pretrained(_HUB_ID)
     return _model, _tok
 
 
+# Pre-load to CPU at module scope so ZeroGPU packs the tensors.
 try:
     _get_model()
 except Exception:
@@ -32,6 +41,10 @@ def translate_to_kannada(en_text: str) -> str:
         raise ValueError("Nothing to translate.")
 
     model, tok = _get_model()
+    # Move to GPU — ZeroGPU intercepts this inside @spaces.GPU and uses the
+    # pre-packed tensors, so no re-download is needed.
+    model = model.to("cuda")
+
     tgt_id = tok.lang_code_to_id[_TGT]
 
     sentences = [s.strip() for s in re.split(r"(?<=[.!?])\s+", text) if s.strip()]
@@ -40,7 +53,7 @@ def translate_to_kannada(en_text: str) -> str:
 
     parts = []
     for sent in sentences:
-        inputs = tok(sent, return_tensors="pt", padding=True).to("cuda")
+        inputs = tok(sent, return_tensors="pt", padding=True).to(model.device)
         with torch.no_grad():
             out = model.generate(**inputs, forced_bos_token_id=tgt_id, max_length=512)
         parts.append(tok.decode(out[0], skip_special_tokens=True))

indic_tts.py

@@ -1,5 +1,9 @@
 """Kannada TTS — primary: sush0401/IndicF5-Kannada-Bedtime-v2 (fine-tuned, non-gated).
 Fallback: facebook/mms-tts-kan (VITS, 16kHz, no voice cloning).
+
+ZeroGPU pattern: models loaded to CPU at module scope so ZeroGPU packs their
+tensors. Inside inference functions (called from @spaces.GPU), .to("cuda") is
+called and ZeroGPU transfers packed tensors to GPU — no re-download needed.
 """
 from __future__ import annotations
 import os
@@ -21,9 +25,10 @@ MMS_SR = 16_000
 def _load_indic():
     global _indic_model, _use_indic
     from transformers import AutoModel
+    # Load to CPU — ZeroGPU packs these tensors.
     _indic_model = AutoModel.from_pretrained(
         _FINETUNE_HUB, trust_remote_code=True,
-    ).to("cuda").eval()
+    )
     _use_indic = True
 
 
@@ -31,7 +36,8 @@ def _load_mms():
     global _mms_model, _mms_tok
     from transformers import VitsModel, AutoTokenizer
     _mms_tok   = AutoTokenizer.from_pretrained(_FALLBACK_HUB)
-    _mms_model = VitsModel.from_pretrained(_FALLBACK_HUB).to("cuda").eval()
+    # Load to CPU — ZeroGPU packs these tensors.
+    _mms_model = VitsModel.from_pretrained(_FALLBACK_HUB)
 
 
 def _get_model():
@@ -40,12 +46,10 @@ def _get_model():
             _load_indic()
         except Exception:
             _load_mms()
-    elif not _use_indic:
-        pass  # already loaded MMS
     return _use_indic
 
 
-# Pre-load at module scope on ZeroGPU
+# Pre-load to CPU at module scope so ZeroGPU packs the tensors.
 try:
     _get_model()
 except Exception:
@@ -68,8 +72,9 @@ def _split(text: str, max_chars: int = 200):
     return out or [text.strip()]
 
 
-def _narrate_indic(ref_wav: str, kannada_text: str) -> np.ndarray:
-    model = _indic_model
+def _narrate_indic(ref_wav: str, kannada_text: str) -> tuple[np.ndarray, int]:
+    # Move to GPU — ZeroGPU intercepts this inside @spaces.GPU.
+    model = _indic_model.to("cuda")
     silence_sr = 24_000
     silence = np.zeros(int(0.55 * silence_sr), dtype=np.float32)
     chunks = []
@@ -86,12 +91,14 @@ def _narrate_indic(ref_wav: str, kannada_text: str) -> np.ndarray:
 
 
 def _narrate_mms(kannada_text: str) -> tuple[np.ndarray, int]:
+    # Move to GPU — ZeroGPU intercepts this inside @spaces.GPU.
+    model = _mms_model.to("cuda")
     silence = np.zeros(int(0.55 * MMS_SR), dtype=np.float32)
     chunks = []
     for sent in _split(kannada_text):
-        inputs = _mms_tok(sent, return_tensors="pt").to("cuda")
+        inputs = _mms_tok(sent, return_tensors="pt").to(model.device)
         with torch.no_grad():
-            wav = _mms_model(**inputs).waveform
+            wav = model(**inputs).waveform
         audio = wav.squeeze().cpu().float().numpy()
         if audio.size:
             chunks.append(audio)