Merge branch 'vad' of hf.co:MoYoYoTech/Translator into vad

* 'vad' of hf.co:MoYoYoTech/Translator:
update
filter [] words
Disable FunASR pbar.

# Conflicts:
# transcribe/pipelines/pipe_vad.py

transcribe/helpers/funasr.py

@@ -30,7 +30,7 @@ class FunASR:
         audio_frames = np.frombuffer(audio_buffer, dtype=np.float32)
         # sf.write(f'{config.ASSERT_DIR}/{time.time()}.wav', audio_frames, samplerate=16000)
         try:
-            output = self.model.generate(input=audio_frames)
+            output = self.model.generate(input=audio_frames, disable_pbar=True)
             return output
         except Exception as e:
             logger.error(e)

transcribe/helpers/vadprocessor.py

@@ -113,6 +113,7 @@ class VADIteratorOnnx:
                  sampling_rate: int = 16000,
                  min_silence_duration_ms: int = 100,
                  max_speech_duration_s: float = float('inf'),
+                 speech_pad_ms: int = 30
                  ):
         self.model = OnnxWrapper(VAD_MODEL_PATH, True)
         self.threshold = threshold
@@ -123,7 +124,7 @@ class VADIteratorOnnx:
 
         self.min_silence_samples = sampling_rate * min_silence_duration_ms / 1000
         self.max_speech_samples = int(sampling_rate * max_speech_duration_s)
-        # self.speech_pad_samples = sampling_rate * speech_pad_ms / 1000
+        self.speech_pad_samples = sampling_rate * speech_pad_ms / 1000
         self.reset_states()
 
     def reset_states(self):
@@ -158,7 +159,8 @@ class VADIteratorOnnx:
 
         if (speech_prob >= self.threshold) and not self.triggered:
             self.triggered = True
-            speech_start = max(0, self.current_sample - window_size_samples)
+            # speech_start = max(0, self.current_sample - window_size_samples)
+            speech_start = max(0, self.current_sample - self.speech_pad_samples - window_size_samples)
             self.start = speech_start
             return {'start': int(speech_start) if not return_seconds else round(speech_start / self.sampling_rate, 1)}
 
@@ -174,7 +176,8 @@ class VADIteratorOnnx:
             if self.current_sample - self.temp_end < self.min_silence_samples:
                 return None
             else:
-                speech_end = self.temp_end - window_size_samples
+                # speech_end = self.temp_end - window_size_samples
+                speech_end = self.temp_end + self.speech_pad_samples - window_size_samples
                 self.temp_end = 0
                 self.triggered = False
                 return {'end': int(speech_end) if not return_seconds else round(speech_end / self.sampling_rate, 1)}

transcribe/helpers/whisper.py

@@ -52,7 +52,7 @@ class WhisperCPP:
                 initial_prompt=prompt,
                 language=language,  
                 # token_timestamps=True, 
-                # split_on_word=True,
+                split_on_word=True,
                 # max_len=max_len
             )
             return output

transcribe/pipelines/pipe_vad.py

@@ -50,7 +50,7 @@ class VadPipe(BasePipe):
             if start_frame:
                 relative_start_frame = start_frame - self._offset
             if end_frame:
-                relative_end_frame = end_frame - self._offset
+                relative_end_frame = max(0, end_frame - self._offset)
             return relative_start_frame, relative_end_frame
 
     def process(self, in_data: MetaItem) -> MetaItem:
@@ -70,13 +70,10 @@ class VadPipe(BasePipe):
                 self._status = "END" # 音频结束
                 target_audio = source_audio[:rel_end_frame]
                 logging.debug(" 🫷Speech ended, capturing audio up to frame: {}".format(rel_end_frame))
-            elif rel_start_frame is not None and rel_end_frame is not None:
+            else:
                 self._status = 'END'
                 target_audio = source_audio[rel_start_frame:rel_end_frame]
                 logging.debug(" 🔄 Speech segment captured from frame {} to frame {}".format(rel_start_frame, rel_end_frame))
-            else:
-                self._status = 'END'
-                target_audio = np.array([],dtype=np.float32)
                 # logging.debug("❌ No valid speech segment detected, setting status to END")
         else:
             if self._status == 'START':

transcribe/utils.py

@@ -7,6 +7,51 @@ from scipy.io.wavfile import write
 import config
 import csv
 import av
+import re
+
+# Compile regex patterns once outside the loop for better performance
+p_pattern = re.compile(r"(\s*\[.*?\])")
+p_start_pattern = re.compile(r"(\s*\[.*)")
+p_end_pattern = re.compile(r"(\s*.*\])")
+
+
+def filter_words(res_word):
+    """
+    Filter words according to specific bracket patterns.
+    
+    Args:
+        res_word: Iterable of word objects with a 'text' attribute
+    
+    Returns:
+        List of filtered word objects
+    """
+    asr_results = []
+    skip_word = False
+    
+    for word in res_word:
+        # Skip words that completely match the pattern
+        if p_pattern.match(word.text):
+            continue
+        
+        # Mark the start of a section to skip
+        if p_start_pattern.match(word.text):
+            skip_word = True
+            continue
+        
+        # Mark the end of a section to skip
+        if p_end_pattern.match(word.text) and skip_word:
+            skip_word = False
+            continue
+        
+        # Skip words if we're in a skip section
+        if skip_word:
+            continue
+        
+        # Add the word to results if it passed all filters
+        asr_results.append(word)
+    
+    return asr_results
+
 def log_block(key: str, value, unit=''):
     if config.DEBUG:
         return 

transcribe/whisper_llm_serve.py

@@ -11,7 +11,7 @@ import config
 import collections
 from api_model import TransResult, Message, DebugResult
 
-from .utils import log_block, save_to_wave, TestDataWriter
+from .utils import log_block, save_to_wave, TestDataWriter, filter_words
 from .translatepipes import TranslatePipes
 from .strategy import (
     TranscriptStabilityAnalyzer, TranscriptToken)
@@ -132,7 +132,7 @@ class WhisperTranscriptionService:
             try:
                 frame_np = self._frame_queue.get(timeout=0.1)
                 frame_np, speech_status = self._apply_voice_activity_detection(frame_np)
-                if frame_np is None:
+                if frame_np is None or len(frame_np) == 0:
                     continue
                 with self.lock:
                     if self.frames_np is None:
@@ -165,19 +165,20 @@ class WhisperTranscriptionService:
         while not self._translate_thread_stop.is_set():
 
             if self.frames_np is None:
-                time.sleep(0.2)
+                time.sleep(0.01)
                 continue
 
-            with self.lock:
-                if len(self.segments_queue) >0:
-                    audio_buffer = self.segments_queue.pop()
-                    partial = False
-                else:
+            
+            if len(self.segments_queue) >0:
+                audio_buffer = self.segments_queue.pop()
+                partial = False
+            else:
+                with self.lock:
                     audio_buffer = self.frames_np[:int(frame_epoch * 1.5 * self.sample_rate)]# 获取 1.5s * epoch 个音频长度
-                    partial = True
+                partial = True
 
             if len(audio_buffer) ==0:
-                time.sleep(0.2)
+                time.sleep(0.01)
                 continue
 
             if len(audio_buffer) < int(self.sample_rate):
@@ -191,6 +192,7 @@ class WhisperTranscriptionService:
             meta_item = self._transcribe_audio(audio_buffer)
             segments = meta_item.segments
             logger.debug(f"Segments: {segments}")
+            segments = filter_words(segments)
             if len(segments):
                 seg_text = self.text_separator.join(seg.text for seg in segments)
                 if self._temp_string: