Transformers documentation
Nemotron ASR Streaming
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
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)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
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)
# 560set_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
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 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ãoTrue) — Indica se o modelo é usado como encoder/decoder ou não. - vocab_size (
int, opcional, padrão1025) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - decoder_hidden_size (
int, opcional, padrão 640) — Tamanho oculto da rede de previsão LSTM (pred_hiddendo NeMo). A rede conjunta projeta as saídas do codificador e do decodificador para esse tamanho (joint_hiddendo NeMo, que todos os checkpoints conhecidos definem igual apred_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ão0) — ID do token usado para preenchimento no vocabulário. - blank_token_id (
int, opcional, padrão 1024) — ID do token em branco. Diferente depad_token_idpara 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.configNemotronAsrStreamingEncoderConfig
classe transformers.NemotronAsrStreamingEncoderConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 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ão1024) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão4096) — Dimensão das representações do MLP. - hidden_act (
str, opcional, padrãosilu) — 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ãoTrue) — 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ãoTrue) — 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ão0.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ão0.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ão0.1) — A taxa de dropout para as ativações dentro da camada totalmente conectada. - attention_dropout (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - max_position_embeddings (
int, opcional, padrão5000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - scale_input (
bool, opcional, padrãoTrue) — Se as embeddings de entrada devem ser escalonadas. - initializer_range (
float, opcional, padrão0.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 aleft_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.configNemotronAsrStreamingFeatureExtractor
classe transformers.NemotronAsrStreamingFeatureExtractor
< source >( 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
< source >( 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 comset_num_lookahead_tokens(). O valor padrão é a primeira entrada desupported_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__
< source >( 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, definais_split_into_words=Truepara 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ãoFalse) — Se o áudio deve ser processado em modo de streaming. QuandoTrue, o áudio pode ser enviado em blocos, usandois_first_audio_chunkpara distinguir o primeiro bloco dos subsequentes. - is_first_audio_chunk (
bool, opcional, padrãoTrue) — Indica se o áudio atual é o primeiro bloco de uma sessão de streaming. O extrator de recursos usacenter=Truepara o primeiro bloco (e para uso offline) ecenter=Falsepara os blocos subsequentes, de modo que a STFT por bloco reproduza, quadro a quadro, uma única passagem de toda a fala. Deve serTruequandois_streaming=False. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo 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
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 viaset_num_lookahead_tokens()). Passe-o para o forward do modelo/encoder (ougenerate); ele desempenha o papel denum_delay_tokensdo Voxtral Realtime.
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
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo. - pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.Tensorde 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
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneloss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedecoder_cache: transformers.models.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
< source >( 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
< source >( 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.Tensorde 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 usandofeature_extractor_class. Consultefeature_extractor_class.__call__para mais detalhes (processor_classusafeature_extractor_classpara processar áudios). - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
Cache, optional) — Sliding-window K/V cache (DynamicCachebuilt fromconfig.sliding_window) for cache-aware streaming attention. - output_attention_mask (
bool, opcional, padrãoTrue) — Indica se a máscara de atenção de saída deve ser retornada. Efetivo apenas quandoattention_maské fornecida. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_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 à esquerdaconfig.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
Moduleem 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.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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
< source >( 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
< source >( 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.Tensorde 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 usandofeature_extractor_class. Consultefeature_extractor_class.__call__para mais detalhes (processor_classusafeature_extractor_classpara processar áudios). - attention_mask (
torch.Tensorde 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.
- decoder_input_ids (
torch.LongTensorde 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.Tensorde 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 deinput_ids). Tokens com índices definidos como-100sã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
Moduleem 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 withuse_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 comuse_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)