update

examples/silero_vad_by_webrtcvad/run.sh

@@ -8,7 +8,7 @@ bash run.sh --stage 3 --stop_stage 5 --system_version centos \
 --noise_patterns "/data/tianxing/HuggingDatasets/nx_noise/data/noise/**/*.wav" \
 --speech_patterns "/data/tianxing/HuggingDatasets/nx_noise/data/speech/dns3-speech/**/*.wav \
 /data/tianxing/HuggingDatasets/nx_noise/data/speech/nx-speech2/**/*.wav" \
---config_file yaml/config-1024-0-20.yaml
+--config_file yaml/config-256-0-20.yaml
 
 END
 

examples/silero_vad_by_webrtcvad/step_5_export_model.py

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

examples/silero_vad_by_webrtcvad/yaml/config-240-n10-20.yaml

@@ -3,8 +3,8 @@ model_name: "silero_vad"
 # spec
 sample_rate: 8000
 nfft: 512
-win_size: 512
-hop_size: 256
+win_size: 240
+hop_size: 80
 win_type: hann
 
 # model
@@ -19,12 +19,12 @@ decoder_num_layers: 2
 
 # lsnr
 n_frame: 3
-min_local_snr_db: -5
+min_local_snr_db: -15
 max_local_snr_db: 30
 norm_tau: 1.
 
 # data
-min_snr_db: 0
+min_snr_db: -10
 max_snr_db: 20
 
 # train

examples/silero_vad_by_webrtcvad/yaml/config-256-0-20.yaml

@@ -0,0 +1,43 @@
+model_name: "silero_vad"
+
+# spec
+sample_rate: 8000
+nfft: 256
+win_size: 256
+hop_size: 128
+win_type: hann
+
+# model
+encoder_in_channels: 64
+encoder_hidden_channels: 128
+encoder_out_channels: 128
+encoder_kernel_size: 3
+encoder_num_layers: 4
+
+decoder_hidden_size: 128
+decoder_num_layers: 2
+
+# lsnr
+n_frame: 3
+min_local_snr_db: -5
+max_local_snr_db: 30
+norm_tau: 1.
+
+# data
+min_snr_db: 0
+max_snr_db: 20
+
+# train
+lr: 0.001
+lr_scheduler: "CosineAnnealingLR"
+lr_scheduler_kwargs:
+  T_max: 250000
+  eta_min: 0.0001
+
+max_epochs: 100
+clip_grad_norm: 10.0
+seed: 1234
+
+num_workers: 4
+batch_size: 128
+eval_steps: 25000

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

@@ -0,0 +1,145 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from pathlib import Path
+import tempfile
+import zipfile
+
+import onnx
+from onnx import shape_inference
+
+from project_settings import project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_path",
+        default=(project_path / "trained_models/native_silero_vad.zip").as_posix(),
+        type=str
+    )
+    parser.add_argument("--no-infer", action="store_true", help="不做 shape 推断")
+
+    args = parser.parse_args()
+    return args
+
+
+def shape2tuple(shape_proto):
+    dims = []
+    for d in shape_proto.dim:
+        dims.append(d.dim_value if (d.dim_value > 0) else None)
+    return tuple(dims)
+
+def summarize_tensor_proto(tensor_proto):
+    dims = tuple(tensor_proto.dims)
+    data_type = tensor_proto.data_type
+    try:
+        arr = numpy_helper.to_array(tensor_proto)
+        sample = arr.flatten()[:5].tolist()
+        return f"tensor shape={dims}, dtype={data_type}, sample={sample}…"
+    except Exception:
+        return f"tensor shape={dims}, dtype={data_type}, (cannot parse values)"
+
+def print_graph(graph: onnx.GraphProto, indent: int = 0, do_infer_shape: bool = True):
+    prefix = " " * indent
+
+    # 推断 shape
+    if do_infer_shape:
+        temp_model = onnx.helper.make_model(graph)
+        inferred = shape_inference.infer_shapes(temp_model)
+        graph_to_use = inferred.graph
+        value_info = {vi.name: vi for vi in graph_to_use.value_info}
+    else:
+        graph_to_use = graph
+        value_info = {vi.name: vi for vi in graph_to_use.value_info}
+
+    print(f"{prefix}Graph '{graph.name}' (nodes = {len(graph_to_use.node)})")
+    # 打印输入
+    for inp in graph_to_use.input:
+        name = inp.name
+        tp = inp.type.tensor_type
+        shape = shape2tuple(tp.shape)
+        print(f"{prefix}  Input: {name}, shape={shape}, elem_type={tp.elem_type}")
+    # 打印输出
+    for out in graph_to_use.output:
+        name = out.name
+        tp = out.type.tensor_type
+        shape = shape2tuple(tp.shape)
+        print(f"{prefix}  Output: {name}, shape={shape}, elem_type={tp.elem_type}")
+    print()
+
+    # 打印节点
+    for idx, node in enumerate(graph_to_use.node):
+        print(f"{prefix}[{idx}] op_type: {node.op_type}, name: {node.name}")
+        print(f"{prefix}     inputs: {node.input}")
+        print(f"{prefix}     outputs: {node.output}")
+
+        # 打印属性
+        for attr in node.attribute:
+            name = attr.name
+            t = attr.type
+            if t == onnx.AttributeProto.GRAPH:
+                subg = attr.g
+                print(f"{prefix}     attr: {name} (GRAPH) -> subgraph '{subg.name}', {len(subg.node)} nodes")
+                # **单独打印子图**，并且作为一个“完整图”
+                print_graph(subg, indent=indent + 4, do_infer_shape=do_infer_shape)
+            elif t == onnx.AttributeProto.TENSOR:
+                desc = summarize_tensor_proto(attr.t)
+                print(f"{prefix}     attr: {name} (TENSOR) -> {desc}")
+            elif t == onnx.AttributeProto.INTS:
+                print(f"{prefix}     attr: {name} (INTS) -> {list(attr.ints)}")
+            elif t == onnx.AttributeProto.INT:
+                print(f"{prefix}     attr: {name} (INT) -> {attr.i}")
+            elif t == onnx.AttributeProto.FLOAT:
+                print(f"{prefix}     attr: {name} (FLOAT) -> {attr.f}")
+            elif t == onnx.AttributeProto.STRING:
+                try:
+                    s = attr.s.decode('utf-8')
+                except:
+                    s = attr.s
+                print(f"{prefix}     attr: {name} (STRING) -> {s}")
+            else:
+                print(f"{prefix}     attr: {name} (type={t})")
+
+        # 打印中间 tensor 的 shape（如果有推断 info）
+        for out_name in node.output:
+            if out_name in value_info:
+                vi = value_info[out_name]
+                shape = shape2tuple(vi.type.tensor_type.shape)
+                print(f"{prefix}     output tensor '{out_name}' shape: {shape}")
+        for in_name in node.input:
+            if in_name in value_info:
+                vi = value_info[in_name]
+                shape = shape2tuple(vi.type.tensor_type.shape)
+                print(f"{prefix}     input tensor '{in_name}' shape: {shape}")
+
+        print()
+
+def print_model_with_branches(onnx_path: str, do_infer_shape: bool = True):
+    model = onnx.load(onnx_path)
+    onnx.checker.check_model(model)
+
+    print("=== Main graph ===")
+    print_graph(model.graph, indent=0, do_infer_shape=do_infer_shape)
+
+
+def main():
+    args = get_args()
+
+    model_path = Path(args.model_path)
+    if model_path.name.endswith(".zip"):
+        with zipfile.ZipFile(model_path.as_posix(), "r") as f_zip:
+            out_root = Path(tempfile.gettempdir()) / "cc_vad"
+            out_root.mkdir(parents=True, exist_ok=True)
+            f_zip.extractall(path=out_root)
+        model_path = out_root / model_path.stem
+
+    onnx_path = (model_path / "silero_vad.onnx").as_posix()
+
+    print_model_with_branches(onnx_path, do_infer_shape=not args.no_infer)
+
+    return
+
+
+if __name__ == "__main__":
+    main()

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

@@ -102,6 +102,7 @@ class InferenceNativeSileroVadOnnx(object):
         context_size = 64 if self.config.sample_rate == 16000 else 32
 
         chunk = torch.cat(tensors=[context, chunk], dim=1)
+        # chunk shape: [1, 256+32=288]
         input_feed = {
             "input": chunk.numpy(),
             "state": state.numpy(),
@@ -114,6 +115,7 @@ class InferenceNativeSileroVadOnnx(object):
         vad_flag = torch.from_numpy(vad_flag)
         state = torch.from_numpy(state)
         context = chunk[..., -context_size:]
+        # context shape: [1, 32]
         return vad_flag, context, state
 
     def infer(self, signal: np.ndarray) -> np.ndarray: