update

examples/silero_vad_by_webrtcvad/run.sh

@@ -74,6 +74,9 @@ evaluation_audio_dir="${file_dir}/evaluation_audio"
 train_dataset="${file_dir}/train.jsonl"
 valid_dataset="${file_dir}/valid.jsonl"
 
+train_vad_dataset="${file_dir}/train-vad.jsonl"
+valid_vad_dataset="${file_dir}/valid-vad.jsonl"
+
 $verbose && echo "system_version: ${system_version}"
 $verbose && echo "file_folder_name: ${file_folder_name}"
 
@@ -89,7 +92,6 @@ 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}" \
@@ -100,11 +102,23 @@ fi
 
 
 if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
-  $verbose && echo "stage 2: train model"
+  $verbose && echo "stage 2: make vad segments"
   cd "${work_dir}" || exit 1
-  python3 step_2_train_model.py \
+  python3 step_2_make_vad_segments.py \
   --train_dataset "${train_dataset}" \
   --valid_dataset "${valid_dataset}" \
+  --train_vad_dataset "${train_vad_dataset}" \
+  --valid_vad_dataset "${valid_vad_dataset}" \
+
+fi
+
+
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+  $verbose && echo "stage 3: train model"
+  cd "${work_dir}" || exit 1
+  python3 step_3_train_model.py \
+  --train_dataset "${train_vad_dataset}" \
+  --valid_dataset "${valid_vad_dataset}" \
   --serialization_dir "${file_dir}" \
   --config_file "${config_file}" \
 

examples/silero_vad_by_webrtcvad/step_1_prepare_data.py

@@ -12,16 +12,11 @@ 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",
@@ -36,7 +31,7 @@ def get_args():
     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("--duration", default=6.0, type=float)
     parser.add_argument("--min_snr_db", default=-10, type=float)
     parser.add_argument("--max_snr_db", default=20, type=float)
 
@@ -44,12 +39,6 @@ def get_args():
 
     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
 
@@ -85,9 +74,6 @@ def target_second_signal_generator(data_dir: str, duration: int = 2, sample_rate
 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)
 
@@ -104,14 +90,6 @@ def main():
         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:
@@ -130,14 +108,6 @@ def main():
             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()
@@ -157,8 +127,6 @@ def main():
 
                 "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)
@@ -173,9 +141,7 @@ def main():
 
             process_bar.update(n=1)
             process_bar.set_postfix({
-                # "duration_seconds": round(duration_seconds, 4),
                 "duration_hours": round(duration_hours, 4),
-
             })
 
     return

examples/silero_vad_by_webrtcvad/step_2_make_vad_segments.py

@@ -0,0 +1,138 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+import librosa
+import numpy as np
+from tqdm import tqdm
+
+from toolbox.webrtcvad.vad import WebRTCVad
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--train_dataset", default="train.jsonl", type=str)
+    parser.add_argument("--valid_dataset", default="valid.jsonl", type=str)
+
+    parser.add_argument("--train_vad_dataset", default="train-vad.jsonl", type=str)
+    parser.add_argument("--valid_vad_dataset", default="valid-vad.jsonl", type=str)
+
+    parser.add_argument("--target_sample_rate", default=8000, type=int)
+
+    # vad
+    parser.add_argument("--agg", default=3, type=int)
+    parser.add_argument("--frame_duration_ms", default=30, type=int)
+    parser.add_argument("--padding_duration_ms", default=30, type=int)
+    parser.add_argument("--silence_duration_threshold", default=0.3, type=float)
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    w_vad = WebRTCVad(
+        agg=args.agg,
+        frame_duration_ms=args.frame_duration_ms,
+        padding_duration_ms=args.padding_duration_ms,
+        silence_duration_threshold=args.silence_duration_threshold,
+        sample_rate=args.target_sample_rate,
+    )
+
+    # valid
+    count = 0
+    process_bar = tqdm(desc="process valid dataset jsonl")
+    with (open(args.valid_dataset, "r", encoding="utf-8") as fvalid,
+          open(args.valid_vad_dataset, "w", encoding="utf-8") as fvalid_vad):
+        for row in fvalid:
+            row = json.loads(row)
+
+            speech_filename = row["speech_filename"]
+            speech_offset = row["speech_offset"]
+            speech_duration = row["speech_duration"]
+
+            waveform, _ = librosa.load(
+                speech_filename,
+                sr=args.expected_sample_rate,
+                offset=speech_offset,
+                duration=speech_duration,
+            )
+            waveform = np.array(waveform * (1 << 15), dtype=np.int16)
+
+            # vad
+            vad_segments = list()
+            segments = w_vad.vad(waveform)
+            vad_segments += segments
+            segments = w_vad.last_vad_segments()
+            vad_segments += segments
+            w_vad.reset()
+
+            row["vad_segments"] = vad_segments
+
+            row = json.dumps(row, ensure_ascii=False)
+            fvalid_vad.write(f"{row}\n")
+
+            count += 1
+            duration_seconds = count * args.duration
+            duration_hours = duration_seconds / 3600
+
+            process_bar.update(n=1)
+            process_bar.set_postfix({
+                "duration_hours": round(duration_hours, 4),
+            })
+
+    # train
+    count = 0
+    process_bar = tqdm(desc="process train dataset jsonl")
+    with (open(args.train_dataset, "r", encoding="utf-8") as ftrain,
+          open(args.train_vad_dataset, "w", encoding="utf-8") as ftrain_vad):
+        for row in ftrain:
+            row = json.loads(row)
+
+            speech_filename = row["speech_filename"]
+            speech_offset = row["speech_offset"]
+            speech_duration = row["speech_duration"]
+
+            waveform, _ = librosa.load(
+                speech_filename,
+                sr=args.expected_sample_rate,
+                offset=speech_offset,
+                duration=speech_duration,
+            )
+            waveform = np.array(waveform * (1 << 15), dtype=np.int16)
+
+            # vad
+            vad_segments = list()
+            segments = w_vad.vad(waveform)
+            vad_segments += segments
+            segments = w_vad.last_vad_segments()
+            vad_segments += segments
+            w_vad.reset()
+
+            row["vad_segments"] = vad_segments
+
+            row = json.dumps(row, ensure_ascii=False)
+            ftrain_vad.write(f"{row}\n")
+
+            count += 1
+            duration_seconds = count * args.duration
+            duration_hours = duration_seconds / 3600
+
+            process_bar.update(n=1)
+            process_bar.set_postfix({
+                "duration_hours": round(duration_hours, 4),
+            })
+
+    return
+
+
+if __name__ == "__main__":
+    main()

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

@@ -246,19 +246,19 @@ def main():
             # noisy_audios shape: [b, num_samples]
             num_samples = noisy_audios.shape[-1]
 
-            predictions = model.forward(noisy_audios)
+            logits, probs = model.forward(noisy_audios)
 
-            targets = BaseVadLoss.get_targets(predictions, batch_vad_segments, duration=num_samples / config.sample_rate)
+            targets = BaseVadLoss.get_targets(probs, batch_vad_segments, duration=num_samples / config.sample_rate)
 
-            bce_loss = bce_loss_fn.forward(predictions, targets)
-            dice_loss = dice_loss_fn.forward(predictions, targets)
+            bce_loss = bce_loss_fn.forward(probs, targets)
+            dice_loss = dice_loss_fn.forward(probs, targets)
 
             loss = 1.0 * bce_loss + 1.0 * dice_loss
             if torch.any(torch.isnan(loss)) or torch.any(torch.isinf(loss)):
                 logger.info(f"find nan or inf in loss. continue.")
                 continue
 
-            vad_accuracy_metrics_fn.__call__(predictions, targets)
+            vad_accuracy_metrics_fn.__call__(probs, targets)
 
             optimizer.zero_grad()
             loss.backward()
@@ -311,19 +311,19 @@ def main():
                         # noisy_audios shape: [b, num_samples]
                         num_samples = noisy_audios.shape[-1]
 
-                        predictions = model.forward(noisy_audios)
+                        logits, probs = model.forward(noisy_audios)
 
-                        targets = BaseVadLoss.get_targets(predictions, batch_vad_segments, duration=num_samples / config.sample_rate)
+                        targets = BaseVadLoss.get_targets(probs, batch_vad_segments, duration=num_samples / config.sample_rate)
 
-                        bce_loss = bce_loss_fn.forward(predictions, targets)
-                        dice_loss = dice_loss_fn.forward(predictions, targets)
+                        bce_loss = bce_loss_fn.forward(probs, targets)
+                        dice_loss = dice_loss_fn.forward(probs, targets)
 
                         loss = 1.0 * bce_loss + 1.0 * dice_loss
                         if torch.any(torch.isnan(loss)) or torch.any(torch.isinf(loss)):
                             logger.info(f"find nan or inf in loss. continue.")
                             continue
 
-                        vad_accuracy_metrics_fn.__call__(predictions, targets)
+                        vad_accuracy_metrics_fn.__call__(probs, targets)
 
                         total_loss += loss.item()
                         total_bce_loss += bce_loss.item()

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

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

toolbox/torchaudio/models/vad/fsmn_vad/fsmn_encoder.py

@@ -0,0 +1,285 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from typing import Tuple, Dict, List
+import copy
+import os
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class LinearTransform(nn.Module):
+    def __init__(self,
+                 input_dim: int,
+                 output_dim: int,
+                 ):
+        super(LinearTransform, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+
+        self.linear = nn.Linear(input_dim, output_dim, bias=False)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        output = self.linear.forward(inputs)
+        return output
+
+
+class AffineTransform(nn.Module):
+    def __init__(self,
+                 input_dim: int,
+                 output_dim: int,
+                 ):
+        super(AffineTransform, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+
+        self.linear = nn.Linear(input_dim, output_dim)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        output = self.linear.forward(inputs)
+        return output
+
+
+class RectifiedLinear(nn.Module):
+    def __init__(self,
+                 input_dim: int,
+                 output_dim: int,
+                 ):
+        super(RectifiedLinear, self).__init__()
+        self.dim = input_dim
+
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.1)
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        output = self.relu(inputs)
+        return output
+
+
+class FSMNBlock(nn.Module):
+    def __init__(self,
+                 hidden_size: int,
+                 lorder: int,
+                 rorder: int = -1,
+                 lstride: int = 1,
+                 rstride: int = 1,
+                 ):
+        super(FSMNBlock, self).__init__()
+        self.hidden_size = hidden_size
+
+        self.lorder = lorder
+        self.rorder = rorder
+        self.lstride = lstride
+        self.rstride = rstride
+
+        self.conv_left = nn.Conv2d(
+            in_channels=self.hidden_size,
+            out_channels=self.hidden_size,
+            kernel_size=[lorder, 1],
+            dilation=[lstride, 1],
+            groups=self.hidden_size,
+            bias=False,
+        )
+
+        self.conv_right = None
+        if self.rorder > 0:
+            self.conv_right = nn.Conv2d(
+                in_channels=self.hidden_size,
+                out_channels=self.hidden_size,
+                kernel_size=[rorder, 1],
+                dilation=[rstride, 1],
+                groups=self.hidden_size,
+                bias=False,
+            )
+
+    def forward(self,
+                inputs: torch.Tensor,
+                cache: torch.Tensor = None,
+                ):
+        # inputs shape: [b, t, f]
+        x = torch.unsqueeze(inputs, dim=1)
+        # x shape: [b, 1, t, f]
+        x_per = x.permute(0, 3, 2, 1)
+        # x shape: [b, f, t, 1] / [b, c, t, 1]
+
+        if cache is None:
+            y_left = F.pad(x_per, pad=[0, 0, (self.lorder - 1) * self.lstride, 0])
+        else:
+            cache = cache.to(x_per.device)
+            y_left = torch.cat(tensors=(cache, x_per), dim=2)
+            cache = y_left[:, :, -(self.lorder - 1) * self.lstride:, :]
+            # cache shape: [b, f, t_pad, 1]
+        # y_left shape: [b, f, t', 1]
+        y_left = self.conv_left(y_left)
+        # y_left shape: [b, f, t, 1]
+
+        out = x_per + y_left
+        # out shape: [b, f, t, 1]
+
+        if self.conv_right is not None:
+            y_right = F.pad(x_per, pad=[0, 0, 0, self.rorder * self.rstride])
+            # y_right shape: [b, f, t', 1]
+
+            y_right = y_right[:, :, self.rstride:, :]
+            y_right = self.conv_right(y_right)
+            out += y_right
+
+        # out shape: [b, f, t, 1]
+        out_per = out.permute(0, 3, 2, 1)
+        # out_per shape: [b, 1, t, f]
+
+        output = out_per.squeeze(1)
+        # output shape: [b, t, f]
+        return output, cache
+
+
+class BasicBlock(nn.Module):
+    def __init__(self,
+                 input_size: int,
+                 hidden_size: int,
+                 lorder: int,
+                 rorder: int = -1,
+                 lstride: int = 1,
+                 rstride: int = 1,
+                 ):
+        super(BasicBlock, self).__init__()
+        self.lorder = lorder
+        self.rorder = rorder
+        self.lstride = lstride
+        self.rstride = rstride
+
+        self.linear = LinearTransform(input_size, hidden_size)
+        self.fsmn_block = FSMNBlock(
+            hidden_size=hidden_size,
+            lorder=lorder,
+            rorder=rorder,
+            lstride=lstride,
+            rstride=rstride,
+        )
+        self.affine = AffineTransform(hidden_size, input_size)
+        self.relu = RectifiedLinear(input_size, input_size)
+
+    def forward(self,
+                inputs: torch.Tensor,
+                cache: torch.Tensor = None,
+                ):
+        # inputs shape: [b, t, f]
+        x1 = self.linear.forward(inputs)
+        # x1 shape: [b, t, f']
+
+        if cache is None:
+            # cache shape: [b, f', t_pad, 1]
+            cache = torch.zeros(size=(x1.shape[0], x1.shape[-1], (self.lorder - 1) * self.lstride, 1))
+        x2, new_cache = self.fsmn_block.forward(x1, cache=cache)
+        # x2 shape: [b, t, f']
+
+        x3 = self.affine.forward(x2)
+        # x3 shape: [b, t, f]
+
+        x4 = self.relu(x3)
+        return x4, new_cache
+
+
+class FSMN(nn.Module):
+    def __init__(
+        self,
+        input_size: int,
+        input_affine_size: int,
+        hidden_size: int,
+        basic_block_layers: int,
+        basic_block_hidden_size: int,
+        basic_block_lorder: int,
+        basic_block_rorder: int,
+        basic_block_lstride: int,
+        basic_block_rstride: int,
+        output_affine_size: int,
+        output_size: int,
+        use_softmax: bool = True,
+    ):
+        super(FSMN, self).__init__()
+        self.input_size = input_size
+        self.input_affine_size = input_affine_size
+        self.hidden_size = hidden_size
+
+        self.basic_block_layers = basic_block_layers
+
+        self.output_affine_size = output_affine_size
+        self.output_size = output_size
+
+        self.in_linear1 = AffineTransform(input_size, input_affine_size)
+        self.in_linear2 = AffineTransform(input_affine_size, hidden_size)
+        self.relu = RectifiedLinear(hidden_size, hidden_size)
+
+        self.fsmn_basic_block_list = nn.ModuleList(modules=[
+            BasicBlock(input_size=hidden_size,
+                       hidden_size=basic_block_hidden_size,
+                       lorder=basic_block_lorder,
+                       rorder=basic_block_rorder,
+                       lstride=basic_block_lstride,
+                       rstride=basic_block_rstride,
+                       )
+            for _ in range(basic_block_layers)
+        ])
+        self.out_linear1 = AffineTransform(hidden_size, output_affine_size)
+        self.out_linear2 = AffineTransform(output_affine_size, output_size)
+
+        self.use_softmax = use_softmax
+        if self.use_softmax:
+            self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self,
+                inputs: torch.Tensor,
+                cache_list: List[torch.Tensor] = None,
+                ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+        # inputs shape: [b, t, f]
+        x = self.in_linear1.forward(inputs)
+        # x shape: [b, t, input_affine_dim]
+        x = self.in_linear2.forward(x)
+        # x shape: [b, t, f]
+
+        x = self.relu(x)
+
+        new_cache_list = list()
+        for idx, fsmn_basic_block in enumerate(self.fsmn_basic_block_list):
+            cache = None if cache_list is None else cache_list[idx]
+            x, new_cache = fsmn_basic_block.forward(x, cache)
+            new_cache_list.append(new_cache)
+
+        # x shape: [b, t, f]
+        x = self.out_linear1.forward(x)
+        outputs = self.out_linear2.forward(x)
+        # outputs shape: [b, t, f]
+
+        if self.use_softmax:
+            outputs = self.softmax(outputs)
+        return outputs, new_cache_list
+
+
+def main():
+    fsmn = FSMN(
+        input_size=32,
+        input_affine_size=16,
+        hidden_size=16,
+        basic_block_layers=3,
+        basic_block_hidden_size=16,
+        basic_block_lorder=3,
+        basic_block_rorder=0,
+        basic_block_lstride=1,
+        basic_block_rstride=1,
+        output_affine_size=16,
+        output_size=32,
+        use_softmax=True,
+    )
+
+    inputs = torch.randn(size=(1, 198, 32), dtype=torch.float32)
+
+    result, _ = fsmn.forward(inputs)
+    print(result.shape)
+
+    return
+
+
+if __name__ == "__main__":
+    main()

toolbox/torchaudio/models/vad/fsmn_vad/modeling_fsmn_vad.py

@@ -0,0 +1,18 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://modelscope.cn/models/iic/speech_fsmn_vad_zh-cn-16k-common-pytorch/summary
+https://huggingface.co/funasr/fsmn-vad
+https://huggingface.co/funasr/fsmn-vad-onnx
+
+https://github.com/lovemefan/fsmn-vad
+
+https://github.com/modelscope/FunASR/blob/main/funasr/models/fsmn_vad_streaming/encoder.py
+
+"""
+
+
+
+
+if __name__ == "__main__":
+    pass

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

@@ -115,9 +115,10 @@ class SileroVadModel(nn.Module):
             nn.Linear(config.hidden_size, 32),
             nn.ReLU(),
             nn.Linear(32, 1),
-            nn.Sigmoid()
         )
 
+        self.sigmoid = nn.Sigmoid()
+
     def forward(self, signal: torch.Tensor):
         mags = self.stft.forward(signal)
         # mags shape: [b, f, t]
@@ -132,10 +133,11 @@ class SileroVadModel(nn.Module):
         # x shape: [b, t, f]
 
         x, _ = self.lstm.forward(x)
-        x = self.classifier.forward(x)
-
-        # x shape: [b, t, 1]
-        return x
+        logits = self.classifier.forward(x)
+        # logits shape: [b, t, 1]
+        probs = self.sigmoid.forward(logits)
+        # probs shape: [b, t, 1]
+        return logits, probs
 
 
 class SileroVadPretrainedModel(SileroVadModel):
@@ -190,9 +192,9 @@ def main():
 
     noisy = torch.randn(size=(1, 16000), dtype=torch.float32)
 
-    probs = model.forward(noisy)
-    print(f"probs: {probs}")
-    print(f"probs.shape: {probs.shape}")
+    logits, probs = model.forward(noisy)
+    print(f"logits: {probs}")
+    print(f"logits.shape: {logits.shape}")
 
     return
 

toolbox/webrtcvad/vad.py

@@ -51,6 +51,24 @@ class WebRTCVad(object):
         self.timestamp_start = 0.0
         self.timestamp_end = 0.0
 
+    def reset(self):
+        # frames
+        self.frame_length = int(self.sample_rate * (self.frame_duration_ms / 1000.0))
+        self.frame_timestamp = 0.0
+        self.signal_cache = None
+
+        # segments
+        self.num_padding_frames = int(self.padding_duration_ms / self.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()
 
@@ -138,6 +156,7 @@ class WebRTCVad(object):
                     self.timestamp_end = end
 
     def vad(self, signal: np.ndarray) -> List[list]:
+        # signal dtype: np.int16
         segments = self.segments_generator(signal)
         vad_segments = self.vad_segments_generator(segments)
         vad_segments = list(vad_segments)