# PE Audio Video

[PE Audio Video](https://huggingface.co/papers/2504.13181) es la rama conjunta de audio y vídeo de la familia Perception Encoder de Meta. Codifica flujos de audio y vídeo junto con una torre de texto compartida, generando embeddings contrastivos para cada combinación por pares, audio-texto, vídeo-texto, audio-vídeo y audio+texto-vídeo, a partir de una única pasada hacia adelante.

Internamente, el modelo alinea la secuencia de características del video con la resolución temporal del audio mediante interpolación de vecino más cercano, de modo que los clips con tasas de fotogramas diferentes a las tasas de muestreo se mantengan sincronizados. Los pesos del codificador de texto están vinculados entre las ramas de audio y video.

Puedes encontrar todos los puntos de control oficiales de PE Audio Video en la colección [perception-encoder-audio-visual](https://huggingface.co/collections/facebook/perception-encoder-audio-visual).

## Introducción

```py
import torch
from datasets import load_dataset
from transformers import AutoProcessor, PeAudioVideoModel
from transformers.video_utils import load_video

processor = AutoProcessor.from_pretrained("facebook/pe-av-large")
model = PeAudioVideoModel.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"]
video, _ = load_video("https://huggingface.co/datasets/hf-internal-testing/fixtures_videos/resolve/main/tennis.mp4")
labels = ["a person playing tennis with background crowd", "a dog barking in a park"]

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

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

print("audio-text:", outputs.logits_audio_text.sigmoid().tolist())
print("video-text:", outputs.logits_video_text.sigmoid().tolist())
print("audio-video:", outputs.logits_audio_video.sigmoid().tolist())
```

## Consejos y notas de uso

- [PeAudioVideoModel](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoModel) requiere al menos dos de `input_ids`, `input_values`, `pixel_values_videos`: si solo se proporcionan dos, se enruta al submodelo de solo audio o de solo video. Si se pasan los tres, se activa la ruta conjunta de audio, video y texto, así como el conjunto completo de matrices de logits en `PeAudioVideoOutput`.
- El audio utiliza `padding_mask` y el video utiliza `padding_mask_videos` simultáneamente. Son máscaras independientes; no las confunda con `attention_mask`, que está reservada para la torre de texto.
- La alineación de audio y vídeo se ejecuta por elemento del lote dentro de `_align_video_hidden_state`, por lo que los lotes con longitudes de audio/vídeo muy diferentes se itera en lugar de vectorizar. Mantenga los elementos del lote aproximadamente equilibrados para mejorar el rendimiento.
- Los pesos de la torre de texto están vinculados entre las ramas mediante `_tied_weights_keys`; no intente cargar codificadores de texto separados para las mitades de audio y video.

## PeAudioVideoConfig[[transformers.PeAudioVideoConfig]]

#### transformers.PeAudioVideoConfig[[transformers.PeAudioVideoConfig]]

```python
transformers.PeAudioVideoConfig(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_video_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/configuration_pe_audio_video.py#L78)

**Parámetros:**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

audio_video_config (`dict` o `PreTrainedConfig`, *opcional*) : Configuración para el componente codificador de audio y vídeo.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un PeAudioVideoModel. Se utiliza para instanciar un modelo Pe Audio Video según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

```python
>>> from transformers import PeAudioVideoModel, PeAudioVideoConfig

>>> # Initializing a PeAudioVideoModel style configuration
>>> configuration = PeAudioVideoConfig()

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

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

## PeAudioVideoEncoderConfig[[transformers.PeAudioVideoEncoderConfig]]

#### transformers.PeAudioVideoEncoderConfig[[transformers.PeAudioVideoEncoderConfig]]

```python
transformers.PeAudioVideoEncoderConfig(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, video_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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/configuration_pe_audio_video.py#L26)

**Parámetros:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de audio.

video_config (`Union[PreTrainedConfig, dict]`, *opcional*) : Configuración para el codificador de video. Si se proporciona un diccionario, se utiliza para instanciar [PeVideoEncoderConfig](/docs/transformers/v5.23.0/es/model_doc/pe_video#transformers.PeVideoEncoderConfig).

hidden_size (`int`, *opcional*, valor predeterminado `1792`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `4800`) : Dimensión de las representaciones MLP.

num_hidden_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `14`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

num_key_value_heads (`int`, *opcional*) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante meanpooling de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

head_dim (`int`, *opcional*, valor predeterminado `128`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads

hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, valor predeterminado `10000`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largas.

attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

Esta es la clase de configuración para almacenar la configuración de un PeAudioVideoModel. Se utiliza para instanciar un modelo Pe Audio Video según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/pe-av-large](https://huggingface.co/facebook/pe-av-large)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

```python
>>> from transformers import PeAudioVideoEncoder, PeAudioVideoEncoderConfig

>>> # Initializing a PeAudioVideoEncoder style configuration
>>> configuration = PeAudioVideoEncoderConfig()

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

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

## PeAudioVideoProcessor[[transformers.PeAudioVideoProcessor]]

#### transformers.PeAudioVideoProcessor[[transformers.PeAudioVideoProcessor]]

```python
transformers.PeAudioVideoProcessor(feature_extractor = None, video_processor = None, tokenizer = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/processing_pe_audio_video.py#L17)

## PeAudioVideoEncoder[[transformers.PeAudioVideoEncoder]]

#### transformers.PeAudioVideoEncoder[[transformers.PeAudioVideoEncoder]]

```python
transformers.PeAudioVideoEncoder(config: PeAudioVideoEncoderConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/modeling_pe_audio_video.py#L554)

**Parámetros:**

config ([PeAudioVideoEncoderConfig](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoEncoderConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo PeAudioVideo Encoder.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.PeAudioVideoEncoder.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/modeling_pe_audio_video.py#L573)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [PeAudioVideoProcessor.__call__()](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel de los videos se pueden obtener usando [PeVideoVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_video#transformers.PeVideoVideoProcessor). Consulte [PeVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para obtener más detalles ([PeAudioVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoProcessor) utiliza [PeVideoVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_video#transformers.PeVideoVideoProcessor) para procesar videos).

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en muestras de relleno de `input_values`. Valores de máscara seleccionados en `[0, 1]`:  - 1 para muestras que **no están enmascaradas**, - 0 para muestras que **están enmascaradas**.

padding_mask_videos (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara para evitar realizar atención en los fotogramas de relleno del vídeo. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para los fotogramas que **no están enmascarados**, - 0 para los fotogramas que **están enmascarados**.

**Devuelve:** `PeAudioVideoEncoderOutput` o `tuple(torch.Tensor)`

Un `PeAudioVideoEncoderOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([PeAudioVideoConfig](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoConfig)) y las entradas.

El método forward de [PeAudioVideoEncoder](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoEncoder) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **audio_model_output** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de audio, que contiene el último estado oculto, la salida agrupada y, opcionalmente, los estados ocultos y las atenciones. Consulte [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) para obtener más detalles.
- **video_model_output** (`BaseModelOutputWithPooling`, *opcional*) -- Salida del codificador de video, que contiene el último estado oculto, la salida agrupada y, opcionalmente, los estados ocultos y las atenciones. Consulte [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) para obtener más detalles.

## PeAudioVideoModel[[transformers.PeAudioVideoModel]]

#### transformers.PeAudioVideoModel[[transformers.PeAudioVideoModel]]

```python
transformers.PeAudioVideoModel(config: PeAudioVideoConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/modeling_pe_audio_video.py#L738)

#### forward[[transformers.PeAudioVideoModel.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pe_audio_video/modeling_pe_audio_video.py#L879)

**Parámetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Los tensores correspondientes al video de entrada. Los valores de píxel de los videos se pueden obtener usando [PeVideoVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_video#transformers.PeVideoVideoProcessor). Consulte [PeVideoVideoProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para obtener más detalles ([PeAudioVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoProcessor) utiliza [PeVideoVideoProcessor](/docs/transformers/v5.23.0/es/model_doc/pe_video#transformers.PeVideoVideoProcessor) para procesar videos).

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de audio de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [PeAudioVideoProcessor.__call__()](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin.__call__) para más detalles.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

padding_mask_videos (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara para evitar realizar atención en los fotogramas de relleno del vídeo. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para los fotogramas que **no están enmascarados**, - 0 para los fotogramas que **están enmascarados**.

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en muestras de relleno de `input_values`. Valores de máscara seleccionados en `[0, 1]`:  - 1 para muestras que **no están enmascaradas**, - 0 para muestras que **están enmascaradas**.

return_loss (`bool`, *opcional*) : Indica si se debe devolver la pérdida o no.

**Devuelve:** `PeAudioVideoOutput` o `tuple(torch.Tensor)`

Un `PeAudioVideoOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([PeAudioVideoConfig](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoConfig)) y las entradas.

El método forward de [PeAudioVideoModel](/docs/transformers/v5.23.0/es/model_doc/pe_audio_video#transformers.PeAudioVideoModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **audio_embeds** (`torch.Tensor`, *opcional*) -- Embeddings de la modalidad de audio. Forma `(batch_size, sequence_length, hidden_size)`.
- **video_embeds** (`torch.Tensor`, *opcional*) -- Embeddings de la modalidad de video. Forma `(batch_size, sequence_length, hidden_size)`.
- **audio_video_embeds** (`torch.Tensor`, *opcional*) -- Incrustaciones conjuntas de audio y vídeo generadas por un módulo de fusión. Forma `(batch_size, sequence_length, hidden_size)`.
- **text_audio_embeds** (`torch.Tensor`, *opcional*) -- Incrustaciones conjuntas de texto y audio. Forma `(batch_size, sequence_length, hidden_size)`.
- **text_video_embeds** (`torch.Tensor`, *opcional*) -- Incrustaciones conjuntas de texto y video. Forma `(batch_size, sequence_length, hidden_size)`.
- **text_audio_video_embeds** (`torch.Tensor`, *opcional*) -- Incrustaciones conjuntas de texto, audio y video que combinan las tres modalidades. Forma `(batch_size, sequence_length, hidden_size)`.
- **audio_plus_text_embeds** (`torch.Tensor`, *opcional*) -- Incrustaciones combinadas de audio y texto (p. ej., concatenación o fusión aditiva). Forma `(batch_size, sequence_length, hidden_size)`.
- **video_plus_text_embeds** (`torch.Tensor`, *opcional*) -- Embeddings combinados de video y texto. Forma `(batch_size, sequence_length, hidden_size)`.
- **text_outputs** (`MaskedLMOutput`, *opcional*) -- Salidas del modelo para el codificador de texto. Incluye estados ocultos, atenciones y, opcionalmente, la pérdida.
- **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salidas del modelo para el codificador de audio, que incluyen el último estado oculto y la salida agrupada.
- **video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salidas del modelo para el codificador de video, que incluyen el último estado oculto y la salida agrupada.
- **audio_video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Salidas del modelo para el codificador conjunto de audio y video.
- **logits_audio_text** (`torch.Tensor`, *opcional*) -- Logits de similitud entre los embeddings de audio y texto. Forma `(batch_size, batch_size)`.
- **logits_video_text** (`torch.Tensor`, *opcional*) -- Logits de similitud entre los embeddings de video y texto. Forma `(batch_size, batch_size)`.
- **logits_audio_video** (`torch.Tensor`, *opcional*) -- Logits de similitud entre los embeddings de audio y video. Forma `(batch_size, batch_size)`.
- **logits_audio_video_text** (`torch.Tensor`, *opcional*) -- Logits de similitud entre las modalidades de audio, vídeo y texto.
- **logits_audio_plus_text_video** (`torch.Tensor`, *opcional*) -- Logits de similitud entre los embeddings fusionados (audio + texto) y los embeddings de video.
- **logits_video_plus_text_audio** (`torch.Tensor`, *opcional*) -- Logits de similitud entre los embeddings fusionados (video + texto) y los embeddings de audio.
- **audio_text_loss** (`torch.Tensor`, *opcional*) -- Pérdida contrastiva calculada entre las representaciones de audio y texto.
- **video_text_loss** (`torch.Tensor`, *opcional*) -- Pérdida contrastiva calculada entre las representaciones de video y texto.
- **audio_video_loss** (`torch.Tensor`, *opcional*) -- Pérdida contrastiva calculada entre las representaciones de audio y video.
- **audio_video_text_loss** (`torch.Tensor`, *opcional*) -- Pérdida conjunta sobre las modalidades de audio, vídeo y texto.
- **audio_plus_text_video_loss** (`torch.Tensor`, *opcional*) -- Pérdida entre las representaciones fusionadas (audio + texto) y el video.
- **video_plus_text_audio_loss** (`torch.Tensor`, *opcional*) -- Pérdida entre las representaciones fusionadas (video + texto) y el audio.
- **loss** (`torch.Tensor`, *opcional*) -- Pérdida combinada de todas las pérdidas por modalidad.

