Upload app.py with huggingface_hub

app.py

@@ -6,15 +6,15 @@ import torch
 import tempfile
 import traceback
 import gc
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 import uvicorn
 from transformers import pipeline, AutoModelForSpeechSeq2Seq, AutoProcessor
 from TTS.api import TTS
 
-# --- [v139] 🚀 H200 SAFEST MODE (FP32 + Standard Attention) ---
-print(f"--- [v139] 📡 BOOTING SAFEST ENGINE ---")
+# --- [v140] 🚀 H200 CORE STABILIZATION (Dynamic Workspace + Explicit FP32) ---
+print(f"--- [v140] 📡 BOOTING CORE ENGINE ---")
 
 try:
     import spaces
@@ -27,14 +27,13 @@ except ImportError:
             if f is None: return lambda x: x
             return f
 
-# --- Strict Stability Config ---
+# --- System Config ---
 os.environ["COQUI_TOS_AGREED"] = "1"
 os.environ["PYTHONWARNINGS"] = "ignore"
-# Disable all hardware acceleration that might cause kernel alignment errors
-os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
-torch.backends.cuda.matmul.allow_tf32 = False
-torch.backends.cudnn.allow_tf32 = False
-torch.backends.cudnn.deterministic = True # Extra safety
+# REMOVED: CUBLAS_WORKSPACE_CONFIG (Let the driver decide)
+torch.backends.cuda.matmul.allow_tf32 = True # Allow TF32 for better alignment on Hopper
+torch.backends.cudnn.allow_tf32 = True
+torch.backends.cudnn.benchmark = False # Avoid erratic kernel selection
 
 app = FastAPI()
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
@@ -42,17 +41,18 @@ app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], all
 MODELS = {"stt": None, "tts": None}
 
 def load_gpu_models():
-    """Persistent loading into GPU VRAM (FP32 focus)."""
+    """Persistent loading with explicit casting."""
     global MODELS
     device = "cuda"
     
     if MODELS.get("stt") is None:
-        print("--- [v139] 📥 LOADING NATIVE WHISPER (FP32 / No-SDPA) ---")
+        print("--- [v140] 📥 LOADING WHISPER (EXPLICIT FP32) ---")
         model_id = "openai/whisper-large-v3-turbo"
-        # Force float32 to avoid CUBLAS_STATUS_INVALID_VALUE on H200 MIG
+        # Load and force cast to float()
         model = AutoModelForSpeechSeq2Seq.from_pretrained(
-            model_id, torch_dtype=torch.float32, low_cpu_mem_usage=True, use_safetensors=True
-        ).to(device)
+            model_id, low_cpu_mem_usage=True, use_safetensors=True
+        ).to(device).float() # FORCE FLOAT32
+        
         processor = AutoProcessor.from_pretrained(model_id)
         
         MODELS["stt"] = pipeline(
@@ -62,36 +62,31 @@ def load_gpu_models():
             feature_extractor=processor.feature_extractor,
             torch_dtype=torch.float32,
             device=device,
-            # Explicitly avoid SDPA/Flash Attention to dodge kernel bugs
-            model_kwargs={"attn_implementation": "eager"} 
+            model_kwargs={"attn_implementation": "eager"}
         )
-        print("--- [v139] ✅ WHISPER LOADED (FP32) ---")
+        print("--- [v140] ✅ WHISPER LOADED (FORCED FP32) ---")
 
     if MODELS.get("tts") is None:
-        print("--- [v139] 📥 LOADING XTTS (SINGLETON) ---")
-        # XTTS is generally stable if in VRAM
+        print("--- [v140] 📥 LOADING XTTS ---")
         MODELS["tts"] = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
-        print("--- [v139] ✅ XTTS LOADED ---")
+        print("--- [v140] ✅ XTTS LOADED ---")
 
 @spaces.GPU(duration=120)
 def core_process(request_dict):
     global MODELS
     action = request_dict.get("action")
-    print(f"--- [v139] 🛠️ SAFE ENGINE: {action} ---")
+    print(f"--- [v140] 🛠️ CORE ENGINE: {action} ---")
     t1 = time.time()
     
     try:
         load_gpu_models()
 
-        # 🎙️ STT PATH
         if action in ["stt", "s2st"]:
             audio_bytes = base64.b64decode(request_dict.get("file"))
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
                 f.write(audio_bytes); temp_path = f.name
-            
             try:
                 lang = request_dict.get("lang")
-                # batch_size=1 for maximum stability
                 result = MODELS["stt"](temp_path, batch_size=1, generate_kwargs={"language": lang if lang and len(lang) <= 3 else None})
                 stt_text = result["text"].strip()
             finally:
@@ -99,19 +94,16 @@ def core_process(request_dict):
             
             if action == "stt": return {"text": stt_text}
 
-        # 🔊 TTS PATH
         if action in ["tts", "s2st"]:
             text = (request_dict.get("text") if action == "tts" else stt_text).strip()
             trans_text = text
-            
             if action == "s2st":
                 from deep_translator import GoogleTranslator
                 target = request_dict.get("target_lang") or "en"
                 text = GoogleTranslator(source='auto', target=target).translate(stt_text)
                 trans_text = text
 
-            if len(text) < 2 or not any(c.isalnum() for c in text): 
-                return {"audio": ""} if action == "tts" else {"text": stt_text, "translated": "", "audio": ""}
+            if len(text) < 2: return {"audio": ""} if action == "tts" else {"text": stt_text, "translated": "", "audio": ""}
 
             XTTS_MAP = {"en": "en", "de": "de", "fr": "fr", "es": "es", "it": "it", "pl": "pl", "pt": "pt", "tr": "tr", "ru": "ru", "nl": "nl", "cs": "cs", "ar": "ar", "hu": "hu", "ko": "ko", "hi": "hi", "zh": "zh-cn"}
             raw_lang = (request_dict.get("lang") if action == "tts" else target).strip().lower()
@@ -121,10 +113,8 @@ def core_process(request_dict):
             if mapped_lang:
                 speaker_wav_path = "default_speaker.wav" 
                 if not os.path.exists(speaker_wav_path): speaker_wav_path = None
-
                 try:
-                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f:
-                        out_p = out_f.name
+                    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_f: out_p = out_f.name
                     MODELS["tts"].tts_to_file(text=text, language=mapped_lang, file_path=out_p, speaker_wav=speaker_wav_path)
                     with open(out_p, "rb") as f: audio_b64 = base64.b64encode(f.read()).decode()
                 finally:
@@ -135,31 +125,26 @@ def core_process(request_dict):
             return {"text": stt_text, "translated": trans_text, "audio": audio_b64}
 
     except Exception as e:
-        print(f"❌ [v139] ERROR: {traceback.format_exc()}")
+        print(f"❌ [v140] ERROR: {traceback.format_exc()}")
         return {"error": str(e)}
     finally:
-        print(f"--- [v139] ✨ DONE ({time.time()-t1:.1f}s) ---")
+        print(f"--- [v140] ✨ DONE ({time.time()-t1:.1f}s) ---")
         torch.cuda.empty_cache() 
 
 @app.post("/process")
 async def api_process(request: Request):
     try:
         data = await request.json()
-        if data.get("action") == "health": return {"status": "awake", "v": "139"}
+        if data.get("action") == "health": return {"status": "awake", "v": "140"}
         return core_process(data)
     except Exception as e: return {"error": str(e)}
 
 @app.get("/health")
-def health(): return {"status": "ok", "v": "139", "gpu": HAS_SPACES}
+def health(): return {"status": "ok", "v": "140", "gpu": HAS_SPACES}
 
 @app.get("/", response_class=HTMLResponse)
 def root():
-    return """
-    <html><head><title>S2ST v139</title><style>body { font-family: sans-serif; background: #111; color: #eee; text-align: center; padding-top: 50px; }</style></head>
-    <body><h1>🚀 AI Engine v139 (FP32 SAFE)</h1><p>H200 Native Stability Test</p><div id="log">Awaiting test...</div>
-    <script>fetch('/health').then(r=>r.json()).then(d=>document.getElementById('log').innerText=JSON.stringify(d));</script>
-    </body></html>
-    """
+    return f"<html><body><h1>🚀 AI Engine v140 (STABLE BASELINE)</h1><p>GPU: {HAS_SPACES}</p></body></html>"
 
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7860)