> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/curator/v26.09/curate-audio/process-data/asr-inference/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/curator/_mcp/server.

# ASR Inference

## Docs

- [NeMo ASR Models](https://docs.nvidia.com/nemo/curator/v26.09/curate-audio/process-data/asr-inference/nemo-models.md): Guide to using NeMo Framework's pretrained ASR models for speech recognition in audio curation pipelines


> **Note:** This page contains both a page directory (above) and the landing page content (below). The page directory is generated for agent use and does not appear on the landing page.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/curator/v26.09/curate-audio/process-data/asr-inference/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/curator/_mcp/server.

> Run automatic speech recognition with Curator audio adapters

# ASR Inference

Use `ASRStage` to transcribe audio with a supported model adapter.

## Choose an Adapter

The maintained tutorials show complete manifest-to-transcript pipelines for
these adapters:

| Adapter              | Use When                                                | Tutorial                                                                                                                   |
| -------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `NeMoASRAdapter`     | You need an NVIDIA NeMo FastConformer checkpoint.       | [NeMo FastConformer ASR tutorial](https://github.com/NVIDIA-NeMo/Curator/tree/main/tutorials/audio/nemo_fastconformer)     |
| `QwenASRAdapter`     | You need Qwen3-ASR transcription with language routing. | [Qwen3-ASR adapter tutorial](https://github.com/NVIDIA-NeMo/Curator/tree/main/tutorials/audio/qwen_asr)                    |
| `QwenOmniASRAdapter` | You need Qwen3-Omni in-process inference.               | [Qwen3-Omni in-process ASR tutorial](https://github.com/NVIDIA-NeMo/Curator/tree/main/tutorials/audio/qwen_omni_inprocess) |
| `FasterWhisperASR`   | You need Faster-Whisper Large-v3 transcription.         | [Faster-Whisper adapter tutorial](https://github.com/NVIDIA-NeMo/Curator/tree/main/tutorials/audio/faster_whisper)         |

Each tutorial includes its optional dependencies, executor settings, model
defaults, and a runnable command. The examples use GPU inference unless the
tutorial documents a CPU option.

Refer to [NeMo ASR models](/curate-audio/process-data/asr-inference/nemo-models)
for the NeMo model catalog and model-specific guidance.

## Configure the Stage

Set `adapter_target` to the adapter import path and `model_id` to the model
checkpoint. The following example shows the shared stage interface:

```python
from nemo_curator.stages.audio.inference.asr.stage import ASRStage
from nemo_curator.stages.resources import Resources

asr = ASRStage(
    adapter_target="nemo_curator.models.asr.nemo_asr.NeMoASRAdapter",
    model_id="nvidia/stt_en_fastconformer_ctc_large",
    max_audio_sec_per_actor=240.0,
    max_inference_duration_s=120.0,
    local_bucketing=True,
    audio_filepath_key="audio_filepath",
    pred_text_key="pred_text",
    batch_size=16,
    resources=Resources(gpus=1.0),
)
```

Use the adapter-specific tutorial when you need `adapter_kwargs`. Those
settings stay with the adapter that implements them. Set `resources.gpus` to
the number of GPUs each worker receives.

## Provide Input Audio

Each `AudioTask` must provide an audio path under the key configured by
`audio_filepath_key`. The default key is `resampled_audio_filepath`, so place a
`ResampleAudioStage` before `ASRStage`, or point the stage at an existing audio
path. For in-memory audio, set `waveform_key` and provide the sample rate under
`sample_rate_key` (default `sampling_rate`) instead. The stage normalizes either
input to mono at `target_sample_rate` (16 kHz by default) before inference.

For manifest pipelines, each JSONL row can contain an audio path and optional
language metadata:

```json
{"audio_filepath": "/data/sample.wav", "source_lang": "en"}
```

Set `source_lang_key` to use another language field. Set `default_language`
when rows do not contain language metadata. If you set
`supported_language_codes`, rows outside that list remain in the output with a
language skip reason instead of being sent to the adapter.

## Read Output

The stage preserves input metadata and writes the transcript to `pred_text_key`,
which defaults to `pred_text`. With waveform input, the waveform is removed
after inference by default; set `keep_waveform=True` when a downstream stage
needs it. Set `extras_key` to store adapter-specific serializable metadata in
one nested field. The stage can also write these control fields:

| Field                   | Meaning                                                       |
| ----------------------- | ------------------------------------------------------------- |
| `pred_text`             | Transcript text; skipped results can contain an empty string. |
| `_skipme`               | Machine-readable reason for a skipped row.                    |
| `additional_notes`      | Additional stage or adapter diagnostics.                      |
| Configured `extras_key` | Adapter-specific metadata when the adapter returns it.        |

Skipped results remain in the output with `_skipme`. By default, an unreadable
audio file receives an `audio_load_error` skip reason; set
`fail_on_audio_error` to `True` when that audio error must fail the pipeline.
Model loading and adapter inference errors propagate to the pipeline. Inspect
`_skipme` and `additional_notes` before consuming the output manifest.

## Tune Batching and Resources

`batch_size` controls how many candidate rows the backend groups for a call to
`process_batch`. The stage splits recordings longer than
`max_inference_duration_s` into segments, then packs those segments into adapter
calls bounded by `max_audio_sec_per_actor`. Set
`max_audio_sec_per_actor` to control padded adapter-call memory; it must be at
least as large as `max_inference_duration_s`. Use `local_bucketing=True` to
group segments with similar durations and reduce padding. The stage stitches
segment transcripts into one result per input row. Pre-segment files only when
you need application-specific or semantic boundaries. Use the tutorial's
documented CPU configuration when the selected adapter supports CPU inference.