update

.gitignore

@@ -9,6 +9,7 @@
 **/log/
 **/logs/
 **/__pycache__/
+**/serialization_dir/
 
 /data/
 /docs/
@@ -21,3 +22,4 @@
 
 **/*.wav
 **/*.xlsx
+**/*.jsonl

Dockerfile

@@ -10,7 +10,9 @@ RUN apt-get install -y ffmpeg build-essential
 RUN pip install --upgrade pip
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-RUN useradd -m -u 1000 user
+RUN pip install --upgrade pip
+
+RUN bash install.sh --stage 1 --stop_stage 2 --system_version centos
 
 USER user
 

download_sound_models.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--trained_model_dir",
+        default=(project_path / "trained_models").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--models_repo_id",
+        default="qgyd2021/vm_sound_classification",
+        type=str,
+    )
+    parser.add_argument(
+        "--model_pattern",
+        default="sound-*-ch32.zip",
+        type=str,
+    )
+    parser.add_argument(
+        "--hf_token",
+        default=environment.get("hf_token"),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    trained_model_dir = Path(args.trained_model_dir)
+    trained_model_dir.mkdir(parents=True, exist_ok=True)
+
+    _ = snapshot_download(
+        repo_id=args.models_repo_id,
+        allow_patterns=[args.model_pattern],
+        local_dir=trained_model_dir.as_posix(),
+        token=args.hf_token,
+    )
+    return
+
+
+if __name__ == '__main__':
+    main()

examples/fsmn_vad/step_1_prepare_data.py

@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+from pathlib import Path
+import random
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+import librosa
+import numpy as np
+from tqdm import tqdm
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--noise_dir",
+        default=r"E:\Users\tianx\HuggingDatasets\nx_noise\data\noise",
+        type=str
+    )
+    parser.add_argument(
+        "--speech_dir",
+        default=r"E:\programmer\asr_datasets\aishell\data_aishell\wav\train",
+        type=str
+    )
+
+    parser.add_argument("--train_dataset", default="train.jsonl", type=str)
+    parser.add_argument("--valid_dataset", default="valid.jsonl", type=str)
+
+    parser.add_argument("--duration", default=6.0, type=float)
+    parser.add_argument("--min_snr_db", default=-10, type=float)
+    parser.add_argument("--max_snr_db", default=20, type=float)
+
+    parser.add_argument("--target_sample_rate", default=8000, type=int)
+
+    parser.add_argument("--max_count", default=-1, type=int)
+
+    args = parser.parse_args()
+    return args
+
+
+def target_second_signal_generator(data_dir: str, duration: int = 6, sample_rate: int = 8000, max_epoch: int = 20000):
+    data_dir = Path(data_dir)
+    for epoch_idx in range(max_epoch):
+        for filename in data_dir.glob("**/*.wav"):
+            signal, _ = librosa.load(filename.as_posix(), sr=sample_rate)
+            raw_duration = librosa.get_duration(y=signal, sr=sample_rate)
+
+            if raw_duration < duration:
+                # print(f"duration less than {duration} s. skip filename: {filename.as_posix()}")
+                continue
+            if signal.ndim != 1:
+                raise AssertionError(f"expected ndim 1, instead of {signal.ndim}")
+
+            signal_length = len(signal)
+            win_size = int(duration * sample_rate)
+            for begin in range(0, signal_length - win_size, win_size):
+                if np.sum(signal[begin: begin+win_size]) == 0:
+                    continue
+                row = {
+                    "epoch_idx": epoch_idx,
+                    "filename": filename.as_posix(),
+                    "raw_duration": round(raw_duration, 4),
+                    "offset": round(begin / sample_rate, 4),
+                    "duration": round(duration, 4),
+                }
+                yield row
+
+
+def main():
+    args = get_args()
+
+    noise_dir = Path(args.noise_dir)
+    speech_dir = Path(args.speech_dir)
+
+    train_dataset = Path(args.train_dataset)
+    valid_dataset = Path(args.valid_dataset)
+    train_dataset.parent.mkdir(parents=True, exist_ok=True)
+    valid_dataset.parent.mkdir(parents=True, exist_ok=True)
+
+    noise_generator = target_second_signal_generator(
+        noise_dir.as_posix(),
+        duration=args.duration,
+        sample_rate=args.target_sample_rate,
+        max_epoch=100000,
+    )
+    speech_generator = target_second_signal_generator(
+        speech_dir.as_posix(),
+        duration=args.duration,
+        sample_rate=args.target_sample_rate,
+        max_epoch=1,
+    )
+
+    count = 0
+    process_bar = tqdm(desc="build dataset jsonl")
+    with open(args.train_dataset, "w", encoding="utf-8") as ftrain, open(args.valid_dataset, "w", encoding="utf-8") as fvalid:
+        for noise, speech in zip(noise_generator, speech_generator):
+            if count >= args.max_count > 0:
+                break
+
+            # row
+            noise_filename = noise["filename"]
+            noise_raw_duration = noise["raw_duration"]
+            noise_offset = noise["offset"]
+            noise_duration = noise["duration"]
+
+            speech_filename = speech["filename"]
+            speech_raw_duration = speech["raw_duration"]
+            speech_offset = speech["offset"]
+            speech_duration = speech["duration"]
+
+            # row
+            random1 = random.random()
+            random2 = random.random()
+
+            row = {
+                "count": count,
+
+                "noise_filename": noise_filename,
+                "noise_raw_duration": noise_raw_duration,
+                "noise_offset": noise_offset,
+                "noise_duration": noise_duration,
+
+                "speech_filename": speech_filename,
+                "speech_raw_duration": speech_raw_duration,
+                "speech_offset": speech_offset,
+                "speech_duration": speech_duration,
+
+                "snr_db": random.uniform(args.min_snr_db, args.max_snr_db),
+
+                "random1": random1,
+            }
+            row = json.dumps(row, ensure_ascii=False)
+            if random2 < (1 / 300 / 1):
+                fvalid.write(f"{row}\n")
+            else:
+                ftrain.write(f"{row}\n")
+
+            count += 1
+            duration_seconds = count * args.duration
+            duration_hours = duration_seconds / 3600
+
+            process_bar.update(n=1)
+            process_bar.set_postfix({
+                "duration_hours": round(duration_hours, 4),
+            })
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/silero_vad_by_webrtcvad/run.sh

@@ -122,7 +122,7 @@ fi
 if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
   $verbose && echo "stage 3: train model"
   cd "${work_dir}" || exit 1
-  python3 step_3_train_model.py \
+  python3 step_4_train_model.py \
   --train_dataset "${train_vad_dataset}" \
   --valid_dataset "${valid_vad_dataset}" \
   --serialization_dir "${file_dir}" \
@@ -131,8 +131,8 @@ if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
 fi
 
 
-if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
-  $verbose && echo "stage 3: test model"
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+  $verbose && echo "stage 4: test model"
   cd "${work_dir}" || exit 1
   python3 step_3_evaluation.py \
   --valid_dataset "${valid_dataset}" \
@@ -143,8 +143,8 @@ if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
 fi
 
 
-if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
-  $verbose && echo "stage 4: collect files"
+if [ ${stage} -le 5 ] && [ ${stop_stage} -ge 5 ]; then
+  $verbose && echo "stage 5: collect files"
   cd "${work_dir}" || exit 1
 
   mkdir -p ${final_model_dir}
@@ -165,8 +165,8 @@ if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
 fi
 
 
-if [ ${stage} -le 5 ] && [ ${stop_stage} -ge 5 ]; then
-  $verbose && echo "stage 5: clear file_dir"
+if [ ${stage} -le 6 ] && [ ${stop_stage} -ge 6 ]; then
+  $verbose && echo "stage 6: clear file_dir"
   cd "${work_dir}" || exit 1
 
   rm -rf "${file_dir}";

examples/silero_vad_by_webrtcvad/step_1_prepare_data.py

@@ -6,6 +6,7 @@ import os
 from pathlib import Path
 import random
 import sys
+import time
 
 pwd = os.path.abspath(os.path.dirname(__file__))
 sys.path.append(os.path.join(pwd, "../../"))
@@ -19,19 +20,21 @@ def get_args():
     parser = argparse.ArgumentParser()
     parser.add_argument(
         "--noise_dir",
-        default=r"E:\Users\tianx\HuggingDatasets\nx_noise\data\noise",
+        default=r"D:\Users\tianx\HuggingDatasets\nx_noise\data\noise",
         type=str
     )
     parser.add_argument(
         "--speech_dir",
-        default=r"E:\programmer\asr_datasets\aishell\data_aishell\wav\train",
+        default=r"D:\Users\tianx\HuggingDatasets\nx_noise\data\speech",
         type=str
     )
 
     parser.add_argument("--train_dataset", default="train.jsonl", type=str)
     parser.add_argument("--valid_dataset", default="valid.jsonl", type=str)
 
-    parser.add_argument("--duration", default=6.0, type=float)
+    parser.add_argument("--duration", default=8.0, type=float)
+    parser.add_argument("--min_speech_duration", default=6.0, type=float)
+    parser.add_argument("--max_speech_duration", default=8.0, type=float)
     parser.add_argument("--min_snr_db", default=-10, type=float)
     parser.add_argument("--max_snr_db", default=20, type=float)
 
@@ -43,21 +46,90 @@ def get_args():
     return args
 
 
-def target_second_signal_generator(data_dir: str, duration: int = 6, sample_rate: int = 8000, max_epoch: int = 20000):
+def target_second_noise_signal_generator(data_dir: str,
+                                         duration: int = 4,
+                                         sample_rate: int = 8000, max_epoch: int = 20000):
+    noise_list = list()
+    wait_duration = duration
+
+    data_dir = Path(data_dir)
+    for epoch_idx in range(max_epoch):
+        for filename in data_dir.glob("**/*.wav"):
+            signal, _ = librosa.load(filename.as_posix(), sr=sample_rate)
+
+            if signal.ndim != 1:
+                raise AssertionError(f"expected ndim 1, instead of {signal.ndim}")
+
+            raw_duration = librosa.get_duration(y=signal, sr=sample_rate)
+
+            offset = 0.
+            rest_duration = raw_duration
+
+            for _ in range(1000):
+                if rest_duration <= 0:
+                    break
+                if rest_duration <= wait_duration:
+                    noise_list.append({
+                        "epoch_idx": epoch_idx,
+                        "filename": filename.as_posix(),
+                        "raw_duration": round(raw_duration, 4),
+                        "offset": round(offset, 4),
+                        "duration": None,
+                        "duration_": round(rest_duration, 4),
+                    })
+                    wait_duration -= rest_duration
+                    offset = 0
+                    rest_duration = 0
+                elif rest_duration > wait_duration:
+                    noise_list.append({
+                        "epoch_idx": epoch_idx,
+                        "filename": filename.as_posix(),
+                        "raw_duration": round(raw_duration, 4),
+                        "offset": round(offset, 4),
+                        "duration": round(wait_duration, 4),
+                        "duration_": round(wait_duration, 4),
+                    })
+                    offset += wait_duration
+                    rest_duration -= wait_duration
+                    wait_duration = 0
+                else:
+                    raise AssertionError
+
+                if wait_duration <= 0:
+                    yield noise_list
+                    noise_list = list()
+                    wait_duration = duration
+
+
+def target_second_speech_signal_generator(data_dir: str,
+                                          min_duration: int = 4,
+                                          max_duration: int = 6,
+                                          sample_rate: int = 8000, max_epoch: int = 1):
     data_dir = Path(data_dir)
     for epoch_idx in range(max_epoch):
         for filename in data_dir.glob("**/*.wav"):
             signal, _ = librosa.load(filename.as_posix(), sr=sample_rate)
             raw_duration = librosa.get_duration(y=signal, sr=sample_rate)
 
-            if raw_duration < duration:
-                # print(f"duration less than {duration} s. skip filename: {filename.as_posix()}")
-                continue
             if signal.ndim != 1:
                 raise AssertionError(f"expected ndim 1, instead of {signal.ndim}")
 
+            if raw_duration < min_duration:
+                # print(f"duration less than {duration} s. skip filename: {filename.as_posix()}")
+                continue
+
+            if raw_duration < max_duration:
+                row = {
+                    "epoch_idx": epoch_idx,
+                    "filename": filename.as_posix(),
+                    "raw_duration": round(raw_duration, 4),
+                    "offset": 0.,
+                    "duration": round(raw_duration, 4),
+                }
+                yield row
+
             signal_length = len(signal)
-            win_size = int(duration * sample_rate)
+            win_size = int(max_duration * sample_rate)
             for begin in range(0, signal_length - win_size, win_size):
                 if np.sum(signal[begin: begin+win_size]) == 0:
                     continue
@@ -66,7 +138,7 @@ def target_second_signal_generator(data_dir: str, duration: int = 6, sample_rate
                     "filename": filename.as_posix(),
                     "raw_duration": round(raw_duration, 4),
                     "offset": round(begin / sample_rate, 4),
-                    "duration": round(duration, 4),
+                    "duration": round(max_duration, 4),
                 }
                 yield row
 
@@ -82,15 +154,16 @@ def main():
     train_dataset.parent.mkdir(parents=True, exist_ok=True)
     valid_dataset.parent.mkdir(parents=True, exist_ok=True)
 
-    noise_generator = target_second_signal_generator(
+    noise_generator = target_second_noise_signal_generator(
         noise_dir.as_posix(),
         duration=args.duration,
         sample_rate=args.target_sample_rate,
         max_epoch=100000,
     )
-    speech_generator = target_second_signal_generator(
+    speech_generator = target_second_speech_signal_generator(
         speech_dir.as_posix(),
-        duration=args.duration,
+        min_duration=args.min_speech_duration,
+        max_duration=args.max_speech_duration,
         sample_rate=args.target_sample_rate,
         max_epoch=1,
     )
@@ -98,21 +171,26 @@ def main():
     count = 0
     process_bar = tqdm(desc="build dataset jsonl")
     with open(args.train_dataset, "w", encoding="utf-8") as ftrain, open(args.valid_dataset, "w", encoding="utf-8") as fvalid:
-        for noise, speech in zip(noise_generator, speech_generator):
+        for speech, noise_list in zip(speech_generator, noise_generator):
             if count >= args.max_count > 0:
                 break
 
             # row
-            noise_filename = noise["filename"]
-            noise_raw_duration = noise["raw_duration"]
-            noise_offset = noise["offset"]
-            noise_duration = noise["duration"]
-
             speech_filename = speech["filename"]
             speech_raw_duration = speech["raw_duration"]
             speech_offset = speech["offset"]
             speech_duration = speech["duration"]
 
+            noise_list = [
+                {
+                    "filename": noise["filename"],
+                    "raw_duration": noise["raw_duration"],
+                    "offset": noise["offset"],
+                    "duration": noise["duration"],
+                }
+                for noise in noise_list
+            ]
+
             # row
             random1 = random.random()
             random2 = random.random()
@@ -120,16 +198,13 @@ def main():
             row = {
                 "count": count,
 
-                "noise_filename": noise_filename,
-                "noise_raw_duration": noise_raw_duration,
-                "noise_offset": noise_offset,
-                "noise_duration": noise_duration,
-
                 "speech_filename": speech_filename,
                 "speech_raw_duration": speech_raw_duration,
                 "speech_offset": speech_offset,
                 "speech_duration": speech_duration,
 
+                "noise_list": noise_list,
+
                 "snr_db": random.uniform(args.min_snr_db, args.max_snr_db),
 
                 "random1": random1,

examples/silero_vad_by_webrtcvad/step_2_make_vad_segments.py

@@ -12,7 +12,8 @@ import librosa
 import numpy as np
 from tqdm import tqdm
 
-from toolbox.webrtcvad.vad import WebRTCVad
+from project_settings import project_path
+from toolbox.vad.vad import WebRTCVoiceClassifier, SileroVoiceClassifier, CCSoundsClassifier, RingVad
 
 
 def get_args():
@@ -24,15 +25,19 @@ def get_args():
     parser.add_argument("--train_vad_dataset", default="train-vad.jsonl", type=str)
     parser.add_argument("--valid_vad_dataset", default="valid-vad.jsonl", type=str)
 
-    parser.add_argument("--duration", default=6.0, type=float)
+    parser.add_argument("--duration", default=8.0, type=float)
     parser.add_argument("--expected_sample_rate", default=8000, type=int)
 
-    # vad
-    parser.add_argument("--agg", default=3, type=int)
-    parser.add_argument("--frame_duration_ms", default=30, type=int)
-    parser.add_argument("--padding_duration_ms", default=30, type=int)
-    parser.add_argument("--silence_duration_threshold", default=0.0, type=float)
-
+    parser.add_argument(
+        "--silero_model_path",
+        default=(project_path / "trained_models/silero_vad.jit").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--cc_sounds_model_path",
+        default=(project_path / "trained_models/sound-2-ch32.zip").as_posix(),
+        type=str,
+    )
     args = parser.parse_args()
     return args
 
@@ -40,17 +45,58 @@ def get_args():
 def main():
     args = get_args()
 
-    w_vad = WebRTCVad(
-        agg=args.agg,
-        frame_duration_ms=args.frame_duration_ms,
-        padding_duration_ms=args.padding_duration_ms,
-        silence_duration_threshold=args.silence_duration_threshold,
+    # webrtcvad
+    # model = SileroVoiceClassifier(model_path=args.silero_model_path, sample_rate=args.expected_sample_rate)
+    # w_vad = RingVad(
+    #     model=model,
+    #     start_ring_rate=0.2,
+    #     end_ring_rate=0.1,
+    #     frame_size_ms=32,
+    #     frame_step_ms=32,
+    #     padding_length_ms=320,
+    #     max_silence_length_ms=320,
+    #     max_speech_length_s=100,
+    #     min_speech_length_s=0.1,
+    #     sample_rate=args.expected_sample_rate,
+    # )
+
+    # webrtcvad
+    model = WebRTCVoiceClassifier(agg=3, sample_rate=args.expected_sample_rate)
+    w_vad = RingVad(
+        model=model,
+        start_ring_rate=0.9,
+        end_ring_rate=0.1,
+        frame_size_ms=30,
+        frame_step_ms=30,
+        padding_length_ms=90,
+        max_silence_length_ms=100,
+        max_speech_length_s=100,
+        min_speech_length_s=0.1,
         sample_rate=args.expected_sample_rate,
     )
 
+    # cc sounds
+    # model = CCSoundsClassifier(model_path=args.cc_sounds_model_path, sample_rate=args.expected_sample_rate)
+    # w_vad = RingVad(
+    #     model=model,
+    #     start_ring_rate=0.5,
+    #     end_ring_rate=0.3,
+    #     frame_size_ms=300,
+    #     frame_step_ms=300,
+    #     padding_length_ms=300,
+    #     max_silence_length_ms=100,
+    #     max_speech_length_s=100,
+    #     min_speech_length_s=0.1,
+    #     sample_rate=args.expected_sample_rate,
+    # )
+
     # valid
+    va_duration = 0
+    raw_duration = 0
+    use_duration = 0
+
     count = 0
-    process_bar = tqdm(desc="process valid dataset jsonl")
+    process_bar_valid = tqdm(desc="process valid dataset jsonl")
     with (open(args.valid_dataset, "r", encoding="utf-8") as fvalid,
           open(args.valid_vad_dataset, "w", encoding="utf-8") as fvalid_vad):
         for row in fvalid:
@@ -81,18 +127,30 @@ def main():
             row = json.dumps(row, ensure_ascii=False)
             fvalid_vad.write(f"{row}\n")
 
+            va_duration += sum([vad_segment[1] - vad_segment[0] for vad_segment in vad_segments])
+            raw_duration += speech_duration
+            use_duration += args.duration
+
             count += 1
-            duration_seconds = count * args.duration
-            duration_hours = duration_seconds / 3600
 
-            process_bar.update(n=1)
-            process_bar.set_postfix({
-                "duration_hours": round(duration_hours, 4),
+            va_rate = va_duration / use_duration
+            va_raw_rate = va_duration / raw_duration
+            use_duration_hours = use_duration / 3600
+
+            process_bar_valid.update(n=1)
+            process_bar_valid.set_postfix({
+                "va_rate": round(va_rate, 4),
+                "va_raw_rate": round(va_raw_rate, 4),
+                "duration_hours": round(use_duration_hours, 4),
             })
 
     # train
+    va_duration = 0
+    raw_duration = 0
+    use_duration = 0
+
     count = 0
-    process_bar = tqdm(desc="process train dataset jsonl")
+    process_bar_train = tqdm(desc="process train dataset jsonl")
     with (open(args.train_dataset, "r", encoding="utf-8") as ftrain,
           open(args.train_vad_dataset, "w", encoding="utf-8") as ftrain_vad):
         for row in ftrain:
@@ -123,13 +181,21 @@ def main():
             row = json.dumps(row, ensure_ascii=False)
             ftrain_vad.write(f"{row}\n")
 
+            va_duration += sum([vad_segment[1] - vad_segment[0] for vad_segment in vad_segments])
+            raw_duration += speech_duration
+            use_duration += args.duration
+
             count += 1
-            duration_seconds = count * args.duration
-            duration_hours = duration_seconds / 3600
 
-            process_bar.update(n=1)
-            process_bar.set_postfix({
-                "duration_hours": round(duration_hours, 4),
+            va_rate = va_duration / use_duration
+            va_raw_rate = va_duration / raw_duration
+            use_duration_hours = use_duration / 3600
+
+            process_bar_train.update(n=1)
+            process_bar_train.set_postfix({
+                "va_rate": round(va_rate, 4),
+                "va_raw_rate": round(va_raw_rate, 4),
+                "duration_hours": round(use_duration_hours, 4),
             })
 
     return

examples/silero_vad_by_webrtcvad/step_3_check_vad.py

@@ -0,0 +1,68 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+import librosa
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.io import wavfile
+from tqdm import tqdm
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--train_vad_dataset", default="train-vad.jsonl", type=str)
+    parser.add_argument("--valid_vad_dataset", default="valid-vad.jsonl", type=str)
+
+    parser.add_argument("--duration", default=8.0, type=float)
+    parser.add_argument("--expected_sample_rate", default=8000, type=int)
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    SAMPLE_RATE = 8000
+
+    with open(args.train_vad_dataset, "r", encoding="utf-8") as f:
+        for row in f:
+            row = json.loads(row)
+
+            speech_filename = row["speech_filename"]
+            speech_offset = row["speech_offset"]
+            speech_duration = row["speech_duration"]
+
+            vad_segments = row["vad_segments"]
+
+            print(f"speech_filename: {speech_filename}")
+            signal, sample_rate = librosa.load(
+                speech_filename,
+                sr=SAMPLE_RATE,
+                offset=speech_offset,
+                duration=speech_duration,
+            )
+
+            # plot
+            time = np.arange(0, len(signal)) / sample_rate
+            plt.figure(figsize=(12, 5))
+            plt.plot(time, signal, color='b')
+            for start, end in vad_segments:
+                plt.axvline(x=start, ymin=0.25, ymax=0.75, color='g', linestyle='--', label='开始端点')  # 标记开始端点
+                plt.axvline(x=end, ymin=0.25, ymax=0.75, color='r', linestyle='--', label='结束端点')  # 标记结束端点
+
+            plt.show()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/silero_vad_by_webrtcvad/{step_3_train_model.py → step_4_train_model.py}

@@ -22,25 +22,26 @@ from torch.nn import functional as F
 from torch.utils.data.dataloader import DataLoader
 from tqdm import tqdm
 
-from toolbox.torch.utils.data.dataset.vad_jsonl_dataset import VadJsonlDataset
+from toolbox.torch.utils.data.dataset.vad_padding_jsonl_dataset import VadPaddingJsonlDataset
 from toolbox.torchaudio.models.vad.silero_vad.configuration_silero_vad import SileroVadConfig
 from toolbox.torchaudio.models.vad.silero_vad.modeling_silero_vad import SileroVadModel, SileroVadPretrainedModel
 from toolbox.torchaudio.losses.vad_loss.base_vad_loss import BaseVadLoss
 from toolbox.torchaudio.losses.bce_loss import BCELoss
 from toolbox.torchaudio.losses.dice_loss import DiceLoss
 from toolbox.torchaudio.metrics.vad_metrics.vad_accuracy import VadAccuracy
+from toolbox.torchaudio.metrics.vad_metrics.vad_f1_score import VadF1Score
 
 
 def get_args():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--train_dataset", default="train.jsonl", type=str)
-    parser.add_argument("--valid_dataset", default="valid.jsonl", type=str)
+    parser.add_argument("--train_dataset", default="train-vad.jsonl", type=str)
+    parser.add_argument("--valid_dataset", default="valid-vad.jsonl", type=str)
 
     parser.add_argument("--num_serialized_models_to_keep", default=15, type=int)
     parser.add_argument("--patience", default=30, type=int)
     parser.add_argument("--serialization_dir", default="serialization_dir", type=str)
 
-    parser.add_argument("--config_file", default="config.yaml", type=str)
+    parser.add_argument("--config_file", default="yaml/config.yaml", type=str)
 
     args = parser.parse_args()
     return args
@@ -116,7 +117,7 @@ def main():
     logger.info(f"GPU available count: {n_gpu}; device: {device}")
 
     # datasets
-    train_dataset = VadJsonlDataset(
+    train_dataset = VadPaddingJsonlDataset(
         jsonl_file=args.train_dataset,
         expected_sample_rate=config.sample_rate,
         max_wave_value=32768.0,
@@ -124,7 +125,7 @@ def main():
         max_snr_db=config.max_snr_db,
         # skip=225000,
     )
-    valid_dataset = VadJsonlDataset(
+    valid_dataset = VadPaddingJsonlDataset(
         jsonl_file=args.valid_dataset,
         expected_sample_rate=config.sample_rate,
         max_wave_value=32768.0,
@@ -205,6 +206,7 @@ def main():
     dice_loss_fn = DiceLoss(reduction="mean").to(device)
 
     vad_accuracy_metrics_fn = VadAccuracy(threshold=0.5)
+    vad_f1_score_metrics_fn = VadF1Score(threshold=0.5)
 
     # training loop
 
@@ -213,6 +215,11 @@ def main():
     average_bce_loss = 1000000000
     average_dice_loss = 1000000000
 
+    accuracy = -1
+    f1 = -1
+    precision = -1
+    recall = -1
+
     model_list = list()
     best_epoch_idx = None
     best_step_idx = None
@@ -230,6 +237,7 @@ def main():
         # train
         model.train()
         vad_accuracy_metrics_fn.reset()
+        vad_f1_score_metrics_fn.reset()
 
         total_loss = 0.
         total_bce_loss = 0.
@@ -259,6 +267,7 @@ def main():
                 continue
 
             vad_accuracy_metrics_fn.__call__(probs, targets)
+            vad_f1_score_metrics_fn.__call__(probs, targets)
 
             optimizer.zero_grad()
             loss.backward()
@@ -277,14 +286,21 @@ def main():
 
             metrics = vad_accuracy_metrics_fn.get_metric()
             accuracy = metrics["accuracy"]
+            metrics = vad_f1_score_metrics_fn.get_metric()
+            f1 = metrics["f1"]
+            precision = metrics["precision"]
+            recall = metrics["recall"]
 
             progress_bar_train.update(1)
             progress_bar_train.set_postfix({
                 "lr": lr_scheduler.get_last_lr()[0],
                 "loss": average_loss,
-                "average_bce_loss": average_bce_loss,
-                "average_dice_loss": average_dice_loss,
+                "bce_loss": average_bce_loss,
+                "dice_loss": average_dice_loss,
                 "accuracy": accuracy,
+                "f1": f1,
+                "precision": precision,
+                "recall": recall,
             })
 
             # evaluation
@@ -295,6 +311,7 @@ def main():
 
                     model.eval()
                     vad_accuracy_metrics_fn.reset()
+                    vad_f1_score_metrics_fn.reset()
 
                     total_loss = 0.
                     total_bce_loss = 0.
@@ -324,6 +341,7 @@ def main():
                             continue
 
                         vad_accuracy_metrics_fn.__call__(probs, targets)
+                        vad_f1_score_metrics_fn.__call__(probs, targets)
 
                         total_loss += loss.item()
                         total_bce_loss += bce_loss.item()
@@ -336,18 +354,26 @@ def main():
 
                         metrics = vad_accuracy_metrics_fn.get_metric()
                         accuracy = metrics["accuracy"]
+                        metrics = vad_f1_score_metrics_fn.get_metric()
+                        f1 = metrics["f1"]
+                        precision = metrics["precision"]
+                        recall = metrics["recall"]
 
                         progress_bar_eval.update(1)
                         progress_bar_eval.set_postfix({
                             "lr": lr_scheduler.get_last_lr()[0],
                             "loss": average_loss,
-                            "average_bce_loss": average_bce_loss,
-                            "average_dice_loss": average_dice_loss,
+                            "bce_loss": average_bce_loss,
+                            "dice_loss": average_dice_loss,
                             "accuracy": accuracy,
+                            "f1": f1,
+                            "precision": precision,
+                            "recall": recall,
                         })
 
                 model.train()
                 vad_accuracy_metrics_fn.reset()
+                vad_f1_score_metrics_fn.reset()
 
                 total_loss = 0.
                 total_bce_loss = 0.
@@ -377,12 +403,12 @@ def main():
                 if best_metric is None:
                     best_epoch_idx = epoch_idx
                     best_step_idx = step_idx
-                    best_metric = accuracy
-                elif accuracy >= best_metric:
+                    best_metric = f1
+                elif f1 >= best_metric:
                     # great is better.
                     best_epoch_idx = epoch_idx
                     best_step_idx = step_idx
-                    best_metric = accuracy
+                    best_metric = f1
                 else:
                     pass
 

install.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 
-# bash install.sh --stage 2 --stop_stage 2 --system_version centos
+# bash install.sh --stage 1 --stop_stage 2 --system_version centos
 
 
-python_version=3.12.1
+python_version=3.12.8
 system_version="centos";
 
 verbose=true;
@@ -41,20 +41,42 @@ while true; do
 done
 
 work_dir="$(pwd)"
+trained_models_dir="$(pwd)/trained_models"
+
+mkdir -p "${trained_models_dir}"
 
 
 if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
-  $verbose && echo "stage 1: install python"
+  $verbose && echo "stage 1: download sound models"
   cd "${work_dir}" || exit 1;
 
-  sh ./script/install_python.sh --python_version "${python_version}" --system_version "${system_version}"
+  python download_sound_models.py
+
 fi
 
 
 if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
-  $verbose && echo "stage 2: create virtualenv"
+  $verbose && echo "stage 2: download silero vad model"
+  cd "${trained_models_dir}" || exit 1;
+
+  wget https://github.com/snakers4/silero-vad/blob/master/src/silero_vad/data/silero_vad.jit
+
+fi
+
+
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+  $verbose && echo "stage 3: install python"
+  cd "${work_dir}" || exit 1;
+
+  sh ./script/install_python.sh --python_version "${python_version}" --system_version "${system_version}"
+fi
+
+
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+  $verbose && echo "stage 4: create virtualenv"
 
-  # /usr/local/python-3.12.1/bin/virtualenv cc_vad
+  # /usr/local/python-3.9.9/bin/pip3 install virtualenv
+  # /usr/local/python-3.9.9/bin/virtualenv cc_vad
   # source /data/local/bin/cc_vad/bin/activate
   /usr/local/python-${python_version}/bin/pip3 install virtualenv
   mkdir -p /data/local/bin

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

@@ -0,0 +1,240 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import json
+import random
+from typing import List
+
+import librosa
+import numpy as np
+import torch
+from torch.utils.data import Dataset, IterableDataset
+
+
+class VadPaddingJsonlDataset(IterableDataset):
+    def __init__(self,
+                 jsonl_file: str,
+                 expected_sample_rate: int,
+                 resample: bool = False,
+                 max_wave_value: float = 1.0,
+                 buffer_size: int = 1000,
+                 min_snr_db: float = None,
+                 max_snr_db: float = None,
+                 speech_target_duration: float = 8.0,
+                 eps: float = 1e-8,
+                 skip: int = 0,
+                 ):
+        self.jsonl_file = jsonl_file
+        self.expected_sample_rate = expected_sample_rate
+        self.resample = resample
+        self.max_wave_value = max_wave_value
+        self.min_snr_db = min_snr_db
+        self.max_snr_db = max_snr_db
+        self.speech_target_duration = speech_target_duration
+        self.eps = eps
+        self.skip = skip
+
+        self.buffer_size = buffer_size
+        self.buffer_samples: List[dict] = list()
+
+    def __iter__(self):
+        self.buffer_samples = list()
+
+        iterable_source = self.iterable_source()
+
+        try:
+            for _ in range(self.skip):
+                next(iterable_source)
+        except StopIteration:
+            pass
+
+        # 初始填充缓冲区
+        try:
+            for _ in range(self.buffer_size):
+                self.buffer_samples.append(next(iterable_source))
+        except StopIteration:
+            pass
+
+        # 动态替换逻辑
+        while True:
+            try:
+                item = next(iterable_source)
+                # 随机替换缓冲区元素
+                replace_idx = random.randint(0, len(self.buffer_samples) - 1)
+                sample = self.buffer_samples[replace_idx]
+                self.buffer_samples[replace_idx] = item
+                yield self.convert_sample(sample)
+            except StopIteration:
+                break
+
+        # 清空剩余元素
+        random.shuffle(self.buffer_samples)
+        for sample in self.buffer_samples:
+            yield self.convert_sample(sample)
+
+    def iterable_source(self):
+        last_sample = None
+        with open(self.jsonl_file, "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+
+                speech_filename = row["speech_filename"]
+                speech_raw_duration = row["speech_raw_duration"]
+                speech_offset = row["speech_offset"]
+                speech_duration = row["speech_duration"]
+
+                noise_list = row["noise_list"]
+                noise_list = [
+                    {
+                        "filename": noise["filename"],
+                        "raw_duration": noise["raw_duration"],
+                        "offset": noise["offset"],
+                        "duration": noise["duration"],
+                    }
+                    for noise in noise_list
+                ]
+
+                if self.min_snr_db is None or self.max_snr_db is None:
+                    snr_db = row["snr_db"]
+                else:
+                    snr_db = random.uniform(self.min_snr_db, self.max_snr_db)
+
+                vad_segments = row["vad_segments"]
+
+                sample = {
+                    "speech_filename": speech_filename,
+                    "speech_raw_duration": speech_raw_duration,
+                    "speech_offset": speech_offset,
+                    "speech_duration": speech_duration,
+
+                    "noise_list": noise_list,
+
+                    "snr_db": snr_db,
+
+                    "vad_segments": vad_segments,
+                }
+                if last_sample is None:
+                    last_sample = sample
+                    continue
+                yield sample
+        yield last_sample
+
+    def convert_sample(self, sample: dict):
+        speech_filename = sample["speech_filename"]
+        speech_offset = sample["speech_offset"]
+        speech_duration = sample["speech_duration"]
+
+        noise_list = sample["noise_list"]
+
+        snr_db = sample["snr_db"]
+
+        vad_segments = sample["vad_segments"]
+
+        speech_wave = self.filename_to_waveform(speech_filename, speech_offset, speech_duration)
+        speech_wave_np = speech_wave.numpy()
+        speech_wave_np, left_pad_duration, _ = self.pad_waveform(speech_wave_np, self.expected_sample_rate, self.speech_target_duration)
+        speech_wave_np = self.make_sure_duration(speech_wave_np, self.expected_sample_rate, self.speech_target_duration)
+
+        noise_wave_list = list()
+        for noise in noise_list:
+            filename = noise["filename"]
+            offset = noise["offset"]
+            duration = noise["duration"]
+            noise_wave_: torch.Tensor = self.filename_to_waveform(filename, offset, duration)
+            noise_wave_list.append(noise_wave_)
+        noise_wave = torch.cat(noise_wave_list, dim=-1)
+        noise_wave_np = noise_wave.numpy()
+        noise_wave_np = self.make_sure_duration(noise_wave_np, self.expected_sample_rate, self.speech_target_duration)
+
+        noisy_wave_np, _ = self.mix_speech_and_noise(
+            speech=speech_wave_np,
+            noise=noise_wave_np,
+            snr_db=snr_db, eps=self.eps,
+        )
+        noisy_wave = torch.tensor(noisy_wave_np, dtype=torch.float32)
+
+        vad_segments = [
+            [
+                vad_segment[0] + left_pad_duration,
+                vad_segment[1] + left_pad_duration,
+            ]
+            for vad_segment in vad_segments
+        ]
+
+        result = {
+            "noisy_wave": noisy_wave,
+            "vad_segments": vad_segments,
+        }
+        return result
+
+    def filename_to_waveform(self, filename: str, offset: float, duration: float):
+        try:
+            waveform, sample_rate = librosa.load(
+                filename,
+                sr=self.expected_sample_rate,
+                offset=offset,
+                duration=duration,
+            )
+        except ValueError as e:
+            print(f"load failed. error type: {type(e)}, error text: {str(e)}, filename: {filename}")
+            raise e
+        waveform = torch.tensor(waveform, dtype=torch.float32)
+        return waveform
+
+    @staticmethod
+    def pad_waveform(waveform: np.ndarray, sample_rate: int = 8000, target_duration: float = 8.0):
+        num_samples = len(waveform)
+        target_num_samples = int(sample_rate * target_duration)
+        if target_num_samples < num_samples:
+            return waveform, 0, 0
+
+        left_pad_size = (target_num_samples - num_samples) // 2
+        right_pad_size = target_num_samples - left_pad_size
+        result = np.concat([
+            np.zeros(left_pad_size, dtype=waveform.dtype),
+            waveform,
+            np.zeros(right_pad_size, dtype=waveform.dtype),
+        ])
+
+        left_pad_duration = left_pad_size / sample_rate
+        right_pad_duration = right_pad_size / sample_rate
+        return result, left_pad_duration, right_pad_duration
+
+    @staticmethod
+    def mix_speech_and_noise(speech: np.ndarray, noise: np.ndarray, snr_db: float, eps: float = 1e-8):
+        l1 = len(speech)
+        l2 = len(noise)
+        l = min(l1, l2)
+        speech = speech[:l]
+        noise = noise[:l]
+
+        # np.float32, value between (-1, 1).
+
+        speech_power = np.mean(np.square(speech))
+        noise_power = speech_power / (10 ** (snr_db / 10))
+
+        noise_adjusted = np.sqrt(noise_power) * noise / (np.sqrt(np.mean(noise ** 2)) + eps)
+
+        noisy_signal = speech + noise_adjusted
+
+        return noisy_signal, noise_adjusted
+
+    @staticmethod
+    def make_sure_duration(waveform: np.ndarray, sample_rate: int = 8000, target_duration: float = 8.0):
+        num_samples = len(waveform)
+        target_num_samples = int(sample_rate * target_duration)
+
+        if target_num_samples < num_samples:
+            waveform = waveform[:target_num_samples]
+        elif target_num_samples > num_samples:
+            pad_size = target_num_samples - num_samples
+            waveform = np.concat([
+                waveform,
+                np.zeros(pad_size, dtype=waveform.dtype),
+            ])
+        else:
+            pass
+        return waveform
+
+
+if __name__ == "__main__":
+    pass

toolbox/torch/utils/data/vocabulary.py

@@ -0,0 +1,211 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from collections import defaultdict, OrderedDict
+import os
+from typing import Any, Callable, Dict, Iterable, List, Set
+
+
+def namespace_match(pattern: str, namespace: str):
+    """
+    Matches a namespace pattern against a namespace string.  For example, ``*tags`` matches
+    ``passage_tags`` and ``question_tags`` and ``tokens`` matches ``tokens`` but not
+    ``stemmed_tokens``.
+    """
+    if pattern[0] == '*' and namespace.endswith(pattern[1:]):
+        return True
+    elif pattern == namespace:
+        return True
+    return False
+
+
+class _NamespaceDependentDefaultDict(defaultdict):
+    def __init__(self,
+                 non_padded_namespaces: Set[str],
+                 padded_function: Callable[[], Any],
+                 non_padded_function: Callable[[], Any]) -> None:
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padded_function = padded_function
+        self._non_padded_function = non_padded_function
+        super(_NamespaceDependentDefaultDict, self).__init__()
+
+    def __missing__(self, key: str):
+        if any(namespace_match(pattern, key) for pattern in self._non_padded_namespaces):
+            value = self._non_padded_function()
+        else:
+            value = self._padded_function()
+        dict.__setitem__(self, key, value)
+        return value
+
+    def add_non_padded_namespaces(self, non_padded_namespaces: Set[str]):
+        # add non_padded_namespaces which weren't already present
+        self._non_padded_namespaces.update(non_padded_namespaces)
+
+
+class _TokenToIndexDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_TokenToIndexDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {padding_token: 0, oov_token: 1},
+                                                       lambda: {})
+
+
+class _IndexToTokenDefaultDict(_NamespaceDependentDefaultDict):
+    def __init__(self, non_padded_namespaces: Set[str], padding_token: str, oov_token: str) -> None:
+        super(_IndexToTokenDefaultDict, self).__init__(non_padded_namespaces,
+                                                       lambda: {0: padding_token, 1: oov_token},
+                                                       lambda: {})
+
+
+DEFAULT_NON_PADDED_NAMESPACES = ("*tags", "*labels")
+DEFAULT_PADDING_TOKEN = '[PAD]'
+DEFAULT_OOV_TOKEN = '[UNK]'
+NAMESPACE_PADDING_FILE = 'non_padded_namespaces.txt'
+
+
+class Vocabulary(object):
+    def __init__(self, non_padded_namespaces: Iterable[str] = DEFAULT_NON_PADDED_NAMESPACES):
+        self._non_padded_namespaces = set(non_padded_namespaces)
+        self._padding_token = DEFAULT_PADDING_TOKEN
+        self._oov_token = DEFAULT_OOV_TOKEN
+        self._token_to_index = _TokenToIndexDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+        self._index_to_token = _IndexToTokenDefaultDict(self._non_padded_namespaces,
+                                                        self._padding_token,
+                                                        self._oov_token)
+
+    def add_token_to_namespace(self, token: str, namespace: str = 'tokens') -> int:
+        if token not in self._token_to_index[namespace]:
+            index = len(self._token_to_index[namespace])
+            self._token_to_index[namespace][token] = index
+            self._index_to_token[namespace][index] = token
+            return index
+        else:
+            return self._token_to_index[namespace][token]
+
+    def get_index_to_token_vocabulary(self, namespace: str = 'tokens') -> Dict[int, str]:
+        return self._index_to_token[namespace]
+
+    def get_token_to_index_vocabulary(self, namespace: str = 'tokens') -> Dict[str, int]:
+        return self._token_to_index[namespace]
+
+    def get_token_index(self, token: str, namespace: str = 'tokens') -> int:
+        if token in self._token_to_index[namespace]:
+            return self._token_to_index[namespace][token]
+        else:
+            return self._token_to_index[namespace][self._oov_token]
+
+    def get_token_from_index(self, index: int, namespace: str = 'tokens'):
+        return self._index_to_token[namespace][index]
+
+    def get_vocab_size(self, namespace: str = 'tokens') -> int:
+        return len(self._token_to_index[namespace])
+
+    def save_to_files(self, directory: str):
+        os.makedirs(directory, exist_ok=True)
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'w', encoding='utf-8') as f:
+            for namespace_str in self._non_padded_namespaces:
+                f.write('{}\n'.format(namespace_str))
+
+        for namespace, token_to_index in self._token_to_index.items():
+            filename = os.path.join(directory, '{}.txt'.format(namespace))
+            with open(filename, 'w', encoding='utf-8') as f:
+                for token, _ in token_to_index.items():
+                    f.write('{}\n'.format(token))
+
+    @classmethod
+    def from_files(cls, directory: str) -> 'Vocabulary':
+        with open(os.path.join(directory, NAMESPACE_PADDING_FILE), 'r', encoding='utf-8') as f:
+            non_padded_namespaces = [namespace_str.strip() for namespace_str in f]
+
+        vocab = cls(non_padded_namespaces=non_padded_namespaces)
+
+        for namespace_filename in os.listdir(directory):
+            if namespace_filename == NAMESPACE_PADDING_FILE:
+                continue
+            if namespace_filename.startswith("."):
+                continue
+            namespace = namespace_filename.replace('.txt', '')
+            if any(namespace_match(pattern, namespace) for pattern in non_padded_namespaces):
+                is_padded = False
+            else:
+                is_padded = True
+            filename = os.path.join(directory, namespace_filename)
+            vocab.set_from_file(filename, is_padded, namespace=namespace)
+
+        return vocab
+
+    def set_from_file(self,
+                      filename: str,
+                      is_padded: bool = True,
+                      oov_token: str = DEFAULT_OOV_TOKEN,
+                      namespace: str = "tokens"
+                      ):
+        if is_padded:
+            self._token_to_index[namespace] = {self._padding_token: 0}
+            self._index_to_token[namespace] = {0: self._padding_token}
+        else:
+            self._token_to_index[namespace] = {}
+            self._index_to_token[namespace] = {}
+
+        with open(filename, 'r', encoding='utf-8') as f:
+            index = 1 if is_padded else 0
+            for row in f:
+                token = str(row).strip()
+                if token == oov_token:
+                    token = self._oov_token
+                self._token_to_index[namespace][token] = index
+                self._index_to_token[namespace][index] = token
+                index += 1
+
+    def convert_tokens_to_ids(self, tokens: List[str], namespace: str = "tokens"):
+        result = list()
+        for token in tokens:
+            idx = self._token_to_index[namespace].get(token)
+            if idx is None:
+                idx = self._token_to_index[namespace][self._oov_token]
+            result.append(idx)
+        return result
+
+    def convert_ids_to_tokens(self, ids: List[int], namespace: str = "tokens"):
+        result = list()
+        for idx in ids:
+            idx = self._index_to_token[namespace][idx]
+            result.append(idx)
+        return result
+
+    def pad_or_truncate_ids_by_max_length(self, ids: List[int], max_length: int, namespace: str = "tokens"):
+        pad_idx = self._token_to_index[namespace][self._padding_token]
+
+        length = len(ids)
+        if length > max_length:
+            result = ids[:max_length]
+        else:
+            result = ids + [pad_idx] * (max_length - length)
+        return result
+
+
+def demo1():
+    import jieba
+
+    vocabulary = Vocabulary()
+    vocabulary.add_token_to_namespace('白天', 'tokens')
+    vocabulary.add_token_to_namespace('晚上', 'tokens')
+
+    text = '不是在白天, 就是在晚上'
+    tokens = jieba.lcut(text)
+
+    print(tokens)
+
+    ids = vocabulary.convert_tokens_to_ids(tokens)
+    print(ids)
+
+    padded_idx = vocabulary.pad_or_truncate_ids_by_max_length(ids, 10)
+    print(padded_idx)
+
+    tokens = vocabulary.convert_ids_to_tokens(padded_idx)
+    print(tokens)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/torchaudio/metrics/vad_metrics/vad_f1_score.py

@@ -0,0 +1,60 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import torch
+
+
+class VadF1Score(object):
+    def __init__(self, threshold: float = 0.5, epsilon: float = 1e-12) -> None:
+        self.threshold = threshold
+        self.epsilon = epsilon  # 防止除零错误
+
+        self.true_positives = 0.0
+        self.false_positives = 0.0
+        self.false_negatives = 0.0
+
+    def __call__(self,
+                 predictions: torch.Tensor,
+                 gold_labels: torch.Tensor,
+                 ):
+        """
+        :param predictions: [b, t, 1], 经过sigmoid的概率输出
+        :param gold_labels: [b, t, 1], 二值标签 (0或1)
+        """
+        # 将预测值转为二进制标签
+        pred_labels = (predictions > self.threshold).float()
+
+        # 计算TP/FP/FN
+        tp = (pred_labels * gold_labels).sum()  # True Positives
+        fp = (pred_labels * (1 - gold_labels)).sum()  # False Positives
+        fn = ((1 - pred_labels) * gold_labels).sum()  # False Negatives
+
+        # 累加统计量
+        self.true_positives += tp.item()
+        self.false_positives += fp.item()
+        self.false_negatives += fn.item()
+
+    def get_metric(self, reset: bool = False):
+        # 计算Precision和Recall
+        precision = self.true_positives / (self.true_positives + self.false_positives + self.epsilon)
+        recall = self.true_positives / (self.true_positives + self.false_negatives + self.epsilon)
+
+        # 计算F1 Score
+        f1 = 2 * (precision * recall) / (precision + recall + self.epsilon)
+
+        if reset:
+            self.reset()
+
+        return {
+            'f1': f1,
+            'precision': precision,
+            'recall': recall
+        }
+
+    def reset(self):
+        self.true_positives = 0.0
+        self.false_positives = 0.0
+        self.false_negatives = 0.0
+
+
+if __name__ == "__main__":
+    pass

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

@@ -0,0 +1,169 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import logging
+from pathlib import Path
+import shutil
+import tempfile, time
+import zipfile
+
+from scipy.io import wavfile
+import librosa
+import numpy as np
+import torch
+import torchaudio
+
+torch.set_num_threads(1)
+
+from project_settings import project_path
+from toolbox.torchaudio.models.vad.silero_vad.configuration_silero_vad import SileroVadConfig
+from toolbox.torchaudio.models.vad.silero_vad.modeling_silero_vad import SileroVadPretrainedModel, MODEL_FILE
+from toolbox.vad.vad import FrameVoiceClassifier, RingVad, process_speech_probs, make_visualization
+
+
+logger = logging.getLogger("toolbox")
+
+
+class SileroVadVoiceClassifier(FrameVoiceClassifier):
+    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, model = 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.model = model
+        self.model.to(device)
+        self.model.eval()
+
+    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 = SileroVadConfig.from_pretrained(
+            pretrained_model_name_or_path=model_path.as_posix(),
+        )
+        model = SileroVadPretrainedModel.from_pretrained(
+            pretrained_model_name_or_path=model_path.as_posix(),
+        )
+        model.to(self.device)
+        model.eval()
+
+        shutil.rmtree(model_path)
+        return config, model
+
+    def predict(self, chunk: np.ndarray) -> float:
+        if chunk.dtype != np.int16:
+            raise AssertionError("signal dtype should be np.int16, instead of {}".format(chunk.dtype))
+
+        chunk = chunk / 32768
+
+        inputs = torch.tensor(chunk, dtype=torch.float32)
+        inputs = torch.unsqueeze(inputs, dim=0)
+
+        try:
+            logits, _ = self.model.forward(inputs)
+        except RuntimeError as e:
+            print(inputs.shape)
+            raise e
+        # logits shape: [b, t, 1]
+        logits_ = torch.mean(logits, dim=1)
+        # logits_ shape: [b, 1]
+        probs = torch.sigmoid(logits_)
+
+        voice_prob = probs[0][0]
+        return float(voice_prob)
+
+
+class InferenceSileroVad(object):
+    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)
+
+        self.voice_classifier = SileroVadVoiceClassifier(pretrained_model_path_or_zip_file, device=device)
+
+        self.ring_vad = RingVad(model=self.voice_classifier,
+                                start_ring_rate=0.2,
+                                end_ring_rate=0.1,
+                                frame_size_ms=30,
+                                frame_step_ms=30,
+                                padding_length_ms=300,
+                                max_silence_length_ms=300,
+                                sample_rate=SAMPLE_RATE,
+                                )
+
+    def vad(self, signal: np.ndarray) -> np.ndarray:
+        self.ring_vad.reset()
+
+        vad_segments = list()
+
+        segments = self.ring_vad.vad(signal)
+        vad_segments += segments
+        # last vad segment
+        segments = self.ring_vad.last_vad_segments()
+        vad_segments += segments
+        return vad_segments
+
+    def get_vad_speech_probs(self):
+        result = self.ring_vad.speech_probs
+        return result
+
+    def get_vad_frame_step(self):
+        result = self.ring_vad.frame_step
+        return result
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--wav_file",
+        default=(project_path / "data/examples/hado/2f16ca0b-baec-4601-8a1e-7893eb875623.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
+
+    infer = InferenceSileroVad(
+        pretrained_model_path_or_zip_file=(project_path / "trained_models/silero-vad-webrtcvad-nx2-dns3.zip").as_posix()
+    )
+
+    vad_segments = infer.vad(signal)
+
+    speech_probs = infer.get_vad_speech_probs()
+    frame_step = infer.get_vad_frame_step()
+
+    # speech_probs
+    speech_probs = process_speech_probs(
+        signal=signal,
+        speech_probs=speech_probs,
+        frame_step=frame_step,
+    )
+
+    # plot
+    make_visualization(signal, speech_probs, SAMPLE_RATE, vad_segments)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/vad/__init__.py

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

toolbox/vad/vad.py

@@ -0,0 +1,450 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import collections
+from functools import lru_cache
+import os
+from pathlib import Path
+import shutil
+import tempfile
+import zipfile
+from typing import List
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.io import wavfile
+import torch
+import webrtcvad
+
+from project_settings import project_path
+from toolbox.torch.utils.data.vocabulary import Vocabulary
+
+
+class FrameVoiceClassifier(object):
+    def predict(self, chunk: np.ndarray) -> float:
+        raise NotImplementedError
+
+
+class WebRTCVoiceClassifier(FrameVoiceClassifier):
+    def __init__(self,
+                 agg: int = 3,
+                 sample_rate: int = 8000
+                 ):
+        self.agg = agg
+        self.sample_rate = sample_rate
+
+        self.model = webrtcvad.Vad(mode=agg)
+
+    def predict(self, chunk: np.ndarray) -> float:
+        if chunk.dtype != np.int16:
+            raise AssertionError("signal dtype should be np.int16, instead of {}".format(chunk.dtype))
+
+        audio_bytes = bytes(chunk)
+        is_speech = self.model.is_speech(audio_bytes, self.sample_rate)
+        return 1.0 if is_speech else 0.0
+
+
+class SileroVoiceClassifier(FrameVoiceClassifier):
+    def __init__(self,
+                 model_path: str,
+                 sample_rate: int = 8000):
+        self.model_path = model_path
+        self.sample_rate = sample_rate
+
+        with open(self.model_path, "rb") as f:
+            model = torch.jit.load(f, map_location="cpu")
+        self.model = model
+        self.model.reset_states()
+
+    def predict(self, chunk: np.ndarray) -> float:
+        if self.sample_rate / len(chunk) > 31.25:
+            raise AssertionError("chunk samples number {} is less than {}".format(len(chunk), self.sample_rate / 31.25))
+        if chunk.dtype != np.int16:
+            raise AssertionError("signal dtype should be np.int16, instead of {}".format(chunk.dtype))
+
+        num_samples = len(chunk)
+        if self.sample_rate == 8000 and num_samples != 256:
+            raise AssertionError(f"win size must be 32 ms for silero vad. ")
+        if self.sample_rate == 16000 and num_samples != 512:
+            raise AssertionError(f"win size must be 32 ms for silero vad. ")
+
+        chunk = chunk / 32768
+        chunk = torch.tensor(chunk, dtype=torch.float32)
+        speech_prob = self.model(chunk, self.sample_rate).item()
+        return float(speech_prob)
+
+
+class CCSoundsClassifier(FrameVoiceClassifier):
+    def __init__(self,
+                 model_path: str,
+                 sample_rate: int = 8000):
+        self.model_path = model_path
+        self.sample_rate = sample_rate
+
+        d = self.load_model(Path(model_path))
+
+        model = d["model"]
+        vocabulary = d["vocabulary"]
+
+        self.model = model
+        self.vocabulary = vocabulary
+
+    @staticmethod
+    @lru_cache(maxsize=100)
+    def load_model(model_file: Path):
+        with zipfile.ZipFile(model_file, "r") as f_zip:
+            out_root = Path(tempfile.gettempdir()) / "cc_audio_8"
+            if out_root.exists():
+                shutil.rmtree(out_root.as_posix())
+            out_root.mkdir(parents=True, exist_ok=True)
+            f_zip.extractall(path=out_root)
+
+        tgt_path = out_root / model_file.stem
+        jit_model_file = tgt_path / "trace_model.zip"
+        vocab_path = tgt_path / "vocabulary"
+
+        vocabulary = Vocabulary.from_files(vocab_path.as_posix())
+
+        with open(jit_model_file.as_posix(), "rb") as f:
+            model = torch.jit.load(f)
+        model.eval()
+
+        shutil.rmtree(tgt_path)
+
+        d = {
+            "model": model,
+            "vocabulary": vocabulary
+        }
+        return d
+
+    def predict(self, chunk: np.ndarray) -> float:
+        if chunk.dtype != np.int16:
+            raise AssertionError("signal dtype should be np.int16, instead of {}".format(chunk.dtype))
+
+        chunk = chunk / (1 << 15)
+        inputs = torch.tensor(chunk, dtype=torch.float32)
+        inputs = torch.unsqueeze(inputs, dim=0)
+
+        with torch.no_grad():
+            logits = self.model(inputs)
+            probs = torch.nn.functional.softmax(logits, dim=-1)
+
+        voice_idx = self.vocabulary.get_token_index(token="voice", namespace="labels")
+
+        probs = probs.cpu()
+
+        voice_prob = probs[0][voice_idx]
+        return float(voice_prob)
+
+
+class Frame(object):
+    def __init__(self, signal: np.ndarray, timestamp_s: float):
+        self.signal = signal
+        self.timestamp_s = timestamp_s
+
+
+class RingVad(object):
+    def __init__(self,
+                 model: FrameVoiceClassifier,
+                 start_ring_rate: float = 0.5,
+                 end_ring_rate: float = 0.5,
+                 frame_size_ms: int = 30,
+                 frame_step_ms: int = 30,
+                 padding_length_ms: int = 300,
+                 max_silence_length_ms: int = 300,
+                 max_speech_length_s: float = 2.0,
+                 min_speech_length_s: float = 0.3,
+                 sample_rate: int = 8000
+                 ):
+        self.model = model
+        self.start_ring_rate = start_ring_rate
+        self.end_ring_rate = end_ring_rate
+        self.frame_size_ms = frame_size_ms
+        self.frame_step_ms = frame_step_ms
+        self.padding_length_ms = padding_length_ms
+        self.max_silence_length_ms = max_silence_length_ms
+        self.max_speech_length_s = max_speech_length_s
+        self.min_speech_length_s = min_speech_length_s
+        self.sample_rate = sample_rate
+
+        # frames
+        self.frame_size = int(sample_rate * (frame_size_ms / 1000.0))
+        self.frame_step = int(sample_rate * (frame_step_ms / 1000.0))
+        self.frame_timestamp_s = 0.0
+        self.signal_cache = np.zeros(shape=(self.frame_size,), dtype=np.int16)
+
+        # segments
+        self.num_padding_frames = int(padding_length_ms / frame_step_ms)
+        self.ring_buffer = collections.deque(maxlen=self.num_padding_frames)
+        self.triggered = False
+        self.voiced_frames: List[Frame] = list()
+        self.segments = list()
+
+        # vad segments
+        self.is_first_segment = True
+        self.timestamp_start_s = 0.0
+        self.timestamp_end_s = 0.0
+
+        # speech probs
+        self.speech_probs: List[float] = list()
+
+    def reset(self):
+        # frames
+        self.frame_size = int(self.sample_rate * (self.frame_size_ms / 1000.0))
+        self.frame_step = int(self.sample_rate * (self.frame_step_ms / 1000.0))
+        self.frame_timestamp_s = 0.0
+        self.signal_cache = np.zeros(shape=(self.frame_size,), dtype=np.int16)
+
+        # segments
+        self.num_padding_frames = int(self.padding_length_ms / self.frame_step_ms)
+        self.ring_buffer = collections.deque(maxlen=self.num_padding_frames)
+        self.triggered = False
+        self.voiced_frames: List[Frame] = list()
+        self.segments = list()
+
+        # vad segments
+        self.is_first_segment = True
+        self.timestamp_start_s = 0.0
+        self.timestamp_end_s = 0.0
+
+        # speech probs
+        self.speech_probs: List[float] = list()
+
+    def signal_to_frames(self, signal: np.ndarray):
+        frames = list()
+
+        l = len(signal)
+
+        duration_s = float(self.frame_step) / self.sample_rate
+
+        for offset in range(0, l - self.frame_size + 1, self.frame_step):
+            sub_signal = signal[offset:offset+self.frame_size]
+            frame = Frame(sub_signal, self.frame_timestamp_s)
+            self.frame_timestamp_s += duration_s
+
+            frames.append(frame)
+        return frames
+
+    def segments_generator(self, signal: np.ndarray):
+        # signal rounding
+        if self.signal_cache is not None:
+            signal = np.concatenate([self.signal_cache, signal])
+
+        # rest
+        rest = (len(signal) - self.frame_size) % self.frame_step
+
+        if rest == 0:
+            self.signal_cache = None
+            signal_ = signal
+        else:
+            self.signal_cache = signal[-rest:]
+            signal_ = signal[:-rest]
+
+        # frames
+        frames = self.signal_to_frames(signal_)
+
+        for frame in frames:
+            speech_prob = self.model.predict(frame.signal)
+            self.speech_probs.append(speech_prob)
+
+            if not self.triggered:
+                self.ring_buffer.append((frame, speech_prob))
+                num_voiced = sum([p for _, p in self.ring_buffer])
+
+                if num_voiced > self.start_ring_rate * self.ring_buffer.maxlen:
+                    self.triggered = True
+
+                    for f, _ in self.ring_buffer:
+                        self.voiced_frames.append(f)
+                continue
+
+            self.voiced_frames.append(frame)
+            self.ring_buffer.append((frame, speech_prob))
+            num_voiced = sum([p for _, p in self.ring_buffer])
+
+            if num_voiced < self.end_ring_rate * self.ring_buffer.maxlen:
+                segment = [
+                    np.concatenate([f.signal for f in self.voiced_frames]),
+                    self.voiced_frames[0].timestamp_s,
+                    self.voiced_frames[-1].timestamp_s,
+                ]
+                yield segment
+                self.triggered = False
+                self.ring_buffer.clear()
+                self.voiced_frames = []
+                continue
+
+    def vad_segments_generator(self, segments_generator):
+        segments = list(segments_generator)
+
+        for i, segment in enumerate(segments):
+            start = round(segment[1], 4)
+            end = round(segment[2], 4)
+
+            if self.timestamp_start_s is None and self.timestamp_end_s is None:
+                self.timestamp_start_s = start
+                self.timestamp_end_s = end
+                continue
+
+            if self.timestamp_end_s - self.timestamp_start_s > self.max_speech_length_s:
+                end_ = self.timestamp_start_s + self.max_speech_length_s
+                vad_segment = [self.timestamp_start_s, end_]
+                yield vad_segment
+                self.timestamp_start_s = end_
+
+            silence_length_ms = (start - self.timestamp_end_s) * 1000
+            if silence_length_ms < self.max_silence_length_ms:
+                self.timestamp_end_s = end
+                continue
+
+            if self.timestamp_end_s - self.timestamp_start_s < self.min_speech_length_s:
+                self.timestamp_start_s = start
+                self.timestamp_end_s = end
+                continue
+
+            vad_segment = [self.timestamp_start_s, self.timestamp_end_s]
+            yield vad_segment
+            self.timestamp_start_s = start
+            self.timestamp_end_s = end
+
+    def vad(self, signal: np.ndarray) -> List[list]:
+        segments = self.segments_generator(signal)
+        vad_segments = self.vad_segments_generator(segments)
+        vad_segments = list(vad_segments)
+        return vad_segments
+
+    def last_vad_segments(self) -> List[list]:
+        # last segments
+        if len(self.voiced_frames) == 0:
+            segments = []
+        else:
+            segment = [
+                np.concatenate([f.signal for f in self.voiced_frames]),
+                self.voiced_frames[0].timestamp_s,
+                self.voiced_frames[-1].timestamp_s
+            ]
+            segments = [segment]
+
+        # last vad segments
+        vad_segments = self.vad_segments_generator(segments)
+        vad_segments = list(vad_segments)
+
+        if self.timestamp_end_s > 1e-5 and self.timestamp_end_s > 1e-5:
+            vad_segments = vad_segments + [[self.timestamp_start_s, self.timestamp_end_s]]
+        return vad_segments
+
+
+def process_speech_probs(signal: np.ndarray, speech_probs: List[float], frame_step: int) -> np.ndarray:
+    speech_probs_ = list()
+    for p in speech_probs[1:]:
+        speech_probs_.extend([p] * frame_step)
+
+    pad = (signal.shape[0] - len(speech_probs_))
+    speech_probs_ = speech_probs_ + [0.0] * pad
+    speech_probs_ = np.array(speech_probs_, dtype=np.float32)
+
+    if len(speech_probs_) != len(signal):
+        raise AssertionError
+    return speech_probs_
+
+
+def make_visualization(signal: np.ndarray, speech_probs, sample_rate: int, vad_segments: list):
+    time = np.arange(0, len(signal)) / sample_rate
+    plt.figure(figsize=(12, 5))
+    plt.plot(time, signal / 32768, color='b')
+    plt.plot(time, speech_probs, color='gray')
+    for start, end in vad_segments:
+        plt.axvline(x=start, ymin=0.15, ymax=0.85, color="g", linestyle="--", label="开始端点")
+        plt.axvline(x=end, ymin=0.15, ymax=0.85, color="r", linestyle="--", label="结束端点")
+
+    plt.show()
+    return
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--wav_file",
+        # default=(project_path / "data/early_media/62/3300999628999191096.wav").as_posix(),
+        default=r"D:/Users/tianx/HuggingDatasets/nx_noise/data/speech/nx-speech/en-PH/2025-05-28/active_media_w_1f650e5c-bd22-4803-bb88-d670b00fccda_30.wav",
+        type=str,
+    )
+    parser.add_argument(
+        "--model_path",
+        default=(project_path / "trained_models/silero_vad.jit").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
+
+    # model = SileroVoiceClassifier(model_path=args.model_path, sample_rate=SAMPLE_RATE)
+    model = WebRTCVoiceClassifier(agg=3, sample_rate=SAMPLE_RATE)
+    # model = CallVoiceClassifier(model_path=(project_path / "trained_models/cnn_voicemail_common_20231130").as_posix())
+
+    # silero vad
+    ring_vad = RingVad(model=model,
+              start_ring_rate=0.2,
+              end_ring_rate=0.1,
+              frame_size_ms=32,
+              frame_step_ms=32,
+              padding_length_ms=320,
+              max_silence_length_ms=320,
+              max_speech_length_s=100,
+              min_speech_length_s=0.1,
+              sample_rate=SAMPLE_RATE,
+              )
+    # webrtcvad
+    ring_vad = RingVad(model=model,
+              start_ring_rate=0.9,
+              end_ring_rate=0.1,
+              frame_size_ms=30,
+              frame_step_ms=30,
+              padding_length_ms=300,
+              max_silence_length_ms=300,
+              max_speech_length_s=100,
+              min_speech_length_s=0.1,
+              sample_rate=SAMPLE_RATE,
+              )
+    print(ring_vad)
+
+    vad_segments = list()
+
+    segments = ring_vad.vad(signal)
+    vad_segments += segments
+    for segment in segments:
+        print(segment)
+
+    # last vad segment
+    segments = ring_vad.last_vad_segments()
+    vad_segments += segments
+    for segment in segments:
+        print(segment)
+
+    print(ring_vad.speech_probs)
+    print(len(ring_vad.speech_probs))
+
+    # speech_probs
+    speech_probs = process_speech_probs(
+        signal=signal,
+        speech_probs=ring_vad.speech_probs,
+        frame_step=ring_vad.frame_step,
+    )
+
+    # plot
+    make_visualization(signal, speech_probs, SAMPLE_RATE, vad_segments)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/webrtcvad/vad.py

@@ -107,6 +107,7 @@ class WebRTCVad(object):
         for frame in frames:
             audio_bytes = bytes(frame.signal)
             is_speech = self._vad.is_speech(audio_bytes, self.sample_rate)
+            print(f"is_speech: {is_speech}")
 
             if not self.triggered:
                 self.ring_buffer.append((frame, is_speech))
@@ -189,8 +190,9 @@ def get_args():
     parser.add_argument(
         "--wav_file",
         # default=(project_path / "data/0eeaef67-ea59-4f2d-a5b8-b70c813fd45c.wav").as_posix(),
-        default=(project_path / "data/1c998b62-c3aa-4541-b59a-d4a40b79eff3.wav").as_posix(),
+        # default=(project_path / "data/1c998b62-c3aa-4541-b59a-d4a40b79eff3.wav").as_posix(),
         # default=(project_path / "data/8cbad66f-2c4e-43c2-ad11-ad95bab8bc15.wav").as_posix(),
+        default=r"D:/Users/tianx/HuggingDatasets/nx_noise/data/speech/nx-speech/en-PH/2025-05-28/active_media_w_1f650e5c-bd22-4803-bb88-d670b00fccda_30.wav",
         type=str,
     )
     parser.add_argument(
@@ -206,12 +208,12 @@ def get_args():
     )
     parser.add_argument(
         "--padding_duration_ms",
-        default=30,
+        default=300,
         type=int,
     )
     parser.add_argument(
         "--silence_duration_threshold",
-        default=0.0,
+        default=0.3,
         type=float,
         help="minimum silence duration, in seconds."
     )