# 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

```python
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)
```

```python
from transformers import AutoModelForRNNT, AutoProcessor
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")

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

inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

### Transcrição em streaming
> [!NOTE]
> Esta é uma funcionalidade experimental e a API está sujeita a alterações.

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

```python
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:

```python
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[[transformers.NemotronAsrStreamingConfig]]

#### transformers.NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

```python
transformers.NemotronAsrStreamingConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 1025, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0, blank_token_id: int = 1024)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L120)

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador 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 predição LSTM (o `pred_hidden` do NeMo). A rede conjunta projeta as saídas do codificador e do decodificador para este tamanho (o `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"`) : 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 codificador.

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](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```python
>>> 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[[transformers.NemotronAsrStreamingEncoderConfig]]

#### transformers.NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

```python
transformers.NemotronAsrStreamingEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02, sliding_window: int = 71, default_num_lookahead_tokens: int = 13)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**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`) : Se deve usar 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 de LayerDrop. Consulte o [artigo do LayerDrop](see 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 usado.

scale_input (`bool`, *opcional*, padrão `True`) : Se as incorporações 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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.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](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```python
>>> 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[[transformers.NemotronAsrStreamingFeatureExtractor]]

#### transformers.NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

```python
transformers.NemotronAsrStreamingFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, mel_filters_dtype = 'float32', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L41)

**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) : Um coeficiente de 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 próprio espectrograma é sempre calculado em float32.

Constrói um extrator de recursos NemotronAsrStreaming.

Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta 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[[transformers.NemotronAsrStreamingProcessor]]

#### transformers.NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

```python
transformers.NemotronAsrStreamingProcessor(feature_extractor, tokenizer, blank_token = '<blank>', supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L50)

**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 quadros 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 em relação a ele. 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__()](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__); altere-o com `set_num_lookahead_tokens()`. O 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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) oferece todas as funcionalidades de [NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) e [ParakeetTokenizer](/docs/transformers/main/pt/model_doc/parakeet#transformers.ParakeetTokenizer). Consulte [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) e [~ParakeetTokenizer](/docs/transformers/main/pt/model_doc/parakeet#transformers.ParakeetTokenizer) para mais informações.

#### __call__[[transformers.NemotronAsrStreamingProcessor.__call__]]

```python
__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 = None, sampling_rate: int | None = None, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.models.nemotron_asr_streaming.processing_nemotron_asr_streaming.NemotronAsrStreamingProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L85)

**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 amostras 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 pretokenizada). Se você passar uma entrada pretokenizada, 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](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature)

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

- **num_lookahead_tokens** -- O contexto de atenção à direita (lookahead, em quadros de codificador 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[[transformers.NemotronAsrStreamingProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L169)

Encaminha os argumentos para [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) e faz o pós-processamento dos timestamps no nível de tokens (se `durations` forem fornecidos), conforme na biblioteca NeMo.

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

#### transformers.NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

```python
transformers.NemotronAsrStreamingEncoderModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L325)

**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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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 frase (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 iniciais opcionais dos embeddings.

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 das atenções 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 conscientes de cache quando `use_cache=True`.

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

#### transformers.NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

```python
transformers.NemotronAsrStreamingRNNTOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_past_key_values (`Cache`, *opcional*): Atualizado cache de janela deslizante de atenção K/V do codificador, retornado ao codificar áudio com `use_cache=True` (streaming com suporte a cache). Passe-o para o forward do próximo chunk. padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *opcional*): Atualizado cache de conv unificado de streaming (Conv2d de subsampling + Conv1d depthwise do conformer), retornado ao codificar áudio com `use_cache=True`. Passe-o para o forward do próximo chunk.

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

#### transformers.NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

```python
transformers.NemotronAsrStreamingEncoder(config: NemotronAsrStreamingEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L877)

**Parâmetros:**

config ([NemotronAsrStreamingEncoderConfig](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo NemotronAsrStreaming Encoder, baseado na [arquitetura Fast Conformer](https://huggingface.co/papers/2305.05084).

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.NemotronAsrStreamingEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, output_attention_mask: bool = True, use_cache: bool | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L900)

**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 obter 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?](../glossary#attention-mask)

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?](../glossary#position-ids)

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 de `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 passo de forward. Combinado com o contexto à esquerda `config.sliding_window - 1`. Padrão é `config.default_num_lookahead_tokens`.

**Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.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) com a 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.NemotronAsrStreamingForRNNT]]

#### transformers.NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

```python
transformers.NemotronAsrStreamingForRNNT(config: NemotronAsrStreamingConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**Parâmetros:**

config ([NemotronAsrStreamingConfig](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.NemotronAsrStreamingForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**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?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, 1)`, *opcional*) : IDs de tokens de entrada do decodificador para inferência de etapa única.

decoder_cache (`NemotronAsrStreamingRNNTDecoderCache`, *opcional*) : Cache do LSTM do decodificador. Reutilizado em previsões de blank para pular a etapa do LSTM.

use_decoder_cache (`bool`, *opcional*) : Se deve alocar e usar um cache de 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 calcular a 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. O padrão é `config.encoder_config.default_num_lookahead_tokens`.

**Retorna:** [NemotronAsrStreamingRNNTOutput](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) ou `tuple(torch.Tensor)`

Um [NemotronAsrStreamingRNNTOutput](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.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](/docs/transformers/main/pt/model_doc/nemotron_asr_streaming#transformers.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 forward do próximo chunk.

Exemplo:

```python
>>> 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[[transformers.NemotronAsrStreamingForRNNT.generate]]

```python
generate(inputs = None, generation_config = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron_asr_streaming/generation_nemotron_asr_streaming.py#L212)