# PE Audio

[PE Audio](https://huggingface.co/papers/2504.13181) est la branche audio de la famille Perception Encoder de Meta. Il aligne de manière contrastive les formes d'onde brutes et le texte dans un espace d'embeddings partagé, entraîné sur des données appariées audio–légende pour la récupération intermodale et la classification audio en zéro tirage.

Deux têtes sont exposées au sommet du même encodeur. [PeAudioModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioModel) renvoie un seul embedding agrégé par clip pour la récupération au niveau du clip, tandis que [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie un embedding toutes les 40 ms pour la localisation d'événements et l'analyse temporelle fine.

Vous pouvez trouver tous les points de contrôle officiels de PE Audio dans la collection [perception-encoder-audio-visual](https://huggingface.co/collections/facebook/perception-encoder-audio-visual).

## Démarrage rapide

```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])})
```

## Conseils et notes d'utilisation

- L'audio doit être en mono (`feature_size=1`) et rééchantillonné à 48 kHz — l'extracteur de caractéristiques émet un avertissement mais ne procède pas à la rééchantillonnage à votre place. L'entrée stéréo n'est pas prise en charge.
- Les audio de longueur variable sont gérés avec `padding_mask` (et non le `attention_mask` habituel). Le masque est sous-échantillonné en interne par `dac_config.hop_length` avant d’atteindre l’encodeur ; passez donc le masque à la résolution de la forme d’onde brute renvoyé par l’extracteur de caractéristiques.
- [PeAudioModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioModel) renvoie des logits de forme `(n_audio, n_text)`. [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie `(n_audio, n_text, n_frames)` avec une frame toutes les 40 ms. Choisissez la classe qui correspond à la tâche — elles partagent les poids, donc le changement est peu coûteux.
- La tour de texte est un encodeur partagé chargé via `AutoModel` à partir de `config.text_config`. Le tokeniseur est rattaché au processeur via `AutoTokenizer`, et non par une classe dédiée.

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

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

**Paramètres :**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone audio.

Ceci est la classe de configuration destinée à stocker la configuration d'un PeAudioModel. Elle est utilisée pour instancier un modèle Pe Audio en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

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

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

**Paramètres :**

dac_config (`Union[PreTrainedConfig, dict]`, *facultatif*) : Configuration de l'encodeur audio DAC utilisé pour tokeniser les entrées audio brutes. Si un dictionnaire est transmis, il sera utilisé pour instancier un [DacConfig](/docs/transformers/main/fr/model_doc/dac#transformers.DacConfig) avec les hyperparamètres DAC par défaut.

hidden_size (`int`, *facultatif*, valeur par défaut `1792`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, par défaut `4800`) : Dimension des représentations MLP.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `14`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*) : C'est le nombre de têtes de key_value à utiliser pour implémenter l'attention par requêtes groupées (Grouped Query Attention). Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention multi-têtes (Multi Head Attention, MHA) ; si `num_key_value_heads=1`, il utilisera l'attention multi-requête (Multi Query Attention, MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête de clé et de valeur du groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.

head_dim (`int`, *facultatif*, valeur par défaut `128`) : La dimension des têtes d'attention. Si None, la valeur par défaut est hidden_size // num_attention_heads

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `10000`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

rms_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation rms.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

Ceci est la classe de configuration destinée à stocker la configuration d'un PeAudioModel. Elle est utilisée pour instancier un modèle Pe Audio en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

feature_size (`int`, *facultatif*, valeur par défaut : 1) : La dimension des caractéristiques des fonctionnalités extraites. Utilisez 1 pour le mono et 2 pour le stéréo.

sampling_rate (`int`, *facultatif*, valeur par défaut 48000) : Le taux d'échantillonnage auquel la forme d'onde audio doit être numérisée, exprimé en hertz (Hz).

padding_value (`float`, *facultatif*, par défaut 0.0) : La valeur utilisée pour le bourrage (padding).

hop_length (`int`, *facultatif*, valeur par défaut 1920) : Longueur de chevauchement entre les fenêtres successives.

Construit un extracteur de fonctionnalités PeAudioFeatureExtractor.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

#### __appel__[[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)
```

[Source](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)
```

[Source](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)
```

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

**Paramètres :**

config ([PeAudioEncoderConfig](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioEncoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle PeAudio Encoder.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

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

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [PeAudioProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails.

padding_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux échantillons de bourrage de `input_values`. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les échantillons qui ne sont **pas masqués**, - 0 pour les échantillons qui sont **masqués**.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PeAudioConfig](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioConfig)) et les entrées.

La méthode forward de [PeAudioEncoder](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioEncoder) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## PeAudioModel[[transformers.PeAudioModel]]

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

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

[Source](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)
```

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

**Paramètres :**

input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [PeAudioProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

padding_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux échantillons de bourrage de `input_values`. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les échantillons qui ne sont **pas masqués**, - 0 pour les échantillons qui sont **masqués**.

return_loss (`bool`, *facultatif*) : Indique s'il faut renvoyer la perte ou non.

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

Un `PeAudioOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PeAudioConfig](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioConfig)) et les entrées.

La méthode forward du [PeAudioModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*) -- Perte contrastive calculée entre les représentations audio et texte.
- **logits_audio_text** (`torch.Tensor` de forme `(batch_size, batch_size)`, *facultatif*) -- Logits de similarité entre les embeddings audio et texte. [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie à la place des logits par frame de forme `(batch_size, batch_size, sequence_length)`.
- **text_audio_embeds** (`torch.Tensor` de forme `(batch_size, hidden_size)`, *facultatif*) -- Embeddings de texte projetés dans l'espace audio-texte.
- **audio_embeds** (`torch.Tensor` de forme `(batch_size, hidden_size)`, *facultatif*) -- Embeddings audio projetés dans l'espace audio-texte. [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie à la place des embeddings par trame de forme `(batch_size, sequence_length, hidden_size)`.
- **text_outputs** (`BaseModelOutputWithPooling`, *facultatif*) -- Sorties du modèle pour l'encodeur de texte, incluant l'état caché final et la sortie agrégée.
- **audio_outputs** (`BaseModelOutputWithPooling`, *facultatif*) -- Sorties du modèle pour l'encodeur audio, incluant l'état caché final et la sortie agrégée.

## PeAudioFrameLevelModel[[transformers.PeAudioFrameLevelModel]]

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

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

[Source](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)
```

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

**Paramètres :**

input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [PeAudioProcessor.__call__()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

padding_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux échantillons de bourrage de `input_values`. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les échantillons qui ne sont **pas masqués**, - 0 pour les échantillons qui sont **masqués**.

return_loss (`bool`, *facultatif*) : Indique s'il faut renvoyer la perte ou non.

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

Un `PeAudioOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PeAudioConfig](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioConfig)) et les entrées.

La méthode forward du modèle [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*) -- Perte contrastive calculée entre les représentations audio et texte.
- **logits_audio_text** (`torch.Tensor` de forme `(batch_size, batch_size)`, *facultatif*) -- Logits de similarité entre les embeddings audio et texte. [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie à la place des logits par frame de forme `(batch_size, batch_size, sequence_length)`.
- **text_audio_embeds** (`torch.Tensor` de forme `(batch_size, hidden_size)`, *facultatif*) -- Embeddings de texte projetés dans l'espace audio-texte.
- **audio_embeds** (`torch.Tensor` de forme `(batch_size, hidden_size)`, *facultatif*) -- Embeddings audio projetés dans l'espace audio-texte. [PeAudioFrameLevelModel](/docs/transformers/main/fr/model_doc/pe_audio#transformers.PeAudioFrameLevelModel) renvoie à la place des embeddings par trame de forme `(batch_size, sequence_length, hidden_size)`.
- **text_outputs** (`BaseModelOutputWithPooling`, *facultatif*) -- Sorties du modèle pour l'encodeur de texte, incluant l'état caché final et la sortie agrégée.
- **audio_outputs** (`BaseModelOutputWithPooling`, *facultatif*) -- Sorties du modèle pour l'encodeur audio, incluant l'état caché final et la sortie agrégée.