update

examples/evaluation/step_1_run_evaluation.py

@@ -26,7 +26,14 @@ def get_args():
     )
     parser.add_argument(
         "--output_file",
-        default=r"evaluation.jsonl",
+        default=r"native_silero_vad.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--vad_engine",
+        # default="fsmn-vad-by-webrtcvad-nx2-dns3",
+        # default="silero-vad-by-webrtcvad-nx2-dns3",
+        default="native_silero_vad",
         type=str
     )
     parser.add_argument("--expected_sample_rate", default=8000, type=int)
@@ -110,8 +117,7 @@ def main():
                 min_silence_length=6,
                 max_speech_length=100000,
                 min_speech_length=15,
-                # engine="fsmn-vad-by-webrtcvad-nx2-dns3",
-                engine="silero-vad-by-webrtcvad-nx2-dns3",
+                engine=args.vad_engine,
                 api_name="/when_click_vad_button"
             )
             js = json.loads(message)

examples/evaluation/step_2_show_metrics.py

@@ -3,6 +3,7 @@
 import argparse
 import json
 import os
+from pathlib import Path
 import sys
 
 pwd = os.path.abspath(os.path.dirname(__file__))
@@ -16,53 +17,77 @@ def get_args():
 
     parser.add_argument(
         "--eval_file",
-        default=r"evaluation.jsonl",
+        # default=r"native_silero_vad.jsonl",
         type=str
     )
     args = parser.parse_args()
     return args
 
 
+evaluation_files = [
+    "native_silero_vad.jsonl",
+    "fsmn-vad.jsonl",
+    "silero-vad.jsonl"
+]
+
+
 def main():
-    args = get_args()
-
-    total = 0
-    total_duration = 0
-    total_accuracy = 0
-    total_precision = 0
-    total_recall = 0
-    total_f1 = 0
-    progress_bar = tqdm(desc="evaluation")
-    with open(args.eval_file, "r", encoding="utf-8") as f:
-        for row in f:
-            row = json.loads(row)
-            duration = row["duration"]
-            accuracy = row["accuracy"]
-            precision = row["precision"]
-            recall = row["recall"]
-            f1 = row["f1"]
-
-            total += 1
-            total_duration += duration
-            total_accuracy += accuracy * duration
-            total_precision += precision * duration
-            total_recall += recall * duration
-            total_f1 += f1 * duration
-
-            average_accuracy = total_accuracy / total_duration
-            average_precision = total_precision / total_duration
-            average_recall = total_recall / total_duration
-            average_f1 = total_f1 / total_duration
-
-            progress_bar.update(1)
-            progress_bar.set_postfix({
-                "total": total,
-                "accuracy": average_accuracy,
-                "precision": average_precision,
-                "recall": average_recall,
-                "f1": average_f1,
-                "total_duration": f"{round(total_duration / 60, 4)}min",
-            })
+    # args = get_args()
+
+    for eval_file in evaluation_files:
+        eval_file = Path(eval_file)
+        total = 0
+        total_duration = 0
+        total_accuracy = 0
+        total_precision = 0
+        total_recall = 0
+        total_f1 = 0
+
+        average_accuracy = 0
+        average_precision = 0
+        average_recall = 0
+        average_f1 = 0
+
+        # progress_bar = tqdm(desc=eval_file.name)
+        with open(eval_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                duration = row["duration"]
+                accuracy = row["accuracy"]
+                precision = row["precision"]
+                recall = row["recall"]
+                f1 = row["f1"]
+
+                total += 1
+                total_duration += duration
+                total_accuracy += accuracy * duration
+                total_precision += precision * duration
+                total_recall += recall * duration
+                total_f1 += f1 * duration
+
+                average_accuracy = total_accuracy / total_duration
+                average_precision = total_precision / total_duration
+                average_recall = total_recall / total_duration
+                average_f1 = total_f1 / total_duration
+
+                # progress_bar.update(1)
+                # progress_bar.set_postfix({
+                #     "total": total,
+                #     "accuracy": average_accuracy,
+                #     "precision": average_precision,
+                #     "recall": average_recall,
+                #     "f1": average_f1,
+                #     "total_duration": f"{round(total_duration / 60, 4)}min",
+                # })
+        summary = (f"{eval_file.name}, "
+                   f"total: {total}, "
+                   f"accuracy: {average_accuracy}, "
+                   f"precision： {average_precision}, "
+                   f"recall： {average_recall}, "
+                   f"f1： {average_f1}, "
+                   f"total_duration： {f"{round(total_duration / 60, 4)}min"}, "
+                   )
+        print(summary)
     return
 
 

examples/evaluation/step_3_show_vad.py

@@ -51,10 +51,17 @@ def show_image(signal: np.ndarray,
     plt.show()
 
 
+evaluation_files = [
+    # "native_silero_vad.jsonl",
+    "fsmn-vad.jsonl",
+    "silero-vad.jsonl"
+]
+
+
 def main():
-    args = get_args()
+    # args = get_args()
 
-    with open(args.eval_file, "r", encoding="utf-8") as f:
+    with open(evaluation_files[0], "r", encoding="utf-8") as f:
         for row in f:
             row = json.loads(row)
             filename = row["filename"]
@@ -77,25 +84,16 @@ def main():
                 begin = int(begin * sample_rate)
                 end = int(end * sample_rate)
                 ground_truth_probs[begin:end] = 1
+
             prediction_probs = np.zeros(shape=(signal_length,), dtype=np.float32)
             for begin, end in prediction:
                 begin = int(begin * sample_rate)
                 end = int(end * sample_rate)
                 prediction_probs[begin:end] = 1
 
-            # p = encoder_num_layers * (encoder_kernel_size - 1) // 2 * hop_size * sample_rate
-            p = 3 * (3 - 1) // 2 * 80
-            p = int(p)
-            print(f"p: {p}")
-            prediction_probs = np.concat(
-                [
-                    prediction_probs[p:], prediction_probs[-p:]
-                ],
-                axis=-1
-            )
-
             show_image(signal,
-                       ground_truth_probs, prediction_probs,
+                       ground_truth_probs,
+                       prediction_probs,
                        sample_rate=sample_rate,
                        )
     return

examples/fsmn_vad_by_webrtcvad/step_4_train_model.py

@@ -127,7 +127,7 @@ def main():
         max_wave_value=32768.0,
         min_snr_db=config.min_snr_db,
         max_snr_db=config.max_snr_db,
-        do_volume_enhancement=True,
+        do_volume_enhancement=False,
         # skip=225000,
     )
     valid_dataset = VadPaddingJsonlDataset(

examples/silero_vad_by_webrtcvad/run.sh

@@ -4,7 +4,7 @@
 
 bash run.sh --stage 3 --stop_stage 5 --system_version centos \
 --file_folder_name silero-vad-by-webrtcvad-nx2-dns3 \
---final_model_name silero-vad-by-webrtcvad-nx2-dns3 \
+--final_model_name silero-vad-by-webrtcvad-nx2-dns3-20250813 \
 --noise_patterns "/data/tianxing/HuggingDatasets/nx_noise/data/noise/**/*.wav" \
 --speech_patterns "/data/tianxing/HuggingDatasets/nx_noise/data/speech/dns3-speech/**/*.wav \
 /data/tianxing/HuggingDatasets/nx_noise/data/speech/nx-speech2/**/*.wav"

examples/silero_vad_by_webrtcvad/step_4_train_model.py

@@ -127,7 +127,7 @@ def main():
         max_wave_value=32768.0,
         min_snr_db=config.min_snr_db,
         max_snr_db=config.max_snr_db,
-        do_volume_enhancement=True,
+        do_volume_enhancement=False,
         # skip=225000,
     )
     valid_dataset = VadPaddingJsonlDataset(
@@ -271,7 +271,8 @@ def main():
             dice_loss = dice_loss_fn.forward(probs, targets)
             lsnr_loss = model.lsnr_loss_fn(lsnr, clean_audios, noisy_audios)
 
-            loss = 1.0 * bce_loss + 1.0 * dice_loss + 0.3 * lsnr_loss
+            # loss = 1.0 * bce_loss + 1.0 * dice_loss + 0.3 * lsnr_loss
+            loss = 1.0 * bce_loss + 1.0 * dice_loss + 1.0 * lsnr_loss
             if torch.any(torch.isnan(loss)) or torch.any(torch.isinf(loss)):
                 logger.info(f"find nan or inf in loss. continue.")
                 continue
@@ -352,7 +353,8 @@ def main():
                         dice_loss = dice_loss_fn.forward(probs, targets)
                         lsnr_loss = model.lsnr_loss_fn(lsnr, clean_audios, noisy_audios)
 
-                        loss = 1.0 * bce_loss + 1.0 * dice_loss + 0.3 * lsnr_loss
+                        # loss = 1.0 * bce_loss + 1.0 * dice_loss + 0.3 * lsnr_loss
+                        loss = 1.0 * bce_loss + 1.0 * dice_loss + 1.0 * lsnr_loss
                         if torch.any(torch.isnan(loss)) or torch.any(torch.isinf(loss)):
                             logger.info(f"find nan or inf in loss. continue.")
                             continue

examples/silero_vad_by_webrtcvad/step_5_export_model.py

@@ -94,7 +94,7 @@ def main():
                           "new_lstm_hidden_state": {2: "batch_size"},
                       })
 
-    ort_session = ort.InferenceSession("silero_vad.onnx")
+    ort_session = ort.InferenceSession("model.onnx")
     input_feed = {
         "inputs": inputs.numpy(),
         "encoder_in_cache": encoder_in_cache.numpy(),

log.py

@@ -15,8 +15,43 @@ def get_converter(tz_info: str = "Asia/Shanghai"):
     return converter
 
 
+def setup_stream(tz_info: str = "Asia/Shanghai"):
+    fmt = "%(asctime)s|%(name)s|%(levelname)s|%(filename)s|%(lineno)d|%(message)s"
+
+    formatter = logging.Formatter(
+        fmt=fmt,
+        datefmt="%Y-%m-%d %H:%M:%S %z"
+    )
+    formatter.converter = get_converter(tz_info)
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(formatter)
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_logger.addHandler(stream_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_logger.addHandler(stream_handler)
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+
+        ]
+    )
+    return
+
+
 def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
-    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+    fmt = "%(asctime)s|%(name)s|%(levelname)s|%(filename)s|%(lineno)d|%(message)s"
 
     formatter = logging.Formatter(
         fmt=fmt,
@@ -38,11 +73,12 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     main_info_file_handler.setLevel(logging.INFO)
-    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_info_file_handler.setFormatter(formatter)
     main_logger.addHandler(main_info_file_handler)
 
     # http
     http_logger = logging.getLogger("http")
+    http_logger.addHandler(stream_handler)
     http_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "http.log"),
         maxBytes=100*1024*1024,  # 100MB
@@ -50,11 +86,12 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     http_file_handler.setLevel(logging.DEBUG)
-    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_file_handler.setFormatter(formatter)
     http_logger.addHandler(http_file_handler)
 
     # api
     api_logger = logging.getLogger("api")
+    api_logger.addHandler(stream_handler)
     api_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "api.log"),
         maxBytes=10*1024*1024,  # 10MB
@@ -62,7 +99,7 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     api_file_handler.setLevel(logging.DEBUG)
-    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_file_handler.setFormatter(formatter)
     api_logger.addHandler(api_file_handler)
 
     # alarm
@@ -74,7 +111,7 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     alarm_file_handler.setLevel(logging.DEBUG)
-    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_file_handler.setFormatter(formatter)
     alarm_logger.addHandler(alarm_file_handler)
 
     debug_file_handler = RotatingFileHandler(
@@ -84,7 +121,7 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     debug_file_handler.setLevel(logging.DEBUG)
-    debug_file_handler.setFormatter(logging.Formatter(fmt))
+    debug_file_handler.setFormatter(formatter)
 
     info_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "info.log"),
@@ -93,7 +130,7 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     info_file_handler.setLevel(logging.INFO)
-    info_file_handler.setFormatter(logging.Formatter(fmt))
+    info_file_handler.setFormatter(formatter)
 
     error_file_handler = RotatingFileHandler(
         filename=os.path.join(log_directory, "error.log"),
@@ -102,7 +139,7 @@ def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
         backupCount=2,
     )
     error_file_handler.setLevel(logging.ERROR)
-    error_file_handler.setFormatter(logging.Formatter(fmt))
+    error_file_handler.setFormatter(formatter)
 
     logging.basicConfig(
         level=logging.DEBUG,

main.py

@@ -25,8 +25,10 @@ from project_settings import environment, project_path, log_directory, time_zone
 from toolbox.os.command import Command
 from toolbox.torchaudio.models.vad.fsmn_vad.inference_fsmn_vad_onnx import InferenceFSMNVadOnnx
 from toolbox.torchaudio.models.vad.silero_vad.inference_silero_vad import InferenceSileroVad
+from toolbox.torchaudio.models.vad.native_silero_vad.inference_native_silero_vad_onnx import InferenceNativeSileroVadOnnx
 from toolbox.torchaudio.utils.visualization import process_speech_probs
 from toolbox.vad.utils import PostProcess
+from toolbox.pydub.volume import get_volume
 
 log.setup_size_rotating(log_directory=log_directory, tz_info=time_zone_info)
 
@@ -93,9 +95,11 @@ def shell(cmd: str):
 
 
 def get_infer_cls_by_model_name(model_name: str):
-    if model_name.__contains__("fsmn"):
+    if model_name.__contains__("native_silero_vad"):
+        infer_cls = InferenceNativeSileroVadOnnx
+    elif model_name.__contains__("fsmn-vad"):
         infer_cls = InferenceFSMNVadOnnx
-    elif model_name.__contains__("silero"):
+    elif model_name.__contains__("silero-vad"):
         infer_cls = InferenceSileroVad
     else:
         raise AssertionError
@@ -158,8 +162,8 @@ def when_click_vad_button(audio_file_t = None, audio_microphone_t = None,
         vad_info = infer_engine.infer(audio)
         time_cost = time.time() - begin
 
-        probs = vad_info["probs"]
-        lsnr = vad_info["lsnr"]
+        probs: np.ndarray = vad_info["probs"]
+        lsnr: np.ndarray = vad_info["lsnr"]
         # lsnr = lsnr / np.max(np.abs(lsnr))
         lsnr = lsnr / 30
 
@@ -197,13 +201,17 @@ def when_click_vad_button(audio_file_t = None, audio_microphone_t = None,
             ] for v in vad_segments
         ]
 
+        # volume
+        volume_map: dict = get_volume(audio, sample_rate)
+
         # message
         rtf = time_cost / audio_duration
         info = {
             "vad_segments": vad_segments,
             "time_cost": round(time_cost, 4),
             "duration": round(audio_duration, 4),
-            "rtf": round(rtf, 4)
+            "rtf": round(rtf, 4),
+            **volume_map
         }
         message = json.dumps(info, ensure_ascii=False, indent=4)
 
@@ -239,8 +247,8 @@ def main():
         }
         for filename in (project_path / "trained_models").glob("*.zip")
         if filename.name not in (
-            "cnn-vad-by-webrtcvad-nx-dns3.zip",
-            "fsmn-vad-by-webrtcvad-nx-dns3.zip",
+            # "cnn-vad-by-webrtcvad-nx-dns3.zip",
+            # "fsmn-vad-by-webrtcvad-nx-dns3.zip",
             "examples.zip",
             "sound-2-ch32.zip",
             "sound-3-ch32.zip",

toolbox/pydub/volume.py

@@ -76,6 +76,45 @@ def set_volume(waveform: np.ndarray, sample_rate: int = 8000, volume: int = 0):
     return samples
 
 
+def get_volume(waveform: np.ndarray, sample_rate: int = 8000):
+    if np.min(waveform) < -1 or np.max(waveform) > 1:
+        raise AssertionError(f"waveform type: {type(waveform)}, dtype: {waveform.dtype}")
+    waveform = np.array(waveform * (1 << 15), dtype=np.int16)
+    raw_data = waveform.tobytes()
+
+    audio_segment = AudioSegment(
+        data=raw_data,
+        sample_width=2,
+        frame_rate=sample_rate,
+        channels=1
+    )
+
+    map_list = [
+        [0, -150],
+        [10, -40],
+        [50, -12],
+        [75, -6],
+        [100, 0],
+    ]
+    scores = [a for a, b in map_list]
+    stages = [b for a, b in map_list]
+
+    audio_dbfs = audio_segment.dBFS
+
+    # 计算目标 volume
+    volume = score_transform(
+        x=audio_dbfs,
+        stages=list(reversed(stages)),
+        scores=list(reversed(scores)),
+    )
+
+    result = {
+        "dbfs": audio_dbfs,
+        "volume": volume,
+    }
+    return result
+
+
 def get_args():
     parser = argparse.ArgumentParser()
     parser.add_argument(

toolbox/torch/utils/data/dataset/vad_padding_jsonl_dataset.py

@@ -139,8 +139,9 @@ class VadPaddingJsonlDataset(IterableDataset):
         speech_wave_np = self.make_sure_duration(speech_wave_np, self.expected_sample_rate, self.speech_target_duration)
 
         # volume enhancement
-        volume = random.randint(10, 80)
-        speech_wave_np = set_volume(speech_wave_np, sample_rate=self.expected_sample_rate, volume=volume)
+        if self.do_volume_enhancement:
+            volume = random.randint(10, 80)
+            speech_wave_np = set_volume(speech_wave_np, sample_rate=self.expected_sample_rate, volume=volume)
 
         noise_wave_list = list()
         for noise in noise_list:

toolbox/torchaudio/models/vad/native_silero_vad/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == "__main__":
+    pass

toolbox/torchaudio/models/vad/native_silero_vad/inference_native_silero_vad_onnx.py

@@ -0,0 +1,198 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import logging
+from pathlib import Path
+import shutil
+import tempfile
+import zipfile
+
+from scipy.io import wavfile
+import numpy as np
+import torch
+import onnxruntime as ort
+from torch.nn import functional as F
+
+torch.set_num_threads(1)
+
+from project_settings import project_path
+from toolbox.torchaudio.utils.visualization import process_speech_probs, make_visualization
+from toolbox.torchaudio.configuration_utils import PretrainedConfig
+
+
+logger = logging.getLogger("toolbox")
+
+
+class NativeSileroVadConfig(PretrainedConfig):
+    def __init__(self,
+                 sample_rate: int = 8000,
+                 win_size: int = 256,
+                 hop_size: int = 256,
+                 **kwargs
+                 ):
+        super(NativeSileroVadConfig, self).__init__(**kwargs)
+        # transform
+        self.sample_rate = sample_rate
+        self.win_size = win_size
+        self.hop_size = hop_size
+
+
+class InferenceNativeSileroVadOnnx(object):
+    """
+    code:
+    https://github.com/snakers4/silero-vad/blob/master/src/silero_vad/utils_vad.py
+
+    model:
+    https://github.com/snakers4/silero-vad/tree/master/src/silero_vad/data
+    """
+    def __init__(self,
+                 pretrained_model_path_or_zip_file: str,
+                 device: str = "cpu"
+                 ):
+        self.pretrained_model_path_or_zip_file = pretrained_model_path_or_zip_file
+        self.device = torch.device(device)
+
+        logger.info(f"loading model; model_file: {self.pretrained_model_path_or_zip_file}")
+        config, ort_session = self.load_models(self.pretrained_model_path_or_zip_file)
+        logger.info(f"model loading completed; model_file: {self.pretrained_model_path_or_zip_file}")
+
+        self.config = config
+        self.ort_session = ort_session
+
+    def load_models(self, model_path: str):
+        model_path = Path(model_path)
+        if model_path.name.endswith(".zip"):
+            with zipfile.ZipFile(model_path.as_posix(), "r") as f_zip:
+                out_root = Path(tempfile.gettempdir()) / "cc_vad"
+                out_root.mkdir(parents=True, exist_ok=True)
+                f_zip.extractall(path=out_root)
+            model_path = out_root / model_path.stem
+
+        config = NativeSileroVadConfig.from_pretrained(
+            pretrained_model_name_or_path=model_path.as_posix(),
+        )
+
+        opts = ort.SessionOptions()
+        opts.inter_op_num_threads = 1
+        opts.intra_op_num_threads = 1
+
+        ort_session = ort.InferenceSession(
+            (model_path / "silero_vad.onnx").as_posix(),
+            sess_options=opts
+        )
+        shutil.rmtree(model_path)
+        return config, ort_session
+
+    def signal_prepare(self, signal: torch.Tensor) -> torch.Tensor:
+        if signal.dim() == 2:
+            signal = torch.unsqueeze(signal, dim=1)
+        _, _, n_samples = signal.shape
+        remainder = (n_samples - self.config.win_size) % self.config.hop_size
+        if remainder > 0:
+            n_samples_pad = self.config.hop_size - remainder
+            signal = F.pad(signal, pad=(0, n_samples_pad), mode="constant", value=0)
+        return signal
+
+    def forward_chunk(self, chunk: torch.Tensor, context: torch.Tensor, state: torch.Tensor):
+        # chunk shape: [1, chunk_size]
+        num_samples = 512 if self.config.sample_rate == 16000 else 256
+        if chunk.shape[-1] != num_samples:
+            raise ValueError(f"Provided number of samples is {chunk.shape[-1]} (Supported values: 256 for 8000 sample rate, 512 for 16000)")
+
+        context_size = 64 if self.config.sample_rate == 16000 else 32
+
+        chunk = torch.cat(tensors=[context, chunk], dim=1)
+        input_feed = {
+            "input": chunk.numpy(),
+            "state": state.numpy(),
+            "sr": np.array(self.config.sample_rate, dtype=np.int64)
+        }
+        ort_outs = self.ort_session.run(output_names=None, input_feed=input_feed)
+        vad_flag, state = ort_outs
+        # vad_flag shape: [b, 1]
+        # state shape: [2, b, 128]
+        vad_flag = torch.from_numpy(vad_flag)
+        state = torch.from_numpy(state)
+        context = chunk[..., -context_size:]
+        return vad_flag, context, state
+
+    def infer(self, signal: np.ndarray) -> np.ndarray:
+        # signal shape: [num_samples,], value between -1 and 1.
+        inputs = torch.tensor(signal, dtype=torch.float32)
+        inputs = torch.unsqueeze(inputs, dim=0)
+        # inputs shape: [1, num_samples]
+
+        n_samples = inputs.shape[-1]
+        inputs = self.signal_prepare(inputs)
+        # inputs shape: [1, 1, num_samples]
+        inputs = torch.squeeze(inputs, dim=1)
+        # inputs shape: [1, num_samples]
+        _, num_samples = inputs.shape
+
+        vad_flags = list()
+
+        context = torch.zeros(0)
+        state = torch.zeros(size=(2, 1, 128), dtype=torch.float32)
+        for i in range(0, num_samples, self.config.hop_size):
+            sub_inputs = inputs[:, i:i+self.config.win_size]
+            vad_flag, context, state = self.forward_chunk(sub_inputs, context, state)
+            vad_flags.append(vad_flag)
+
+        vad_flags = torch.cat(vad_flags, dim=1).cpu()
+        # vad_flags, torch.Tensor, shape: [b, num_chunks]
+        vad_flags = vad_flags.numpy()
+        # vad_flags, np.ndarray, shape: [b, num_chunks]
+        vad_flags = vad_flags[0]
+        # vad_flags shape: [num_chunk,]
+
+        result = {
+            "probs": vad_flags,
+            "lsnr": np.zeros_like(vad_flags),
+        }
+        return result
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--wav_file",
+        # default=r"D:\Users\tianx\HuggingDatasets\nx_noise\data\speech\en-SG\2025-05-19\active_media_r_0ddac777-d986-4a5c-9c7c-ff64be0a463d_11.wav",
+        default=(project_path / "data/examples/speech/active_media_r_0ba69730-66a4-4ecd-8929-ef58f18f4612_2.wav").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+SAMPLE_RATE = 8000
+
+
+def main():
+    args = get_args()
+
+    sample_rate, signal = wavfile.read(args.wav_file)
+    if SAMPLE_RATE != sample_rate:
+        raise AssertionError
+    signal = signal / (1 << 15)
+
+    infer = InferenceNativeSileroVadOnnx(
+        pretrained_model_path_or_zip_file=(project_path / "trained_models/native_silero_vad.zip").as_posix(),
+    )
+
+    vad_info = infer.infer(signal)
+    speech_probs = vad_info["probs"]
+    # speech_probs, np.ndarray shape: [num_chunk,]
+
+    speech_probs = process_speech_probs(
+        signal=signal,
+        speech_probs=speech_probs,
+        frame_step=infer.config.hop_size,
+    )
+
+    # plot
+    make_visualization(signal, speech_probs, SAMPLE_RATE)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/models/vad/silero_vad/inference_silero_vad_onnx.py

@@ -109,9 +109,6 @@ class InferenceSileroVadOnnx(object):
         }
         return result
 
-    def post_process(self, probs: List[float]):
-        return
-
 
 def get_args():
     parser = argparse.ArgumentParser()
@@ -157,7 +154,7 @@ def main():
         raise AssertionError
     signal = signal / (1 << 15)
 
-    infer = InferenceFSMNVadOnnx(
+    infer = InferenceSileroVadOnnx(
         # pretrained_model_path_or_zip_file=(project_path / "trained_models/fsmn-vad-by-webrtcvad-nx-dns3.zip").as_posix(),
         pretrained_model_path_or_zip_file = (project_path / "trained_models/fsmn-vad-by-webrtcvad-nx2-dns3.zip").as_posix(),
     )