Hugging Face's logo

Transformers documentation

Nemotron 3.5 ASR

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2026-06-27.

Nemotron 3.5 ASR

Aperçu

Nemotron 3.5 ASR est un modèle de reconnaissance vocale multilingue de 600 millions de paramètres développé par NVIDIA, conçu pour une transcription de haute qualité dans des configurations à faible latence en flux continu et à haut débit par lots, avec une ponctuation et une majuscule natives. Pour le flux continu, il propose des tailles de blocs configurables—80 ms, 160 ms, 560 ms et 1120 ms—permettant aux utilisateurs d'ajuster le compromis entre latence et précision selon leur application. Son architecture FastConformer-RNNT sensible au cache est au cœur de cette capacité : contrairement au flux continu par tampon traditionnel, qui re-traite de manière répétée des fenêtres audio superposées, le modèle ne traite que chaque nouveau bloc entrant tout en réutilisant le contexte encodeur mis en cache des blocs précédents. Cela élimine les calculs redondants, améliore considérablement l'efficacité et minimise la latence de bout en bout sans sacrifier la précision, ce qui le rend particulièrement adapté aux charges de travail de transcription en temps réel.

Utilisation

Transcription hors ligne

Pipeline
AutoModel
from transformers import pipeline

pipe = pipeline(
    "automatic-speech-recognition",
    model="nvidia/nemotron-3.5-asr-streaming-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)

Le pipeline utilise le prompt de langue par défaut (index 0, en-US). Pour un conditionnement explicite de la langue ou une détection automatique, passez l'argument language du processeur (voir l'onglet AutoModel).

Transcription en streaming

Il s'agit d'une fonctionnalité expérimentale et l'API est susceptible d'évoluer.

Pour la transcription en temps réel, l’audio est découpé en segments selon :

from threading import Thread
from transformers import AutoModelForRNNT, AutoProcessor, TextIteratorStreamer
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

processor.set_num_lookahead_tokens(6)
print(f"Streaming latency: {processor.streaming_latency_ms} ms")

# The language prompt rides along on every chunk; use a locale (e.g. "de-DE") or "auto".
language = "en-US"

sampling_rate = processor.feature_extractor.sampling_rate
audio = load_audio(
    "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/obama.mp3",
    sampling_rate=sampling_rate,
)

first_chunk_inputs = processor(
    audio[: processor.num_samples_first_audio_chunk],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=True,
    language=language,
    return_tensors="pt",
)
first_chunk_inputs = first_chunk_inputs.to(model.device, dtype=model.dtype)


def input_features_generator():
    yield first_chunk_inputs.input_features[:, : processor.num_mel_frames_first_audio_chunk, :]

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    n_fft = processor.feature_extractor.n_fft

    start_idx = mel_frame_idx * hop_length - n_fft // 2
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
            language=language,
            return_tensors="pt",
        )
        inputs = inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.num_mel_frames_per_audio_chunk
        start_idx = mel_frame_idx * hop_length - n_fft // 2


streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True)
generate_kwargs = {
    **first_chunk_inputs,
    "input_features": input_features_generator(),
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)
thread.join()

Latence de streaming

La latence est définie par num_lookahead_tokens, le contexte d’attention adéquat (lookahead, dans les trames d’encodeur sous-échantillonnées) que chaque bloc attend avant d’être émis. Une valeur plus élevée permet à chaque bloc de voir plus d’audio futur : meilleure précision au prix d’une latence plus élevée. Inspectez les compromis pris en charge, sélectionnez-en un, puis lisez la latence résultante :

from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-3.5-asr-streaming-0.6b")

# Each supported `num_lookahead_tokens` mapped to its streaming latency in milliseconds:
print(processor.supported_streaming_latencies_ms)
# {3: 320, 0: 80, 6: 560, 13: 1120}

# Select a right attention context (this also re-derives the streaming chunk sizes used above):
processor.set_num_lookahead_tokens(6)

# Latency of the current selection:
print(processor.streaming_latency_ms)
# 560

set_num_lookahead_tokens détermine la taille des blocs émis par le processeur, et le num_lookahead_tokens correspondant doit parvenir à generate (dans l’exemple ci-dessus, il transite par **inputs/**first_chunk_inputs, qui transporte num_lookahead_tokens). Le generate en streaming lève une erreur s’il est omis.

Nemotron3_5AsrConfig

classe transformers.Nemotron3_5AsrConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 13088decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 0blank_token_id: int = 13087num_prompts: int = 128prompt_intermediate_size: int = 2048default_prompt_id: int = 101 )

Paramètres

  • is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
  • vocab_size (int, facultatif, par défaut 13088) — Taille du vocabulaire de la sortie du réseau conjoint (y compris le jeton vide).
  • decoder_hidden_size (int, facultatif, valeur par défaut 640) — Taille cachée du réseau de prédiction LSTM (pred_hidden de NeMo).
  • num_decoder_layers (int, facultatif, valeur par défaut 2) — Nombre de couches LSTM dans le réseau de prédiction.
  • hidden_act (str, facultatif, par défaut "relu") — Fonction d'activation dans le réseau conjoint.
  • max_symbols_per_step (int, facultatif, valeur par défaut 10) — Nombre maximal de symboles non vides émis par pas de temps de l’encodeur lors du décodage glouton.
  • encoder_config (Union[dict, NemotronAsrStreamingEncoderConfig], facultatif) — L’objet de configuration ou le dictionnaire de l’encodeur. Réutilise directement NemotronAsrStreamingEncoderConfig, puisque l’encodeur est identique à celui de NemotronAsrStreaming.
  • pad_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • blank_token_id (int, facultatif, valeur par défaut 13087) — Identifiant du jeton vide pour le décodage RNN-T.
  • num_prompts (int, facultatif, valeur par défaut 128) — Nombre de slots de prompts de langue. La langue cible est encodée sous forme de vecteur one-hot de cette taille, diffusée sur l’axe temporel de l’encodeur et concaténée avec la sortie de l’encodeur avant le MLP de fusion prompt_kernel.
  • prompt_intermediate_size (int, facultatif, par défaut 2048) — Taille cachée du MLP de fusion prompt_kernel (Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)).
  • default_prompt_id (int, facultatif, par défaut 101) — Index de prompt utilisé pour conditionner le modèle lorsque prompt_ids n’est pas fourni. Par défaut, il correspond à l’emplacement de détection de langue auto (index 101 dans le dictionnaire de prompts NeMo), ce qui est cohérent avec la valeur par défaut de NeMo, target_lang="auto" : le modèle détecte lui-même la langue et émet un tag <xx-XX>.

Ceci est la classe de configuration destinée à stocker la configuration d'un Nemotron3_5AsrForRNNT. Elle est utilisée pour instancier un modèle Nemotron 3.5 Asr en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nvidia/nemotron-3.5-asr-streaming-0.6b

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

>>> configuration = Nemotron3_5AsrConfig()
>>> model = Nemotron3_5AsrForRNNT(configuration)
>>> configuration = model.config

Nemotron3_5AsrProcessor

classe transformers.Nemotron3_5AsrProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'decoder_type = Nonesupported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = Noneprompt_dictionary = Nonenum_prompts = 128 )

Paramètres

  • feature_extractor (NemotronAsrStreamingFeatureExtractor) — L'extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (ParakeetTokenizer) — Le tokenizer est une entrée obligatoire.
  • blank_token (str, facultatif, par défaut "<blank>") — Jeton vide pour le décodage RNN-T.
  • decoder_type (str, facultatif) — Mode de décodage/émission des horodatages (par ex. "ctc", "rnnt", "tdt"). Si None, le type de décodeur est inféré automatiquement pour la compatibilité ascendante.
  • supported_num_lookahead_tokens (list[int], facultatif) — Contextes d'attention à droite pris en charge (lookaheads, dans les trames d'encodeur sous-échantillonnées), reflétant NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens. Utilisé pour valider streaming_latency_ms et pour dériver le num_lookahead_tokens renvoyé.
  • default_num_lookahead_tokens (int, facultatif) — Le contexte droit utilisé lorsque streaming_latency_ms n’est pas fourni. Par défaut, il s’agit de la première entrée de supported_num_lookahead_tokens.
  • prompt_dictionary (dict[str, int], facultatif) — Correspondance entre une chaîne de caractères de langue cible (par ex. "en-US", "de-DE", le code seul "de", ou "auto") et son index de prompt. Par défaut, le dictionnaire de prompts du point de contrôle NeMo est utilisé.
  • num_prompts (int, facultatif, valeur par défaut 128) — Nombre de slots de prompts de langue (taille du vecteur one-hot de prompt), reflétant Nemotron3_5AsrConfig.num_prompts.

Construit un Nemotron3_5AsrProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

Nemotron3_5AsrProcessor offre toutes les fonctionnalités de NemotronAsrStreamingFeatureExtractor et de ParakeetTokenizer. Consultez ~NemotronAsrStreamingFeatureExtractor et ~ParakeetTokenizer pour plus d’informations.

décoder

< >

( *argsdurations = None**kwargs )

Transmet les arguments à decode() et post-traite les horodatages au niveau des jetons (si durations sont fournis), comme dans la bibliothèque NeMo.

set_num_lookahead_tokens

< >

( num_lookahead_tokens: int )

Sélectionnez le contexte d'attention approprié (anticipation, dans les trames d'encodeur sous-échantillonnées) utilisé pour le streaming.

Définit default_num_lookahead_tokens, de sorte que chaque propriété de streaming dérivée (num_mel_frames_first_audio_chunk, num_mel_frames_per_audio_chunk, num_samples_first_audio_chunk, num_samples_per_audio_chunk) est recalculée à partir de la nouvelle valeur. num_lookahead_tokens doit être l'un des éléments de supported_num_lookahead_tokens.

Transmettez la même valeur de num_lookahead_tokens à model.generate afin que le contexte droit de l’attention utilisé dans le forward corresponde aux tailles de blocs produites ici ; sinon, le generate en streaming lève une erreur.

Nemotron3_5AsrRNNTOutput

classe transformers.Nemotron3_5AsrRNNTOutput

< >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneloss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedecoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

Paramètres

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.
  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire à travers les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement à travers une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • loss (torch.Tensor, facultatif, renvoyé lorsque labels est fourni) — Perte du transducteur RNN-T.
  • logits (torch.Tensor de forme (batch_size, encoder_length, decoder_length, vocab_size + 1)) — Scores du réseau conjoint sur le vocabulaire plus le symbole vide, pour chaque paire de trames encodeur/décodeur.
  • decoder_cache (Nemotron3_5AsrRNNTDecoderCache, facultatif) — Mise à jour du cache LSTM du décodeur. Réutilisé lors des prédictions vides pour passer l’étape LSTM.
  • encoder_past_key_values (Cache, facultatif) — Mise à jour du cache de fenêtre glissante des K/V de l’attention de l’encodeur, renvoyée lors de l’encodage d’audio avec use_cache=True (streaming conscient du cache). À transmettre au forward du prochain fragment.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) — Mise à jour du cache de convolution unifié pour le streaming (Conv2d de sous-échantillonnage + Conv1d en profondeur du conformer), renvoyé lors de l’encodage audio avec use_cache=True. À transmettre au forward du chunk suivant.

Nemotron3_5AsrForRNNT

classe transformers.Nemotron3_5AsrForRNNT

< >

( config: Nemotron3_5AsrConfig )

Paramètres

  • config (Nemotron3_5AsrConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Encodeur Nemotron3_5Asr avec une tête RNN-T (Recurrent Neural Network Transducer) et un conditionnement par prompt d'identification de la langue.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.modeling_outputs.BaseModelOutputWithPooling | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = Noneprompt_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Nemotron3_5AsrRNNTOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de feature_extractor_class. Consultez feature_extractor_class.__call__ pour plus de détails (processor_class utilise feature_extractor_class pour le traitement des audios).
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • decoder_input_ids (torch.LongTensor de forme (batch_size, 1), facultatif) — Identifiants des jetons d’entrée du décodeur pour une inférence en une étape.
  • decoder_cache (Nemotron3_5AsrRNNTDecoderCache, facultatif) — Cache du LSTM du décodeur. Réutilisé lors des prédictions vides pour passer l’étape du LSTM.
  • use_decoder_cache (bool, facultatif) — Indique s'il faut allouer et utiliser un cache de décodeur lorsqu'aucun n'est fourni.
  • encoder_outputs (tuple(torch.Tensor), facultatif) — Sorties de l’encodeur précalculées (last_hidden_state, pooler_output, …).
  • labels (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [0, ..., config.vocab_size] ou -100 (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].
  • num_lookahead_tokens (int, facultatif) — Contexte d'attention à droite (lookahead, en trames d'encodeur sous-échantillonnées) transmis à l'encodeur. Valeur par défaut : config.encoder_config.default_num_lookahead_tokens.
  • prompt_ids (torch.LongTensor de forme (batch_size,), facultatif) — Indices de prompt de langue pour le conditionnement par identifiant de langue. Générés par le processeur à partir de language. Convertis en one-hot diffusé, consommé par prompt_projector.

Retourne

Nemotron3_5AsrRNNTOutput ou tuple(torch.Tensor)

Un Nemotron3_5AsrRNNTOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de Nemotron3_5AsrForRNNT redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • loss (torch.Tensor, facultatif, renvoyé lorsque labels est fourni) — Perte du transducteur RNN-T.

  • logits (torch.Tensor de forme (batch_size, encoder_length, decoder_length, vocab_size + 1)) — Scores du réseau conjoint sur le vocabulaire plus le symbole vide, pour chaque paire de trames encodeur/décodeur.

  • decoder_cache (Nemotron3_5AsrRNNTDecoderCache, facultatif) — Cache LSTM du décodeur mis à jour. Réutilisé lors des prédictions vides pour passer l’étape LSTM.

  • encoder_past_key_values (Cache, facultatif) — Mise à jour du cache de fenêtre glissante des K/V de l’attention de l’encodeur, renvoyée lors de l’encodage d’audio avec use_cache=True (streaming conscient du cache). À transmettre au forward du chunk suivant.

  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, facultatif) — Cache unifié de convolution streaming mis à jour (Conv2d de sous-échantillonnage + Conv1d en profondeur du conformer), renvoyé lors de l’encodage audio avec use_cache=True. Transmettez-le au forward du chunk suivant.

Exemple :

>>> from transformers import AutoProcessor, Nemotron3_5AsrForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5AsrForRNNT.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"], language="en-US")
>>> outputs = model(**inputs)

generate

< >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3 Diarization Nemotron 3.5 Transcribe→