Update core/silero_vad.py

core/silero_vad.py

@@ -2,29 +2,63 @@ import torch
 import numpy as np
 from typing import Optional, Callable
 from config.settings import settings
+import os
 
 class SileroVAD:
     def __init__(self):
         self.model = None
-        self.sample_rate = 16000  # Silero VAD yêu cầu 16kHz
+        self.sample_rate = 16000
         self.is_streaming = False
         self.speech_callback = None
         self.audio_buffer = []
         self._initialize_model()
 
     def _initialize_model(self):
-        """Khởi tạo Silero VAD model"""
+        """Khởi tạo Silero VAD model sử dụng torch.hub"""
         try:
-            print("🔄 Đang tải Silero VAD model...")
-            torch.hub.download_url_to_file(
-                'https://raw.githubusercontent.com/snakers4/silero-vad/master/files/model.jit',
-                'silero_vad.jit'
+            print("🔄 Đang tải Silero VAD model từ torch.hub...")
+            
+            # Sử dụng torch.hub để load model (cách chính thức)
+            self.model = torch.hub.load(
+                repo_or_dir=settings.VAD_MODEL,
+                model='silero_vad',
+                force_reload=False,  # Sử dụng cache nếu có
+                trust_repo=True
             )
-            self.model = torch.jit.load('silero_vad.jit')
-            self.model.eval()
+            
             print("✅ Đã tải Silero VAD model thành công")
+            
         except Exception as e:
             print(f"❌ Lỗi tải Silero VAD model: {e}")
+            print("🔄 Đang thử cách tải thay thế...")
+            self._initialize_model_fallback()
+
+    def _initialize_model_fallback(self):
+        """Fallback method nếu cách chính thức không hoạt động"""
+        try:
+            # Cách 2: Sử dụng direct download
+            model_urls = {
+                'silero_vad.jit': 'https://github.com/snakers4/silero-vad/raw/master/files/silero_vad.jit'
+            }
+            
+            # Tạo thư mục cache
+            os.makedirs('./models', exist_ok=True)
+            model_path = './models/silero_vad.jit'
+            
+            if not os.path.exists(model_path):
+                print("📥 Đang download Silero VAD model...")
+                torch.hub.download_url_to_file(
+                    model_urls['silero_vad.jit'],
+                    model_path
+                )
+            
+            # Load model
+            self.model = torch.jit.load(model_path)
+            self.model.eval()
+            print("✅ Đã tải Silero VAD model thành công (fallback)")
+            
+        except Exception as e:
+            print(f"❌ Lỗi tải Silero VAD model fallback: {e}")
             self.model = None
 
     def start_stream(self, speech_callback: Callable):
@@ -52,16 +86,16 @@ class SileroVAD:
             return
 
         try:
-            # Resample nếu cần (Silero yêu cầu 16kHz)
+            # Resample nếu cần
             if sample_rate != self.sample_rate:
                 audio_chunk = self._resample_audio(audio_chunk, sample_rate, self.sample_rate)
 
             # Thêm vào buffer
             self.audio_buffer.extend(audio_chunk)
 
-            # Xử lý khi buffer đủ lớn (1 giây - Silero làm việc tốt với chunk nhỏ)
+            # Xử lý khi buffer đủ lớn (1 giây)
             buffer_duration = len(self.audio_buffer) / self.sample_rate
-            if buffer_duration >= 1.0:  # Giảm từ 2.0 xuống 1.0 giây
+            if buffer_duration >= 1.0:
                 self._process_buffer()
 
         except Exception as e:
@@ -70,7 +104,6 @@ class SileroVAD:
     def _process_buffer(self):
         """Xử lý buffer audio với Silero VAD"""
         try:
-            # Silero VAD làm việc tốt với chunk 1 giây
             chunk_size = self.sample_rate  # 1 giây
             if len(self.audio_buffer) < chunk_size:
                 return
@@ -80,10 +113,15 @@ class SileroVAD:
             
             # Chuẩn hóa audio cho Silero
             if audio_chunk.dtype != np.float32:
-                audio_chunk = audio_chunk.astype(np.float32) / 32768.0  # Normalize to [-1, 1]
+                audio_chunk = audio_chunk.astype(np.float32)
+                if np.max(np.abs(audio_chunk)) > 1.0:
+                    audio_chunk = audio_chunk / 32768.0  # Normalize từ int16
+            
+            # Đảm bảo audio trong range [-1, 1]
+            audio_chunk = np.clip(audio_chunk, -1.0, 1.0)
             
             # Chuyển thành tensor
-            audio_tensor = torch.from_numpy(audio_chunk).unsqueeze(0)
+            audio_tensor = torch.from_numpy(audio_chunk).float().unsqueeze(0)
             
             # Phát hiện speech với Silero VAD
             with torch.no_grad():
@@ -91,7 +129,7 @@ class SileroVAD:
             
             print(f"🎯 Silero VAD speech probability: {speech_prob:.3f}")
             
-            # Ngưỡng phát hiện speech (có thể điều chỉnh)
+            # Ngưỡng phát hiện speech
             if speech_prob > settings.VAD_THRESHOLD:
                 print(f"🎯 Silero VAD phát hiện speech: {speech_prob:.3f}")
                 
@@ -99,7 +137,7 @@ class SileroVAD:
                 if self.speech_callback:
                     self.speech_callback(audio_chunk, self.sample_rate)
 
-            # Giữ lại 0.3 giây cuối để overlap (Silero nhạy hơn)
+            # Giữ lại 0.3 giây cuối để overlap
             keep_samples = int(self.sample_rate * 0.3)
             if len(self.audio_buffer) > keep_samples:
                 self.audio_buffer = self.audio_buffer[-keep_samples:]
@@ -142,15 +180,19 @@ class SileroVAD:
             
             # Chuẩn hóa audio
             if audio_chunk.dtype != np.float32:
-                audio_chunk = audio_chunk.astype(np.float32) / 32768.0
+                audio_chunk = audio_chunk.astype(np.float32)
+                if np.max(np.abs(audio_chunk)) > 1.0:
+                    audio_chunk = audio_chunk / 32768.0
+            
+            audio_chunk = np.clip(audio_chunk, -1.0, 1.0)
             
             # Đảm bảo độ dài phù hợp
-            if len(audio_chunk) < 512:  # Silero cần ít nhất 512 samples
-                padding = np.zeros(512 - len(audio_chunk))
+            if len(audio_chunk) < 512:
+                padding = np.zeros(512 - len(audio_chunk), dtype=np.float32)
                 audio_chunk = np.concatenate([audio_chunk, padding])
             
             # Chuyển thành tensor
-            audio_tensor = torch.from_numpy(audio_chunk).unsqueeze(0)
+            audio_tensor = torch.from_numpy(audio_chunk).float().unsqueeze(0)
             
             # Phát hiện speech
             with torch.no_grad():
@@ -164,7 +206,7 @@ class SileroVAD:
             return True
 
     def get_speech_probability(self, audio_chunk: np.ndarray, sample_rate: int) -> float:
-        """Lấy xác suất speech (dùng cho debugging)"""
+        """Lấy xác suất speech"""
         if self.model is None:
             return 0.0
             
@@ -175,15 +217,19 @@ class SileroVAD:
             
             # Chuẩn hóa audio
             if audio_chunk.dtype != np.float32:
-                audio_chunk = audio_chunk.astype(np.float32) / 32768.0
+                audio_chunk = audio_chunk.astype(np.float32)
+                if np.max(np.abs(audio_chunk)) > 1.0:
+                    audio_chunk = audio_chunk / 32768.0
+            
+            audio_chunk = np.clip(audio_chunk, -1.0, 1.0)
             
             # Đảm bảo độ dài phù hợp
             if len(audio_chunk) < 512:
-                padding = np.zeros(512 - len(audio_chunk))
+                padding = np.zeros(512 - len(audio_chunk), dtype=np.float32)
                 audio_chunk = np.concatenate([audio_chunk, padding])
             
             # Chuyển thành tensor
-            audio_tensor = torch.from_numpy(audio_chunk).unsqueeze(0)
+            audio_tensor = torch.from_numpy(audio_chunk).float().unsqueeze(0)
             
             # Phát hiện speech
             with torch.no_grad():