Transformers documentation

Nemotron 3.5 ASR

Transformers

Comenzar

Transformers Instalación Introducción

Clases base

Modelos

Preprocesadores

Inferencia

API de Pipeline

Generar API

Optimización

Chatear con modelos

Servicio

Entrenamiento

Comenzar

Personalización

Ajuste fino eficiente en parámetros

Rendimiento

Entrenamiento distribuido

Hardware

Cuantización

Integraciones del ecosistema

Recursos

API

Clases principales

Modelos

Modelos de texto

Modelos de visión

Modelos de audio

Modelos de video

Modelos multimodales

Modelos de aprendizaje por refuerzo

Modelos de series temporales

Funciones auxiliares internas

Referencia

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).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo fue aportado a Hugging Face Transformers el 27 de junio de 2026.

Nemotron 3.5 ASR

Resumen

Nemotron 3.5 ASR es un modelo de reconocimiento de voz multilingüe de 600M parámetros de NVIDIA, diseñado para transcripciones de alta calidad tanto en configuraciones de streaming de baja latencia como en procesamiento por lotes de alto rendimiento, con puntuación y mayúsculas nativas. Para streaming, ofrece tamaños de bloque configurables—80ms, 160ms, 560ms y 1120ms—lo que permite a los usuarios equilibrar la latencia frente a la precisión según su aplicación. Su arquitectura FastConformer-RNNT consciente de la caché es fundamental para esta capacidad: a diferencia del streaming con búfer tradicional, que reprocesa repetidamente ventanas de audio superpuestas, el modelo procesa solo cada nuevo bloque entrante mientras reutiliza el contexto del codificador en caché de los bloques anteriores. Esto elimina el cálculo redundante, mejora significativamente la eficiencia y minimiza la demora de extremo a extremo sin sacrificar la precisión, lo que lo hace muy adecuado para cargas de trabajo de transcripción en tiempo real.

Uso

Transcripción sin conexión

Pipeline

AutoModel

Transcripción en streaming

Esta es una función experimental y la API está sujeta a cambios.

Para la transcripción en tiempo real, el audio se divide en fragmentos según lo siguiente:

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()

Latencia de streaming

La latencia la establece num_lookahead_tokens, el contexto de atención adecuado (lookahead, en fotogramas de codificador subsampleados) que cada bloque espera antes de ser emitido. Un valor mayor permite que cada bloque vea más audio futuro: mayor precisión a costa de una latencia más alta. Inspecciona los compromisos admitidos, selecciona uno y lee la latencia resultante:

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 define el tamaño de los fragmentos que emite el procesador, y el parámetro correspondiente num_lookahead_tokens debe llegar a generate (en el fragmento anterior, viaja a través de **inputs/**first_chunk_inputs, que transporta num_lookahead_tokens). El generate en streaming lanza una excepción si se omite.

Nemotron3_5AsrConfig

clase transformers.Nemotron3_5AsrConfig

< source >

( 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 )

Parámetros

is_encoder_decoder (bool, opcional, valor predeterminado True) — Indica si el modelo se utiliza como codificador/decodificador o no.
vocab_size (int, opcional, valor predeterminado 13088) — Tamaño del vocabulario de la salida de la red conjunta (incluido el token en blanco).
decoder_hidden_size (int, opcional, valor predeterminado 640) — Tamaño oculto de la red de predicción LSTM (pred_hidden de NeMo).
num_decoder_layers (int, opcional, valor predeterminado 2) — Número de capas LSTM en la red de predicción.
hidden_act (str, opcional, valor predeterminado "relu") — Función de activación en la red conjunta.
max_symbols_per_step (int, opcional, valor predeterminado 10) — Número máximo de símbolos no vacíos emitidos por cada paso de tiempo del codificador durante la decodificación codiciosa.
encoder_config (Union[dict, NemotronAsrStreamingEncoderConfig], opcional) — El objeto de configuración o diccionario del codificador. Reutiliza directamente NemotronAsrStreamingEncoderConfig, ya que el codificador es idéntico al de NemotronAsrStreaming.
pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
blank_token_id (int, opcional, valor predeterminado 13087) — Id del token en blanco para la decodificación RNN-T.
num_prompts (int, opcional, valor predeterminado 128) — Número de ranuras de prompts de lenguaje. El idioma objetivo se codifica como un vector one-hot de este tamaño, que se difunde a lo largo del eje temporal del codificador y se concatena con la salida del codificador antes del MLP de fusión prompt_kernel.
prompt_intermediate_size (int, opcional, valor predeterminado 2048) — Tamaño oculto del MLP de fusión prompt_kernel (Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)).
default_prompt_id (int, opcional, valor predeterminado 101) — Índice de prompt utilizado para condicionar el modelo cuando no se proporciona prompt_ids. El valor predeterminado es el slot de detección de idioma auto (índice 101 en el diccionario de prompts de NeMo), coincidiendo con el valor predeterminado de NeMo de target_lang="auto": el modelo detecta el idioma por sí mismo y emite una etiqueta <xx-XX>.

Esta es la clase de configuración para almacenar la configuración de un Nemotron3_5AsrForRNNT. Se utiliza para instanciar un modelo Nemotron3 5 Asr según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de nvidia/nemotron-3.5-asr-streaming-0.6b

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

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

Nemotron3_5AsrProcessor

clase transformers.Nemotron3_5AsrProcessor

< source >

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

Parámetros

feature_extractor (NemotronAsrStreamingFeatureExtractor) — El extractor de características es una entrada obligatoria.
tokenizer (ParakeetTokenizer) — El tokenizador es una entrada obligatoria.
blank_token (str, opcional, valor predeterminado "<blank>") — Token en blanco para la decodificación RNN-T.
decoder_type (str, opcional) — Modo de decodificación/emisión de marcas de tiempo (p. ej. "ctc", "rnnt", "tdt"). Si es None, el tipo de decodificador se infiere automáticamente por compatibilidad con versiones anteriores.
supported_num_lookahead_tokens (list[int], opcional) — Contextos de atención a la derecha admitidos (lookaheads, en fotogramas de codificador subsampleados), que reflejan NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens. Se utiliza para validar streaming_latency_ms y para derivar el num_lookahead_tokens devuelto.
default_num_lookahead_tokens (int, opcional) — El contexto derecho utilizado cuando no se proporciona streaming_latency_ms. Por defecto, es la primera entrada de supported_num_lookahead_tokens.
prompt_dictionary (dict[str, int], opcional) — Mapeo de una cadena de idioma objetivo (p. ej. "en-US", "de-DE", el código simple "de" o "auto") a su índice de prompt. El valor predeterminado es el diccionario de prompts del checkpoint de NeMo.
num_prompts (int, opcional, valor predeterminado 128) — Número de ranuras de prompts de lenguaje (tamaño del vector one-hot de prompt), que refleja Nemotron3_5AsrConfig.num_prompts.

Construye un Nemotron3_5AsrProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

Nemotron3_5AsrProcessor ofrece todas las funcionalidades de NemotronAsrStreamingFeatureExtractor y ParakeetTokenizer. Consulte ~NemotronAsrStreamingFeatureExtractor y ~ParakeetTokenizer para obtener más información.

decode

< source >

( *argsdurations = None**kwargs )

Pasa los argumentos a decode() y procesa los timestamps a nivel de token (si se proporcionan durations) de la misma manera que en la biblioteca NeMo.

set_num_lookahead_tokens

< source >

( num_lookahead_tokens: int )

Seleccione el contexto de atención adecuado (lookahead, en fotogramas del codificador subsampleados) utilizado para la transmisión en streaming.

Establece default_num_lookahead_tokens, de modo que cada propiedad de streaming derivada (num_mel_frames_first_audio_chunk, num_mel_frames_per_audio_chunk, num_samples_first_audio_chunk, num_samples_per_audio_chunk) se rederive a partir del nuevo valor. num_lookahead_tokens debe ser uno de supported_num_lookahead_tokens.

Pase el mismo num_lookahead_tokens a model.generate para que el contexto derecho de atención utilizado en el forward coincida con los tamaños de bloque generados aquí; de lo contrario, el generate en streaming generará un error.

Nemotron3_5AsrRNNTOutput

clase transformers.Nemotron3_5AsrRNNTOutput

< source >

( 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 )

Parámetros

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
hidden_states (tuple(torch.Tensor), opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de las incrustaciones, si el modelo tiene una capa de incrustación, + uno para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (tuple(torch.Tensor), opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) con forma (batch_size, num_heads, sequence_length, sequence_length).
Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
loss (torch.Tensor, opcional, se devuelve cuando se proporciona labels) — Pérdida del transductor RNN-T.
logits (torch.Tensor de forma (batch_size, encoder_length, decoder_length, vocab_size + 1)) — Puntuaciones de la red conjunta sobre el vocabulario más el símbolo en blanco, para cada par de fotogramas codificador/decodificador.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, opcional) — Caché actualizada del LSTM del decodificador. Se reutiliza en predicciones en blanco para omitir el paso del LSTM.
encoder_past_key_values (Cache, opcional) — Actualizada caché de ventana deslizante de K/V de la atención del codificador, devuelta al codificar audio con use_cache=True (streaming consciente de la caché). Pásala al forward del siguiente fragmento.
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Caché unificada de streaming conv actualizada (subsampling Conv2d + conformer depthwise Conv1d), devuelta al codificar audio con use_cache=True. Pásala al forward del siguiente fragmento.

Nemotron3_5AsrForRNNT

clase transformers.Nemotron3_5AsrForRNNT

< source >

( config: Nemotron3_5AsrConfig )

Parámetros

config (Nemotron3_5AsrConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Nemotron3_5Asr Encoder con una cabeza RNN-T (Recurrent Neural Network Transducer) y condicionamiento de prompt de identificación de idioma.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< source >

( 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)

Parámetros

input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim), opcional) — Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener utilizando feature_extractor_class. Consulte feature_extractor_class.__call__ para más detalles (processor_class utiliza feature_extractor_class para procesar audios).
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
¿Qué son las máscaras de atención?
decoder_input_ids (torch.LongTensor de forma (batch_size, 1), opcional) — ids de tokens de entrada del decodificador para inferencia de un solo paso.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, opcional) — Caché del LSTM del decodificador. Se reutiliza en predicciones en blanco para omitir el paso del LSTM.
use_decoder_cache (bool, opcional) — Si se debe asignar y usar una caché del decodificador cuando no se proporciona ninguna.
encoder_outputs (tuple(torch.Tensor), opcional) — Salidas del codificador precalculadas (last_hidden_state, pooler_output, …).
labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en [0, ..., config.vocab_size] o ser -100 (ver la docstring de input_ids). Los tokens con índices establecidos en -100 se ignoran (enmascarados); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
num_lookahead_tokens (int, opcional) — Contexto de atención a la derecha (lookahead, en fotogramas del codificador subsampleados) que se envía al codificador. Por defecto, config.encoder_config.default_num_lookahead_tokens.
prompt_ids (torch.LongTensor de forma (batch_size,), opcional) — Índices de prompt de lenguaje para la condicionamiento por ID de lenguaje. Generados por el procesador a partir de language. Se convierten en el one-hot de difusión consumido por prompt_projector.

Devuelve

Nemotron3_5AsrRNNTOutput o tuple(torch.Tensor)

Un Nemotron3_5AsrRNNTOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (None) y las entradas.

El método forward de Nemotron3_5AsrForRNNT sobrescribe el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
loss (torch.Tensor, opcional, se devuelve cuando se proporciona labels) — Pérdida del transductor RNN-T.
logits (torch.Tensor de forma (batch_size, encoder_length, decoder_length, vocab_size + 1)) — Puntuaciones de la red conjunta sobre el vocabulario más el símbolo en blanco, para cada par de fotogramas codificador/decodificador.
decoder_cache (Nemotron3_5AsrRNNTDecoderCache, opcional) — Caché actualizada del LSTM del decodificador. Se reutiliza en predicciones en blanco para omitir el paso del LSTM.
encoder_past_key_values (Cache, opcional) — Caché de ventana deslizante de atención K/V del codificador actualizada, devuelta al codificar audio con use_cache=True (streaming consciente de la caché). Pásala al forward del siguiente fragmento.
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Caché unificada actualizada para convoluciones en streaming (Conv2d de subsampling + Conv1d depthwise de conformer), devuelta al codificar audio con use_cache=True. Pásala al forward del siguiente fragmento.

Ejemplo:

>>> 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

< source >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3 Diarization Nemotron 3.5 Transcribe→