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.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em papers do HF em 2023-05-08 e contribuído para o Hugging Face Transformers em 2026-06-18.

Nemotron ASR Streaming

Visão geral

Nemotron ASR Streaming é um modelo de reconhecimento de fala em inglês com 600M de parâmetros da NVIDIA, projetado para transcrição de alta qualidade tanto em configurações de streaming de baixa latência quanto em processamento em lote de alto rendimento, com pontuação e capitalização nativas. Para streaming, oferece tamanhos de chunk configuráveis — 80ms, 160ms, 560ms e 1120ms —, permitindo que os usuários equilibrem latência e precisão de acordo com sua aplicação. Sua arquitetura FastConformer-RNNT com suporte a cache é central para essa capacidade: diferentemente do streaming com buffer tradicional, que reprocessa repetidamente janelas de áudio sobrepostas, o modelo processa apenas cada novo chunk recebido, reutilizando o contexto do encoder em cache dos chunks anteriores. Isso elimina cálculos redundantes, melhora significativamente a eficiência e minimiza o atraso de ponta a ponta sem sacrificar a precisão, tornando-o adequado para cargas de trabalho de transcrição em tempo real.

Uso

Transcrição offline

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)

Transcrição em streaming

Esta é uma funcionalidade experimental e a API está sujeita a alterações.

Para transcrição em tempo real, o áudio é dividido em blocos seguindo:

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

Latência de streaming

A latência é definida por num_lookahead_tokens, o contexto de atenção à direita (lookahead, em quadros de codificador subsampleados) que cada chunk aguarda antes de ser emitido. Um valor maior permite que cada chunk veja mais áudio futuro: melhor precisão ao custo de maior latência. Inspecione os trade-offs suportados, selecione um e leia de volta a latência 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 o tamanho dos blocos emitidos pelo processador, e o correspondente num_lookahead_tokens deve chegar até generate (no trecho acima, ele é transmitido por meio de **inputs/**first_chunk_inputs, que carrega num_lookahead_tokens). O generate em streaming gera um erro se ele for omitido.

NemotronAsrStreamingConfig

classe 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, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • vocab_size (int, opcional, padrão 1025) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • decoder_hidden_size (int, opcional, padrão 640) — Tamanho oculto da rede de previsão LSTM (pred_hidden do NeMo). A rede conjunta projeta as saídas do codificador e do decodificador para esse tamanho (joint_hidden do NeMo, que todos os checkpoints conhecidos definem igual a pred_hidden).
  • num_decoder_layers (int, opcional, padrão 2) — Número de camadas LSTM na rede de predição.
  • hidden_act (str, opcional, padrão "relu") — Função de ativação na rede conjunta.
  • max_symbols_per_step (int, opcional, padrão 10) — Número máximo de símbolos não vazios emitidos por passo de tempo do codificador durante a decodificação gulosa.
  • encoder_config (Union[dict, NemotronAsrStreamingEncoderConfig], opcional) — O objeto de configuração ou dicionário do encoder.
  • pad_token_id (int, opcional, padrão 0) — ID do token usado para preenchimento no vocabulário.
  • blank_token_id (int, opcional, padrão 1024) — ID do token em branco. Diferente de pad_token_id para RNN-T.

Esta é a classe de configuração para armazenar a configuração de um NemotronAsrStreamingForRNNT. Ela é usada para instanciar um modelo Nemotron Asr Streaming de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/nemotron-speech-streaming-en-0.6b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe 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, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • attention_bias (bool, opcional, padrão True) — Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • convolution_bias (bool, opcional, padrão True) — Indica se deve ser usado viés nas convoluções do módulo de convolução do conformer.
  • conv_kernel_size (int, opcional, padrão 9) — O tamanho do kernel das camadas de convolução no bloco Conformer.
  • subsampling_factor (int, opcional, padrão 8) — O fator pelo qual a sequência de entrada é subsampleada.
  • subsampling_conv_channels (int, opcional, padrão 256) — O número de canais nas camadas de convolução de subsampling.
  • num_mel_bins (int, opcional, padrão 80) — Número de recursos mel.
  • subsampling_conv_kernel_size (int, opcional, padrão 3) — O tamanho do kernel das camadas de convolução de subsampling.
  • subsampling_conv_stride (int, opcional, padrão 2) — O stride das camadas de convolução de subsampling.
  • dropout (Union[float, int], opcional, padrão 0.1) — A proporção para todas as camadas de dropout.
  • dropout_positions (float, opcional, padrão 0.0) — A taxa de dropout para as posições na sequência de entrada.
  • layerdrop (Union[float, int], opcional, padrão 0.1) — A probabilidade do LayerDrop. Consulte o [artigo do LayerDrop](veja https://huggingface.co/papers/1909.11556) para mais detalhes.
  • activation_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
  • attention_dropout (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as probabilidades de atenção.
  • max_position_embeddings (int, opcional, padrão 5000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • scale_input (bool, opcional, padrão True) — Se as embeddings de entrada devem ser escalonadas.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • sliding_window (int, opcional, padrão 71) — Tamanho da janela deslizante de atenção K/V (em quadros de codificador subsampleados). É igual a left_context + 1 (o quadro atual mais o contexto à esquerda), portanto o contexto de atenção à esquerda é sliding_window - 1 — o mesmo para todos os lookaheads suportados.
  • default_num_lookahead_tokens (int, opcional, padrão 13) — O contexto de atenção à direita (lookahead, em quadros de codificador subsampleados) usado quando nenhum é passado para o forward. O conjunto suportado com o qual o modelo foi treinado está em NemotronAsrStreamingProcessor.

Esta é a classe de configuração para armazenar a configuração de um NemotronAsrStreamingForRNNT. Ela é usada para instanciar um modelo Nemotron Asr Streaming de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do nvidia/nemotron-speech-streaming-en-0.6b

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe 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, padrão 80) — A dimensão dos recursos das características extraídas.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
  • hop_length (int, opcional, padrão 160) — Comprimento das janelas sobrepostas para a STFT usada para obter os coeficientes de Frequência Mel.
  • n_fft (int, opcional, padrão 512) — Tamanho da transformada de Fourier.
  • win_length (int, opcional, padrão 400) — O comprimento da janela para o cálculo da STFT.
  • preemphasis (float, opcional, padrão 0.97) — Coeficiente de um filtro de pré-ênfase. 0.0 significa que não há filtro de pré-ênfase.
  • padding_value (float, opcional, padrão 0.0) — Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.
  • mel_filters_dtype (str, opcional, padrão "float32") — Precisão do banco de filtros mel e da janela STFT armazenados. Alguns checkpoints mantêm essas constantes em uma precisão reduzida ("bfloat16" para Nemotron 3.5 Transcribe): o banco de filtros e a janela são então arredondados para esse dtype quando os recursos são calculados, de modo que os recursos log-mel correspondam ao front-end original; o espectrograma em si é sempre calculado em float32.

Constrói um extrator de recursos NemotronAsrStreaming.

Este extrator de características herda de SequenceFeatureExtractor, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

Esta classe extrai recursos de banco de filtros mel a partir de fala bruta usando uma implementação customizada em numpy da Short Time Fourier Transform, que deve corresponder ao equivalente torch.stft do pytorch.

NemotronAsrStreamingProcessor

classe transformers.NemotronAsrStreamingProcessor

< >

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

Parâmetros

  • feature_extractor (NemotronAsrStreamingFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (ParakeetTokenizer) — O tokenizer é uma entrada obrigatória.
  • blank_token (str, opcional, padrão "<blank>") — Token em branco para decodificação RNN-T.
  • supported_num_lookahead_tokens (list[int], opcional) — Contextos de atenção à direita (lookaheads, em frames de codificador subsampleados) com os quais o modelo foi treinado. O processador é a única fonte de verdade para esse conjunto: set_num_lookahead_tokens() valida com base nele. O padrão é o conjunto consciente de cache do NeMo [13, 6, 1, 0].
  • default_num_lookahead_tokens (int, opcional) — O contexto à direita usado para dimensionar os blocos de streaming e emitido por call(); altere-o com set_num_lookahead_tokens(). O valor padrão é a primeira entrada de supported_num_lookahead_tokens.

Constrói um NemotronAsrStreamingProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

NemotronAsrStreamingProcessor oferece todas as funcionalidades de NemotronAsrStreamingFeatureExtractor e ParakeetTokenizer. Consulte ~NemotronAsrStreamingFeatureExtractor e ~ParakeetTokenizer para mais informações.

__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]]) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostragem do áudio.
  • text (Union[str, list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • sampling_rate (int, opcional) — A taxa de amostragem do áudio de entrada em Hz. Deve corresponder à taxa de amostragem esperada pelo extrator de recursos (padrão: 16000 Hz). Se fornecida, será validada em relação à taxa de amostragem esperada pelo processador, e um erro será lançado caso não correspondam. Se não for fornecida, um aviso será emitido e a taxa de amostragem padrão será assumida.
  • is_streaming (bool, opcional, padrão False) — Se o áudio deve ser processado em modo de streaming. Quando True, o áudio pode ser enviado em blocos, usando is_first_audio_chunk para distinguir o primeiro bloco dos subsequentes.
  • is_first_audio_chunk (bool, opcional, padrão True) — Indica se o áudio atual é o primeiro bloco de uma sessão de streaming. O extrator de recursos usa center=True para o primeiro bloco (e para uso offline) e center=False para os blocos subsequentes, de modo que a STFT por bloco reproduza, quadro a quadro, uma única passagem de toda a fala. Deve ser True quando is_streaming=False.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Retorna

BatchFeature

as saídas do feature-extractor (e do tokenizer opcional), acrescidas de:

  • num_lookahead_tokens — O contexto de atenção à direita (lookahead, em frames do encoder subsampleados), ou seja, default_num_lookahead_tokens (definido via set_num_lookahead_tokens()). Passe-o para o forward do modelo/encoder (ou generate); ele desempenha o papel de num_delay_tokens do Voxtral Realtime.

decode

< >

( *argsdurations = None**kwargs )

Encaminha os argumentos para decode() e faz o pós-processamento dos timestamps no nível de tokens (se durations forem fornecidos), conforme na biblioteca NeMo.

NemotronAsrStreamingEncoderModelOutput

classe 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)) — Sequência de estados ocultos na saída da última camada do modelo.
  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima sentença (classificação) durante o pré-treinamento.
  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento após a compressão da sequência. Retornada porque o comprimento da sequência pode diferir do comprimento da sequência de entrada. Valores da máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.
  • past_key_values (Cache, optional) — Updated attention K/V sliding-window cache from the encoder. Pass to the next chunk call.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Cache de streaming unificado que sustenta as camadas Conv2d de subsampling e o Conv1d depthwise do conformer.

Estende ParakeetEncoderModelOutput com caches de streaming opcionais. Os caches são preenchidos apenas para modelos com suporte a cache quando use_cache=True.

NemotronAsrStreamingRNNTOutput

classe 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, optional): Updated encoder attention K/V sliding-window cache, returned when encoding audio with use_cache=True (cache-aware streaming). Pass it to the next chunk’s forward. padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, optional): Updated unified streaming conv cache (subsampling Conv2d + conformer depthwise Conv1d), returned when encoding audio with use_cache=True. Pass it to the next chunk’s forward.

NemotronAsrStreamingEncoder

classe transformers.NemotronAsrStreamingEncoder

< >

( config: NemotronAsrStreamingEncoderConfig )

Parâmetros

  • config (NemotronAsrStreamingEncoderConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo NemotronAsrStreaming Encoder, baseado na arquitetura Fast Conformer.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (Cache, optional) — Sliding-window K/V cache (DynamicCache built from config.sliding_window) for cache-aware streaming attention.
  • output_attention_mask (bool, opcional, padrão True) — Indica se a máscara de atenção de saída deve ser retornada. Efetivo apenas quando attention_mask é fornecida.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Cache de streaming unificado que sustenta as camadas Conv2d de subsampling e o Conv1d depthwise do conformer.
  • num_lookahead_tokens (int, opcional) — Substituição do contexto de atenção à direita (lookahead, em quadros de codificador subsampleados) para este forward pass. Combinado com o contexto à esquerda config.sliding_window - 1. O padrão é config.default_num_lookahead_tokens.

Retorna

BaseModelOutput ou tuple(torch.Tensor)

Um BaseModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (None) e das entradas.

O método forward da NemotronAsrStreamingEncoder substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

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

classe transformers.NemotronAsrStreamingForRNNT

< >

( config: NemotronAsrStreamingConfig )

Parâmetros

  • config (NemotronAsrStreamingConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

NemotronAsrStreaming Encoder com uma cabeça RNN-T (Recurrent Neural Network Transducer).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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) — Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando feature_extractor_class. Consulte feature_extractor_class.__call__ para mais detalhes (processor_class usa feature_extractor_class para processar áudios).
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • decoder_input_ids (torch.LongTensor de forma (batch_size, 1), opcional) — IDs de tokens de entrada do decodificador para inferência em etapa única.
  • decoder_cache (NemotronAsrStreamingRNNTDecoderCache, opcional) — Cache do LSTM do decodificador. Reutilizado em previsões de espaço em branco para pular a etapa do LSTM.
  • use_decoder_cache (bool, opcional) — Se deve alocar e usar um cache do decodificador quando nenhum for fornecido.
  • encoder_outputs (NemotronAsrStreamingEncoderModelOutput, opcional) — Saídas pré-computadas do codificador (last_hidden_state, pooler_output, …).
  • labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].
  • num_lookahead_tokens (int, opcional) — Contexto de atenção à direita (lookahead, em quadros do codificador subsampleados) encaminhado ao codificador. Padrão: config.encoder_config.default_num_lookahead_tokens.

Retorna

NemotronAsrStreamingRNNTOutput ou tuple(torch.Tensor)

Um NemotronAsrStreamingRNNTOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (None) e das entradas.

O método forward da NemotronAsrStreamingForRNNT substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • encoder_past_key_values (Cache, optional) — Updated encoder attention K/V sliding-window cache, returned when encoding audio with use_cache=True (cache-aware streaming). Pass it to the next chunk’s forward.
  • padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache, opcional) — Cache unificado de streaming conv atualizado (subsampling Conv2d + conformer depthwise Conv1d), retornado ao codificar áudio com use_cache=True. Passe-o para o próximo forward do chunk.

Exemplo:

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