fix: 将语音分词器切换到 CPU (#2193)

Co-authored-by: Codex <codex@local>

deploy/selfmedia-voice/api.py

@@ -28,8 +28,7 @@ class Runtime:
     def __init__(self) -> None:
         self.model = None
         self.loaded_at = None
-        self.onnx_providers = None
-        self.onnx_provider_options = None
+        self.speech_tokenizer_providers = None
         self.error = None
         self.lock = threading.Lock()
 
@@ -38,15 +37,19 @@ class Runtime:
             if not torch.cuda.is_available():
                 raise RuntimeError("CUDA is unavailable")
             device = os.environ["VOICE_DEVICE"]
-            if not device.startswith("cuda:"):
-                raise RuntimeError("VOICE_DEVICE must select a CUDA device")
+            if device != "cuda:0":
+                raise RuntimeError("VOICE_DEVICE must be cuda:0")
+            if not env_bool("VOICE_FP16"):
+                raise RuntimeError("VOICE_FP16 must remain enabled for core CUDA inference")
             torch.cuda.set_device(int(device.split(":", 1)[1]))
             original_inference_session = onnxruntime.InferenceSession
-            cuda_options = onnx_cuda_provider_options()
+            speech_tokenizer_provider = os.environ["VOICE_SPEECH_TOKENIZER_PROVIDER"]
+            if speech_tokenizer_provider != "CPUExecutionProvider":
+                raise RuntimeError("VOICE_SPEECH_TOKENIZER_PROVIDER must be CPUExecutionProvider")
 
             def inference_session(*args, **kwargs):
                 if kwargs.get("providers") == ["CUDAExecutionProvider"]:
-                    kwargs["providers"] = [("CUDAExecutionProvider", cuda_options)]
+                    kwargs["providers"] = [speech_tokenizer_provider]
                 return original_inference_session(*args, **kwargs)
 
             onnxruntime.InferenceSession = inference_session
@@ -59,18 +62,9 @@ class Runtime:
                 )
             finally:
                 onnxruntime.InferenceSession = original_inference_session
-            self.onnx_providers = self.model.frontend.speech_tokenizer_session.get_providers()
-            self.onnx_provider_options = self.model.frontend.speech_tokenizer_session.get_provider_options()
-            if not self.onnx_providers or self.onnx_providers[0] != "CUDAExecutionProvider":
-                raise RuntimeError(f"CUDAExecutionProvider was not instantiated: {self.onnx_providers}")
-            actual_cuda_options = self.onnx_provider_options.get("CUDAExecutionProvider", {})
-            mismatches = {
-                key: {"expected": value, "actual": actual_cuda_options.get(key)}
-                for key, value in cuda_options.items()
-                if actual_cuda_options.get(key) != value
-            }
-            if mismatches:
-                raise RuntimeError(f"CUDAExecutionProvider options were not applied: {mismatches}")
+            self.speech_tokenizer_providers = self.model.frontend.speech_tokenizer_session.get_providers()
+            if self.speech_tokenizer_providers != [speech_tokenizer_provider]:
+                raise RuntimeError(f"speech tokenizer provider mismatch: {self.speech_tokenizer_providers}")
             self.loaded_at = time.time()
         except Exception as error:
             self.error = f"{type(error).__name__}: {error}"
@@ -84,17 +78,6 @@ def env_bool(name: str) -> bool:
     return value == "true"
 
 
-def onnx_cuda_provider_options() -> dict[str, str]:
-    gpu_mem_limit_mib = int(os.environ["VOICE_ONNX_CUDA_GPU_MEM_LIMIT_MIB"])
-    if gpu_mem_limit_mib <= 0:
-        raise RuntimeError("VOICE_ONNX_CUDA_GPU_MEM_LIMIT_MIB must be positive")
-    return {
-        "gpu_mem_limit": str(gpu_mem_limit_mib * 1024 * 1024),
-        "arena_extend_strategy": os.environ["VOICE_ONNX_CUDA_ARENA_EXTEND_STRATEGY"],
-        "cudnn_conv_use_max_workspace": "1" if env_bool("VOICE_ONNX_CUDA_CUDNN_CONV_USE_MAX_WORKSPACE") else "0",
-    }
-
-
 runtime = Runtime()
 
 
@@ -118,19 +101,13 @@ def health() -> dict:
         "torchaudio": torchaudio.__version__,
         "cuda": torch.version.cuda,
         "gpu": torch.cuda.get_device_name(torch.cuda.current_device()) if torch.cuda.is_available() else None,
-        "device": os.environ["VOICE_DEVICE"],
-        "fp16": env_bool("VOICE_FP16"),
+        "coreInferenceDevice": os.environ["VOICE_DEVICE"],
+        "coreInferenceFp16": env_bool("VOICE_FP16"),
         "loadTrt": env_bool("VOICE_LOAD_TRT"),
         "loadVllm": env_bool("VOICE_LOAD_VLLM"),
         "workers": int(os.environ["VOICE_WORKERS"]),
         "concurrency": os.environ["VOICE_CONCURRENCY"],
-        "onnxProviders": runtime.onnx_providers,
-        "onnxProviderOptions": runtime.onnx_provider_options,
-        "onnxCudaMemory": {
-            "gpuMemLimitMiB": int(os.environ["VOICE_ONNX_CUDA_GPU_MEM_LIMIT_MIB"]),
-            "arenaExtendStrategy": os.environ["VOICE_ONNX_CUDA_ARENA_EXTEND_STRATEGY"],
-            "cudnnConvUseMaxWorkspace": env_bool("VOICE_ONNX_CUDA_CUDNN_CONV_USE_MAX_WORKSPACE"),
-        },
+        "speechTokenizerProviders": runtime.speech_tokenizer_providers,
         "loadedAt": runtime.loaded_at,
         "error": runtime.error,
     }

deploy/selfmedia-voice/compose.d518.yaml

@@ -67,9 +67,7 @@ services:
       VOICE_PORT: ${VOICE_PORT}
       PYTORCH_CUDA_ALLOC_CONF: ${PYTORCH_CUDA_ALLOC_CONF}
       CUDA_MODULE_LOADING: ${CUDA_MODULE_LOADING}
-      VOICE_ONNX_CUDA_GPU_MEM_LIMIT_MIB: ${VOICE_ONNX_CUDA_GPU_MEM_LIMIT_MIB}
-      VOICE_ONNX_CUDA_ARENA_EXTEND_STRATEGY: ${VOICE_ONNX_CUDA_ARENA_EXTEND_STRATEGY}
-      VOICE_ONNX_CUDA_CUDNN_CONV_USE_MAX_WORKSPACE: ${VOICE_ONNX_CUDA_CUDNN_CONV_USE_MAX_WORKSPACE}
+      VOICE_SPEECH_TOKENIZER_PROVIDER: ${VOICE_SPEECH_TOKENIZER_PROVIDER}
       LD_LIBRARY_PATH: ${TORCH_LIBRARY_PATH}
     volumes:
       - ${VOICE_CACHE_DIR}/model:/model:ro