Nemotron Asr Finetune

NVIDIAOfficialCreated by Nemotron Speech TeamDistributed by NVIDIA

Skill
Workflow
Data and AI
Apache-2.0
Medium risk
Has scripts

From the author

Orchestration skill for NVIDIA Nemotron Speech (Riva) / NeMo ASR domain and language adaptation. Given a goal like "improve/fine-tune ASR for my domain or language", it scopes the task, picks the cheapest sufficient path (word boosting → n-gram LM → fine-tuning), delegates each stage to the right sub-skill (data generation, training, evaluation, deployment), and answers cost/time/data questions along the way.

— the description by Nemotron Speech Team

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill acts as an intelligent orchestrator for adapting NVIDIA Nemotron Speech (Riva) ASR models to specific domains or languages. Rather than jumping straight to training, it guides users through a cost-effective ladder of customization techniques, starting with word boosting and n-gram language models before escalating to full acoustic fine-tuning. It manages the end-to-end lifecycle by scoping requirements, delegating tasks to specialized sub-skills for data generation, training, evaluation, and deployment, and providing data-driven estimates for time, cost, and hardware requirements.

What it does

Scopes ASR customization goals based on domain, language, and performance targets.
Identifies the cheapest sufficient path for improvement, from word boosting to full fine-tuning.
Delegates execution to specialized sub-skills for data, training, evaluation, and deployment.
Performs pre-flight checks for dataset quality and environment compatibility.
Provides estimates for data volume, GPU requirements, and expected costs.
Maintains a structured workflow to ensure efficient, measurable model adaptation.

When to use it

When you need to improve ASR accuracy for a specific industry domain or jargon.
When you need to adapt an ASR model to a new language.
When you want to reduce Word Error Rate (WER) in noisy environments like call centers.
When you need to plan a cost-effective ASR customization strategy.
When you are unsure whether to use word boosting, language models, or full fine-tuning.

Advantages

Prevents unnecessary, expensive training by prioritizing cheaper, effective methods first.
Ensures a structured, repeatable approach to model adaptation.
Provides clear guidance on hardware selection and data requirements.
Reduces risk of catastrophic forgetting by enforcing data volume and mixing best practices.
Centralizes planning while leveraging specialized sub-skills for execution.

Usage examples

“I need to improve ASR accuracy for my medical domain, it gets jargon wrong.”: The agent will scope the jargon issues, suggest a word-boosting pilot to test offline, and outline the data requirements for potential fine-tuning if boosting is insufficient.
“How much data do I need to fine-tune an ASR model for a new language?”: The agent will explain the requirements for cross-language transfer versus training from scratch, emphasizing the need for real audio and providing a data-volume estimate.
“What is the cheapest way to improve my ASR model's performance?”: The agent will initiate a diagnostic process to measure the baseline WER and recommend the lowest-cost rung on the customization ladder, such as word boosting or n-gram LM.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/nemotron-asr-finetune/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip nemotron-asr-finetune.zip -d .agents/skills

Documentation by Nemotron Speech Team

Nemotron Speech ASR Customization — Orchestration Skill

Note: "Nemotron Speech" is the public-facing name for what NVIDIA documents today as Riva / Riva NIM; the acoustic models are trained and fine-tuned with NVIDIA NeMo. Commands, config paths, imports, and doc URLs still use "Riva" / "NeMo" — the rename is brand-only. Do not rename them.

What This Skill Is

This is a high-level orchestration skill, not a step-by-step training manual. Its job, given a goal such as "I want to fine-tune ASR for my domain/language", is to:

Scope the problem (how much real audio, target eval set, latency/hardware budget, language/domain).
Choose the cheapest sufficient path — word boosting, n-gram LM fusion, or fine-tuning — and escalate only when quality falls short.
Delegate each stage to the right sub-skill (data generation, training, evaluation, deployment/optimization).
Answer cost/time/data questions along the way (how many hours to hit X% WER, synthetic vs real, L40S vs H100, expected cost).

It owns the plan and the routing; the sub-skills own the execution. When a needed sub-skill does not exist yet, this skill names it as a placeholder and gives interim guidance.

When to Use

Use for any request to make a Nemotron Speech / Riva ASR model work better on a specific domain or language — improving accuracy, reducing WER, adding a language, or planning a fine-tune. Start here even when the user names a specific technique: treat it as a candidate until the orchestration step confirms it is the cheapest sufficient path, then sequence the right sub-skills.

Orchestration Workflow

Run the loop below; each stage names the sub-skill it invokes. Full detail in references/workflow.md.

#	Stage	What happens	Sub-skill
1	State the goal	Capture the target: domain/language, the errors, the metric.	Orchestration (this skill)
2	Clarify & scope	Ask the discovery questions: how much real audio? target eval set? latency/HW budget? deployment target?	Orchestration
3	Choose the path	Pick the cheapest sufficient rung (boosting → n-gram LM → fine-tune). Escalate only if quality is short; experiment while proposing the full plan.	Orchestration → Research/Training
4	Get the data right	If data is scarce/noisy: synthetic (TTS), TTS-friendly formatting, noise profiling/harvest, blend, score vendor samples; align customer data to training format; flag missing real data.	SDG / Data
5	Train	Apply the recipe (configs, hyperparameters, replay/curriculum, GPU/OOM preflight) and run.	Research / Training
6	Evaluate	Normalized WER on the domain set + A/B forgetting check on a general set; error-driven analysis to find the next lever.	Evaluation
7	Loop or ship	If short of target, loop to 4/5 with targeted data; else select/average checkpoints. Consult the user before more cycles.	Orchestration
8	Deploy	Export to NIM/HF, hot-swap the checkpoint, serve.	Deployment / Optimization

Stages 4–8 are the fine-tune path (data → NeMo train → NeMo eval → Riva deploy). Cheaper rungs (boosting, custom vocab, n-gram LM) take a shorter branch owned by a single sub-skill — don't force them through the full loop. See the branch-by-rung table in references/workflow.md (§3b).

Before training (Stage 5), run the pre-flight dataset quality check (§4a): verify/convert audio to 16 kHz, and, on user request, audit transcript quality by running a reference pretrained model and checking WER against the provided ground truth. See references/workflow.md §4a.

Also before training (Stage 5), run the pre-flight environment/dependency check (§4b): if no NeMo is provided, pull the latest main (local execution) or the latest published container tag (container execution). If a NeMo checkout/install is already provided, check its version, but still recommend switching to latest main (staleness risk) and ask the user — if they insist on the provided one, proceed with it and only revisit once a concrete version issue (e.g. unsupported functionality) is actually hit. See references/workflow.md §4b.

Throughout, answer the "along the way" questions (data volume, synthetic vs real, hours to reach a WER target, cost, GPU choice) — see references/planning-answers.md.

Sub-Skills This Skill Calls

Detailed registry, invocation, and handoff contracts in references/sub-skills.md.

Role (per the architecture)	Purpose	Sub-skill to invoke
Research / Training	NeMo configs, recipes, fine-tuning, checkpoint averaging; also owns the NeMo-side word-boosting and n-gram LM pilots	`nemo-speech-asr-finetune`
SDG / Data Designer	Synthetic transcripts/text, noise profiling, vendor-data impact, blends	`data-designer` (synthetic text; audio via TTS in `nemotron-speech`); placeholder: `asr-data-profiling`
Evaluation	Normalized WER, A/B forgetting, error analysis	Offline file WER → `nemo-speech-asr-finetune`; served-endpoint WER → `nemotron-speech`
Deployment / Optimization	NIM/Riva export, checkpoint swap, NIM-build optimization, serving	`nemotron-speech`

If a sub-skill is unavailable, say so, give the interim guidance from the reference, and continue the plan.

Choosing The Path (cheapest first)

The scoping in Stage 3 selects the lowest-cost rung that can meet the target. Summary; full docs-grounded ladder in references/path-selection.md.

Word boosting — a bounded set of known words/names/jargon. Two realizations that are different artifacts: pilot (NeMo) to prove lift offline via GPU-PB context biasing (nemo-speech-asr-finetune), or deploy (Riva) to ship it via runtime boosted_lm_score (nemotron-speech) — different score systems, don't reuse one for the other. Runtime, no training either way. See references/path-selection.md.
Custom vocabulary / pronunciation — OOV or consistently mispronounced terms. Deploy-time. → Deployment sub-skill.
N-gram (KenLM) LM — domain phrasing/word-sequences when you have text but little audio. Two realizations, built the same way but deployed differently by architecture: pilot (NeMo, NGPU-LM) to prove lift offline (nemo-speech-asr-finetune), or deploy (Riva) to ship it (nemotron-speech). For CTC, rebuild the pilot corpus into a Riva word-level LM — don't ship the pilot artifact as-is. For RNN-T/TDT, the opposite: hand the pilot's .nemo artifact to Riva unchanged, no rebuild. See references/path-selection.md.
Fine-tune — real acoustic gaps (accents, noise, channel) with enough transcribed audio (NIM guide: 100+ h; ~10 h floor only if mixed to avoid catastrophic forgetting). Below ~10 h, do not recommend fine-tuning — recommend word boosting instead (severe catastrophic-forgetting/overfitting risk). → Research/Training.
Train from scratch / cross-language transfer — a new language with no suitable checkpoint (last resort). → Research/Training.

Ordering and per-model support follow the NVIDIA Speech NIM ASR customization guide: https://docs.nvidia.com/nim/speech/latest/asr/customization/customization.html.

Key Principles

Scope before you pick. Don't recommend fine-tuning before the discovery questions and a measured baseline.
Cheapest sufficient path. Escalate rungs only when the current one provably can't hit the target; you may experiment on a cheap rung while presenting the full fine-tuning plan.
Measure with a contract. Report normalized WER on the domain set plus an A/B forgetting check on a general set — never in-training logs alone.
Verify before you train. Run the pre-flight dataset quality check before Stage 5: verify/convert audio to 16 kHz, and, when the user asks, audit ground-truth transcripts by comparing them to a reference model's WER. Don't train on an unresampled or unaudited-on-request dataset. See references/workflow.md §4a.
Know your environment before you train. If no NeMo is provided, pull the latest main (or latest published container tag). If one is provided, check its version but still recommend latest main and ask the user first — a provided checkout always carries staleness risk. If they insist on keeping it, don't pull preemptively; only revisit once a concrete version issue (e.g. unsupported functionality) is actually hit. Record what was resolved in the ledger. See references/workflow.md §4b.
Delegate, don't reimplement. Route execution to the sub-skills; keep this skill focused on the plan, sequencing, and cost/time/data answers.
Real target-domain audio is the usual bottleneck. Prefer real data; use synthetic to fill measured gaps, kept separately weighted so it can be ablated.
Consult the user before extra tuning cycles, and when a needed sub-skill is a placeholder.

Source of Truth

Topic	Location
NIM Speech docs home	https://docs.nvidia.com/nim/speech/latest/index.html
ASR customization guide (methods, per-model support)	https://docs.nvidia.com/nim/speech/latest/asr/customization/customization.html
ASR support matrix (models & features)	https://docs.nvidia.com/nim/speech/latest/reference/support-matrix/asr.html
NeMo fine-tuning (flags/config)	`docs/source/asr/fine_tuning.rst`, and the `nemo-speech-asr-finetune` sub-skill
Riva ASR tutorials (boosting, LM, fine-tune)	https://github.com/nvidia-riva/tutorials
Tokenizer extension to new language + acoustic fine-tune	https://github.com/nvidia-riva/tutorials/blob/main/asr-extend-tokenizer-to-newlang-ft-acoustic-model.ipynb

Limitations

Orchestration only — execution happens in the sub-skills. Where a sub-skill is a placeholder, guidance is interim until it exists.
GPU required for the training rungs; deployment/serving is owned by the nemotron-speech sub-skill.
Model names, config paths, flags, and per-model feature support drift across NeMo/Riva releases — verify against the support matrix and the current checkout.
Public branding is "Nemotron Speech"; commands, imports, config paths, and doc URLs still use "Riva" / "NeMo" — do not rename.

Files

ATTRIBUTION.mdAdded by AutoGineer935 B
BENCHMARK.md10.7 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md11.6 KiB
assets/experiment-ledger-template.md3.5 KiB
evals/EVAL.md8.7 KiB
evals/evals.json20.4 KiB
references/path-selection.md14.8 KiB
references/planning-answers.md3.3 KiB
references/sub-skills.md10.8 KiB
references/workflow.md19.9 KiB
scripts/link-nemo-subskill.shScript3.6 KiB
scripts/main.pyScript10.9 KiB
skill-card.md4.9 KiB
skill.oms.sig6.3 KiB

references/sub-skills.md

Sub-Skill Registry

The orchestrator delegates execution to these sub-skills. Each entry gives the role (from the ASR customization architecture), the skill to invoke, what to hand it, what it returns, and the fallback when it is a placeholder (not yet available). Invoke a sub-skill with the Skill tool by its name; if unavailable, tell the user, give the interim guidance, and continue.

Research / Training

Invoke: nemo-speech-asr-finetune (NeMo ASR fine-tuning: container setup, checkpoint selection, Lhotse data, tokenizer, training, checkpoint averaging, and the eval stage).
Hand it: the chosen path, checkpoint/family, style-audited train/val/test manifests, constraints (streaming/offline, precision, GPU budget), and any blend/replay requirement.
Returns: trained/averaged .nemo checkpoint(s) and in-training val_wer.
Notes: owns all exact NeMo flags/config paths and model-family recipes (CTC/RNNT/TDT/hybrid/AED, plain vs prompted cache-aware streaming). Also holds the "recipes / best-practice knowledge base." (Do not route ASR training to nemotron-customize — that skill is for Nemotron LLM customization, not speech.)
Also owns the n-gram LM pilot (offline only, NGPU-LM): build a subword KenLM with train_kenlm.py (save_nemo=True) and score via speech_to_text_eval.py's GPU shallow fusion — CTC uses ctc_decoding.*, RNN-T/TDT uses rnnt_decoding.* (no CTC-only script substitutes for RNNT; eval_beamsearch_ngram_ctc.py is a CTC-only grid-search convenience tool, not the general path). CTC also has a second, older NeMo-side mechanism — its own Flashlight decoder (word-level KenLM + lexicon). Whether a pilot artifact ships to nemotron-speech unchanged depends on architecture and which pilot mechanism was used, not a blanket rule: the NGPU-LM .nemo artifact is subword-tokenized, so it definitely needs the corpus rebuilt into a Riva word-level LM for CTC — confirmed. Whether the Flashlight mechanism's own word-level KenLM + lexicon can be reused as-is for CTC is unverified, not a confirmed rebuild either way. RNNT hands the exact same NGPU-LM pilot .nemo file straight to nemotron-speech, confirmed. See the n-gram Rung Note in path-selection.md.
Also owns the word-boosting pilot (offline only, GPU-PB context biasing): decode-time shallow fusion via a GPU-accelerated boosting tree — no retraining. CTC uses ctc_decoding.*.boosting_tree, RNN-T/TDT uses rnnt_decoding.*.boosting_tree, both via speech_to_text_eval.py, weighted by boosting_tree_alpha; optionally pre-built with scripts/asr_context_biasing/build_gpu_boosting_tree.py. This uses a different score system (context_score/depth_scaling/boosting_tree_alpha) than Riva's boosted_lm_score — a NeMo pilot result does not hand off a reusable score to nemotron-speech, only a validated phrase list and confidence that boosting helps. See the word-boosting Rung Note in path-selection.md.
Setup — this sub-skill is not catalog-published. Unlike the other sub-skills, nemo-speech-asr-finetune is a project-local Claude Code skill living inside the NeMo/Speech repo itself (.claude/skills/nemo-speech-asr-finetune/), not the nvidia-skills catalog — every command in it is a path relative to that repo's root, so it only works when reachable from inside (or linked to) an actual checkout. Do not assume it is invocable just because it was named here. Before handing off to it:
1. Try the standard installer first: npx skills add NVIDIA-NeMo/Speech --skill nemo-speech-asr-finetune --agent claude-code --global --yes. Unverified whether the installer supports arbitrary repos beyond the nvidia/skills catalog — test it before relying on it.
2. If that doesn't work, fall back to the bundled ../scripts/link-nemo-subskill.sh <checkout_path> — validates the source, refuses to clobber an existing real directory, and records the real repo root so it can be found reliably afterward.
3. Either way, see workflow.md §4b for resolving the checkout in the first place, and for the required step of changing the working context into that checkout before Stage 5 actually runs any of this sub-skill's commands — linking it only makes it discoverable, not runnable.

SDG / Data Designer

Invoke: data-designer (or the NeMo-platform variant nemo-data-designer-plugin) to build synthetic text datasets — domain term lists, target-style transcripts, and prompts. It generates text/tabular data, not audio.
For synthetic audio: turn that text into speech with a TTS model. nemotron-speech can run TTS inference (e.g. Magpie) to synthesize audio, but it is a NIM deploy/run skill, so this is a heavier step than text generation — scope whether synthetic audio is actually needed before committing.
Hand it: the domain/language, target transcript style, required volume, and formats of any vendor/customer data.
Returns: synthetic transcripts/text (data-designer) and, if used, synthesized audio (via TTS).
Placeholder — asr-data-profiling: noise profiling, in-domain noise harvest, vendor-data impact analysis, and assembling (audio, transcript) manifests are not yet a dedicated skill. Interim: profile audio (sample rate, SNR, duration/tps distributions), harvest realistic in-domain noise, score vendor samples with the current model, align format, and keep synthetic sources separately weighted. Flag missing real target-domain data explicitly.
Owns the pre-flight sample-rate audit/conversion (see workflow.md §4a) as part of format alignment: verify every file is 16 kHz and resample offline (sox/ffmpeg) any file that is not, before handing the manifest to training.

Evaluation

Evaluation has two surfaces — route to the one that matches the branch (see workflow.md §3b/§6):

Offline file WER (a .nemo/.riva checkpoint, before serving) — Invoke: nemo-speech-asr-finetune's evaluation stage: standalone WER/CER via speech_to_text_eval.py (default contract: lowercased, punctuation removed) and cache-aware streaming eval; the n-gram pilot (NGPU-LM) uses this same script's ctc_decoding.*.ngram_lm_model/rnnt_decoding.*.ngram_lm_model overrides, and the word-boosting pilot uses its ctc_decoding.*.boosting_tree/rnnt_decoding.*.boosting_tree overrides.
- Hand it: the checkpoint(s), the domain eval set, and a general guardrail set.
- Returns: normalized domain WER and per-variant comparisons; the orchestrator computes the general-set forgetting delta and the error-category breakdown from these to pick the next lever.
Served-endpoint WER (a client scoring a running NIM, for any served rung: boosting, custom vocab, n-gram LM deploy, or a fine-tune after deploy) — owned by nemotron-speech (it serves the NIM; score it with the riva client). Use this for the deployed before/after — the served decoder can differ from the in-NeMo result.
Note: nemo-evaluator-plugin is a NeMo Platform eval CLI for served endpoints/LLM-style metrics, not ASR WER — do not route ASR accuracy evaluation there.
Also reused pre-training: the pre-flight transcript-quality audit (workflow.md §4a) uses this same WER tooling — offline via nemo-speech-asr-finetune or served via nemotron-speech — but scores a stock pretrained reference checkpoint against the provided ground truth, not a fine-tune checkpoint against a held-out set. Same mechanism, different purpose: flagging bad labels before training, not measuring a trained model.

Deployment / Optimization

Invoke: nemotron-speech (Riva NIM: export nemo2riva, riva-build/riva-deploy, pipeline config, and serving). This is also where runtime/decoding customizations (word boosting, custom vocab/pronunciation, n-gram LM at decode, ITN, VAD, diarization) and any NIM build-time optimization live — exact riva-build flags and LM file formats are documented there (references/pipelines.md's Language Models section), not duplicated here. It owns the deploy realization of word boosting end-to-end — per-request, no build step, no dependency on the NeMo pilot — and the deploy realization of the n-gram LM, which differs by architecture: CTC's NGPU-LM path needs a rebuilt Riva-format LM — confirmed, since that pilot artifact is subword-tokenized (whether the Flashlight-pilot's own word-level KenLM + lexicon can be reused as-is is unverified — see path-selection.md); RNNT reuses the NeMo pilot's .nemo artifact directly, no rebuild step, confirmed. Owns the served-endpoint WER for both.
Hand it: the source model (a deployable .riva when only doing decode-time changes, else the evaluated .nemo), the target hardware/latency, and any runtime customization list (boost words, LM, vocab) recommended in path selection.
Artifact typing (n-gram LM) — differs by architecture, confirm which applies before handoff:
- CTC: nemotron-speech consumes a Riva word-level LM, not a subword one — see references/pipelines.md for the exact format/flags. Never hand it the NeMo subword pilot LM for CTC — it will not decode correctly (rebuild for Riva from the same corpus).
- RNN-T/TDT: the opposite — hand nemotron-speech the pilot's .nemo NGPU-LM artifact (from train_kenlm.py ... save_nemo=True) unchanged — see references/pipelines.md for the exact flags. Do not rebuild it into a CTC-style word-level form; that's not what the RNNT deploy path expects. Deploy-side prerequisites nemotron-speech owns: .nemo→.riva via a version-matched nemo2riva (or start from a deployable .riva), and NIM images ship different riva-build CLIs (classic rejects .nemo; Hydra accepts it) — verify before choosing the ingestion path.
Returns: a deployed/served NIM, runtime configuration, and served-endpoint WER.
Note: ASR export/serving optimization is part of the NIM build in nemotron-speech; do not route it to nemotron-customize (Nemotron LLM customization/ModelOpt), which does not apply to speech models.

Ownership / provenance (for maintainers)

The architecture assigns owners per box — Research/Training (Research), SDG/Data (Data Designer + Eng), Evaluation (Research/Eng), Deployment/Optimization (Skills/NIM). Keep this registry updated as placeholder skills are published so routing points at the real name rather than interim guidance. A working analog of this orchestration pattern is the Clinical ASR Flywheel (digital-health-clinical-asr-*: setup → build → eval → finetune), read from those skills' frontmatter.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Nemotron Speech Team

Publisher

NVIDIA (Official)

Distributed by

NVIDIA

Source

NVIDIA/skills · skills/nemotron-asr-finetune · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Nemotron Speech Team or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nemotron-asr-finetune.zip