Hugging Face's logo

Transformers documentation

Nemotron ASR Streaming

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

Este modelo se publicó en HF papers el 2023-05-08 y se contribuyó a Hugging Face Transformers el 2026-06-18.

Nemotron ASR Streaming

Resumen

Nemotron ASR Streaming es un modelo de reconocimiento de voz en inglés de 600 millones de parámetros de NVIDIA, diseñado para transcripciones de alta calidad tanto en configuraciones de streaming de baja latencia como en lotes de alto rendimiento, con puntuación y mayúsculas nativas. Para streaming, ofrece tamaños de fragmento configurables: 80 ms, 160 ms, 560 ms y 1120 ms, 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 fragmento entrante mientras reutiliza el contexto del codificador en caché de los fragmentos 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
from transformers import pipeline

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

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-speech-streaming-en-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")

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,
    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,
            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-speech-streaming-en-0.6b")

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

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

NemotronAsrStreamingConfig

clase transformers.NemotronAsrStreamingConfig

< >

( 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 = 1025decoder_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 = 1024 )

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 1025) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
  • decoder_hidden_size (int, opcional, valor predeterminado 640) — Tamaño oculto de la red de predicción LSTM (el pred_hidden de NeMo). La red conjunta proyecta tanto las salidas del codificador como las del decodificador a este tamaño (el joint_hidden de NeMo, que todos los puntos de control conocidos establecen igual a pred_hidden).
  • 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 el diccionario del codificador.
  • 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 1024) — Id del token en blanco. Difiere de pad_token_id para RNN-T.

Esta es la clase de configuración para almacenar la configuración de un NemotronAsrStreamingForRNNT. Se utiliza para instanciar un modelo Nemotron Asr Streaming 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-speech-streaming-en-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 NemotronAsrStreamingForRNNT, NemotronAsrStreamingConfig

>>> # Initializing a NemotronAsrStreaming RNN-T configuration
>>> configuration = NemotronAsrStreamingConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingForRNNT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

NemotronAsrStreamingEncoderConfig

clase transformers.NemotronAsrStreamingEncoderConfig

< >

( 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02sliding_window: int = 71default_num_lookahead_tokens: int = 13 )

Parámetros

  • hidden_size (int, opcional, valor predeterminado 1024) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 24) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 4096) — Dimensión de las representaciones del MLP.
  • hidden_act (str, opcional, valor predeterminado silu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • attention_bias (bool, opcional, valor predeterminado True) — Si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.
  • convolution_bias (bool, opcional, valor predeterminado True) — Si se usa sesgo en las convoluciones del módulo de convolución del conformer.
  • conv_kernel_size (int, opcional, valor predeterminado 9) — El tamaño del kernel de las capas de convolución en el bloque Conformer.
  • subsampling_factor (int, opcional, valor predeterminado 8) — El factor por el cual se realiza el submuestreo de la secuencia de entrada.
  • subsampling_conv_channels (int, opcional, valor predeterminado 256) — El número de canales en las capas de convolución de subsampling.
  • num_mel_bins (int, opcional, valor predeterminado 80) — Número de características mel.
  • subsampling_conv_kernel_size (int, opcional, valor predeterminado 3) — El tamaño del kernel de las capas de convolución de subsampling.
  • subsampling_conv_stride (int, opcional, valor predeterminado 2) — El paso de las capas de convolución de subsampling.
  • dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción para todas las capas de dropout.
  • dropout_positions (float, opcional, valor predeterminado 0.0) — La proporción de dropout para las posiciones de la secuencia de entrada.
  • layerdrop (Union[float, int], opcional, valor predeterminado 0.1) — La probabilidad de LayerDrop. Consulte el [artículo de LayerDrop](ver https://huggingface.co/papers/1909.11556) para más detalles.
  • activation_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las activaciones dentro de la capa totalmente conectada.
  • attention_dropout (Union[float, int], opcional, valor predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
  • max_position_embeddings (int, opcional, valor predeterminado 5000) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
  • scale_input (bool, opcional, valor predeterminado True) — Si se deben escalar los embeddings de entrada.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • sliding_window (int, opcional, valor predeterminado 71) — Tamaño de la ventana deslizante de atención K/V (en fotogramas del codificador subsampleados). Es igual a left_context + 1 (el fotograma actual más el contexto izquierdo), por lo que el contexto de atención izquierdo es sliding_window - 1 — el mismo para todos los lookaheads admitidos.
  • default_num_lookahead_tokens (int, opcional, valor predeterminado 13) — El contexto de atención a la derecha (lookahead, en fotogramas del codificador subsampleados) utilizado cuando no se pasa ninguno al forward. El conjunto admitido con el que se entrenó el modelo se encuentra en NemotronAsrStreamingProcessor.

Esta es la clase de configuración para almacenar la configuración de un NemotronAsrStreamingForRNNT. Se utiliza para instanciar un modelo Nemotron Asr Streaming 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-speech-streaming-en-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 NemotronAsrStreamingEncoder, NemotronAsrStreamingEncoderConfig

>>> # Initializing a `NemotronAsrStreamingEncoder` configuration
>>> configuration = NemotronAsrStreamingEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingEncoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

NemotronAsrStreamingFeatureExtractor

clase transformers.NemotronAsrStreamingFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0mel_filters_dtype = 'float32'**kwargs )

Parámetros

  • feature_size (int, opcional, valor predeterminado 80) — La dimensión de las características de las características extraídas.
  • sampling_rate (int, opcional, valor predeterminado 16000) — La tasa de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).
  • hop_length (int, opcional, valor predeterminado 160) — Longitud de las ventanas superpuestas para la STFT utilizada para obtener los coeficientes de Frecuencia Mel.
  • n_fft (int, opcional, valor predeterminado 512) — Tamaño de la transformada de Fourier.
  • win_length (int, opcional, valor predeterminado 400) — La longitud de la ventana para el cálculo de la STFT.
  • preemphasis (float, opcional, valor predeterminado 0.97) — Coeficiente de un filtro de preénfasis. 0.0 significa que no se aplica ningún filtro de preénfasis.
  • padding_value (float, opcional, valor predeterminado 0.0) — Valor de relleno utilizado para rellenar el audio. Debe corresponder a silencios.
  • mel_filters_dtype (str, opcional, por defecto "float32") — Precisión del banco de filtros mel y de la ventana STFT almacenados. Algunos puntos de control mantienen estas constantes en una precisión reducida ("bfloat16" para Nemotron 3.5 Transcribe): el banco de filtros y la ventana se redondean entonces a ese dtype cuando se calculan las características, de modo que las características log-mel coincidan con el front-end original; el propio espectrograma siempre se calcula en float32.

Construye un extractor de características NemotronAsrStreaming.

Este extractor de características hereda de SequenceFeatureExtractor, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

Esta clase extrae características de banco de filtros mel de audio en bruto mediante una implementación personalizada de numpy de la Short Time Fourier Transform que debe coincidir con el equivalente torch.stft de pytorch.

NemotronAsrStreamingProcessor

clase transformers.NemotronAsrStreamingProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'supported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = None )

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.
  • supported_num_lookahead_tokens (list[int], opcional) — Contextos de atención a la derecha (lookaheads, en fotogramas de codificador subsampleados) con los que se entrenó el modelo. El procesador es la única fuente de verdad para este conjunto: set_num_lookahead_tokens() lo valida contra él. El valor predeterminado es el conjunto consciente de la caché de NeMo [13, 6, 1, 0].
  • default_num_lookahead_tokens (int, opcional) — El contexto derecho utilizado para dimensionar los fragmentos de transmisión y emitido por call(); cámbielo con set_num_lookahead_tokens(). Por defecto, es la primera entrada de supported_num_lookahead_tokens.

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

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

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]text: str | list[str] | list[list[str]] | None = Nonesampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool | None = True**kwargs: *<class 'transformers.models.nemotron_asr_streaming.processing_nemotron_asr_streaming.NemotronAsrStreamingProcessorKwargs'> ) → BatchFeature

Parámetros

  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]) — El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de la muestra del audio.
  • text (Union[str, list[str], list[list[str]]], opcional) — La secuencia o lote de secuencias que se codificarán. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas de caracteres (cadenas pre-tokenizadas). Si se pasa una entrada pre-tokenizada, establezca is_split_into_words=True para evitar ambigüedad con las entradas por lotes.
  • sampling_rate (int, opcional) — La tasa de muestreo del audio de entrada en Hz. Debe coincidir con la tasa de muestreo esperada por el extractor de características (por defecto, 16000 Hz). Si se proporciona, se validará contra la tasa de muestreo esperada por el procesador y se generará un error si no coinciden. Si no se proporciona, se emitirá una advertencia y se asumirá la tasa de muestreo predeterminada.
  • is_streaming (bool, opcional, valor predeterminado False) — Indica si se debe procesar el audio en modo de transmisión. Cuando es True, el audio puede pasarse en fragmentos, utilizando is_first_audio_chunk para distinguir el primer fragmento de los siguientes.
  • is_first_audio_chunk (bool, opcional, valor predeterminado True) — Indica si el audio actual es el primer fragmento de una sesión de streaming. El extractor de características utiliza center=True para el primer fragmento (y para uso offline) y center=False para los fragmentos posteriores, de modo que la STFT por fragmento reproduzca, cuadro a cuadro, una única pasada de la utterance completa. Debe ser True cuando is_streaming=False.
  • return_tensors (str o TensorType, opcional) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, videos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Devuelve

BatchFeature

las salidas del feature-extractor (y el tokenizer opcional), aumentadas con:

  • num_lookahead_tokens — El contexto de atención a la derecha (lookahead, en los fotogramas del codificador subsampleados), es decir, default_num_lookahead_tokens (establecido mediante set_num_lookahead_tokens()). Pásalo al forward del modelo/codificador (o a generate); cumple el papel de num_delay_tokens de Voxtral Realtime.

decode

< >

( *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.

NemotronAsrStreamingEncoderModelOutput

clase transformers.NemotronAsrStreamingEncoderModelOutput

< >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.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.

  • 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 después de la compresión de la secuencia. Se devuelve porque la longitud de la secuencia puede diferir de la longitud de la secuencia de entrada. Valores de la máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.
  • past_key_values (Cache, opcional) — Caché de ventana deslizante de K/V de atención actualizada del codificador. Pásala a la llamada del siguiente fragmento.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Cache de streaming unificado que respalda las capas Conv2d de subsampling y el Conv1d de profundidad del conformer.

Extiende ParakeetEncoderModelOutput con cachés de streaming opcionales. Las cachés solo se rellenan para modelos conscientes de la caché cuando use_cache=True.

NemotronAsrStreamingRNNTOutput

clase transformers.NemotronAsrStreamingRNNTOutput

< >

( 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.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

encoder_past_key_values (Cache, opcional): Actualizada caché de ventana deslizante de atención K/V del codificador, devuelta al codificar audio con use_cache=True (transmisión consciente de la caché). Pásala al forward del siguiente fragmento. padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional): Actualizada caché unificada de convolución de transmisión (Conv2d de subsampleo + Conv1d de profundidad del conformer), devuelta al codificar audio con use_cache=True. Pásala al forward del siguiente fragmento.

NemotronAsrStreamingEncoder

clase transformers.NemotronAsrStreamingEncoder

< >

( config: NemotronAsrStreamingEncoderConfig )

Parámetros

  • config (NemotronAsrStreamingEncoderConfig) — 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.

El modelo NemotronAsrStreaming Encoder, basado en la arquitectura Fast Conformer.

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

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneoutput_attention_mask: bool = Trueuse_cache: bool | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

Parámetros

  • input_features (torch.Tensor de forma (batch_size, sequence_length, feature_dim)) — 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?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango [0, config.n_positions - 1].

    ¿Qué son los IDs de posición?

  • past_key_values (Cache, opcional) — Caché K/V de ventana deslizante (DynamicCache construido a partir de config.sliding_window) para la atención de streaming consciente de la caché.
  • output_attention_mask (bool, opcional, valor predeterminado True) — Si se debe devolver la máscara de atención de salida. Solo es efectivo cuando se proporciona attention_mask.
  • use_cache (bool, opcional) — Si se establece en True, se devuelven los estados de clave-valor de past_key_values y pueden usarse para acelerar la decodificación (ver past_key_values).
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Cache de streaming unificado que respalda las capas Conv2d de subsampling y el Conv1d de profundidad del conformer.
  • num_lookahead_tokens (int, opcional) — Sustitución del contexto de atención a la derecha (lookahead, en los fotogramas del codificador subsampleados) para esta paso de adelante. Combinado con el contexto izquierdo config.sliding_window - 1. Por defecto es config.default_num_lookahead_tokens.

Devuelve

BaseModelOutput o tuple(torch.Tensor)

Un BaseModelOutput 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 NemotronAsrStreamingEncoder 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.

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

Ejemplo:

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

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = NemotronAsrStreamingEncoder.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"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)

NemotronAsrStreamingForRNNT

clase transformers.NemotronAsrStreamingForRNNT

< >

( config: NemotronAsrStreamingConfig )

Parámetros

  • config (NemotronAsrStreamingConfig) — 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.

NemotronAsrStreaming Encoder con una cabeza RNN-T (Recurrent Neural Network Transducer).

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

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → NemotronAsrStreamingRNNTOutput 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 (NemotronAsrStreamingRNNTDecoderCache, 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 (NemotronAsrStreamingEncoderModelOutput, 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.

Devuelve

NemotronAsrStreamingRNNTOutput o tuple(torch.Tensor)

Un NemotronAsrStreamingRNNTOutput 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 NemotronAsrStreamingForRNNT 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.

  • 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, NemotronAsrStreamingForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = NemotronAsrStreamingForRNNT.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"])
>>> outputs = model(**inputs)

generate

< >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3.5 Transcribe NeuCodec→