# VoxtralRealtime

VoxtralRealtime é um modelo de transcrição de fala em streaming da [Mistral AI](https://mistral.ai), projetado para reconhecimento automático de fala (ASR) em tempo real. Diferentemente do modelo offline [Voxtral](./voxtral), que processa arquivos de áudio completos, o VoxtralRealtime é arquitetado para transcrição incremental de baixa latência, processando o áudio em blocos conforme ele chega.

O modelo combina um codificador de áudio com um decodificador de modelo de linguagem baseado em Mistral, utilizando embeddings de condicionamento temporal e convoluções causais com caches de padding para permitir inferência em streaming eficiente.

## Uso

### Transcrição offline

Para transcrever arquivos de áudio completos, use o processador e o modelo diretamente. O comprimento da geração é determinado automaticamente a partir do comprimento do áudio.

```python
from datasets import load_dataset

from transformers import AutoProcessor, VoxtralRealtimeForConditionalGeneration

repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

processor = AutoProcessor.from_pretrained(repo_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]["array"]

inputs = processor(audio, return_tensors="pt").to(model.device)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs)
decoded_outputs = processor.batch_decode(outputs, skip_special_tokens=True)

print(decoded_outputs[0])
```

### Transcrição offline em lote

Vários amostras de áudio podem ser transcritas em uma única passagem de frente:

```python
from datasets import load_dataset

from transformers import AutoProcessor, VoxtralRealtimeForConditionalGeneration

repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

processor = AutoProcessor.from_pretrained(repo_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, device_map="auto")

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = [ds[i]["audio"]["array"] for i in range(2)]

inputs = processor(audio, return_tensors="pt").to(model.device)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs)
decoded_outputs = processor.batch_decode(outputs, skip_special_tokens=True)

for decoded_output in decoded_outputs:
    print(decoded_output)
```

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

import numpy as np
import torch
from datasets import load_dataset

from transformers import (
    TextIteratorStreamer,
    VoxtralRealtimeForConditionalGeneration,
    VoxtralRealtimeProcessor,
)

model_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"
processor = VoxtralRealtimeProcessor.from_pretrained(model_id)
model = VoxtralRealtimeForConditionalGeneration.from_pretrained(model_id, device_map=torch.accelerator.current_accelerator())

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]["array"]
# Manually pad the audio to account for right padding tokens required by the model
xaudio = np.pad(audio, (0, processor.num_right_pad_tokens * processor.raw_audio_length_per_tok))

first_chunk_inputs = processor(
    audio[:processor.num_samples_first_audio_chunk],
    is_streaming=True,
    is_first_audio_chunk=True,
    return_tensors="pt"
)
first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    win_length = processor.feature_extractor.win_length

    start_idx = mel_frame_idx * hop_length - win_length // 2
    end_idx = start_idx + processor.num_samples_per_audio_chunk

    while (end_idx:=start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            is_streaming=True,
            is_first_audio_chunk=False,
            return_tensors="pt"
        )
        inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.audio_length_per_tok
        start_idx = mel_frame_idx * hop_length - win_length // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True, clean_up_tokenization_spaces=True)
generate_kwargs = {
    "input_ids": first_chunk_inputs.input_ids,
    "input_features": input_features_generator(),
    "num_delay_tokens": first_chunk_inputs.num_delay_tokens,
    "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)
```

Este modelo foi contribuído por [Eustache Le Bihan](https://huggingface.co/eustlb).

## VoxtralRealtimeConfig[[transformers.VoxtralRealtimeConfig]]

#### transformers.VoxtralRealtimeConfig[[transformers.VoxtralRealtimeConfig]]

```python
transformers.VoxtralRealtimeConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projector_hidden_act: str = 'gelu', audio_length_per_tok: int = 8, default_num_delay_tokens: int = 6, downsample_factor: int = 4, tie_word_embeddings: bool = True, use_cache: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/configuration_voxtral_realtime.py#L125)

**Parâmetros:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

projector_hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação usada pelo projetor multimodal.

audio_length_per_tok (`int`, *opcional*, padrão 8) : O número de quadros de áudio correspondentes a cada token de texto.

default_num_delay_tokens (`int`, *opcional*, padrão 6) : O número padrão de tokens de atraso usados para streaming.

downsample_factor (`int`, *opcional*, padrão 4) : O fator de downsampling aplicado às características de áudio antes da projeção.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

Esta é a classe de configuração para armazenar a configuração de um VoxtralRealtimeModel. Ela é usada para instanciar um modelo Voxtral Realtime 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 [mistralai/Voxtral-Mini-4B-Realtime-2602](https://huggingface.co/mistralai/Voxtral-Mini-4B-Realtime-2602)

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.

```python
>>> from transformers import VoxtralRealtimeForConditionalGeneration, VoxtralRealtimeConfig

>>> # Initializing a VoxtralRealtime configuration
>>> configuration = VoxtralRealtimeConfig()

>>> # Initializing a model with random weights
>>> model = VoxtralRealtimeForConditionalGeneration(configuration)

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

## VoxtralRealtimeEncoderConfig[[transformers.VoxtralRealtimeEncoderConfig]]

#### transformers.VoxtralRealtimeEncoderConfig[[transformers.VoxtralRealtimeEncoderConfig]]

```python
transformers.VoxtralRealtimeEncoderConfig(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, vocab_size: int = 131072, hidden_size: int = 1280, intermediate_size: int = 5120, num_hidden_layers: int = 32, num_attention_heads: int = 32, activation_function: str = 'gelu', num_mel_bins: int = 128, initializer_range: float = 0.02, attention_dropout: float | int = 0.0, hidden_act: str = 'silu', max_position_embeddings: int = 1500, rms_norm_eps: float = 1e-05, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 750, head_dim: int = 64, use_cache: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/configuration_voxtral_realtime.py#L73)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `131072`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `1280`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `5120`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `32`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

activation_function (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

num_mel_bins (`int`, *opcional*, padrão `128`) : Número de recursos mel usados por quadro de entrada. Deve corresponder ao valor usado na classe `AutoFeatureExtractor`.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

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.

max_position_embeddings (`int`, *opcional*, padrão `1500`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado.

rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

sliding_window (`int`, *opcional*, padrão `750`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada.

head_dim (`int`, *opcional*, padrão `64`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

Esta é a classe de configuração para armazenar a configuração de um VoxtralRealtimeModel. Ela é usada para instanciar um modelo Voxtral Realtime 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 [mistralai/Voxtral-Mini-4B-Realtime-2602](https://huggingface.co/mistralai/Voxtral-Mini-4B-Realtime-2602)

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 VoxtralRealtimeEncoderConfig, VoxtralRealtimeEncoder

>>> # Initializing a VoxtralRealtimeEncoderConfig
>>> configuration = VoxtralRealtimeEncoderConfig()

>>> # Initializing a VoxtralRealtimeEncoder (with random weights)
>>> model = VoxtralRealtimeEncoder(configuration)

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

## VoxtralRealtimeTextConfig[[transformers.VoxtralRealtimeTextConfig]]

#### transformers.VoxtralRealtimeTextConfig[[transformers.VoxtralRealtimeTextConfig]]

```python
transformers.VoxtralRealtimeTextConfig(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, vocab_size: int = 32000, hidden_size: int = 4096, intermediate_size: int = 14336, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int | None = 4096, attention_dropout: float | int = 0.0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/configuration_voxtral_realtime.py#L26)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `32000`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `14336`) : Dimensão das representações do MLP.

num_hidden_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `32`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

num_key_value_heads (`int`, *opcional*, padrão `8`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

head_dim (`int`, *opcional*) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

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.

max_position_embeddings (`int`, *opcional*, padrão `131072`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário.

bos_token_id (`int`, *opcional*, padrão `1`) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : ID do token usado para o fim do fluxo no vocabulário.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

sliding_window (`int`, *opcional*, padrão `4096`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada.

attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

Esta é a classe de configuração para armazenar a configuração de um VoxtralRealtimeModel. Ela é usada para instanciar um modelo Voxtral Realtime 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 [mistralai/Voxtral-Mini-4B-Realtime-2602](https://huggingface.co/mistralai/Voxtral-Mini-4B-Realtime-2602)

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.

## VoxtralRealtimeFeatureExtractor[[transformers.VoxtralRealtimeFeatureExtractor]]

#### transformers.VoxtralRealtimeFeatureExtractor[[transformers.VoxtralRealtimeFeatureExtractor]]

```python
transformers.VoxtralRealtimeFeatureExtractor(feature_size = 128, sampling_rate = 16000, hop_length = 160, n_fft = 400, win_length = 400, padding_value = 0.0, global_log_mel_max = 1.5, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/feature_extraction_voxtral_realtime.py#L32)

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 128) : 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.

padding_value (`float`, *opcional*, padrão 0.0) : Valor de preenchimento usado para preencher o áudio. Deve corresponder a silêncios.

Constrói um extrator de recursos VOXTRAL_REALTIME.

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.

## VoxtralRealtimeProcessor[[transformers.VoxtralRealtimeProcessor]]

#### transformers.VoxtralRealtimeProcessor[[transformers.VoxtralRealtimeProcessor]]

```python
transformers.VoxtralRealtimeProcessor(feature_extractor, tokenizer)
```

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

**Parâmetros:**

feature_extractor (`VoxtralRealtimeFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`MistralCommonBackend`) : O tokenizer é uma entrada obrigatória.

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

[VoxtralRealtimeProcessor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeProcessor) oferece todas as funcionalidades de [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor) e [MistralCommonBackend](/docs/transformers/main/pt/model_doc/mistral#transformers.MistralCommonBackend). Consulte [~VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor) e [~MistralCommonBackend](/docs/transformers/main/pt/model_doc/mistral#transformers.MistralCommonBackend) para mais informações.

#### __call__[[transformers.VoxtralRealtimeProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.models.voxtral_realtime.processing_voxtral_realtime.VoxtralRealtimeProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/processing_voxtral_realtime.py#L130)

**Parâmetros:**

audio (`AudioInput`, *opcional*) : Áudio de entrada ou lote de áudios como arrays NumPy ou tensores PyTorch.

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 em uma sessão de streaming. Quando `True`, o áudio é codificado em uma solicitação completa de transcrição com texto tokenizado. Quando `False`, apenas os recursos de áudio são extraídos (a codificação do texto é ignorada). Deve ser `True` quando `is_streaming=False`.

**Retorna:** [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature)

Um [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) com os seguintes campos:

- **input_ids** -- Lista de ids de tokens a serem fornecidos ao modelo. Retornado quando `is_first_audio_chunk=True`.
- **attention_mask** -- Lista de índices que especifica quais tokens devem ser considerados pelo modelo. Retornado quando `is_first_audio_chunk=True`.
- **input_features** -- Características do espectrograma de Mel extraídas da entrada de áudio.
- **num_delay_tokens** -- O número de tokens de atraso usados para streaming.

Método principal para preparar a entrada de áudio para o modelo Voxtral Realtime. Este método codifica o áudio em uma solicitação de transcrição usando `mistral_common`, tokeniza o texto resultante e extrai os recursos de espectrograma mel usando o extrator de recursos. Suporta tanto o modo de streaming quanto o modo não-streaming.

## VoxtralRealtimeEncoder[[transformers.VoxtralRealtimeEncoder]]

#### transformers.VoxtralRealtimeEncoder[[transformers.VoxtralRealtimeEncoder]]

```python
transformers.VoxtralRealtimeEncoder(config: VoxtralRealtimeEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L499)

**Parâmetros:**

config ([VoxtralRealtimeEncoderConfig](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeEncoderConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O encoder do VoxtralRealtime, que é um encoder do Whisper.

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.VoxtralRealtimeEncoder.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, use_padding_cache: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L530)

**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 [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor). Consulte `VoxtralRealtimeFeatureExtractor.__call__()` para detalhes ([VoxtralRealtimeProcessor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeProcessor) usa [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor) para processar áudios).

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_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

padding_cache (`VoxtralRealtimeConv1dPaddingCache`, *opcional*) : Cache para preenchimento em camadas convolucionais para manter o estado entre blocos de streaming.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

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

use_padding_cache (`bool`, *opcional*) : Se deve usar o cache de padding.

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)

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

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([VoxtralRealtimeConfig](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeConfig)) e das entradas.

O método forward do [VoxtralRealtimeEncoder](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeEncoder) 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.
- **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) 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.

## VoxtralRealtimeModel[[transformers.VoxtralRealtimeModel]]

#### transformers.VoxtralRealtimeModel[[transformers.VoxtralRealtimeModel]]

```python
transformers.VoxtralRealtimeModel(config: VoxtralRealtimeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L863)

**Parâmetros:**

config ([VoxtralRealtimeConfig](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo VoxtralRealtime, que consiste em um codificador de estilo Whisper em streaming, um projetor multimodal, um modelo de linguagem baseado em Mistral e um embedding de tempo, sem uma cabeça de modelagem de linguagem.

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.VoxtralRealtimeModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, num_delay_tokens: typing.Union[int, torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L920)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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 [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor). Consulte `VoxtralRealtimeFeatureExtractor.__call__()` para detalhes ([VoxtralRealtimeProcessor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeProcessor) usa [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor) 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_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

encoder_past_key_values (`Cache`, *opcional*) : Estados ocultos pré-computados (chave e valor nos blocos de autoatenção) para o codificador.

padding_cache (`VoxtralRealtimeConv1dPaddingCache`, *opcional*) : Cache para preenchimento em camadas convolucionais para manter o estado entre blocos de streaming.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

encoder_inputs_embeds (`torch.Tensor`, *opcional*) : Opcionalmente, em vez de passar `input_features`, você pode escolher passar diretamente uma representação incorporada para o codificador.

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

num_delay_tokens (`int` ou `torch.Tensor`, *opcional*) : Número de tokens de atraso usados ao preparar as entradas.

**Retorna:** `VoxtralRealtimeModelOutputWithPast` ou `tuple(torch.Tensor)`

Uma `VoxtralRealtimeModelOutputWithPast` 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 ([VoxtralRealtimeConfig](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeConfig)) e das entradas.

O método forward do [VoxtralRealtimeModel](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeModel) 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`, *opcional*) -- Estados ocultos pré-computados (chave e valor nos blocos de autoatenção) para o codificador de áudio que podem ser usados para acelerar a decodificação sequencial.
- **padding_cache** (`VoxtralRealtimeConv1dPaddingCache`, *opcional*) -- Cache para preenchimento em camadas convolucionais para manter o estado entre blocos de streaming.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de áudio projetados antes de serem adicionados aos embeddings de texto.

## VoxtralRealtimeForConditionalGeneration[[transformers.VoxtralRealtimeForConditionalGeneration]]

#### transformers.VoxtralRealtimeForConditionalGeneration[[transformers.VoxtralRealtimeForConditionalGeneration]]

```python
transformers.VoxtralRealtimeForConditionalGeneration(config: VoxtralRealtimeConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L1011)

#### forward[[transformers.VoxtralRealtimeForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.voxtral_realtime.modeling_voxtral_realtime.VoxtralRealtimeConv1dPaddingCache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, num_delay_tokens: typing.Union[int, torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L1024)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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 [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor). Consulte `VoxtralRealtimeFeatureExtractor.__call__()` para detalhes ([VoxtralRealtimeProcessor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeProcessor) usa [VoxtralRealtimeFeatureExtractor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeFeatureExtractor) 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_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

encoder_past_key_values (`Cache`, *opcional*) : Estados ocultos pré-computados (chave e valor nos blocos de autoatenção) para o codificador que podem ser usados para acelerar a decodificação sequencial.

padding_cache (`VoxtralRealtimeConv1dPaddingCache`, *opcional*) : Cache para preenchimento em camadas convolucionais para manter o estado entre blocos de streaming.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

encoder_inputs_embeds (`torch.Tensor`, *opcional*) : Opcionalmente, em vez de passar `input_features`, você pode escolher passar diretamente uma representação incorporada para o codificador.

labels (`torch.LongTensor` 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]`.

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

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).

num_delay_tokens (`int` ou `torch.Tensor`, *opcional*) : Número de tokens de atraso usados ao preparar as entradas, veja [~VoxtralRealtimeProcessor](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeProcessor) para mais detalhes.

**Retorna:** `VoxtralRealtimeCausalLMOutputWithPast` ou `tuple(torch.Tensor)`

Um `VoxtralRealtimeCausalLMOutputWithPast` 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 ([VoxtralRealtimeConfig](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeConfig)) e das entradas.

O método forward de [VoxtralRealtimeForConditionalGeneration](/docs/transformers/main/pt/model_doc/voxtral_realtime#transformers.VoxtralRealtimeForConditionalGeneration) 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`, *opcional*) -- Estados ocultos pré-computados (chave e valor nos blocos de autoatenção) para o codificador de áudio que podem ser usados para acelerar a decodificação sequencial.
- **padding_cache** (`VoxtralRealtimeConv1dPaddingCache`, *opcional*) -- Cache para preenchimento em camadas convolucionais para manter o estado entre blocos de streaming.

Exemplo:

```python
>>> import torch
>>> from transformers import VoxtralRealtimeForConditionalGeneration, AutoProcessor
>>> from datasets import load_dataset

>>> repo_id = "mistralai/Voxtral-Mini-4B-Realtime-2602"

>>> processor = AutoProcessor.from_pretrained(repo_id)
>>> model = VoxtralRealtimeForConditionalGeneration.from_pretrained(repo_id, dtype=torch.bfloat16, device_map="auto")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio = ds[0]["audio"]["array"]

>>> inputs = processor(audio, return_tensors="pt")
>>> inputs = inputs.to(model.device, dtype=model.dtype)

>>> outputs = model.generate(**inputs)
>>> processor.batch_decode(outputs, skip_special_tokens=True)
```

#### get_audio_features[[transformers.VoxtralRealtimeForConditionalGeneration.get_audio_features]]

```python
get_audio_features(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/voxtral_realtime/modeling_voxtral_realtime.py#L1021)