# PE Áudio Vídeo [PE Audio Video](https://huggingface.co/papers/2504.13181) é o ramo conjunto de áudio e vídeo da família Perception Encoder da Meta. Ele codifica fluxos de áudio e vídeo juntos com uma torre de texto compartilhada, produzindo embeddings contrastivos para cada combinação em pares, áudio-texto, vídeo-texto, áudio-vídeo e áudio+texto-vídeo, a partir de uma única passagem direta. Internamente, o modelo alinha a sequência de recursos do vídeo à resolução temporal do áudio por meio de interpolação de vizinho mais próximo, de modo que clipes com taxas de quadros diferentes das taxas de amostragem permaneçam sincronizados. Os pesos do codificador de texto são compartilhados entre os ramos de áudio e vídeo. Você pode encontrar todos os checkpoints oficiais de PE Audio Video 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, 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()) ``` ## Dicas e observações de uso - [PeAudioVideoModel](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoModel) requer pelo menos dois de `input_ids`, `input_values`, `pixel_values_videos` — se apenas dois forem fornecidos, ele direciona para o submodelo somente de áudio ou somente de vídeo. Passar os três ativa o caminho conjunto de áudio-vídeo-texto e o conjunto completo de matrizes de logits em `PeAudioVideoOutput`. - O áudio usa `padding_mask` e o vídeo usa `padding_mask_videos` simultaneamente. São máscaras independentes; não as confunda com `attention_mask`, que é reservada para a torre de texto. - O alinhamento de áudio e vídeo é executado por elemento do lote dentro de `_align_video_hidden_state`, de modo que lotes com comprimentos de áudio/vídeo muito diferentes itera em vez de vetorizar. Mantenha os itens do lote aproximadamente equilibrados para garantir o desempenho. - Os pesos da torre de texto são compartilhados entre os ramos por meio de `_tied_weights_keys` — não tente carregar codificadores de texto separados para as metades de áudio e vídeo. ## 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio_video/configuration_pe_audio_video.py#L78) **Parâmetros:** text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. audio_video_config (`dict` ou `PreTrainedConfig`, *opcional*) : Configuração para o componente codificador de áudio e vídeo. 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. Esta é a classe de configuração para armazenar a configuração de um PeAudioVideoModel. Ela é usada para instanciar um modelo Pe Audio Video 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 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio_video/configuration_pe_audio_video.py#L26) **Parâmetros:** audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio. video_config (`Union[PreTrainedConfig, dict]`, *opcional*) : Configuração para o codificador de vídeo. Se um dicionário for fornecido, ele será usado para instanciar [PeVideoEncoderConfig](/docs/transformers/main/pt/model_doc/pe_video#transformers.PeVideoEncoderConfig). 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 PeAudioVideoModel. Ela é usada para instanciar um modelo Pe Audio Video 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 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio_video/processing_pe_audio_video.py#L17) ## PeAudioVideoEncoder[[transformers.PeAudioVideoEncoder]] #### transformers.PeAudioVideoEncoder[[transformers.PeAudioVideoEncoder]] ```python transformers.PeAudioVideoEncoder(config: PeAudioVideoEncoderConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pe_audio_video/modeling_pe_audio_video.py#L554) **Parâmetros:** config ([PeAudioVideoEncoderConfig](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoEncoderConfig)) : 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 PeAudioVideo 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.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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/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 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 padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [PeAudioVideoProcessor.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [PeVideoVideoProcessor](/docs/transformers/main/pt/model_doc/pe_video#transformers.PeVideoVideoProcessor). Veja [PeVideoVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([PeAudioVideoProcessor](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoProcessor) usa [PeVideoVideoProcessor](/docs/transformers/main/pt/model_doc/pe_video#transformers.PeVideoVideoProcessor) para processar vídeos). 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**. padding_mask_videos (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara para evitar a execução de atenção em quadros de vídeo de preenchimento. Valores da máscara selecionados em `[0, 1]`: - 1 para quadros que **não estão mascarados**, - 0 para quadros que **estão mascarados**. **Retorna:** `PeAudioVideoEncoderOutput` ou `tuple(torch.Tensor)` Um `PeAudioVideoEncoderOutput` 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 ([PeAudioVideoConfig](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoConfig)) e das entradas. O método forward de [PeAudioVideoEncoder](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoEncoder) 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. - **audio_model_output** (`BaseModelOutputWithPooling`, *opcional*) -- Saída do codificador de áudio, contendo o último estado oculto, a saída agrupada e estados ocultos e atenções opcionais. Consulte [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) para mais detalhes. - **video_model_output** (`BaseModelOutputWithPooling`, *opcional*) -- Saída do codificador de vídeo, contendo o último estado oculto, a saída agrupada e estados ocultos e atenções opcionais. Consulte [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) para mais detalhes. ## PeAudioVideoModel[[transformers.PeAudioVideoModel]] #### transformers.PeAudioVideoModel[[transformers.PeAudioVideoModel]] ```python transformers.PeAudioVideoModel(config: PeAudioVideoConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/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 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) pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [PeVideoVideoProcessor](/docs/transformers/main/pt/model_doc/pe_video#transformers.PeVideoVideoProcessor). Veja [PeVideoVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([PeAudioVideoProcessor](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoProcessor) usa [PeVideoVideoProcessor](/docs/transformers/main/pt/model_doc/pe_video#transformers.PeVideoVideoProcessor) para processar vídeos). input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : 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 padding e conversão em um tensor do tipo `torch.Tensor`. Consulte [PeAudioVideoProcessor.__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_videos (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara para evitar a execução de atenção em quadros de vídeo de preenchimento. Valores da máscara selecionados em `[0, 1]`: - 1 para quadros que **não estão mascarados**, - 0 para quadros que **estão mascarados**. 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:** `PeAudioVideoOutput` ou `tuple(torch.Tensor)` Um `PeAudioVideoOutput` 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 ([PeAudioVideoConfig](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoConfig)) e das entradas. O método forward do [PeAudioVideoModel](/docs/transformers/main/pt/model_doc/pe_audio_video#transformers.PeAudioVideoModel) 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. - **audio_embeds** (`torch.Tensor`, *opcional*) -- Embeddings da modalidade de áudio. Formato `(batch_size, sequence_length, hidden_size)`. - **video_embeds** (`torch.Tensor`, *opcional*) -- Embeddings da modalidade de vídeo. Formato `(batch_size, sequence_length, hidden_size)`. - **audio_video_embeds** (`torch.Tensor`, *opcional*) -- Incorporações conjuntas de áudio e vídeo produzidas por um módulo de fusão. Formato `(batch_size, sequence_length, hidden_size)`. - **text_audio_embeds** (`torch.Tensor`, *opcional*) -- Incorporações conjuntas de texto e áudio. Formato `(batch_size, sequence_length, hidden_size)`. - **text_video_embeds** (`torch.Tensor`, *opcional*) -- Incorporações conjuntas de texto e vídeo. Formato `(batch_size, sequence_length, hidden_size)`. - **text_audio_video_embeds** (`torch.Tensor`, *opcional*) -- Incorporações conjuntas de texto, áudio e vídeo que combinam as três modalidades. Formato `(batch_size, sequence_length, hidden_size)`. - **audio_plus_text_embeds** (`torch.Tensor`, *opcional*) -- Incorporações combinadas de áudio e texto (por exemplo, concatenação ou fusão aditiva). Formato `(batch_size, sequence_length, hidden_size)`. - **video_plus_text_embeds** (`torch.Tensor`, *opcional*) -- Embeddings combinados de vídeo e texto. Formato `(batch_size, sequence_length, hidden_size)`. - **text_outputs** (`MaskedLMOutput`, *opcional*) -- Saídas do modelo para o codificador de texto. Inclui estados ocultos, atenções e, opcionalmente, a perda. - **audio_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de áudio, incluindo o último estado oculto e a saída agrupada. - **video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador de vídeo, incluindo o último estado oculto e a saída agrupada. - **audio_video_outputs** (`BaseModelOutputWithPooling`, *opcional*) -- Saídas do modelo para o codificador conjunto de áudio e vídeo. - **logits_audio_text** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre embeddings de áudio e texto. Formato `(batch_size, batch_size)`. - **logits_video_text** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre embeddings de vídeo e texto. Formato `(batch_size, batch_size)`. - **logits_audio_video** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre os embeddings de áudio e vídeo. Formato `(batch_size, batch_size)`. - **logits_audio_video_text** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre as modalidades de áudio, vídeo e texto. - **logits_audio_plus_text_video** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre os embeddings fundidos (áudio + texto) e os embeddings de vídeo. - **logits_video_plus_text_audio** (`torch.Tensor`, *opcional*) -- Logits de similaridade entre os embeddings fundidos (vídeo + texto) e os embeddings de áudio. - **audio_text_loss** (`torch.Tensor`, *opcional*) -- Perda contrastiva calculada entre as representações de áudio e texto. - **video_text_loss** (`torch.Tensor`, *opcional*) -- Perda contrastiva calculada entre as representações de vídeo e texto. - **audio_video_loss** (`torch.Tensor`, *opcional*) -- Perda contrastiva calculada entre as representações de áudio e vídeo. - **audio_video_text_loss** (`torch.Tensor`, *opcional*) -- Perda conjunta sobre as modalidades de áudio, vídeo e texto. - **audio_plus_text_video_loss** (`torch.Tensor`, *opcional*) -- Perda entre as representações fundidas (áudio + texto) e o vídeo. - **video_plus_text_audio_loss** (`torch.Tensor`, *opcional*) -- Perda entre as representações fundidas (vídeo + texto) e o áudio. - **loss** (`torch.Tensor`, *opcional*) -- Perda combinada para todas as perdas por modalidade.