Simplify RNNT ASR samples and remove Python inference bindings

.github/workflows/export-nvidia-asr-model.yml

@@ -65,8 +65,12 @@ jobs:
           elif [[ -z "$BASE_SHA" ]] || ! git cat-file -e "${BASE_SHA}^{commit}"; then
             force=true
           elif git diff --quiet "$BASE_SHA" "$SOURCE_REF" -- \
-            'asr/rnnt/python/*.py' \
-            'asr/rnnt/python/**/*.py' \
+            'asr/parakeet/model_export/**' \
+            'asr/nemotron/model_export/**' \
+            'asr/parakeet/requirements.txt' \
+            'asr/nemotron/requirements.txt' \
+            'common/model_export/nemo_export.py' \
+            'common/model_export/requirements-nemo.txt' \
             '.github/workflows/export-nvidia-asr-model.yml' \
             '.github/workflows/nvidia-asr.yml'; then
             force=false
@@ -194,11 +198,7 @@ jobs:
           set -euxo pipefail
           python -m pip install --upgrade pip
           python -m pip install --index-url https://download.pytorch.org/whl/cpu torch
-          python -m pip install \
-            onnx \
-            onnxscript \
-            soundfile \
-            "nemo_toolkit[asr] @ git+https://github.com/NVIDIA/NeMo.git@main"
+          python -m pip install -r common/model_export/requirements-nemo.txt
 
       - name: Export NVIDIA ASR ONNX
         if: steps.selection.outputs.export == 'true'
@@ -211,7 +211,6 @@ jobs:
           MODEL_SLUG: ${{ inputs.model_slug }}
           MODEL_TYPE: ${{ inputs.model_type }}
           PRECISION: ${{ inputs.precision }}
-          PYTHONPATH: asr/rnnt/python
           SOURCE_REF: ${{ inputs.source_ref }}
         run: |
           set -uo pipefail
@@ -227,15 +226,15 @@ jobs:
             dtype="$(export_dtype "$1")"
             case "$MODEL_TYPE" in
               parakeet)
-                python asr/rnnt/python/tools/export_parakeet_tdt_onnx.py \
+                python asr/parakeet/model_export/export_parakeet.py \
                   --model "$MODEL_ID" \
                   --output "$MODEL_OUTPUT" \
                   --device cpu \
                   --dtype "$dtype" \
                   --external-data
                 ;;
               nemotron)
-                python asr/rnnt/python/tools/export_nemotron_onnx.py \
+                python asr/nemotron/model_export/export_nemotron.py \
                   --model "$MODEL_ID" \
                   --output "$MODEL_OUTPUT" \
                   --device cpu \

CMakeLists.txt

@@ -99,7 +99,10 @@ add_subdirectory(tests/base)
 add_subdirectory(tests/tokenizer)
 add_subdirectory(image_gen/flux2)
 add_subdirectory(image_gen/pixeldit)
-add_subdirectory(asr/rnnt)
+add_subdirectory(asr/common)
+add_subdirectory(tests/asr_cli)
+add_subdirectory(asr/parakeet)
+add_subdirectory(asr/nemotron)
 add_subdirectory(vision/sam2)
 add_subdirectory(asr/whisper)
 add_subdirectory(asr/qwen3)

README.md

@@ -17,8 +17,8 @@ DIN Deploy is a collection of practical samples for exporting and running local
 | Model | Hugging Face ID | Docs |
 | --- | --- | --- |
 | OpenAI Whisper | `openai/whisper-tiny`<br>`openai/whisper-base`<br>`openai/whisper-small`<br>`openai/whisper-medium`<br>`openai/whisper-large-v3`<br>`openai/whisper-large-v3-turbo` | [Whisper](asr/whisper/README.md) |
-| NVIDIA Parakeet TDT 0.6B v3 | `nvidia/parakeet-tdt-0.6b-v3` | [RNNT](asr/rnnt/README.md) |
-| NVIDIA Nemotron 3.5 ASR Streaming 0.6B | `nvidia/nemotron-3.5-asr-streaming-0.6b` | [RNNT](asr/rnnt/README.md) |
+| NVIDIA Parakeet TDT 0.6B v3 | `nvidia/parakeet-tdt-0.6b-v3` | [Parakeet](asr/parakeet/README.md) |
+| NVIDIA Nemotron 3.5 ASR Streaming 0.6B | `nvidia/nemotron-3.5-asr-streaming-0.6b` | [Nemotron ASR](asr/nemotron/README.md) |
 | Qwen3 ASR | `Qwen/Qwen3-ASR-0.6B-hf`<br>`Qwen/Qwen3-ASR-1.7B-hf` | [Qwen3](asr/qwen3/README.md) |
 | Qwen3 Forced Aligner | `Qwen/Qwen3-ForcedAligner-0.6B-hf` | [Qwen3](asr/qwen3/README.md) |
 

asr/common/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_library(din_asr_common INTERFACE)
+target_include_directories(din_asr_common INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")

asr/common/asr_common.h

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <initializer_list>
+#include <iostream>
+#include <memory>
+#include <numeric>
+#include <span>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace din::asr::common
+{
+
+// --- file helpers --------------------------------------------------------
+
+inline std::string ReadText(const std::string& path)
+{
+    std::ifstream stream(path);
+    if (!stream)
+    {
+        throw std::runtime_error("failed to open: " + path);
+    }
+    std::ostringstream buffer;
+    buffer << stream.rdbuf();
+    return buffer.str();
+}
+
+inline std::string RequirePath(const std::filesystem::path& path, std::string_view name)
+{
+    if (!std::filesystem::exists(path))
+    {
+        throw std::runtime_error("missing " + std::string{name} + ": " + path.string());
+    }
+    return path.string();
+}
+
+inline std::vector<float> ReadFloatFile(const std::filesystem::path& path)
+{
+    std::ifstream stream(path, std::ios::binary);
+    if (!stream)
+    {
+        return {};
+    }
+    stream.seekg(0, std::ios::end);
+    const auto size = stream.tellg();
+    stream.seekg(0, std::ios::beg);
+    std::vector<float> values(static_cast<size_t>(size) / sizeof(float));
+    stream.read(reinterpret_cast<char*>(values.data()), size);
+    return values;
+}
+
+// --- timing helper -------------------------------
+
+inline double SecondsSince(std::chrono::steady_clock::time_point start)
+{
+    return std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
+}
+
+// --- Shared command-line front end --------------------------------------
+
+struct TranscriptionOptions
+{
+    std::string timestamps = "none";
+};
+
+}  // namespace din::asr::common

asr/rnnt/cpp/asr_common.h → asr/common/cli.h

@@ -3,82 +3,13 @@
 
 #pragma once
 
-#include <algorithm>
-#include <chrono>
-#include <cstdint>
-#include <cstdlib>
-#include <filesystem>
-#include <fstream>
-#include <functional>
-#include <initializer_list>
-#include <iostream>
-#include <memory>
-#include <numeric>
-#include <span>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include "ort_session.h"
+#include "asr_common.h"
 #include <argparse/argparse.hpp>
-#include <onnxruntime_cxx_api.h>
+#include <nlohmann/json.hpp>
 
 namespace din::asr::common
 {
 
-// --- file helpers --------------------------------------------------------
-
-inline std::string ReadText(const std::string& path)
-{
-    std::ifstream stream(path);
-    if (!stream)
-    {
-        throw std::runtime_error("failed to open: " + path);
-    }
-    std::ostringstream buffer;
-    buffer << stream.rdbuf();
-    return buffer.str();
-}
-
-inline std::string RequirePath(const std::filesystem::path& path, std::string_view name)
-{
-    if (!std::filesystem::exists(path))
-    {
-        throw std::runtime_error("missing " + std::string{name} + ": " + path.string());
-    }
-    return path.string();
-}
-
-inline std::vector<float> ReadFloatFile(const std::filesystem::path& path)
-{
-    std::ifstream stream(path, std::ios::binary);
-    if (!stream)
-    {
-        return {};
-    }
-    stream.seekg(0, std::ios::end);
-    const auto size = stream.tellg();
-    stream.seekg(0, std::ios::beg);
-    std::vector<float> values(static_cast<size_t>(size) / sizeof(float));
-    stream.read(reinterpret_cast<char*>(values.data()), size);
-    return values;
-}
-
-// --- timing helper -------------------------------
-
-inline double SecondsSince(std::chrono::steady_clock::time_point start)
-{
-    return std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count();
-}
-
-// --- Shared command-line front end --------------------------------------
-
-struct TranscriptionOptions
-{
-    std::string timestamps = "none";
-};
-
 struct CliSpec
 {
     std::string fallback_name;                    // executable name when argv[0] is unavailable
@@ -102,6 +33,7 @@ int RunCli(int argc, char** argv, const CliSpec& spec)
 
         argparse::ArgumentParser parser(spec.fallback_name);
         parser.add_description("Transcribe audio with exported " + spec.artifact_label + " ONNX artifacts.");
+        parser.add_argument("--json").default_value(false).implicit_value(true).help("Print transcription as JSON.");
         parser.add_argument("audiofile").help("Audio file to transcribe.");
         parser.add_argument("--model-dir")
             .default_value(config.model_dir.string())
@@ -207,16 +139,25 @@ int RunCli(int argc, char** argv, const CliSpec& spec)
         const auto load_seconds = SecondsSince(load_start);
 
         const auto result = pipeline.TranscribeFile(audio_file);
-        pipeline.Print(std::cout, result, options);
-
-        std::cout << "\nprovider: " << provider << '\n';
-        std::cout << "audio: " << result.audio_seconds << "s\n";
-        std::cout << "load: " << load_seconds << "s\n";
-        std::cout << "transcribe: " << result.transcribe_seconds << "s\n";
-        std::cout << "encode: " << result.encode_seconds << "s\n";
-        std::cout << "greedy: " << result.greedy_seconds << "s\n";
-        std::cout << "speed: " << (result.audio_seconds / result.transcribe_seconds) << "x\n";
-        std::cout << "total: " << SecondsSince(total_start) << "s\n";
+        const bool json_output = parser.get<bool>("--json");
+        if (json_output)
+            std::cout << nlohmann::json{{"transcription", result.text},
+                                        {"audio_seconds", result.audio_seconds},
+                                        {"transcribe_seconds", result.transcribe_seconds}}
+                             .dump()
+                      << '\n';
+        else
+            pipeline.Print(std::cout, result, options);
+        auto& timing = json_output ? std::cerr : std::cout;
+
+        timing << "\nprovider: " << provider << '\n';
+        timing << "audio: " << result.audio_seconds << "s\n";
+        timing << "load: " << load_seconds << "s\n";
+        timing << "transcribe: " << result.transcribe_seconds << "s\n";
+        timing << "encode: " << result.encode_seconds << "s\n";
+        timing << "greedy: " << result.greedy_seconds << "s\n";
+        timing << "speed: " << (result.audio_seconds / result.transcribe_seconds) << "x\n";
+        timing << "total: " << SecondsSince(total_start) << "s\n";
     }
     catch (const std::exception& exception)
     {

asr/nemotron/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_din_shared_library(din_asr_nemotron nemotron.cpp)
+target_include_directories(din_asr_nemotron PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(din_asr_nemotron PUBLIC din_asr_common din_common_ort din_common_io nlohmann_json::nlohmann_json)
+
+add_din_executable(din_asr_nemotron_cli main.cpp)
+target_link_libraries(din_asr_nemotron_cli PRIVATE din_asr_nemotron argparse)

asr/nemotron/README.md

@@ -0,0 +1,39 @@
+# Nemotron 3.5 ASR
+
+NeMo → standard ONNX → C++ inference through ONNX Runtime (CPU or TensorRT RTX).
+
+## Export
+
+Python 3.12+ is needed only for export and reference validation.
+
+```bash
+python -m pip install -r asr/nemotron/requirements.txt
+python asr/nemotron/model_export/export_nemotron.py --output artifacts/nemotron/onnx --device cpu --external-data
+```
+
+## Build and run
+
+```bash
+cmake --preset linux-x64
+cmake --build --preset linux-x64-release --target din_asr_nemotron_cli
+out/build/linux-x64/bin/Release/din_asr_nemotron_cli audio.wav --model-dir artifacts/nemotron/onnx --provider cpu --lang-id en-US
+```
+
+Use `--json` for a JSON transcript, or `--timestamps token` for token timestamps.
+The existing C++ target names and exported artifact formats are preserved.
+
+## Validate
+
+Compare one real recording against NeMo; add `--truth transcript.txt` to measure WER
+against a human transcript, and `--max-wer 0.1` to enforce a threshold.
+
+```bash
+python asr/nemotron/model_export/validate_nemotron.py --audio audio.wav \
+  --cli out/build/linux-x64/bin/Release/din_asr_nemotron_cli \
+  --model-dir artifacts/nemotron/onnx --lang-id en-US
+```
+
+The Python inference package, native bindings, dataset evaluation, plotting, and
+quantization tools have been removed. Run inference with the C++ CLI; prepare
+models with the scripts above. Shared NeMo export and validation helpers live in
+`common/model_export/`; shared C++ ASR utilities live in `asr/common/`.

asr/rnnt/cpp/nemotron_main.cpp → asr/nemotron/main.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-#include "asr_common.h"
+#include "cli.h"
 #include "nemotron.h"
 
 int main(int argc, char** argv)