Update core/silero_vad.py

core/silero_vad.py

@@ -240,14 +240,16 @@
 #             return 0.0import torch
 import torch
 import numpy as np
-from typing import Optional, Callable
+from typing import Callable
 from config.settings import settings
 import os
 import time
 
+
 class SileroVAD:
     def __init__(self):
         self.model = None
+        self.utils = None  # giữ các hàm tiện ích
         self.sample_rate = 16000
         self.is_streaming = False
         self.speech_callback = None
@@ -260,37 +262,38 @@ class SileroVAD:
         """Khởi tạo Silero VAD model"""
         try:
             print("🔄 Đang tải Silero VAD model...")
-            
-            # Sử dụng torch.hub
-            self.model = torch.hub.load(
+
+            # ✅ Cách tải đúng (model, utils)
+            self.model, self.utils = torch.hub.load(
                 repo_or_dir='snakers4/silero-vad',
                 model='silero_vad',
                 force_reload=False,
                 trust_repo=True
             )
-            
+
             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}")
             self._initialize_model_fallback()
 
     def _initialize_model_fallback(self):
-        """Fallback method"""
+        """Fallback nếu torch.hub.load thất bại"""
         try:
-            # Tạo model trực tiếp
             model_dir = torch.hub.get_dir()
-            model_path = os.path.join(model_dir, 'snakers4_silero-vad_master', 'files', 'silero_vad.jit')
-            
+            model_path = os.path.join(
+                model_dir, 'snakers4_silero-vad_master', 'files', 'silero_vad.jit'
+            )
+
             if os.path.exists(model_path):
                 self.model = torch.jit.load(model_path)
                 self.model.eval()
                 print("✅ Đã tải Silero VAD model thành công (fallback)")
             else:
-                print("❌ Không tìm thấy model file")
+                print("❌ Không tìm thấy model file (fallback thất bại)")
                 self.model = None
-                
+
         except Exception as e:
             print(f"❌ Lỗi tải Silero VAD model fallback: {e}")
             self.model = None
@@ -300,7 +303,7 @@ class SileroVAD:
         if self.model is None:
             print("❌ Silero VAD model chưa được khởi tạo")
             return False
-        
+
         self.is_streaming = True
         self.speech_callback = speech_callback
         self.audio_buffer = []
@@ -317,7 +320,7 @@ class SileroVAD:
         print("🛑 Đã dừng Silero VAD streaming")
 
     def process_stream(self, audio_chunk: np.ndarray, sample_rate: int):
-        """Xử lý audio chunk với Silero VAD cải tiến"""
+        """Xử lý audio chunk với Silero VAD"""
         if not self.is_streaming or self.model is None:
             return
 
@@ -329,7 +332,7 @@ class SileroVAD:
             # Thêm vào buffer
             self.audio_buffer.extend(audio_chunk)
 
-            # Xử lý khi buffer đủ lớn (0.5 giây)
+            # Xử lý khi buffer đủ 0.5 giây
             buffer_duration = len(self.audio_buffer) / self.sample_rate
             if buffer_duration >= 0.5:
                 self._process_buffer()
@@ -338,55 +341,45 @@ class SileroVAD:
             print(f"❌ Lỗi xử lý Silero VAD: {e}")
 
     def _process_buffer(self):
-        """Xử lý buffer audio với Silero VAD cải tiến"""
+        """Xử lý buffer audio với Silero VAD"""
         try:
-            chunk_size = int(self.sample_rate * 0.5)  # 0.5 giây
+            chunk_size = int(self.sample_rate * 0.5)
             if len(self.audio_buffer) < chunk_size:
                 return
 
             # Lấy chunk
             audio_chunk = np.array(self.audio_buffer[:chunk_size])
-            
-            # Chuẩn hóa audio
             audio_chunk = self._normalize_audio(audio_chunk)
-            
-            # Phát hiện speech
+
+            # Dự đoán xác suất speech
             speech_prob = self._get_speech_probability(audio_chunk)
-            
             print(f"🎯 Silero VAD speech probability: {speech_prob:.3f}")
-            
-            # Ngưỡng phát hiện speech
+
+            # Nếu vượt ngưỡng, xác nhận là speech
             if speech_prob > settings.VAD_THRESHOLD:
                 current_time = time.time()
-                
+
                 if self.speech_start_time == 0:
                     self.speech_start_time = current_time
                     print("🎯 Bắt đầu phát hiện speech")
-                
-                # Gọi callback nếu đủ thời gian speech
+
                 speech_duration = current_time - self.speech_start_time
                 if speech_duration >= self.min_speech_duration:
                     if self.speech_callback:
-                        # Lấy toàn bộ audio từ buffer
                         full_audio = np.array(self.audio_buffer)
                         full_audio = self._normalize_audio(full_audio)
                         self.speech_callback(full_audio, self.sample_rate)
-                        
-                        # Xóa buffer sau khi xử lý
+
                         self.audio_buffer = []
                         self.speech_start_time = 0
             else:
-                # Reset nếu không phải speech
                 if self.speech_start_time > 0:
                     print("🔇 Kết thúc speech segment")
+
                 self.speech_start_time = 0
-                
-                # Giữ lại 0.2 giây cuối để overlap
+                # Giữ lại 0.2 giây overlap
                 keep_samples = int(self.sample_rate * 0.2)
-                if len(self.audio_buffer) > keep_samples:
-                    self.audio_buffer = self.audio_buffer[-keep_samples:]
-                else:
-                    self.audio_buffer = []
+                self.audio_buffer = self.audio_buffer[-keep_samples:]
 
         except Exception as e:
             print(f"❌ Lỗi xử lý Silero VAD buffer: {e}")
@@ -394,89 +387,66 @@ class SileroVAD:
             self.speech_start_time = 0
 
     def _normalize_audio(self, audio: np.ndarray) -> np.ndarray:
-        """Chuẩn hóa audio cho Silero VAD"""
+        """Chuẩn hóa audio"""
         if audio.dtype != np.float32:
             audio = audio.astype(np.float32)
             if np.max(np.abs(audio)) > 1.0:
-                audio = audio / 32768.0  # Normalize từ int16
-        
+                audio = audio / 32768.0
         return np.clip(audio, -1.0, 1.0)
 
     def _get_speech_probability(self, audio_chunk: np.ndarray) -> float:
-        """Lấy xác suất speech từ audio chunk"""
+        """Trả về xác suất speech"""
         try:
-            # Đảm bảo độ dài phù hợp
             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).float().unsqueeze(0)
-            
-            # Phát hiện speech
+
             with torch.no_grad():
                 return self.model(audio_tensor, self.sample_rate).item()
-            
+
         except Exception as e:
             print(f"❌ Lỗi lấy speech probability: {e}")
             return 0.0
 
     def _resample_audio(self, audio: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
-        """Resample audio"""
+        """Resample đơn giản"""
         if orig_sr == target_sr:
             return audio
-        
         try:
-            # Simple resampling
-            orig_length = len(audio)
-            new_length = int(orig_length * target_sr / orig_sr)
-            
-            x_old = np.linspace(0, 1, orig_length)
-            x_new = np.linspace(0, 1, new_length)
-            resampled_audio = np.interp(x_new, x_old, audio)
-            
-            return resampled_audio
+            orig_len = len(audio)
+            new_len = int(orig_len * target_sr / orig_sr)
+            x_old = np.linspace(0, 1, orig_len)
+            x_new = np.linspace(0, 1, new_len)
+            return np.interp(x_new, x_old, audio)
         except Exception as e:
             print(f"⚠️ Lỗi resample: {e}")
             return audio
 
     def is_speech(self, audio_chunk: np.ndarray, sample_rate: int) -> bool:
-        """Kiểm tra xem audio chunk có phải là speech không"""
+        """Kiểm tra chunk có phải speech không"""
         if self.model is None:
             return True
-            
         try:
-            # Resample nếu cần
             if sample_rate != self.sample_rate:
                 audio_chunk = self._resample_audio(audio_chunk, sample_rate, self.sample_rate)
-            
-            # Chuẩn hóa audio
             audio_chunk = self._normalize_audio(audio_chunk)
-            
-            # Lấy xác suất speech
-            speech_prob = self._get_speech_probability(audio_chunk)
-            
-            return speech_prob > settings.VAD_THRESHOLD
-            
+            prob = self._get_speech_probability(audio_chunk)
+            return prob > settings.VAD_THRESHOLD
         except Exception as e:
-            print(f"❌ Lỗi kiểm tra speech với Silero: {e}")
+            print(f"❌ Lỗi kiểm tra speech: {e}")
             return True
 
     def get_speech_probability(self, audio_chunk: np.ndarray, sample_rate: int) -> float:
         """Lấy xác suất speech"""
         if self.model is None:
             return 0.0
-            
         try:
-            # Resample nếu cần
             if sample_rate != self.sample_rate:
                 audio_chunk = self._resample_audio(audio_chunk, sample_rate, self.sample_rate)
-            
-            # Chuẩn hóa audio
             audio_chunk = self._normalize_audio(audio_chunk)
-            
             return self._get_speech_probability(audio_chunk)
-            
         except Exception as e:
             print(f"❌ Lỗi lấy speech probability: {e}")
-            return 0.0
+            return 0.0