first commit

.dockerignore

@@ -0,0 +1,5 @@
+
+.git/
+.idea/
+
+/examples/

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,23 @@
+
+.gradio/
+.git/
+.idea/
+
+**/evaluation_audio/
+**/file_dir/
+**/flagged/
+**/log/
+**/logs/
+**/__pycache__/
+
+/data/
+/docs/
+/dotenv/
+/hub_datasets/
+/script/
+/thirdparty/
+/trained_models/
+/temp/
+
+**/*.wav
+**/*.xlsx

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.12
+
+WORKDIR /code
+
+COPY . /code
+
+RUN apt-get update
+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
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+CMD ["python3", "main.py"]

README.md

@@ -0,0 +1,129 @@
+---
+title: CC VAD
+emoji: 🐢
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## CC VAD
+
+
+### datasets
+
+```text
+
+AISHELL (15G)
+https://openslr.trmal.net/resources/33/
+
+AISHELL-3 (19G)
+http://www.openslr.org/93/
+
+DNS3
+https://github.com/microsoft/DNS-Challenge/blob/master/download-dns-challenge-3.sh
+噪音数据来源于 DEMAND, FreeSound, AudioSet. 
+
+MS-SNSD
+https://github.com/microsoft/MS-SNSD
+噪音数据来源于 DEMAND, FreeSound. 
+
+MUSAN
+https://www.openslr.org/17/
+其中包含 music, noise, speech. 
+music 是一些纯音乐, noise 包含 free-sound, sound-bible, sound-bible部分也许可以做为补充部分. 
+总的来说, 有用的不部不多, 可能噪音数据仍然需要自己收集为主, 更加可靠. 
+
+CHiME-4
+https://www.chimechallenge.org/challenges/chime4/download.html
+
+freesound
+https://freesound.org/
+
+AudioSet
+https://research.google.com/audioset/index.html
+```
+
+
+### ### 创建训练容器
+
+```text
+在容器中训练模型，需要能够从容器中访问到 GPU，参考：
+https://hub.docker.com/r/ollama/ollama
+
+docker run -itd \
+--name cc_vad \
+--network host \
+--gpus all \
+--privileged \
+--ipc=host \
+-v /data/tianxing/HuggingDatasets/nx_noise/data:/data/tianxing/HuggingDatasets/nx_noise/data \
+-v /data/tianxing/PycharmProjects/cc_vad:/data/tianxing/PycharmProjects/cc_vad \
+python:3.12
+
+
+查看GPU
+nvidia-smi
+watch -n 1 -d nvidia-smi
+
+
+```
+
+```text
+在容器中访问 GPU
+
+参考：
+https://blog.csdn.net/footless_bird/article/details/136291344
+步骤：
+# 安装 
+yum install -y nvidia-container-toolkit
+
+# 编辑文件 /etc/docker/daemon.json
+cat /etc/docker/daemon.json
+{
+    "data-root": "/data/lib/docker",
+    "default-runtime": "nvidia",
+    "runtimes": {
+        "nvidia": {
+            "path": "/usr/bin/nvidia-container-runtime",
+            "runtimeArgs": []
+        }
+    },
+    "registry-mirrors": [
+        "https://docker.m.daocloud.io", 
+        "https://dockerproxy.com", 
+        "https://docker.mirrors.ustc.edu.cn", 
+        "https://docker.nju.edu.cn"
+    ]
+}
+
+# 重启 docker
+systemctl restart docker
+systemctl daemon-reload
+
+# 测试容器内能否访问 GPU. 
+docker run --gpus all python:3.12-slim nvidia-smi
+
+# 通过这种方式启动容器, 在容器中, 可以查看到 GPU. 但是容器中没有 GPU驱动 nvidia-smi 不工作. 
+docker run -it --privileged python:3.12-slim /bin/bash
+apt update
+apt install -y pciutils
+lspci | grep -i nvidia
+#00:08.0 3D controller: NVIDIA Corporation TU104GL [Tesla T4] (rev a1)
+
+# 网上看的是这种启动容器的方式, 但是进去后仍然是 nvidia-smi 不工作.
+docker run \
+--device /dev/nvidia0:/dev/nvidia0 \
+--device /dev/nvidiactl:/dev/nvidiactl \
+--device /dev/nvidia-uvm:/dev/nvidia-uvm \
+-v /usr/local/nvidia:/usr/local/nvidia \
+-it --privileged python:3.12-slim /bin/bash
+
+
+# 这种方式进入容器, nvidia-smi 可以工作. 应该关键是 --gpus all 参数. 
+docker run -itd --gpus all --name open_unsloth python:3.12-slim /bin/bash
+docker run -itd --gpus all --name Qwen2-7B-Instruct python:3.12-slim /bin/bash
+
+```

examples/silero_vad_by_webrtcvad/run.sh

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+: <<'END'
+
+sh run.sh --stage 2 --stop_stage 2 --system_version windows --file_folder_name file_dir --final_model_name dfnet-nx-speech \
+--noise_dir "E:/Users/tianx/HuggingDatasets/nx_noise/data/noise" \
+--speech_dir "E:/Users/tianx/HuggingDatasets/nx_noise/data/speech"
+
+sh run.sh --stage 2 --stop_stage 2 --system_version centos --file_folder_name file_dir --final_model_name dfnet2-nx-dns3 \
+--noise_dir "/data/tianxing/HuggingDatasets/nx_noise/data/noise" \
+--speech_dir "/data/tianxing/HuggingDatasets/nx_noise/data/speech/dns3-speech"
+
+sh run.sh --stage 2 --stop_stage 2 --system_version centos --file_folder_name file_dir --final_model_name dfnet2-nx2 \
+--noise_dir "/data/tianxing/HuggingDatasets/nx_noise/data/noise/nx-noise" \
+--speech_dir "/data/tianxing/HuggingDatasets/nx_noise/data/speech/nx-speech2"
+
+sh run.sh --stage 2 --stop_stage 2 --system_version centos --file_folder_name dfnet2-nx2-dns3 --final_model_name dfnet2-nx2-dns3 \
+--noise_dir "/data/tianxing/HuggingDatasets/nx_noise/data/noise/" \
+--speech_dir "/data/tianxing/HuggingDatasets/nx_noise/data/speech/"
+
+
+END
+
+
+# params
+system_version="windows";
+verbose=true;
+stage=0 # start from 0 if you need to start from data preparation
+stop_stage=9
+
+work_dir="$(pwd)"
+file_folder_name=file_folder_name
+final_model_name=final_model_name
+config_file="yaml/config.yaml"
+limit=10
+
+noise_dir=/data/tianxing/HuggingDatasets/nx_noise/data/noise
+speech_dir=/data/tianxing/HuggingDatasets/aishell/data_aishell/wav/train
+
+max_count=-1
+
+nohup_name=nohup.out
+
+# model params
+batch_size=64
+max_epochs=200
+save_top_k=10
+patience=5
+
+
+# parse options
+while true; do
+  [ -z "${1:-}" ] && break;  # break if there are no arguments
+  case "$1" in
+    --*) name=$(echo "$1" | sed s/^--// | sed s/-/_/g);
+      eval '[ -z "${'"$name"'+xxx}" ]' && echo "$0: invalid option $1" 1>&2 && exit 1;
+      old_value="(eval echo \\$$name)";
+      if [ "${old_value}" == "true" ] || [ "${old_value}" == "false" ]; then
+        was_bool=true;
+      else
+        was_bool=false;
+      fi
+
+      # Set the variable to the right value-- the escaped quotes make it work if
+      # the option had spaces, like --cmd "queue.pl -sync y"
+      eval "${name}=\"$2\"";
+
+      # Check that Boolean-valued arguments are really Boolean.
+      if $was_bool && [[ "$2" != "true" && "$2" != "false" ]]; then
+        echo "$0: expected \"true\" or \"false\": $1 $2" 1>&2
+        exit 1;
+      fi
+      shift 2;
+      ;;
+
+    *) break;
+  esac
+done
+
+file_dir="${work_dir}/${file_folder_name}"
+final_model_dir="${work_dir}/../../trained_models/${final_model_name}";
+evaluation_audio_dir="${file_dir}/evaluation_audio"
+
+train_dataset="${file_dir}/train.jsonl"
+valid_dataset="${file_dir}/valid.jsonl"
+
+$verbose && echo "system_version: ${system_version}"
+$verbose && echo "file_folder_name: ${file_folder_name}"
+
+if [ $system_version == "windows" ]; then
+  alias python3='D:/Users/tianx/PycharmProjects/virtualenv/nx_denoise/Scripts/python.exe'
+elif [ $system_version == "centos" ] || [ $system_version == "ubuntu" ]; then
+  #source /data/local/bin/nx_denoise/bin/activate
+  alias python3='/data/local/bin/nx_denoise/bin/python3'
+fi
+
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+  $verbose && echo "stage 1: prepare data"
+  cd "${work_dir}" || exit 1
+  python3 step_1_prepare_data.py \
+  --file_dir "${file_dir}" \
+  --noise_dir "${noise_dir}" \
+  --speech_dir "${speech_dir}" \
+  --train_dataset "${train_dataset}" \
+  --valid_dataset "${valid_dataset}" \
+  --max_count "${max_count}" \
+
+fi
+
+
+if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
+  $verbose && echo "stage 2: train model"
+  cd "${work_dir}" || exit 1
+  python3 step_2_train_model.py \
+  --train_dataset "${train_dataset}" \
+  --valid_dataset "${valid_dataset}" \
+  --serialization_dir "${file_dir}" \
+  --config_file "${config_file}" \
+
+fi
+
+
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+  $verbose && echo "stage 3: test model"
+  cd "${work_dir}" || exit 1
+  python3 step_3_evaluation.py \
+  --valid_dataset "${valid_dataset}" \
+  --model_dir "${file_dir}/best" \
+  --evaluation_audio_dir "${evaluation_audio_dir}" \
+  --limit "${limit}" \
+
+fi
+
+
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+  $verbose && echo "stage 4: collect files"
+  cd "${work_dir}" || exit 1
+
+  mkdir -p ${final_model_dir}
+
+  cp "${file_dir}/best"/* "${final_model_dir}"
+  cp -r "${file_dir}/evaluation_audio" "${final_model_dir}"
+
+  cd "${final_model_dir}/.." || exit 1;
+
+  if [ -e "${final_model_name}.zip" ]; then
+    rm -rf "${final_model_name}_backup.zip"
+    mv "${final_model_name}.zip" "${final_model_name}_backup.zip"
+  fi
+
+  zip -r "${final_model_name}.zip" "${final_model_name}"
+  rm -rf "${final_model_name}"
+
+fi
+
+
+if [ ${stage} -le 5 ] && [ ${stop_stage} -ge 5 ]; then
+  $verbose && echo "stage 5: clear file_dir"
+  cd "${work_dir}" || exit 1
+
+  rm -rf "${file_dir}";
+
+fi

examples/silero_vad_by_webrtcvad/step_1_prepare_data.py

@@ -0,0 +1,185 @@
+#!/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 scipy.io import wavfile
+from tqdm import tqdm
+
+from toolbox.webrtcvad.vad import WebRTCVad
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--file_dir", default="./", type=str)
+
+    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=4.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)
+
+    # 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.3, type=float)
+
+    args = parser.parse_args()
+    return args
+
+
+def target_second_signal_generator(data_dir: str, duration: int = 2, 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()
+
+    file_dir = Path(args.file_dir)
+    file_dir.mkdir(exist_ok=True)
+
+    noise_dir = Path(args.noise_dir)
+    speech_dir = Path(args.speech_dir)
+
+    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,
+    )
+
+    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,
+        sample_rate=args.target_sample_rate,
+    )
+
+    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"]
+
+            # vad
+            _, signal = wavfile.read(speech_filename)
+            vad_segments = list()
+            segments = w_vad.vad(signal)
+            vad_segments += segments
+            segments = w_vad.last_vad_segments()
+            vad_segments += segments
+
+            # 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),
+
+                "vad_segments": vad_segments,
+
+                "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_seconds": round(duration_seconds, 4),
+                "duration_hours": round(duration_hours, 4),
+
+            })
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/silero_vad_by_webrtcvad/step_2_train_model.py

@@ -0,0 +1,469 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://github.com/Rikorose/DeepFilterNet
+"""
+import argparse
+import json
+import logging
+from logging.handlers import TimedRotatingFileHandler
+import os
+import platform
+from pathlib import Path
+import random
+import sys
+import shutil
+from typing import List
+
+from fontTools.varLib.plot import stops
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from torch.utils.data.dataloader import DataLoader
+from tqdm import tqdm
+
+from toolbox.torch.utils.data.dataset.denoise_jsonl_dataset import DenoiseJsonlDataset
+from toolbox.torchaudio.losses.snr import NegativeSISNRLoss
+from toolbox.torchaudio.losses.spectral import LSDLoss, MultiResolutionSTFTLoss
+from toolbox.torchaudio.metrics.pesq import run_pesq_score
+from toolbox.torchaudio.models.dfnet2.configuration_dfnet2 import DfNet2Config
+from toolbox.torchaudio.models.dfnet2.modeling_dfnet2 import DfNet2, DfNet2PretrainedModel
+
+
+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("--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)
+
+    args = parser.parse_args()
+    return args
+
+
+def logging_config(file_dir: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    logging.basicConfig(format=fmt,
+                        datefmt="%m/%d/%Y %H:%M:%S",
+                        level=logging.INFO)
+    file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(file_dir, "main.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(logging.Formatter(fmt))
+    logger = logging.getLogger(__name__)
+    logger.addHandler(file_handler)
+
+    return logger
+
+
+class CollateFunction(object):
+    def __init__(self):
+        pass
+
+    def __call__(self, batch: List[dict]):
+        clean_audios = list()
+        noisy_audios = list()
+        snr_db_list = list()
+
+        for sample in batch:
+            # noise_wave: torch.Tensor = sample["noise_wave"]
+            clean_audio: torch.Tensor = sample["speech_wave"]
+            noisy_audio: torch.Tensor = sample["mix_wave"]
+            # snr_db: float = sample["snr_db"]
+
+            clean_audios.append(clean_audio)
+            noisy_audios.append(noisy_audio)
+
+        clean_audios = torch.stack(clean_audios)
+        noisy_audios = torch.stack(noisy_audios)
+
+        # assert
+        if torch.any(torch.isnan(clean_audios)) or torch.any(torch.isinf(clean_audios)):
+            raise AssertionError("nan or inf in clean_audios")
+        if torch.any(torch.isnan(noisy_audios)) or torch.any(torch.isinf(noisy_audios)):
+            raise AssertionError("nan or inf in noisy_audios")
+        return clean_audios, noisy_audios
+
+
+collate_fn = CollateFunction()
+
+
+def main():
+    args = get_args()
+
+    config = DfNet2Config.from_pretrained(
+        pretrained_model_name_or_path=args.config_file,
+    )
+
+    serialization_dir = Path(args.serialization_dir)
+    serialization_dir.mkdir(parents=True, exist_ok=True)
+
+    logger = logging_config(serialization_dir)
+
+    random.seed(config.seed)
+    np.random.seed(config.seed)
+    torch.manual_seed(config.seed)
+    logger.info(f"set seed: {config.seed}")
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    n_gpu = torch.cuda.device_count()
+    logger.info(f"GPU available count: {n_gpu}; device: {device}")
+
+    # datasets
+    train_dataset = DenoiseJsonlDataset(
+        jsonl_file=args.train_dataset,
+        expected_sample_rate=config.sample_rate,
+        max_wave_value=32768.0,
+        min_snr_db=config.min_snr_db,
+        max_snr_db=config.max_snr_db,
+        # skip=225000,
+    )
+    valid_dataset = DenoiseJsonlDataset(
+        jsonl_file=args.valid_dataset,
+        expected_sample_rate=config.sample_rate,
+        max_wave_value=32768.0,
+        min_snr_db=config.min_snr_db,
+        max_snr_db=config.max_snr_db,
+    )
+    train_data_loader = DataLoader(
+        dataset=train_dataset,
+        batch_size=config.batch_size,
+        # shuffle=True,
+        sampler=None,
+        # Linux 系统中可以使用多个子进程加载数据, 而在 Windows 系统中不能.
+        num_workers=0 if platform.system() == "Windows" else os.cpu_count() // 2,
+        collate_fn=collate_fn,
+        pin_memory=False,
+        prefetch_factor=None if platform.system() == "Windows" else 2,
+    )
+    valid_data_loader = DataLoader(
+        dataset=valid_dataset,
+        batch_size=config.batch_size,
+        # shuffle=True,
+        sampler=None,
+        # Linux 系统中可以使用多个子进程加载数据, 而在 Windows 系统中不能.
+        num_workers=0 if platform.system() == "Windows" else os.cpu_count() // 2,
+        collate_fn=collate_fn,
+        pin_memory=False,
+        prefetch_factor=None if platform.system() == "Windows" else 2,
+    )
+
+    # models
+    logger.info(f"prepare models. config_file: {args.config_file}")
+    model = DfNet2PretrainedModel(config).to(device)
+    model.to(device)
+    model.train()
+
+    # optimizer
+    logger.info("prepare optimizer, lr_scheduler, loss_fn, evaluation_metric")
+    optimizer = torch.optim.AdamW(model.parameters(), config.lr)
+
+    # resume training
+    last_step_idx = -1
+    last_epoch = -1
+    for step_idx_str in serialization_dir.glob("steps-*"):
+        step_idx_str = Path(step_idx_str)
+        step_idx = step_idx_str.stem.split("-")[1]
+        step_idx = int(step_idx)
+        if step_idx > last_step_idx:
+            last_step_idx = step_idx
+    # last_epoch = 1
+
+    if last_step_idx != -1:
+        logger.info(f"resume from steps-{last_step_idx}.")
+        model_pt = serialization_dir / f"steps-{last_step_idx}/model.pt"
+
+        logger.info(f"load state dict for model.")
+        with open(model_pt.as_posix(), "rb") as f:
+            state_dict = torch.load(f, map_location="cpu", weights_only=True)
+        model.load_state_dict(state_dict, strict=True)
+
+    if config.lr_scheduler == "CosineAnnealingLR":
+        lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer,
+            last_epoch=last_epoch,
+            # T_max=10 * config.eval_steps,
+            # eta_min=0.01 * config.lr,
+            **config.lr_scheduler_kwargs,
+        )
+    elif config.lr_scheduler == "MultiStepLR":
+        lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
+            optimizer,
+            last_epoch=last_epoch,
+            milestones=[10000, 20000, 30000, 40000, 50000], gamma=0.5
+        )
+    else:
+        raise AssertionError(f"invalid lr_scheduler: {config.lr_scheduler}")
+
+    neg_si_snr_loss_fn = NegativeSISNRLoss(reduction="mean").to(device)
+    mr_stft_loss_fn = MultiResolutionSTFTLoss(
+        fft_size_list=[256, 512, 1024],
+        win_size_list=[256, 512, 1024],
+        hop_size_list=[128, 256, 512],
+        factor_sc=1.5,
+        factor_mag=1.0,
+        reduction="mean"
+    ).to(device)
+
+    # training loop
+
+    # state
+    average_pesq_score = 1000000000
+    average_loss = 1000000000
+    average_mr_stft_loss = 1000000000
+    average_neg_si_snr_loss = 1000000000
+    average_mask_loss = 1000000000
+    average_lsnr_loss = 1000000000
+
+    model_list = list()
+    best_epoch_idx = None
+    best_step_idx = None
+    best_metric = None
+    patience_count = 0
+
+    step_idx = 0 if last_step_idx == -1 else last_step_idx
+
+    logger.info("training")
+    early_stop_flag = False
+    for epoch_idx in range(max(0, last_epoch+1), config.max_epochs):
+        if early_stop_flag:
+            break
+
+        # train
+        model.train()
+
+        total_pesq_score = 0.
+        total_loss = 0.
+        total_mr_stft_loss = 0.
+        total_neg_si_snr_loss = 0.
+        total_mask_loss = 0.
+        total_lsnr_loss = 0.
+        total_batches = 0.
+
+        progress_bar_train = tqdm(
+            initial=step_idx,
+            desc="Training; epoch-{}".format(epoch_idx),
+        )
+        for train_batch in train_data_loader:
+            clean_audios, noisy_audios = train_batch
+            clean_audios: torch.Tensor = clean_audios.to(device)
+            noisy_audios: torch.Tensor = noisy_audios.to(device)
+
+            est_spec, est_wav, est_mask, lsnr = model.forward(noisy_audios)
+            # est_wav shape: [b, 1, n_samples]
+            est_wav = torch.squeeze(est_wav, dim=1)
+            # est_wav shape: [b, n_samples]
+
+            mr_stft_loss = mr_stft_loss_fn.forward(est_wav, clean_audios)
+            neg_si_snr_loss = neg_si_snr_loss_fn.forward(est_wav, clean_audios)
+            mask_loss = model.mask_loss_fn(est_mask, clean_audios, noisy_audios)
+            lsnr_loss = model.lsnr_loss_fn(lsnr, clean_audios, noisy_audios)
+
+            loss = 1.0 * mr_stft_loss + 1.0 * neg_si_snr_loss + 1.0 * mask_loss + 0.01 * 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
+
+            denoise_audios_list_r = list(est_wav.detach().cpu().numpy())
+            clean_audios_list_r = list(clean_audios.detach().cpu().numpy())
+            pesq_score = run_pesq_score(clean_audios_list_r, denoise_audios_list_r, sample_rate=config.sample_rate, mode="nb")
+
+            optimizer.zero_grad()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=config.clip_grad_norm)
+            optimizer.step()
+            lr_scheduler.step()
+
+            total_pesq_score += pesq_score
+            total_loss += loss.item()
+            total_mr_stft_loss += mr_stft_loss.item()
+            total_neg_si_snr_loss += neg_si_snr_loss.item()
+            total_mask_loss += mask_loss.item()
+            total_lsnr_loss += lsnr_loss.item()
+            total_batches += 1
+
+            average_pesq_score = round(total_pesq_score / total_batches, 4)
+            average_loss = round(total_loss / total_batches, 4)
+            average_mr_stft_loss = round(total_mr_stft_loss / total_batches, 4)
+            average_neg_si_snr_loss = round(total_neg_si_snr_loss / total_batches, 4)
+            average_mask_loss = round(total_mask_loss / total_batches, 4)
+            average_lsnr_loss = round(total_lsnr_loss / total_batches, 4)
+
+            progress_bar_train.update(1)
+            progress_bar_train.set_postfix({
+                "lr": lr_scheduler.get_last_lr()[0],
+                "pesq_score": average_pesq_score,
+                "loss": average_loss,
+                "mr_stft_loss": average_mr_stft_loss,
+                "neg_si_snr_loss": average_neg_si_snr_loss,
+                "mask_loss": average_mask_loss,
+                "lsnr_loss": average_lsnr_loss,
+            })
+
+            # evaluation
+            step_idx += 1
+            if step_idx % config.eval_steps == 0:
+                with torch.no_grad():
+                    torch.cuda.empty_cache()
+
+                    model.eval()
+
+                    total_pesq_score = 0.
+                    total_loss = 0.
+                    total_mr_stft_loss = 0.
+                    total_neg_si_snr_loss = 0.
+                    total_mask_loss = 0.
+                    total_lsnr_loss = 0.
+                    total_batches = 0.
+
+                    progress_bar_train.close()
+                    progress_bar_eval = tqdm(
+                        desc="Evaluation; steps-{}k".format(int(step_idx/1000)),
+                    )
+                    for eval_batch in valid_data_loader:
+                        clean_audios, noisy_audios = eval_batch
+                        clean_audios: torch.Tensor = clean_audios.to(device)
+                        noisy_audios: torch.Tensor = noisy_audios.to(device)
+
+                        est_spec, est_wav, est_mask, lsnr = model.forward(noisy_audios)
+                        # est_wav shape: [b, 1, n_samples]
+                        est_wav = torch.squeeze(est_wav, dim=1)
+                        # est_wav shape: [b, n_samples]
+
+                        mr_stft_loss = mr_stft_loss_fn.forward(est_wav, clean_audios)
+                        neg_si_snr_loss = neg_si_snr_loss_fn.forward(est_wav, clean_audios)
+                        mask_loss = model.mask_loss_fn(est_mask, clean_audios, noisy_audios)
+                        lsnr_loss = model.lsnr_loss_fn(lsnr, clean_audios, noisy_audios)
+
+                        loss = 1.0 * mr_stft_loss + 1.0 * neg_si_snr_loss + 1.0 * mask_loss + 0.01 * 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
+
+                        denoise_audios_list_r = list(est_wav.detach().cpu().numpy())
+                        clean_audios_list_r = list(clean_audios.detach().cpu().numpy())
+                        pesq_score = run_pesq_score(clean_audios_list_r, denoise_audios_list_r, sample_rate=config.sample_rate, mode="nb")
+
+                        total_pesq_score += pesq_score
+                        total_loss += loss.item()
+                        total_mr_stft_loss += mr_stft_loss.item()
+                        total_neg_si_snr_loss += neg_si_snr_loss.item()
+                        total_mask_loss += mask_loss.item()
+                        total_lsnr_loss += lsnr_loss.item()
+                        total_batches += 1
+
+                        average_pesq_score = round(total_pesq_score / total_batches, 4)
+                        average_loss = round(total_loss / total_batches, 4)
+                        average_mr_stft_loss = round(total_mr_stft_loss / total_batches, 4)
+                        average_neg_si_snr_loss = round(total_neg_si_snr_loss / total_batches, 4)
+                        average_mask_loss = round(total_mask_loss / total_batches, 4)
+                        average_lsnr_loss = round(total_lsnr_loss / total_batches, 4)
+
+                        progress_bar_eval.update(1)
+                        progress_bar_eval.set_postfix({
+                            "lr": lr_scheduler.get_last_lr()[0],
+                            "pesq_score": average_pesq_score,
+                            "loss": average_loss,
+                            "mr_stft_loss": average_mr_stft_loss,
+                            "neg_si_snr_loss": average_neg_si_snr_loss,
+                            "mask_loss": average_mask_loss,
+                            "lsnr_loss": average_lsnr_loss,
+                        })
+
+                model.train()
+
+                total_pesq_score = 0.
+                total_loss = 0.
+                total_mr_stft_loss = 0.
+                total_neg_si_snr_loss = 0.
+                total_mask_loss = 0.
+                total_lsnr_loss = 0.
+                total_batches = 0.
+
+                progress_bar_eval.close()
+                progress_bar_train = tqdm(
+                    initial=progress_bar_train.n,
+                    postfix=progress_bar_train.postfix,
+                    desc=progress_bar_train.desc,
+                )
+
+                # save path
+                save_dir = serialization_dir / "steps-{}".format(step_idx)
+                save_dir.mkdir(parents=True, exist_ok=False)
+
+                # save models
+                model.save_pretrained(save_dir.as_posix())
+
+                model_list.append(save_dir)
+                if len(model_list) >= args.num_serialized_models_to_keep:
+                    model_to_delete: Path = model_list.pop(0)
+                    shutil.rmtree(model_to_delete.as_posix())
+
+                # save metric
+                if best_metric is None:
+                    best_epoch_idx = epoch_idx
+                    best_step_idx = step_idx
+                    best_metric = average_pesq_score
+                elif average_pesq_score >= best_metric:
+                    # great is better.
+                    best_epoch_idx = epoch_idx
+                    best_step_idx = step_idx
+                    best_metric = average_pesq_score
+                else:
+                    pass
+
+                metrics = {
+                    "epoch_idx": epoch_idx,
+                    "best_epoch_idx": best_epoch_idx,
+                    "best_step_idx": best_step_idx,
+                    "pesq_score": average_pesq_score,
+                    "loss": average_loss,
+                    "mr_stft_loss": average_mr_stft_loss,
+                    "neg_si_snr_loss": average_neg_si_snr_loss,
+                    "mask_loss": average_mask_loss,
+                    "lsnr_loss": average_lsnr_loss,
+                }
+                metrics_filename = save_dir / "metrics_epoch.json"
+                with open(metrics_filename, "w", encoding="utf-8") as f:
+                    json.dump(metrics, f, indent=4, ensure_ascii=False)
+
+                # save best
+                best_dir = serialization_dir / "best"
+                if best_epoch_idx == epoch_idx and best_step_idx == step_idx:
+                    if best_dir.exists():
+                        shutil.rmtree(best_dir)
+                    shutil.copytree(save_dir, best_dir)
+
+                # early stop
+                early_stop_flag = False
+                if best_epoch_idx == epoch_idx and best_step_idx == step_idx:
+                    patience_count = 0
+                else:
+                    patience_count += 1
+                if patience_count >= args.patience:
+                    early_stop_flag = True
+
+                # early stop
+                if early_stop_flag:
+                    break
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/silero_vad_by_webrtcvad/yaml/config.yaml

@@ -0,0 +1,22 @@
+model_name: "silero_vad"
+
+sample_rate: 8000
+nfft: 512
+win_size: 240
+hop_size: 80
+win_type: hann
+
+in_channels: 64
+hidden_size: 128
+
+lr: 0.001
+lr_scheduler: CosineAnnealingLR
+lr_scheduler_kwargs: {}
+
+max_epochs: 100
+clip_grad_norm: 10.0
+seed: 1234
+
+num_workers: 4
+batch_size: 4
+eval_steps: 25000

install.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+
+# bash install.sh --stage 2 --stop_stage 2 --system_version centos
+
+
+python_version=3.12.1
+system_version="centos";
+
+verbose=true;
+stage=-1
+stop_stage=0
+
+
+# parse options
+while true; do
+  [ -z "${1:-}" ] && break;  # break if there are no arguments
+  case "$1" in
+    --*) name=$(echo "$1" | sed s/^--// | sed s/-/_/g);
+      eval '[ -z "${'"$name"'+xxx}" ]' && echo "$0: invalid option $1" 1>&2 && exit 1;
+      old_value="(eval echo \\$$name)";
+      if [ "${old_value}" == "true" ] || [ "${old_value}" == "false" ]; then
+        was_bool=true;
+      else
+        was_bool=false;
+      fi
+
+      # Set the variable to the right value-- the escaped quotes make it work if
+      # the option had spaces, like --cmd "queue.pl -sync y"
+      eval "${name}=\"$2\"";
+
+      # Check that Boolean-valued arguments are really Boolean.
+      if $was_bool && [[ "$2" != "true" && "$2" != "false" ]]; then
+        echo "$0: expected \"true\" or \"false\": $1 $2" 1>&2
+        exit 1;
+      fi
+      shift 2;
+      ;;
+
+    *) break;
+  esac
+done
+
+work_dir="$(pwd)"
+
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+  $verbose && echo "stage 1: install python"
+  cd "${work_dir}" || exit 1;
+
+  sh ./script/install_python.sh --python_version "${python_version}" --system_version "${system_version}"
+fi
+
+
+if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
+  $verbose && echo "stage 2: create virtualenv"
+
+  # /usr/local/python-3.12.1/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
+  cd /data/local/bin || exit 1;
+  /usr/local/python-${python_version}/bin/virtualenv cc_vad
+
+fi

log.py

@@ -0,0 +1,220 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from datetime import datetime
+import logging
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+import os
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+
+def get_converter(tz_info: str = "Asia/Shanghai"):
+    def converter(timestamp):
+        dt = datetime.fromtimestamp(timestamp, ZoneInfo(tz_info))
+        result = dt.timetuple()
+        return result
+    return converter
+
+
+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"
+
+    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)
+    main_info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+def setup_time_rotating(log_directory: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(logging.Formatter(fmt))
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+if __name__ == "__main__":
+    pass

main.py

@@ -0,0 +1,69 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import logging
+import platform
+
+import gradio as gr
+
+import log
+from project_settings import environment, log_directory, time_zone_info
+from toolbox.os.command import Command
+
+log.setup_size_rotating(log_directory=log_directory, tz_info=time_zone_info)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--hf_token",
+        default=environment.get("hf_token"),
+        type=str,
+    )
+    parser.add_argument(
+        "--server_port",
+        default=environment.get("server_port", 7860),
+        type=int
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+def shell(cmd: str):
+    return Command.popen(cmd)
+
+
+def main():
+    args = get_args()
+
+    # ui
+    with gr.Blocks() as blocks:
+        gr.Markdown(value="vad.")
+        with gr.Tabs():
+            with gr.TabItem("shell"):
+                shell_text = gr.Textbox(label="cmd")
+                shell_button = gr.Button("run")
+                shell_output = gr.Textbox(label="output")
+
+                shell_button.click(
+                    shell,
+                    inputs=[shell_text,],
+                    outputs=[shell_output],
+                )
+
+    # http://127.0.0.1:7866/
+    # http://10.75.27.247:7866/
+    blocks.queue().launch(
+        # share=True,
+        share=False if platform.system() == "Windows" else False,
+        server_name="127.0.0.1" if platform.system() == "Windows" else "0.0.0.0",
+        server_port=args.server_port
+    )
+    return
+
+
+if __name__ == "__main__":
+    main()

project_settings.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+from toolbox.os.environment import EnvironmentManager
+
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+time_zone_info = "Asia/Shanghai"
+
+log_directory = project_path / "logs"
+log_directory.mkdir(parents=True, exist_ok=True)
+
+# temp_directory = project_path / "temp"
+# temp_directory.mkdir(parents=True, exist_ok=True)
+
+environment = EnvironmentManager(
+    path=os.path.join(project_path, "dotenv"),
+    env=os.environ.get("environment", "dev"),
+)
+
+
+if __name__ == '__main__':
+    pass

requirements.txt

@@ -0,0 +1,13 @@
+gradio==5.33.0
+gradio_client==1.10.2
+datasets==3.2.0
+python-dotenv==1.0.1
+scipy==1.15.1
+librosa==0.10.2.post1
+pandas==2.2.3
+openpyxl==3.1.5
+torch==2.5.1
+torchaudio==2.5.1
+overrides==7.7.0
+webrtcvad==2.0.10
+matplotlib==3.10.3

toolbox/__init__.py

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

toolbox/json/__init__.py

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

toolbox/json/misc.py

@@ -0,0 +1,63 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import Callable
+
+
+def traverse(js, callback: Callable, *args, **kwargs):
+    if isinstance(js, list):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return result
+    elif isinstance(js, tuple):
+        result = list()
+        for l in js:
+            l = traverse(l, callback, *args, **kwargs)
+            result.append(l)
+        return tuple(result)
+    elif isinstance(js, dict):
+        result = dict()
+        for k, v in js.items():
+            k = traverse(k, callback, *args, **kwargs)
+            v = traverse(v, callback, *args, **kwargs)
+            result[k] = v
+        return result
+    elif isinstance(js, int):
+        return callback(js, *args, **kwargs)
+    elif isinstance(js, str):
+        return callback(js, *args, **kwargs)
+    else:
+        return js
+
+
+def demo1():
+    d = {
+        "env": "ppe",
+        "mysql_connect": {
+            "host": "$mysql_connect_host",
+            "port": 3306,
+            "user": "callbot",
+            "password": "NxcloudAI2021!",
+            "database": "callbot_ppe",
+            "charset": "utf8"
+        },
+        "es_connect": {
+            "hosts": ["10.20.251.8"],
+            "http_auth": ["elastic", "ElasticAI2021!"],
+            "port": 9200
+        }
+    }
+
+    def callback(s):
+        if isinstance(s, str) and s.startswith('$'):
+            return s[1:]
+        return s
+
+    result = traverse(d, callback=callback)
+    print(result)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/__init__.py

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

toolbox/os/command.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+
+class Command(object):
+    custom_command = [
+        "cd"
+    ]
+
+    @staticmethod
+    def _get_cmd(command):
+        command = str(command).strip()
+        if command == "":
+            return None
+        cmd_and_args = command.split(sep=" ")
+        cmd = cmd_and_args[0]
+        args = " ".join(cmd_and_args[1:])
+        return cmd, args
+
+    @classmethod
+    def popen(cls, command):
+        cmd, args = cls._get_cmd(command)
+        if cmd in cls.custom_command:
+            method = getattr(cls, cmd)
+            return method(args)
+        else:
+            resp = os.popen(command)
+            result = resp.read()
+            resp.close()
+            return result
+
+    @classmethod
+    def cd(cls, args):
+        if args.startswith("/"):
+            os.chdir(args)
+        else:
+            pwd = os.getcwd()
+            path = os.path.join(pwd, args)
+            os.chdir(path)
+
+    @classmethod
+    def system(cls, command):
+        return os.system(command)
+
+    def __init__(self):
+        pass
+
+
+def ps_ef_grep(keyword: str):
+    cmd = "ps -ef | grep {}".format(keyword)
+    rows = Command.popen(cmd)
+    rows = str(rows).split("\n")
+    rows = [row for row in rows if row.__contains__(keyword) and not row.__contains__("grep")]
+    return rows
+
+
+if __name__ == "__main__":
+    pass

toolbox/os/environment.py

@@ -0,0 +1,114 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import json
+import os
+
+from dotenv import load_dotenv
+from dotenv.main import DotEnv
+
+from toolbox.json.misc import traverse
+
+
+class EnvironmentManager(object):
+    def __init__(self, path, env, override=False):
+        filename = os.path.join(path, '{}.env'.format(env))
+        self.filename = filename
+
+        load_dotenv(
+            dotenv_path=filename,
+            override=override
+        )
+
+        self._environ = dict()
+
+    def open_dotenv(self, filename: str = None):
+        filename = filename or self.filename
+        dotenv = DotEnv(
+            dotenv_path=filename,
+            stream=None,
+            verbose=False,
+            interpolate=False,
+            override=False,
+            encoding="utf-8",
+        )
+        result = dotenv.dict()
+        return result
+
+    def get(self, key, default=None, dtype=str):
+        result = os.environ.get(key)
+        if result is None:
+            if default is None:
+                result = None
+            else:
+                result = default
+        else:
+            result = dtype(result)
+        self._environ[key] = result
+        return result
+
+
+_DEFAULT_DTYPE_MAP = {
+    'int': int,
+    'float': float,
+    'str': str,
+    'json.loads': json.loads
+}
+
+
+class JsonConfig(object):
+    """
+    将 json 中, 形如 `$float:threshold` 的值, 处理为:
+    从环境变量中查到 threshold, 再将其转换为 float 类型.
+    """
+    def __init__(self, dtype_map: dict = None, environment: EnvironmentManager = None):
+        self.dtype_map = dtype_map or _DEFAULT_DTYPE_MAP
+        self.environment = environment or os.environ
+
+    def sanitize_by_filename(self, filename: str):
+        with open(filename, 'r', encoding='utf-8') as f:
+            js = json.load(f)
+
+        return self.sanitize_by_json(js)
+
+    def sanitize_by_json(self, js):
+        js = traverse(
+            js,
+            callback=self.sanitize,
+            environment=self.environment
+        )
+        return js
+
+    def sanitize(self, string, environment):
+        """支持 $ 符开始的, 环境变量配置"""
+        if isinstance(string, str) and string.startswith('$'):
+            dtype, key = string[1:].split(':')
+            dtype = self.dtype_map[dtype]
+
+            value = environment.get(key)
+            if value is None:
+                raise AssertionError('environment not exist. key: {}'.format(key))
+
+            value = dtype(value)
+            result = value
+        else:
+            result = string
+        return result
+
+
+def demo1():
+    import json
+
+    from project_settings import project_path
+
+    environment = EnvironmentManager(
+        path=os.path.join(project_path, 'server/callbot_server/dotenv'),
+        env='dev',
+    )
+    init_scenes = environment.get(key='init_scenes', dtype=json.loads)
+    print(init_scenes)
+    print(environment._environ)
+    return
+
+
+if __name__ == '__main__':
+    demo1()

toolbox/os/other.py

@@ -0,0 +1,9 @@
+import os
+import inspect
+
+
+def pwd():
+    """你在哪个文件调用此函数, 它就会返回那个文件所在的 dir 目标"""
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    return os.path.dirname(os.path.abspath(module.__file__))

toolbox/torch/__init__.py

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

toolbox/torch/utils/__init__.py

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

toolbox/torch/utils/data/__init__.py

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

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

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

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

@@ -0,0 +1,179 @@
+#!/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 VadJsonlDataset(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,
+                 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.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)
+                noise_filename = row["noise_filename"]
+                noise_raw_duration = row["noise_raw_duration"]
+                noise_offset = row["noise_offset"]
+                noise_duration = row["noise_duration"]
+
+                speech_filename = row["speech_filename"]
+                speech_raw_duration = row["speech_raw_duration"]
+                speech_offset = row["speech_offset"]
+                speech_duration = row["speech_duration"]
+
+                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 = {
+                    "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": 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):
+        noise_filename = sample["noise_filename"]
+        noise_offset = sample["noise_offset"]
+        noise_duration = sample["noise_duration"]
+
+        speech_filename = sample["speech_filename"]
+        speech_offset = sample["speech_offset"]
+        speech_duration = sample["speech_duration"]
+
+        snr_db = sample["snr_db"]
+
+        vad_segments = sample["vad_segments"]
+
+        noise_wave = self.filename_to_waveform(noise_filename, noise_offset, noise_duration)
+        speech_wave = self.filename_to_waveform(speech_filename, speech_offset, speech_duration)
+
+        noisy_wave, _ = self.mix_speech_and_noise(
+            speech=speech_wave.numpy(),
+            noise=noise_wave.numpy(),
+            snr_db=snr_db, eps=self.eps,
+        )
+        noisy_wave = torch.tensor(noisy_wave, dtype=torch.float32)
+
+        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 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
+
+
+if __name__ == "__main__":
+    pass

toolbox/torchaudio/__init__.py

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

toolbox/torchaudio/configuration_utils.py

@@ -0,0 +1,64 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import copy
+import os
+from typing import Any, Dict, Union
+
+import yaml
+
+
+CONFIG_FILE = "config.yaml"
+DISCRIMINATOR_CONFIG_FILE = "discriminator_config.yaml"
+
+
+class PretrainedConfig(object):
+    def __init__(self, **kwargs):
+        pass
+
+    @classmethod
+    def _dict_from_yaml_file(cls, yaml_file: Union[str, os.PathLike]):
+        with open(yaml_file, encoding="utf-8") as f:
+            config_dict = yaml.safe_load(f)
+        return config_dict
+
+    @classmethod
+    def get_config_dict(
+        cls, pretrained_model_name_or_path: Union[str, os.PathLike]
+    ) -> Dict[str, Any]:
+        if os.path.isdir(pretrained_model_name_or_path):
+            config_file = os.path.join(pretrained_model_name_or_path, CONFIG_FILE)
+        else:
+            config_file = pretrained_model_name_or_path
+        config_dict = cls._dict_from_yaml_file(config_file)
+        return config_dict
+
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any], **kwargs):
+        for k, v in kwargs.items():
+            if k in config_dict.keys():
+                config_dict[k] = v
+        config = cls(**config_dict)
+        return config
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        pretrained_model_name_or_path: Union[str, os.PathLike],
+        **kwargs,
+    ):
+        config_dict = cls.get_config_dict(pretrained_model_name_or_path)
+        return cls.from_dict(config_dict, **kwargs)
+
+    def to_dict(self):
+        output = copy.deepcopy(self.__dict__)
+        return output
+
+    def to_yaml_file(self, yaml_file_path: Union[str, os.PathLike]):
+        config_dict = self.to_dict()
+
+        with open(yaml_file_path, "w", encoding="utf-8") as writer:
+            yaml.safe_dump(config_dict, writer)
+
+
+if __name__ == '__main__':
+    pass

toolbox/torchaudio/losses/__init__.py

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

toolbox/torchaudio/losses/vad_loss/__init__.py

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

toolbox/torchaudio/losses/vad_loss/base_vad_loss.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+
+
+class BaseVadLoss(nn.Module):
+    def __init__(self):
+        super(BaseVadLoss, self).__init__()
+
+    @staticmethod
+    def get_targets(inputs: torch.Tensor, batch_vad_segments: List[List[Tuple[float, float]]], duration: float):
+        """
+        :param inputs: torch.Tensor, shape: [b, t, 1]. vad prob, after sigmoid activation.
+        :param batch_vad_segments: VAD segment for each audio
+        :param duration: float. The total duration of each audio in the batch.
+        :return: targets, shape as `inputs`.
+        """
+        b, t, _ = inputs.shape
+
+        batch_vad_segments_ = list()
+        for vad_segments in batch_vad_segments:
+            vad_segments_ = list()
+            for start, end in vad_segments:
+                start_ = start / duration * t
+                end_ = end / duration * t
+                start_ = round(start_)
+                end_ = round(end_)
+                vad_segments_.append([start_, end_])
+            batch_vad_segments_.append(vad_segments_)
+
+        targets = torch.zeros_like(inputs)
+        for idx, vad_segments_ in enumerate(batch_vad_segments_):
+            for start_, end_ in vad_segments_:
+                targets[idx, start_:end_, :] = 1
+
+        return targets
+
+
+if __name__ == "__main__":
+    pass

toolbox/torchaudio/losses/vad_loss/bce_vad_loss.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+
+from toolbox.torchaudio.losses.vad_loss.base_vad_loss import BaseVadLoss
+
+
+class BCEVadLoss(BaseVadLoss):
+    """
+    Binary Cross-Entropy Loss, BCE Loss
+    """
+    def __init__(self,
+                 reduction: str = "mean",
+                 ):
+        super(BCEVadLoss, self).__init__()
+        self.reduction = reduction
+
+        self.bce_loss_fn = nn.BCELoss(reduction=reduction)
+
+    def forward(self, inputs: torch.Tensor, batch_vad_segments: List[List[Tuple[float, float]]], duration: float):
+        """
+        :param inputs: torch.Tensor, shape: [b, t, 1]. vad prob, after sigmoid activation.
+        :param batch_vad_segments: VAD segment for each audio
+        :param duration: float. The total duration of each audio in the batch.
+        :return:
+        """
+
+        targets = self.get_targets(inputs, batch_vad_segments, duration)
+
+        loss = self.bce_loss_fn.forward(inputs, targets)
+        return loss
+
+
+def main():
+    inputs = torch.zeros(size=(1, 198, 1), dtype=torch.float32)
+
+    vad_segments = [
+        [[0.24, 1.15], [2.21, 3.2]],
+    ]
+
+    loss_fn = BCEVadLoss()
+
+    loss = loss_fn.forward(inputs, vad_segments, duration=4)
+    print(loss)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/losses/vad_loss/dice_vad_loss.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import List, Tuple
+
+import torch
+import torch.nn as nn
+
+from toolbox.torchaudio.losses.vad_loss.base_vad_loss import BaseVadLoss
+
+
+class DiceVadLoss(BaseVadLoss):
+    def __init__(self,
+                 reduction: str = "mean",
+                 eps: float = 1e-6,
+                 ):
+        super(DiceVadLoss, self).__init__()
+        self.reduction = reduction
+        self.eps = eps
+
+        if reduction not in ("sum", "mean"):
+            raise AssertionError(f"param reduction must be sum or mean.")
+
+    def forward(self, inputs: torch.Tensor, batch_vad_segments: List[List[Tuple[float, float]]], duration: float):
+        """
+        :param inputs: torch.Tensor, shape: [b, t, 1]. vad prob, after sigmoid activation.
+        :param batch_vad_segments: VAD segment for each audio
+        :param duration: float. The total duration of each audio in the batch.
+        :return:
+        """
+        targets = self.get_targets(inputs, batch_vad_segments, duration)
+
+        inputs_ = torch.squeeze(inputs, dim=-1)
+        targets_ = torch.squeeze(targets, dim=-1)
+        # shape: [b, t]
+
+        intersection = (inputs_ * targets_).sum(dim=-1)
+        union = (inputs_ + targets_).sum(dim=-1)
+        # shape: [b,]
+
+        dice = (2. * intersection + self.eps) / (union + self.eps)
+        # shape: [b,]
+
+        loss = 1. - dice
+        # shape: [b,]
+
+        if self.reduction == "mean":
+            loss = torch.mean(loss)
+        elif self.reduction == "sum":
+            loss = torch.sum(loss)
+        else:
+            raise AssertionError
+        return loss
+
+
+def main():
+    inputs = torch.zeros(size=(1, 198, 1), dtype=torch.float32)
+
+    vad_segments = [
+        [[0.24, 1.15], [2.21, 3.2]],
+    ]
+
+    loss_fn = DiceVadLoss()
+
+    loss = loss_fn.forward(inputs, vad_segments, duration=4)
+    print(loss)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/metrics/__init__.py

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

toolbox/torchaudio/metrics/vad_metrics/__init__.py

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

toolbox/torchaudio/metrics/vad_metrics/vad_accuracy.py

@@ -0,0 +1,60 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import torch
+
+
+class VadAccuracy(object):
+    def __init__(self, threshold: float = 0.5) -> None:
+        self.threshold = threshold
+
+        self.correct_count = 0.
+        self.total_count = 0.
+
+    def __call__(self,
+                 predictions: torch.Tensor,
+                 gold_labels: torch.Tensor,
+                 ):
+        """
+        :param predictions: torch.Tensor, shape: [b, t, 1]. vad prob, after sigmoid activation.
+        :param gold_labels: torch.Tensor, shape: [b, t, 1].
+        :return:
+        """
+        predictions = (predictions > self.threshold).float()
+        correct = predictions.eq(gold_labels).float()
+        self.correct_count += correct.sum()
+        self.total_count += gold_labels.numel()
+
+    def get_metric(self, reset: bool = False):
+        """
+        Returns
+        -------
+        The accumulated accuracy.
+        """
+        if self.total_count > 1e-12:
+            accuracy = float(self.correct_count) / float(self.total_count)
+        else:
+            accuracy = 0.0
+        if reset:
+            self.reset()
+        return {'accuracy': accuracy}
+
+    def reset(self):
+        self.correct_count = 0.0
+        self.total_count = 0.0
+
+
+def main():
+    inputs = torch.zeros(size=(1, 198, 1), dtype=torch.float32)
+    targets = torch.zeros(size=(1, 198, 1), dtype=torch.float32)
+
+    metric_fn = VadAccuracy()
+
+    metric_fn.__call__(inputs, targets)
+
+    metrics = metric_fn.get_metric()
+    print(metrics)
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/models/__init__.py

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

toolbox/torchaudio/models/vad/__init__.py

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

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

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

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

@@ -0,0 +1,66 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import Tuple
+
+from toolbox.torchaudio.configuration_utils import PretrainedConfig
+
+
+class SileroVadConfig(PretrainedConfig):
+    def __init__(self,
+                 sample_rate: int = 8000,
+                 nfft: int = 512,
+                 win_size: int = 240,
+                 hop_size: int = 80,
+                 win_type: str = "hann",
+
+                 in_channels: int = 64,
+                 hidden_size: int = 128,
+
+                 lr: float = 0.001,
+                 lr_scheduler: str = "CosineAnnealingLR",
+                 lr_scheduler_kwargs: dict = None,
+
+                 max_epochs: int = 100,
+                 clip_grad_norm: float = 10.,
+                 seed: int = 1234,
+
+                 num_workers: int = 4,
+                 batch_size: int = 4,
+                 eval_steps: int = 25000,
+
+                 **kwargs
+                 ):
+        super(SileroVadConfig, self).__init__(**kwargs)
+        # transform
+        self.sample_rate = sample_rate
+        self.nfft = nfft
+        self.win_size = win_size
+        self.hop_size = hop_size
+        self.win_type = win_type
+
+        # encoder
+        self.in_channels = in_channels
+        self.hidden_size = hidden_size
+
+        # train
+        self.lr = lr
+        self.lr_scheduler = lr_scheduler
+        self.lr_scheduler_kwargs = lr_scheduler_kwargs or dict()
+
+        self.max_epochs = max_epochs
+        self.clip_grad_norm = clip_grad_norm
+        self.seed = seed
+
+        self.num_workers = num_workers
+        self.batch_size = batch_size
+        self.eval_steps = eval_steps
+
+
+def main():
+    config = SileroVadConfig()
+    config.to_yaml_file("config.yaml")
+    return
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,151 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://github.com/snakers4/silero-vad/wiki/Quality-Metrics
+
+https://pytorch.org/hub/snakers4_silero-vad_vad/
+https://github.com/snakers4/silero-vad
+
+https://github.com/snakers4/silero-vad/blob/master/src/silero_vad/data/silero_vad.jit
+"""
+import torch
+import torch.nn as nn
+
+from toolbox.torchaudio.models.vad.silero_vad.configuration_silero_vad import SileroVadConfig
+from toolbox.torchaudio.modules.conv_stft import ConvSTFT
+
+
+MODEL_FILE = "model.pt"
+
+
+class EncoderBlock(nn.Module):
+    def __init__(self,
+                 in_channels: int = 64,
+                 out_channels: int = 128,
+                 ):
+        super(EncoderBlock, self).__init__()
+        self.conv1d = nn.Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=3,
+            padding="same",
+        )
+        self.activation = nn.ReLU()
+        self.norm = nn.BatchNorm1d(out_channels)
+
+    def forward(self, x: torch.Tensor):
+        # x shape: [b, t, f]
+        x = torch.transpose(x, dim0=1, dim1=2)
+        # x shape: [b, f, t]
+
+        x = self.conv1d.forward(x)
+        x = self.activation(x)
+        x = self.norm(x)
+
+        x = torch.transpose(x, dim0=1, dim1=2)
+        # x shape: [b, t, f]
+
+        return x
+
+
+class Encoder(nn.Module):
+    def __init__(self,
+                 in_channels: int = 64,
+                 out_channels: int = 128,
+                 num_layers: int = 3,
+                 ):
+        super(Encoder, self).__init__()
+
+        self.layers = nn.ModuleList(modules=[
+            EncoderBlock(
+                in_channels=in_channels,
+                out_channels=out_channels,
+            )
+            if i == 0 else
+            EncoderBlock(
+                in_channels=out_channels,
+                out_channels=out_channels,
+            )
+            for i in range(num_layers)
+        ])
+
+    def forward(self, x: torch.Tensor):
+        for layer in self.layers:
+            x = layer.forward(x)
+        return x
+
+
+class SileroVadModel(nn.Module):
+    def __init__(self, config: SileroVadConfig):
+        super(SileroVadModel, self).__init__()
+        self.config = config
+        self.eps = 1e-12
+
+        self.stft = ConvSTFT(
+            nfft=config.nfft,
+            win_size=config.win_size,
+            hop_size=config.hop_size,
+            win_type=config.win_type,
+            power=1,
+            requires_grad=False
+        )
+
+        self.linear = nn.Linear(
+            in_features=(config.nfft // 2 + 1),
+            out_features=config.in_channels,
+        )
+
+        self.encoder = Encoder(
+            in_channels=config.in_channels,
+            out_channels=config.hidden_size,
+        )
+
+        self.lstm = nn.LSTM(
+            input_size=config.hidden_size,
+            hidden_size=config.hidden_size,
+            bidirectional=False,
+            batch_first=True
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Linear(config.hidden_size, 32),
+            nn.ReLU(),
+            nn.Linear(32, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, signal: torch.Tensor):
+        mags = self.stft.forward(signal)
+        # mags shape: [b, f, t]
+
+        x = torch.transpose(mags, dim0=1, dim1=2)
+        # x shape: [b, t, f]
+
+        x = self.linear.forward(x)
+        # x shape: [b, t, f']
+
+        x = self.encoder.forward(x)
+        # x shape: [b, t, f]
+
+        x, _ = self.lstm.forward(x)
+        x = self.classifier.forward(x)
+
+        # x shape: [b, t, 1]
+        return x
+
+
+def main():
+    config = SileroVadConfig()
+    model = SileroVadModel(config=config)
+
+    noisy = torch.randn(size=(1, 16000), dtype=torch.float32)
+
+    probs = model.forward(noisy)
+    print(f"probs: {probs}")
+    print(f"probs.shape: {probs.shape}")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/models/vad/silero_vad/yaml/config.yaml

@@ -0,0 +1,22 @@
+model_name: "silero_vad"
+
+sample_rate: 8000
+nfft: 512
+win_size: 240
+hop_size: 80
+win_type: hann
+
+in_channels: 64
+hidden_size: 128
+
+lr: 0.001
+lr_scheduler: CosineAnnealingLR
+lr_scheduler_kwargs: {}
+
+max_epochs: 100
+clip_grad_norm: 10.0
+seed: 1234
+
+num_workers: 4
+batch_size: 4
+eval_steps: 25000

toolbox/torchaudio/modules/__init__.py

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

toolbox/torchaudio/modules/conv_stft.py

@@ -0,0 +1,271 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://github.com/modelscope/modelscope/blob/master/modelscope/models/audio/ans/conv_stft.py
+"""
+from collections import defaultdict
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from scipy.signal import get_window
+
+
+def init_kernels(nfft: int, win_size: int, hop_size: int, win_type: str = None, inverse=False):
+    if win_type == "None" or win_type is None:
+        window = np.ones(win_size)
+    else:
+        window = get_window(win_type, win_size, fftbins=True)**0.5
+
+    fourier_basis = np.fft.rfft(np.eye(nfft))[:win_size]
+    real_kernel = np.real(fourier_basis)
+    image_kernel = np.imag(fourier_basis)
+    kernel = np.concatenate([real_kernel, image_kernel], 1).T
+
+    if inverse:
+        kernel = np.linalg.pinv(kernel).T
+
+    kernel = kernel * window
+    kernel = kernel[:, None, :]
+    result = (
+        torch.from_numpy(kernel.astype(np.float32)),
+        torch.from_numpy(window[None, :, None].astype(np.float32))
+    )
+    return result
+
+
+class ConvSTFT(nn.Module):
+
+    def __init__(self,
+                 nfft: int,
+                 win_size: int,
+                 hop_size: int,
+                 win_type: str = "hamming",
+                 power: int = None,
+                 requires_grad: bool = False):
+        super(ConvSTFT, self).__init__()
+
+        if nfft is None:
+            self.nfft = int(2**np.ceil(np.log2(win_size)))
+        else:
+            self.nfft = nfft
+
+        kernel, _ = init_kernels(self.nfft, win_size, hop_size, win_type)
+        self.weight = nn.Parameter(kernel, requires_grad=requires_grad)
+
+        self.win_size = win_size
+        self.hop_size = hop_size
+
+        self.stride = hop_size
+        self.dim = self.nfft
+        self.power = power
+
+    def forward(self, waveform: torch.Tensor):
+        if waveform.dim() == 2:
+            waveform = torch.unsqueeze(waveform, 1)
+
+        matrix = F.conv1d(waveform, self.weight, stride=self.stride)
+        dim = self.dim // 2 + 1
+        real = matrix[:, :dim, :]
+        imag = matrix[:, dim:, :]
+        spec = torch.complex(real, imag)
+        # spec shape: [b, f, t], torch.complex64
+
+        if self.power is None:
+            return spec
+        elif self.power == 1:
+            mags = torch.sqrt(real**2 + imag**2)
+            # phase = torch.atan2(imag, real)
+            return mags
+        elif self.power == 2:
+            power = real**2 + imag**2
+            return power
+        else:
+            raise AssertionError
+
+
+class ConviSTFT(nn.Module):
+
+    def __init__(self,
+                 win_size: int,
+                 hop_size: int,
+                 nfft: int = None,
+                 win_type: str = "hamming",
+                 requires_grad: bool = False):
+        super(ConviSTFT, self).__init__()
+        if nfft is None:
+            self.nfft = int(2**np.ceil(np.log2(win_size)))
+        else:
+            self.nfft = nfft
+
+        kernel, window = init_kernels(self.nfft, win_size, hop_size, win_type, inverse=True)
+        self.weight = nn.Parameter(kernel, requires_grad=requires_grad)
+        # weight shape: [f*2, 1, nfft]
+        # f = nfft // 2 + 1
+
+        self.win_size = win_size
+        self.hop_size = hop_size
+        self.win_type = win_type
+
+        self.stride = hop_size
+        self.dim = self.nfft
+
+        self.register_buffer("window", window)
+        self.register_buffer("enframe", torch.eye(win_size)[:, None, :])
+        # window shape: [1, nfft, 1]
+        # enframe shape: [nfft, 1, nfft]
+
+    def forward(self,
+                spec: torch.Tensor):
+        """
+        self.weight shape: [f*2, 1, win_size]
+        self.window shape: [1, win_size, 1]
+        self.enframe shape: [win_size, 1, win_size]
+
+        :param spec: torch.Tensor, shape: [b, f, t, 2]
+        :return:
+        """
+        spec = torch.view_as_real(spec)
+        # spec shape: [b, f, t, 2]
+        matrix = torch.concat(tensors=[spec[..., 0], spec[..., 1]], dim=1)
+        # matrix shape: [b, f*2, t]
+
+        waveform = F.conv_transpose1d(matrix, self.weight, stride=self.stride)
+        # waveform shape: [b, 1, num_samples]
+
+        # this is from torch-stft: https://github.com/pseeth/torch-stft
+        t = self.window.repeat(1, 1, matrix.size(-1))**2
+        # t shape: [1, win_size, t]
+        coff = F.conv_transpose1d(t, self.enframe, stride=self.stride)
+        # coff shape: [1, 1, num_samples]
+        waveform = waveform / (coff + 1e-8)
+        # waveform = waveform / coff
+        return waveform
+
+    @torch.no_grad()
+    def forward_chunk(self,
+                      spec: torch.Tensor,
+                      cache_dict: dict = None
+                      ):
+        """
+        :param spec: shape: [b, f, t]
+        :param cache_dict: dict,
+        waveform_cache shape: [b, 1, win_size - hop_size]
+        coff_cache shape: [b, 1, win_size - hop_size]
+        :return:
+        """
+        if cache_dict is None:
+            cache_dict = defaultdict(lambda: None)
+        waveform_cache = cache_dict["waveform_cache"]
+        coff_cache = cache_dict["coff_cache"]
+
+        spec = torch.view_as_real(spec)
+        matrix = torch.concat(tensors=[spec[..., 0], spec[..., 1]], dim=1)
+
+        waveform_current = F.conv_transpose1d(matrix, self.weight, stride=self.stride)
+
+        t = self.window.repeat(1, 1, matrix.size(-1))**2
+        coff_current = F.conv_transpose1d(t, self.enframe, stride=self.stride)
+
+        overlap_size = self.win_size - self.hop_size
+
+        if waveform_cache is not None:
+            waveform_current[:, :, :overlap_size] += waveform_cache
+        waveform_output = waveform_current[:, :, :self.hop_size]
+        new_waveform_cache = waveform_current[:, :, self.hop_size:]
+
+        if coff_cache is not None:
+            coff_current[:, :, :overlap_size] += coff_cache
+        coff_output = coff_current[:, :, :self.hop_size]
+        new_coff_cache = coff_current[:, :, self.hop_size:]
+
+        waveform_output = waveform_output / (coff_output + 1e-8)
+
+        new_cache_dict = {
+            "waveform_cache": new_waveform_cache,
+            "coff_cache": new_coff_cache,
+        }
+        return waveform_output, new_cache_dict
+
+
+def main():
+    nfft = 512
+    win_size = 512
+    hop_size = 256
+
+    stft = ConvSTFT(nfft=nfft, win_size=win_size, hop_size=hop_size, power=None)
+    istft = ConviSTFT(nfft=nfft, win_size=win_size, hop_size=hop_size)
+
+    mixture = torch.rand(size=(1, 16000), dtype=torch.float32)
+    b, num_samples = mixture.shape
+    t = (num_samples - win_size) / hop_size + 1
+
+    spec = stft.forward(mixture)
+    b, f, t = spec.shape
+
+    # 如果 spec 是由 stft 变换得来的，以下两种 waveform 还原方法就是一致的，否则还原出的 waveform 会有差异。
+    # spec = spec + 0.01 * torch.randn(size=(1, nfft//2+1, t), dtype=torch.float32)
+    print(f"spec.shape: {spec.shape}, spec.dtype: {spec.dtype}")
+
+    waveform = istft.forward(spec)
+    # shape: [batch_size, channels, num_samples]
+    print(f"waveform.shape: {waveform.shape}, waveform.dtype: {waveform.dtype}")
+    print(waveform[:, :, 300: 302])
+
+    waveform = torch.zeros(size=(b, 1, num_samples), dtype=torch.float32)
+    for i in range(int(t)):
+        begin = i * hop_size
+        end = begin + win_size
+        sub_spec = spec[:, :, i:i+1]
+        sub_waveform = istft.forward(sub_spec)
+        # (b, 1, win_size)
+        waveform[:, :, begin:end] = sub_waveform
+    print(f"waveform.shape: {waveform.shape}, waveform.dtype: {waveform.dtype}")
+    print(waveform[:, :, 300: 302])
+
+    return
+
+
+def main2():
+    nfft = 512
+    win_size = 512
+    hop_size = 256
+
+    stft = ConvSTFT(nfft=nfft, win_size=win_size, hop_size=hop_size, power=None)
+    istft = ConviSTFT(nfft=nfft, win_size=win_size, hop_size=hop_size)
+
+    mixture = torch.rand(size=(1, 16128), dtype=torch.float32)
+    b, num_samples = mixture.shape
+
+    spec = stft.forward(mixture)
+    b, f, t = spec.shape
+
+    # 如果 spec 是由 stft 变换得来的，以下两种 waveform 还原方法就是一致的，否则还原出的 waveform 会有差异。
+    spec = spec + 0.01 * torch.randn(size=(1, nfft//2+1, t), dtype=torch.float32)
+    print(f"spec.shape: {spec.shape}, spec.dtype: {spec.dtype}")
+
+    waveform = istft.forward(spec)
+    # shape: [batch_size, channels, num_samples]
+    print(f"waveform.shape: {waveform.shape}, waveform.dtype: {waveform.dtype}")
+    print(waveform[:, :, 300: 302])
+
+    cache_dict = None
+    waveform = torch.zeros(size=(b, 1, num_samples), dtype=torch.float32)
+    for i in range(int(t)):
+        sub_spec = spec[:, :, i:i+1]
+        begin = i * hop_size
+
+        end = begin + win_size - hop_size
+        sub_waveform, cache_dict = istft.forward_chunk(sub_spec, cache_dict=cache_dict)
+        # end = begin + win_size
+        # sub_waveform = istft.forward(sub_spec)
+
+        waveform[:, :, begin:end] = sub_waveform
+    print(f"waveform.shape: {waveform.shape}, waveform.dtype: {waveform.dtype}")
+    print(waveform[:, :, 300: 302])
+
+    return
+
+
+if __name__ == "__main__":
+    main2()

toolbox/webrtcvad/__init__.py

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

toolbox/webrtcvad/vad.py

@@ -0,0 +1,249 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import collections
+from typing import List
+
+import numpy as np
+from scipy.io import wavfile
+import webrtcvad
+
+from project_settings import project_path
+
+
+class Frame(object):
+    def __init__(self, signal: np.ndarray, timestamp, duration):
+        self.signal = signal
+        self.timestamp = timestamp
+        self.duration = duration
+
+
+class WebRTCVad(object):
+    def __init__(self,
+                 agg: int = 3,
+                 frame_duration_ms: int = 30,
+                 padding_duration_ms: int = 300,
+                 silence_duration_threshold: float = 0.3,
+                 sample_rate: int = 8000
+                 ):
+        self.agg = agg
+        self.frame_duration_ms = frame_duration_ms
+        self.padding_duration_ms = padding_duration_ms
+        self.silence_duration_threshold = silence_duration_threshold
+        self.sample_rate = sample_rate
+
+        self._vad = webrtcvad.Vad(mode=agg)
+
+        # frames
+        self.frame_length = int(sample_rate * (frame_duration_ms / 1000.0))
+        self.frame_timestamp = 0.0
+        self.signal_cache = None
+
+        # segments
+        self.num_padding_frames = int(padding_duration_ms / frame_duration_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 = 0.0
+        self.timestamp_end = 0.0
+
+    def signal_to_frames(self, signal: np.ndarray):
+        frames = list()
+
+        l = len(signal)
+
+        duration = (float(self.frame_length) / self.sample_rate)
+
+        for offset in range(0, l, self.frame_length):
+            sub_signal = signal[offset:offset+self.frame_length]
+
+            frame = Frame(sub_signal, self.frame_timestamp, duration)
+            self.frame_timestamp += duration
+
+            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 = len(signal) % self.frame_length
+
+        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:
+            audio_bytes = bytes(frame.signal)
+            is_speech = self._vad.is_speech(audio_bytes, self.sample_rate)
+
+            if not self.triggered:
+                self.ring_buffer.append((frame, is_speech))
+                num_voiced = len([f for f, speech in self.ring_buffer if speech])
+
+                if num_voiced > 0.9 * self.ring_buffer.maxlen:
+                    self.triggered = True
+
+                    for f, _ in self.ring_buffer:
+                        self.voiced_frames.append(f)
+                    self.ring_buffer.clear()
+            else:
+                self.voiced_frames.append(frame)
+                self.ring_buffer.append((frame, is_speech))
+                num_unvoiced = len([f for f, speech in self.ring_buffer if not speech])
+                if num_unvoiced > 0.9 * self.ring_buffer.maxlen:
+                    self.triggered = False
+                    segment = [
+                        np.concatenate([f.signal for f in self.voiced_frames]),
+                        self.voiced_frames[0].timestamp,
+                        self.voiced_frames[-1].timestamp
+                    ]
+                    yield segment
+                    self.ring_buffer.clear()
+                    self.voiced_frames: List[Frame] = list()
+
+    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.is_first_segment:
+                self.timestamp_start = start
+                self.timestamp_end = end
+                self.is_first_segment = False
+                continue
+
+            if self.timestamp_start:
+                sil_duration = start - self.timestamp_end
+                if sil_duration > self.silence_duration_threshold:
+                    vad_segment = [self.timestamp_start, self.timestamp_end]
+                    yield vad_segment
+
+                    self.timestamp_start = start
+                    self.timestamp_end = end
+                else:
+                    self.timestamp_end = 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,
+                self.voiced_frames[-1].timestamp
+            ]
+            segments = [segment]
+
+        # last vad segments
+        vad_segments = self.vad_segments_generator(segments)
+        vad_segments = list(vad_segments)
+
+        vad_segments = vad_segments + [[self.timestamp_start, self.timestamp_end]]
+        return vad_segments
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    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/8cbad66f-2c4e-43c2-ad11-ad95bab8bc15.wav").as_posix(),
+        type=str,
+    )
+    parser.add_argument(
+        "--agg",
+        default=3,
+        type=int,
+        help="The level of aggressiveness of the VAD: [0-3]'"
+    )
+    parser.add_argument(
+        "--frame_duration_ms",
+        default=30,
+        type=int,
+    )
+    parser.add_argument(
+        "--padding_duration_ms",
+        default=300,
+        type=int,
+    )
+    parser.add_argument(
+        "--silence_duration_threshold",
+        default=0.3,
+        type=float,
+        help="minimum silence duration, in seconds."
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    import matplotlib.pyplot as plt
+
+    args = get_args()
+
+    SAMPLE_RATE = 8000
+
+    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,
+        sample_rate=SAMPLE_RATE,
+    )
+
+    sample_rate, signal = wavfile.read(args.wav_file)
+    if SAMPLE_RATE != sample_rate:
+        raise AssertionError
+
+    vad_segments = list()
+
+    segments = w_vad.vad(signal)
+    vad_segments += segments
+    for segment in segments:
+        print(segment)
+
+    # last vad segment
+    segments = w_vad.last_vad_segments()
+    vad_segments += segments
+    for segment in segments:
+        print(segment)
+
+    # plot
+    time = np.arange(0, len(signal)) / sample_rate
+    plt.figure(figsize=(12, 5))
+    plt.plot(time, signal / 32768, color='b')
+    for start, end in vad_segments:
+        # start -= (w_vad.padding_duration_ms - 2*w_vad.frame_duration_ms) / 1000
+        end -= (w_vad.padding_duration_ms - 0*w_vad.frame_duration_ms) / 1000
+
+        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()