Upload folder using huggingface_hub

handler.py

@@ -110,16 +110,81 @@ class AudioFeatureExtractorEndpoint:
         self.sr = 16000
         self.emotion_cnn = EmotionCNN()
 
-        # Load Silero VAD
+        # Load Silero VAD from HuggingFace Hub (more reliable on HF Spaces)
         try:
-            self.vad_model, self.vad_utils = torch.hub.load(
-                repo_or_dir="snakers4/silero-vad", model="silero_vad", trust_repo=True
+            from huggingface_hub import hf_hub_download
+            
+            # Download the model file from HF
+            model_path = hf_hub_download(
+                repo_id="snakers4/silero-vad",
+                filename="files/silero_vad.jit"
             )
-            self.get_speech_timestamps = self.vad_utils[0]
-            print("✓ Silero VAD loaded")
+            
+            # Load the JIT model
+            self.vad_model = torch.jit.load(model_path)
+            self.vad_model.eval()
+            
+            # Get the get_speech_timestamps function
+            # The model itself has this as a method in newer versions
+            def get_speech_timestamps(audio, model, sampling_rate=16000, **kwargs):
+                """Wrapper for VAD speech detection"""
+                if not isinstance(audio, torch.Tensor):
+                    audio = torch.FloatTensor(audio)
+                
+                # Get speech timestamps using the model
+                speech_probs = []
+                chunk_size = 512
+                for i in range(0, len(audio), chunk_size):
+                    chunk = audio[i:i + chunk_size]
+                    if len(chunk) < chunk_size:
+                        chunk = torch.nn.functional.pad(chunk, (0, chunk_size - len(chunk)))
+                    with torch.no_grad():
+                        speech_prob = model(chunk, sampling_rate).item()
+                        speech_probs.append((i, speech_prob))
+                
+                # Convert probabilities to timestamps
+                threshold = kwargs.get('threshold', 0.5)
+                min_speech_duration_ms = kwargs.get('min_speech_duration_ms', 250)
+                min_silence_duration_ms = kwargs.get('min_silence_duration_ms', 100)
+                
+                timestamps = []
+                in_speech = False
+                speech_start = 0
+                
+                for i, prob in speech_probs:
+                    if prob > threshold and not in_speech:
+                        speech_start = i
+                        in_speech = True
+                    elif prob <= threshold and in_speech:
+                        duration_ms = (i - speech_start) / sampling_rate * 1000
+                        if duration_ms >= min_speech_duration_ms:
+                            timestamps.append({'start': speech_start, 'end': i})
+                        in_speech = False
+                
+                # Close last segment if still in speech
+                if in_speech:
+                    timestamps.append({'start': speech_start, 'end': len(audio)})
+                
+                return timestamps
+            
+            self.get_speech_timestamps = get_speech_timestamps
+            print("✓ Silero VAD loaded from HuggingFace Hub")
         except Exception as e:
-            print(f"⚠ Silero VAD failed: {e}")
-            self.vad_model = None
+            print(f"⚠ Silero VAD failed to load from HF Hub: {e}")
+            print(f"   Trying fallback torch.hub.load...")
+            try:
+                # Fallback to torch.hub
+                self.vad_model, self.vad_utils = torch.hub.load(
+                    repo_or_dir="snakers4/silero-vad", 
+                    model="silero_vad", 
+                    trust_repo=True,
+                    force_reload=False
+                )
+                self.get_speech_timestamps = self.vad_utils[0]
+                print("✓ Silero VAD loaded via torch.hub (fallback)")
+            except Exception as e2:
+                print(f"⚠ Both HF Hub and torch.hub failed for Silero VAD: {e2}")
+                self.vad_model = None
 
     # -------- V1: SNR --------
     def extract_snr(self, audio: np.ndarray) -> float:

requirements.txt

@@ -13,3 +13,4 @@ torchaudio
 fastapi==0.95.2
 uvicorn==0.22.0
 python-multipart==0.0.6
+huggingface_hub>=0.19.0