Update README.md

README.md

@@ -75,56 +75,86 @@ Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated sys
 
 
 ## How to Use the Model:
+To train, fine-tune or play with the model you will need to install [NVIDIA NeMo](https://github.com/NVIDIA/NeMo).
+
+```bash
+pip install -U nemo_toolkit['asr']
+``` 
 The model is available for use in the NeMo toolkit [2], and can be used as a pre-trained checkpoint for inference.
 
 ### Automatically load the model
 
 ```python
+import torch
 import nemo.collections.asr as nemo_asr
 vad_model = nemo_asr.models.EncDecFrameClassificationModel.from_pretrained(model_name="nvidia/frame_vad_multilingual_marblenet_v2.0")
-```
 
-### Perform VAD Inference
+# Move the model to GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+vad_model = vad_model.to(device)
+vad_model.eval()
+```
 
+### Inference with PyTorch
+First, let's get a sample
 ```bash
-python <NEMO_ROOT>/examples/asr/speech_classification/frame_vad_infer.py \
-  --config-path="../conf/vad" \
-  --config-name="frame_vad_infer_postprocess.yaml" \
-  vad.model_path="nvidia/frame_vad_multilingual_marblenet_v2.0" \
-  vad.parameters.shift_length_in_sec=0.02 \
-  prepare_manifest.auto_split=True \
-  prepare_manifest.split_duration=7200 \
-  input_manifest=<Path of manifest file of evaluation data, where audio files should have unique names> \
-  out_manifest_filepath=<Path of output manifest file>
+wget https://dldata-public.s3.us-east-2.amazonaws.com/2086-149220-0033.wav
+```
+Then run the following:
+
+```python
+import librosa
+
+# Load the audio
+input_signal = librosa.load("2086-149220-0033.wav", sr=16000, mono=True)[0]
+input_signal = torch.tensor(input_signal).unsqueeze(0).float()
+input_signal_length = torch.tensor([input_signal.shape[1]]).long()
+
+# Perform inference
+with torch.no_grad():
+   torch_outputs = vad_model(
+        input_signal=input_signal.to(device),
+        input_signal_length=input_signal_length.to(device)
+    ).cpu()
+
+# Check output dimensions
+B, T, C = torch_outputs.shape
+assert C == 2, "Output channels should be 2"
 ```
-### Export a PyTorch to ONNX
+
+### Export to ONNX
 
 ```python
-import torch, onnx 
+import onnx 
 from nemo.core import typecheck
-import nemo.collections.asr as nemo_asr
 typecheck.set_typecheck_enabled(False)
 
+# Output file path for ONNX export
 ONNX_EXPORT_PATH = "frame_vad_multilingual_marblenet_v2.0.onnx"
 
-# Load pretrained frame-level VAD model and move to CPU in eval mode
-vad_model = nemo_asr.models.EncDecFrameClassificationModel.from_pretrained(
-    model_name="nvidia/frame_vad_multilingual_marblenet_v2.0"
-).eval().cpu()
+# Move everything to CPU
+vad_model = vad_model.cpu()
+input_signal = input_signal.cpu()
+input_signal_length = input_signal_length.cpu()
+
+# Preprocess input signal
+processed_signal, processed_signal_length = vad_model.preprocessor(
+    input_signal=input_signal,
+    length=input_signal_length
+)
 
 # Define input example for ONNX export
-B, F, T = 16, 80, 400  # batch, feature dim, sequence length
 inputs = {
-    "processed_signal": torch.randn(B, F, T).float(),
-    "processed_signal_length": torch.full((B,), T, dtype=torch.long)
+    "processed_signal": processed_signal,
+    "processed_signal_length": processed_signal_length
 }
 
-# Export model to ONNX
+# Export
 torch.onnx.export(
     model=vad_model,
     args=inputs,
     f=ONNX_EXPORT_PATH,
-    input_names=["processed_signal", "processed_signal_length"],
+    input_names=list(inputs.keys()),
     output_names=["output"],
     dynamic_axes={
         "processed_signal": {0: "batch_size", 2: "sequence_length"},
@@ -133,9 +163,50 @@ torch.onnx.export(
     }
 )
 
-# Validate exported ONNX model
+# Validate ONNX model
 onnx.checker.check_model(onnx.load(ONNX_EXPORT_PATH))
 ```
+
+### Inference with ONNX Runtime
+```python
+import onnxruntime
+
+# Load the ONNX model
+session = onnxruntime.InferenceSession(
+    ONNX_EXPORT_PATH, 
+    providers=["CPUExecutionProvider"]
+)
+
+# Prepare input for ONNX Runtime
+ort_inputs = {
+    input.name: inputs[input.name].numpy()
+    for input in session.get_inputs()
+}
+
+# Run inference
+onnx_outputs = session.run(None, ort_inputs)[0]
+
+# Compare with PyTorch output
+for torch_out, onnx_out in zip(torch_outputs, onnx_outputs):
+    torch.testing.assert_close(torch_out, torch.from_numpy(onnx_out), atol=1e-3, rtol=1e-3)
+print("✅ PyTorch and ONNX Runtime outputs match!")
+```
+
+### RTTM Output from Frame-Level Speech Predictions
+
+To generate RTTM (Rich Transcription Time Marked) files from audio using the pretrained model:
+```bash
+python <NEMO_ROOT>/examples/asr/speech_classification/frame_vad_infer.py \
+  --config-path="../conf/vad" \
+  --config-name="frame_vad_infer_postprocess.yaml" \
+  vad.model_path="nvidia/frame_vad_multilingual_marblenet_v2.0" \
+  vad.parameters.shift_length_in_sec=0.02 \
+  prepare_manifest.auto_split=True \
+  prepare_manifest.split_duration=7200 \
+  input_manifest=<Path of manifest file of evaluation data, where audio files should have unique names> \
+  out_manifest_filepath=<Path of output manifest file>
+```
+
 ## Software Integration:
 **Runtime Engine(s):** 
 * NeMo-2.0.0 <br>