# PE Audio

[PE Audio](https://huggingface.co/papers/2504.13181) é o ramo de áudio da família Perception Encoder da Meta. Ele alinha contrastivamente formas de onda brutas com texto em um espaço de incorporação compartilhado, treinado em dados de áudio e legendas em pares para recuperação entre modalidades e classificação de áudio zero-shot.

Duas cabeças são expostas no topo do mesmo codificador. [PeAudioModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioModel) retorna um embedding agregado por clipe para recuperação em nível de clipe, enquanto [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna um embedding a cada 40 ms para localização de eventos e análise temporal de granularidade fina.

Você pode encontrar todos os checkpoints oficiais do PE Audio na coleção [perception-encoder-audio-visual](https://huggingface.co/collections/facebook/perception-encoder-audio-visual).

## Início rápido

```py
import torch
from datasets import load_dataset
from transformers import AutoProcessor, PeAudioModel

processor = AutoProcessor.from_pretrained("facebook/pe-av-large")
model = PeAudioModel.from_pretrained(
    "facebook/pe-av-large",
    device_map="auto",
)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio = ds[0]["audio"]["array"]
labels = ["a dog barking", "a person speaking", "music playing"]

audio_inputs = processor.feature_extractor(audio, sampling_rate=48_000, return_tensors="pt").to(model.device)
text_inputs = processor.tokenizer(labels, padding=True, return_tensors="pt").to(model.device)
inputs = {**audio_inputs, **text_inputs}

with torch.no_grad():
    outputs = model(**inputs)

probs = outputs.logits_audio_text.sigmoid()
print({label: p.item() for label, p in zip(labels, probs[0])})
```

## Dicas e observações de uso

- O áudio deve ser mono (`feature_size=1`) e reamostrado para 48 kHz — o extrator de recursos emite um aviso, mas não realiza a reamostragem por você. A entrada estéreo não é suportada.
- Áudio de comprimento variável é tratado com `padding_mask` (e não com o habitual `attention_mask`). A máscara é reduzida internamente por `dac_config.hop_length` antes de chegar ao codificador, portanto, passe a máscara na resolução da forma de onda bruta que o extrator de recursos retorna.
- [PeAudioModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioModel) retorna logits com a forma `(n_audio, n_text)`. [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna `(n_audio, n_text, n_frames)` com um frame a cada 40 ms. Escolha a classe que corresponde à tarefa — elas compartilham pesos, então a troca é barata.
- A torre de texto é um codificador compartilhado carregado via `AutoModel` a partir de `config.text_config`. O tokenizador é anexado ao processador via `AutoTokenizer`, e não por meio de uma classe dedicada.

## PeAudioConfig[[transformers.PeAudioConfig]]

#### transformers.PeAudioConfig[[transformers.PeAudioConfig]]

```python
transformers.PeAudioConfig(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/configuration_pe_audio.py#L88)

**Parâmetros:**

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

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

Esta é a classe de configuração para armazenar a configuração de um PeAudioModel. Ela é usada para instanciar um modelo Pe Audio 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 [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

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 PeAudioModel, PeAudioConfig

>>> # Initializing a PeAudioModel style configuration
>>> configuration = PeAudioConfig()

>>> # Initializing a model from the pe-av-large style configuration
>>> model = PeAudioModel(configuration)

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

## PeAudioEncoderConfig[[transformers.PeAudioEncoderConfig]]

#### transformers.PeAudioEncoderConfig[[transformers.PeAudioEncoderConfig]]

```python
transformers.PeAudioEncoderConfig(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, dac_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 1792, intermediate_size: int = 4800, num_hidden_layers: int = 6, num_attention_heads: int = 14, num_key_value_heads: int | None = None, head_dim: int = 128, hidden_act: str = 'silu', max_position_embeddings: int = 10000, initializer_range: float = 0.02, rms_norm_eps: float = 1e-05, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int = 0.0)
```

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

**Parâmetros:**

dac_config (`Union[PreTrainedConfig, dict]`, *opcional*) : Configuração para o codificador de áudio DAC usado para tokenizar as entradas de áudio bruto. Se um dicionário for passado, ele será usado para instanciar um [DacConfig](/docs/transformers/main/pt/model_doc/dac#transformers.DacConfig) com hiperparâmetros padrão do DAC.

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

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

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

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

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

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

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 PeAudioModel. Ela é usada para instanciar um modelo Pe Audio 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 [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

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 PeAudioEncoder, PeAudioEncoderConfig

>>> # Initializing a PeAudioEncoder style configuration
>>> configuration = PeAudioEncoderConfig()

>>> # Initializing a model from the pe-av-large style configuration
>>> model = PeAudioEncoder(configuration)

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

## PeAudioFeatureExtractor[[transformers.PeAudioFeatureExtractor]]

#### transformers.PeAudioFeatureExtractor[[transformers.PeAudioFeatureExtractor]]

```python
transformers.PeAudioFeatureExtractor(feature_size: int = 1, sampling_rate: int = 48000, padding_value: float = 0.0, hop_length: int = 1920, **kwargs)
```

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

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 1) : A dimensão dos recursos dos recursos extraídos. Use 1 para mono, 2 para estéreo.

sampling_rate (`int`, *opcional*, padrão 48000) : A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).

padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preenchimento.

hop_length (`int`, *opcional*, padrão 1920) : Comprimento de sobreposição entre janelas sucessivas.

Constrói um extrator de recursos de áudio PeAudioFeatureExtractor.

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.

#### __call__[[transformers.PeAudioFeatureExtractor.__call__]]

```python
__call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | str | list[str], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/feature_extraction_pe_audio.py#L63)

## PeAudioProcessor[[transformers.PeAudioProcessor]]

#### transformers.PeAudioProcessor[[transformers.PeAudioProcessor]]

```python
transformers.PeAudioProcessor(*args, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/processing_pe_audio.py#L17)

## PeAudioEncoder[[transformers.PeAudioEncoder]]

#### transformers.PeAudioEncoder[[transformers.PeAudioEncoder]]

```python
transformers.PeAudioEncoder(config: PeAudioEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L606)

**Parâmetros:**

config ([PeAudioEncoderConfig](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioEncoderConfig)) : 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 PeAudio Encoder.

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

```python
forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L625)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [PeAudioProcessor.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes.

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção em amostras de preenchimento de `input_values`. Valores de máscara selecionados em `[0, 1]`:  - 1 para amostras que **não estão mascaradas**, - 0 para amostras que **estão mascaradas**.

**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 ([PeAudioConfig](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioConfig)) e das entradas.

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

## PeAudioModel[[transformers.PeAudioModel]]

#### transformers.PeAudioModel[[transformers.PeAudioModel]]

```python
transformers.PeAudioModel(config: PeAudioConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L711)

#### forward[[transformers.PeAudioModel.forward]]

```python
forward(input_ids: Tensor, input_values: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, return_loss: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L744)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Í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 obter detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [PeAudioProcessor.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes.

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)

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção em amostras de preenchimento de `input_values`. Valores de máscara selecionados em `[0, 1]`:  - 1 para amostras que **não estão mascaradas**, - 0 para amostras que **estão mascaradas**.

return_loss (`bool`, *opcional*) : Se deve ou não retornar a perda.

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

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

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*) -- Perda contrastiva calculada entre as representações de áudio e texto.
- **logits_audio_text** (`torch.Tensor` de forma `(batch_size, batch_size)`, *opcional*) -- Logits de similaridade entre embeddings de áudio e texto. [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna logits por quadro de forma `(batch_size, batch_size, sequence_length)` em vez disso.
- **text_audio_embeds** (`torch.Tensor` de forma `(batch_size, hidden_size)`, *opcional*) -- Embebidos de texto projetados para o espaço áudio-texto.
- **audio_embeds** (`torch.Tensor` de forma `(batch_size, hidden_size)`, *opcional*) -- Embebidings de áudio projetados no espaço áudio-texto. [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna embebidings por quadro de forma `(batch_size, sequence_length, hidden_size)` em vez disso.
- **text_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de texto, incluindo o último estado oculto e a saída agrupada.
- **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de áudio, incluindo o último estado oculto e a saída agrupada.

## PeAudioFrameLevelModel[[transformers.PeAudioFrameLevelModel]]

#### transformers.PeAudioFrameLevelModel[[transformers.PeAudioFrameLevelModel]]

```python
transformers.PeAudioFrameLevelModel(config: PeAudioConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L800)

#### forward[[transformers.PeAudioFrameLevelModel.forward]]

```python
forward(input_ids: Tensor, input_values: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, return_loss: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio/modeling_pe_audio.py#L811)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Í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 obter detalhes. [O que são IDs de entrada?](../glossary#input-ids)

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`) : Valores em ponto flutuante da forma de onda bruta de fala de entrada. Os valores podem ser obtidos carregando um arquivo de áudio `.flac` ou `.wav` em um array do tipo `list[float]`, um `numpy.ndarray` ou um `torch.Tensor`, *por exemplo*, por meio da biblioteca torchcodec (`pip install torchcodec`) ou da biblioteca soundfile (`pip install soundfile`). Para preparar o array para `input_values`, o [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor) deve ser usado para preenchimento (padding) e conversão em um tensor do tipo `torch.Tensor`. Consulte [PeAudioProcessor.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes.

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)

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção em amostras de preenchimento de `input_values`. Valores de máscara selecionados em `[0, 1]`:  - 1 para amostras que **não estão mascaradas**, - 0 para amostras que **estão mascaradas**.

return_loss (`bool`, *opcional*) : Se deve ou não retornar a perda.

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

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

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*) -- Perda contrastiva calculada entre as representações de áudio e texto.
- **logits_audio_text** (`torch.Tensor` de forma `(batch_size, batch_size)`, *opcional*) -- Logits de similaridade entre embeddings de áudio e texto. [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna logits por quadro de forma `(batch_size, batch_size, sequence_length)` em vez disso.
- **text_audio_embeds** (`torch.Tensor` de forma `(batch_size, hidden_size)`, *opcional*) -- Embebidos de texto projetados para o espaço áudio-texto.
- **audio_embeds** (`torch.Tensor` de forma `(batch_size, hidden_size)`, *opcional*) -- Embebidings de áudio projetados no espaço áudio-texto. [PeAudioFrameLevelModel](/docs/transformers/main/pt/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) retorna embebidings por quadro de forma `(batch_size, sequence_length, hidden_size)` em vez disso.
- **text_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de texto, incluindo o último estado oculto e a saída agrupada.
- **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de áudio, incluindo o último estado oculto e a saída agrupada.