NbAiLab/nb-asr-nemotron35-lunde07-verbatim-150k

NB-ASR beta · Nemotron 3.5 ASR · verbatim

This model is part of the NB-ASR beta group. Try it on your own Norwegian recordings and help us understand which transcript style works for your workflow, where recognition fails, and what needs improvement.

This is the verbatim model. Choose it when closeness to the spoken wording matters: for example, when reviewing interviews, conversations, or speech where repetitions and hesitations are relevant. It is trained on verbatim references; it is not a phonetic or dialect-preserving transcription system.

Adapted by NbAiLab from NVIDIA Nemotron 3.5 ASR Streaming 0.6B, it transcribes speech into Norwegian Bokmål. Its cache-aware architecture processes audio in chunks while retaining context, making it suitable for exploring streaming transcription as well as transcribing recordings.

Choose the transcript style

Model	Intended output
Nemotron reading-optimised	More readable written Bokmål: a starting point for transcripts intended for readers.
Nemotron verbatim	Closer to the spoken wording, where repetitions, hesitations, and spoken form matter.

The distinction is the training transcript style, not an inference switch. Try both on the same audio to decide which suits your use. Neither guarantees perfect preservation or editing of every utterance.

Also in the beta family: Parakeet RNNT XXL 1.1B verbatim. It is a separate model family with its own setup and usage instructions.

Setup and access

You need access to this private Hugging Face repository, Python 3.10 or later, and a compatible NVIDIA GPU/PyTorch environment for practical inference. The weights are about 2.6 GB; runtime GPU memory use is larger and depends on audio length and decoding settings. Minimum GPU memory has not been benchmarked for this beta release.

Start with a fresh environment. The commands below pin the NeMo source revision used for evaluation; they do not recreate every cluster dependency. Install a CUDA-compatible PyTorch build using the PyTorch installation selector before installing NeMo.

python3 -m venv .venv-nb-asr-nemotron
source .venv-nb-asr-nemotron/bin/activate
export PYTHONNOUSERSITE=1
python -m pip install --upgrade pip setuptools wheel

# Install the appropriate CUDA-enabled PyTorch build here, then:
git clone https://github.com/NVIDIA/NeMo.git NeMo
git -C NeMo checkout 85aac64752f868a95fd82bfdb943f0ac4a8a7a08
python -m pip install -e './NeMo[asr]' huggingface_hub soundfile

python -c "import torch; print(torch.__version__, torch.version.cuda); assert torch.cuda.is_available(), 'CUDA is unavailable'"
hf auth login

Authenticate with an account granted access to the beta repo and a read token. Keep tokens out of scripts and shared logs. Run the examples below from this same working directory, with the environment activated. Install FFmpeg for the audio conversion command.

Quick start: transcribe a recording

Prepare mono, 16 kHz audio. Replace your_recording.mp3 with your input; example.wav is a converted copy.

ffmpeg -i your_recording.mp3 -ac 1 -ar 16000 -c:a pcm_s16le example.wav

Save the following as transcribe.py and run python transcribe.py. Start with a short recording, for example 10–30 seconds. The first run downloads the checkpoint; later runs reuse the Hugging Face cache.

from pathlib import Path

import torch
from huggingface_hub import hf_hub_download
from nemo.collections.asr.models import ASRModel

MODEL_ID = "NbAiLab/nb-asr-nemotron35-lunde07-verbatim-150k"
# Pin the release containing the evaluated weights.
MODEL_REVISION = "71593c1cc0f3928510bd736914127bff24224239"

model_path = hf_hub_download(
    repo_id=MODEL_ID,
    filename="nemotron-3.5-asr-streaming-0.6b.nemo",
    revision=MODEL_REVISION,
)
model = ASRModel.restore_from(restore_path=model_path, map_location="cuda:0")
model.eval()
model.encoder.set_default_att_context_size([56, 3])
model.decoding.set_strip_lang_tags(True)

with torch.inference_mode():
    hypotheses = model.transcribe(
        audio=["example.wav"],
        batch_size=1,
        target_lang="nb-NO",
        return_hypotheses=True,
    )

text = hypotheses[0].text
print(text)
Path("transcript.txt").write_text(text + "\n", encoding="utf-8")

The text is printed and saved to transcript.txt. For multiple short files, pass a list of paths and process the returned hypotheses in the same order.

Always pass target_lang="nb-NO". This selects the Bokmål language prompt (langID); this Python API does not require a separate prompt_mode argument. Automatic language selection is not the evaluated beta configuration.

This convenience API transcribes whole files. Selecting [56,3] alone does not make it a live streaming application or reproduce the cache-aware evaluation below.

Cache-aware streaming

This path processes recordings chunk by chunk with encoder caches using the settings from our evaluation. It simulates streaming from files; microphone capture, transport, and a live caption interface require application code.

Download the same checkpoint to a predictable location:

hf download NbAiLab/nb-asr-nemotron35-lunde07-verbatim-150k \
  nemotron-3.5-asr-streaming-0.6b.nemo \
  --revision 71593c1cc0f3928510bd736914127bff24224239 \
  --local-dir model

Save the next example as prepare_manifest.py and run python prepare_manifest.py. It records the WAV's actual duration and absolute path. Use one manifest row per recording when extending it.

import json
from pathlib import Path

import soundfile as sf

audio = Path("example.wav").resolve()
info = sf.info(str(audio))
assert info.samplerate == 16000 and info.channels == 1
row = {
    "audio_filepath": str(audio),
    "duration": info.duration,
    "text": "",
    "lang": "nb-NO",
    "target_lang": "nb-NO",
    "prompt_mode": "langID",
}
Path("audio.jsonl").write_text(json.dumps(row) + "\n", encoding="utf-8")

Run this from the directory containing NeMo, model, and audio.jsonl:

python NeMo/examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streaming_infer.py \
  model_path=model/nemotron-3.5-asr-streaming-0.6b.nemo \
  dataset_manifest=audio.jsonl \
  output_path=streaming_output \
  target_lang=nb-NO \
  'att_context_size=[56,3]' \
  decoder_type=rnnt \
  pad_and_drop_preencoded=true \
  strip_lang_tags=true \
  batch_size=1 \
  cuda=0

The script writes streaming_output/streaming_out_nemotron-3.5-asr-streaming-0.6b_audio.json. Despite the .json suffix, it contains one JSON object per line. Each pred_text is a transcript, in manifest order.

Blank text means no reference transcript was supplied. Ignore the script's WER fields in that case (they can be infinite). To measure errors, provide human references in the model's intended style. The script's raw WER also differs from the normalized WER reported below.

With batch size 1, encoder and decoder state persist within each recording and reset between recordings. In a live application, retain state across chunks of the same stream and reset it at a new recording/session boundary. [56,3] is our primary evaluated context; other contexts need separate accuracy and latency testing.

Practical notes and troubleshooting

Symptom	What to check
Download returns 401, 403, or 404	Run hf auth whoami and confirm that this account has access to the private repo.
Restore fails or prompt methods are missing	Use the pinned NeMo checkout above in a clean environment. Older releases may lack this model class.
CUDA is unavailable or a CUDA library cannot load	Check the GPU driver and PyTorch installation; include the exact error and versions in feedback.
GPU runs out of memory	Start with batch size 1 and a short file; use cache-aware decoding for longer recordings.
Wrong language or visible language tags	Check nb-NO and the language-tag stripping setting.
Repeated or missing phrases	Listen around the affected interval and report the duration, model revision, and decoding path.

These examples return text only. Speaker diarization, reliable speaker names, and a subtitle editor are separate workflow components. Word timestamps need a separately validated alignment/timestamping workflow. The Parakeet card's extra workflows should not be assumed to work unchanged with these models.

Evaluation and limitations

At 150,000 optimizer steps, continuous cache-aware decoding of 207 style-matched Språkrådet recordings at [56,3] produced 19.22% normalized WER and 9.59% normalized CER. The eight recordings of at least 30 seconds produced 27.22% normalized WER. State was reset only at recording boundaries.

WER counts word substitutions, deletions, and insertions relative to a human reference; CER measures character errors. Lower is better under the same conditions. Our normalization lowercases text, removes language tags and most punctuation, and collapses whitespace. Raw and normalized results are in metrics_all.json.

The two models were scored against their respective transcript styles. Their aggregate WER values are not a controlled head-to-head comparison. The evaluation contains only eight recordings of at least 30 seconds, so it does not establish performance on hours of continuous audio, all dialects, or your particular recording conditions.

Review names, numbers, overlapping speech, noise, code-switching, and long passages. Outputs may omit or repeat speech; a verbatim model may still normalize wording. Use the result as a draft that needs checking.

Feedback from the beta group

Send reports through the NB-ASR beta group's usual feedback channel. Include the model name and revision, audio duration and format, whether you used transcribe() or cache-aware streaming, your GPU/software versions, and a short example of expected and actual text. For omissions or repetitions, include the approximate time in the recording.

Share audio only when you have permission through the agreed channel. If you cannot share it, a description and an anonymized example still help.

Files, attribution, and reproducibility

File	Purpose
nemotron-3.5-asr-streaming-0.6b.nemo	Weights, configuration, and tokenizer for NeMo.
SHA256SUMS	Checksum for verifying downloaded weights.
provenance.json	Model, training-job, and NeMo revision metadata.
experiment_config.yaml	Experiment configuration; operational paths refer to the training environment.
evaluation_run_config.json	Checkpoint, manifest checksum, and evaluation settings.
metrics_all.json	Aggregate and per-domain evaluation results.

The architecture is a roughly 0.6B-parameter cache-aware FastConformer/RNNT from NVIDIA, fine-tuned by NbAiLab for Bokmål. The pretrained tokenizer was retained. Credit NVIDIA for the base model and NbAiLab for the adaptation.

Training used NbAiLab/lunde-nor-nob-verbatim-v07 revision 00a86a62b2dd4d9ad0a50749cc75dcf2d1c230ae: 4,124,775 prepared manifest rows and 11,423.62 hours. The NeMo/Lhotse sampler mixed short and dynamically concatenated cuts with 50/50 sampler weights. Training ran for 150,000 optimizer steps using AdamW, peak learning rate 1e-4, 3,000 warmup steps, cosine decay to 1e-5, bf16, and 16 H200 GPUs. The primary configuration was target_lang="nb-NO" and prompt_mode="langID". NeMo commit: 85aac64752f868a95fd82bfdb943f0ac4a8a7a08.

Experiment: EXP-0013. Training reached step 150,000 in RUN-EXP-0013-015 / continuation job 2297675, resumed from the verified durable step-145,000 checkpoint after jobs 2257361 and 2294313. Evaluation job: 2302255; W&B evaluation run.

Model SHA-256: de9ec1f7f0e47686770361c53b584b932965be2f817e319010fc516008a20441.

The upstream model declares OpenMDW-1.1. This derived repository remains private pending a complete model/data rights review. Beta access does not change that status; the Parakeet repository's license is not a license statement for this Nemotron checkpoint.