Update inference_gradio.py

inference_gradio.py

@@ -22,27 +22,32 @@ last_checkpoint = ""
 last_device = ""
 last_ema = None
 
+# Detect whether we are running inside a HF Space with stateless GPU.
+IS_SPACES = os.getenv("SYSTEM") == "spaces"
+
 # Device detection
-device = (
-    "cuda"
-    if torch.cuda.is_available()
-    else "xpu"
-    if torch.xpu.is_available()
-    else "mps"
-    if torch.backends.mps.is_available()
-    else "cpu"
-)
+if IS_SPACES:
+    # On Spaces main process we must not initialize CUDA; keep TTS on CPU.
+    device = "cpu"
+else:
+    device = (
+        "cuda"
+        if torch.cuda.is_available()
+        else "xpu"
+        if torch.xpu.is_available()
+        else "mps"
+        if torch.backends.mps.is_available()
+        else "cpu"
+    )
 
 REPO_ROOT = Path(__file__).resolve().parent
 
 # HF location for large TTS checkpoints (too big for Space storage)
 HF_PRETRAINED_ROOT = "hf://LEMAS-Project/LEMAS-TTS/pretrained_models"
 
-# # 1) 指向 `pretrained_models` 里的 libespeak-ng.so（本地路径）
-# ESPEAK_LIB = Path(PRETRAINED_ROOT) / "espeak-ng-lib" / "libespeak-ng.so"
-# os.environ["PHONEMIZER_ESPEAK_LIBRARY"] = str(ESPEAK_LIB)
-
-# 2) 指向 `pretrained_models` 里的 espeak-ng-data（本地路径）
+# 指向 `pretrained_models` 里的 espeak-ng-data（本地自带的字典）
+# 动态库交给系统安装的 espeak-ng 来提供（通过 apt），不强行指定 PHONEMIZER_ESPEAK_LIBRARY，
+# 避免本地复制的 .so 与 Space 基础镜像不兼容。
 ESPEAK_DATA_DIR = Path(PRETRAINED_ROOT) / "espeak-ng-data"
 os.environ["ESPEAK_DATA_PATH"] = str(ESPEAK_DATA_DIR)
 os.environ["ESPEAKNG_DATA_PATH"] = str(ESPEAK_DATA_DIR)
@@ -52,44 +57,76 @@ class UVR5:
     """Small wrapper around the bundled uvr5 implementation for denoising."""
 
     def __init__(self, model_dir: Path, code_dir: Path):
-        self.model = self.load_model(str(model_dir), str(code_dir))
+        # Keep paths as strings; actual model is loaded lazily.
+        self.model_dir = str(model_dir)
+        self.code_dir = str(code_dir)
+        self.model = None
+        self.device = "cpu"
 
-    def load_model(self, model_dir: str, code_dir: str):
+    def load_model(self, device: str = "cpu"):
         import sys
         import json
+        import torch as _torch
 
-        if code_dir not in sys.path:
-            sys.path.append(code_dir)
+        if self.code_dir not in sys.path:
+            sys.path.append(self.code_dir)
+
+        # Reuse an already-loaded model if it matches the requested device.
+        if self.model is not None and self.device == device:
+            return self.model
 
         from multiprocess_cuda_infer import ModelData, Inference
 
-        model_path = os.path.join(model_dir, "Kim_Vocal_1.onnx")
-        config_path = os.path.join(model_dir, "MDX-Net-Kim-Vocal1.json")
+        model_path = os.path.join(self.model_dir, "Kim_Vocal_1.onnx")
+        config_path = os.path.join(self.model_dir, "MDX-Net-Kim-Vocal1.json")
         with open(config_path, "r", encoding="utf-8") as f:
             configs = json.load(f)
         model_data = ModelData(
             model_path=model_path,
-            audio_path=model_dir,
-            result_path=model_dir,
-            device="cpu",
+            audio_path=self.model_dir,
+            result_path=self.model_dir,
+            device=device,
             process_method="MDX-Net",
-            base_dir=model_dir,  # keep base_dir and model_dir the same (paths under `pretrained_models`)
+            # keep base_dir and model_dir the same (paths under `pretrained_models`)
+            base_dir=self.model_dir,
             **configs,
         )
 
-        uvr5_model = Inference(model_data, "cpu")
-        uvr5_model.load_model(model_path, 1)
-        return uvr5_model
+        uvr5_model = Inference(model_data, device)
+        # On HF Spaces with stateless GPU, we must not initialize CUDA in the
+        # main process. When running there and staying on CPU, temporarily
+        # spoof torch.cuda.is_available() so UVR5 never touches CUDA APIs.
+        if IS_SPACES and device == "cpu":
+            orig_is_available = _torch.cuda.is_available
+            _torch.cuda.is_available = lambda: False
+            try:
+                uvr5_model.load_model(model_path, 1)
+            finally:
+                _torch.cuda.is_available = orig_is_available
+        else:
+            uvr5_model.load_model(model_path, 1)
+
+        self.model = uvr5_model
+        self.device = device
+        return self.model
 
     def denoise(self, audio_info):
         print("denoise UVR5: ", audio_info)
+        # On Spaces, force CPU; locally prefer CUDA if available.
+        if IS_SPACES:
+            dev = "cpu"
+        else:
+            dev = "cuda" if torch.cuda.is_available() else "cpu"
+        model = self.load_model(device=dev)
+
         input_audio = load_wav(audio_info, sr=44100, channel=2)
-        output_audio = self.model.demix_base({0: input_audio.squeeze()}, is_match_mix=False)
-        return output_audio.squeeze().T.numpy(), 44100
+        output_audio = model.demix_base({0: input_audio.squeeze()}, is_match_mix=False, device=dev)
+        return output_audio.squeeze().T.cpu().numpy(), 44100
+
 
 denoise_model = UVR5(
-    model_dir=str(Path(PRETRAINED_ROOT) / "uvr5"),
-    code_dir=str(REPO_ROOT / "uvr5"),
+    model_dir=Path(PRETRAINED_ROOT) / "uvr5",
+    code_dir=REPO_ROOT / "uvr5",
 )
 
 def load_wav(audio_info, sr=16000, channel=1):
@@ -194,7 +231,7 @@ def get_available_projects():
     # Fallback: if no local data dir, default to known HF projects
     if not project_list:
         project_list = ["multilingual_grl", "multilingual_prosody"]
-    project_list.sort(reverse=True)
+    project_list.sort()
     print("project_list:", project_list)
     return project_list