# VideoPrism

O modelo VideoPrism foi proposto no artigo [VideoPrism: A Foundational Visual Encoder for Video Understanding](https://huggingface.co/papers/2402.13217) da Google DeepMind ([post no blog](https://research.google/blog/videoprism-a-foundational-visual-encoder-for-video-understanding/)).

VideoPrism é um codificador de vídeo de uso geral que lida com diversas tarefas de compreensão de vídeo com um único modelo congelado. O modelo é pré-treinado em um corpus heterogêneo em larga escala, contendo 36M de pares de vídeo-legenda de alta qualidade e 582M de clipes de vídeo com texto paralelo ruidoso (por exemplo, transcrições ASR). A abordagem de pré-treinamento aprimora o auto-codificação mascarada por meio da destilação global-local de embeddings semânticos de vídeo e de um esquema de embaralhamento de tokens, permitindo que o modelo foque principalmente na modalidade de vídeo, ao mesmo tempo em que aproveita o texto associado aos vídeos. O VideoPrism atinge desempenho de estado da arte em 31 dos 33 benchmarks de compreensão de vídeo, abrangendo quatro grupos amplos de tarefas, desde perguntas e respostas sobre vídeos da web até visão computacional para a ciência.

    

Você pode encontrar todos os checkpoints originais do VideoPrism na coleção [VideoPrism](https://huggingface.co/collections/google/videoprism).

Observações:

- VideoPrism utiliza uma arquitetura de codificador espaço-temporal fatorado, processando vídeos por meio de transformadores espaciais e temporais separados.
- O modelo suporta aprendizado contrastivo de vídeo e texto por meio de `VideoPrismClipModel`, que combina um codificador de vídeo e um codificador de texto. `VideoPrismConfig` deve ser usado com este modelo.
- Para tarefas de classificação de vídeo, use `VideoPrismForVideoClassification`, que adiciona uma cabeça de classificação sobre o codificador de vídeo. `VideoPrismVisionConfig` deve ser usado com este modelo.
- O codificador de visão pode ser usado de forma independente via `VideoPrismVisionModel` para extrair recursos de vídeo. `VideoPrismVisionConfig` deve ser usado com este modelo.
- A resolução de entrada padrão é de 288x288 pixels, com 16 quadros por clipe de vídeo para os modelos base e 8 quadros para os modelos grandes. Defina interpolate_pos_encoding=True para usar os modelos com resolução personalizada e número de quadros por clipe.

Este modelo foi contribuído por [MHRDYN7](https://github.com/MHRDYN7) e revisado por [vasqu](https://github.com/vasqu) & [zucchini-nlp](https://github.com/zucchini-nlp). O código original pode ser encontrado [aqui](https://github.com/google-deepmind/videoprism).

## Exemplo de uso

O trecho abaixo mostra como carregar o VideoPrismVisionModel para extração de recursos usando a classe `AutoModel`.

```py
import torch
from transformers import AutoModel, AutoVideoProcessor

processor = AutoVideoProcessor.from_pretrained("google/videoprism-base-f16r288", revision="refs/pr/4")
model = AutoModel.from_pretrained(
    "google/videoprism-base-f16r288",
    revision="refs/pr/4",
    device_map="auto",
    # use "flash_attention_2" for faster inference on supported hardware
    # attn_implementation="flash_attention_2" 
)

video_url = "https://huggingface.co/datasets/nateraw/kinetics-mini/resolve/main/val/archery/-Qz25rXdMjE_000014_000024.mp4"

# when do_sample_frames=True, 16/8 frames will be sampled by default depending on the checkpoint size base/large.
processed_video_inputs = processor(videos=[video_url], return_metadata=True, do_sample_frames=True)
video_metadata = processed_video_inputs["video_metadata"]
video_inputs = processed_video_inputs["pixel_values_videos"].to(model.device)
outputs = model(video_inputs)

# VideoPrism encoder outputs
encoder_outputs = outputs.last_hidden_state

```

## VideoPrismVisionConfig[[transformers.VideoPrismVisionConfig]]

#### transformers.VideoPrismVisionConfig[[transformers.VideoPrismVisionConfig]]

```python
transformers.VideoPrismVisionConfig(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, image_size: int | list[int] | tuple[int, int] = 288, num_frames: int = 16, tubelet_size: list[int] | tuple[int, ...] = (1, 18, 18), num_channels: int = 3, hidden_size: int = 768, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu_python', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, qkv_bias: bool = True, num_spatial_layers: int = 12, num_temporal_layers: int = 4, attn_logit_softcapping: float = 50.0, num_auxiliary_layers: int = 2, apply_l2norm: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/configuration_videoprism.py#L30)

**Parâmetros:**

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `288`) : O tamanho (resolução) de cada imagem.

num_frames (`int`, *opcional*, padrão 16) : O número de quadros no vídeo de entrada.

tubelet_size (`List[int]`, *opcional*, padrão `[1, 18, 18]`) : O tamanho do patch de tubelet.

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

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

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

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

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

hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

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

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

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

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

num_spatial_layers (`int`, *opcional*, padrão 12) : Número de blocos de transformador espacial.

num_temporal_layers (`int`, *opcional*, padrão 4) : Número de blocos de transformer temporal.

attn_logit_softcapping (`float`, *opcional*, padrão 50.0) : Constante de softcapping para logits de atenção.

num_auxiliary_layers (`int`, *opcional*, padrão 2) : Número de camadas auxiliares. Isso é usado no VideoPrismVideoModel, que faz parte do VideoPrismClipModel.

apply_l2norm (`bool`, *opcional*, padrão `True`) : Se deve aplicar normalização L2 à saída. Isso é usado no VideoPrismVideoModel, que faz parte do VideoPrismClipModel.

Esta é a classe de configuração para armazenar a configuração de um VideoPrismClipModel. Ela é usada para instanciar um modelo Videoprism 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 [google/videoprism-base-f16r288](https://huggingface.co/google/videoprism-base-f16r288)

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.

## VideoPrismTextConfig[[transformers.VideoPrismTextConfig]]

#### transformers.VideoPrismTextConfig[[transformers.VideoPrismTextConfig]]

```python
transformers.VideoPrismTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, hidden_size: int = 768, intermediate_size: int = 3072, num_hidden_layers: int = 12, num_attention_heads: int = 12, max_position_embeddings: int = 64, hidden_act: str = 'relu', layer_norm_eps: float = 1e-06, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, attention_probs_dropout_prob: float | int = 0.0, apply_l2norm: bool = True, qkv_bias: bool = True, hidden_dropout_prob: float = 0.0, initializer_range: float = 0.02, attn_logit_softcapping: float = 50.0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/configuration_videoprism.py#L72)

**Parâmetros:**

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

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

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

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

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

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

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

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

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

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

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

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

apply_l2norm (`bool`, *opcional*, padrão `True`) : Se deve aplicar normalização L2 à saída do VideoPrismTextEncoder.

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

hidden_dropout_prob (`float`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

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

attn_logit_softcapping (`float`, *opcional*, padrão 50.0) : Constante de softcapping para logits de atenção.

Esta é a classe de configuração para armazenar a configuração de um VideoPrismClipModel. Ela é usada para instanciar um modelo Videoprism 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 [google/videoprism-lvt-base-f16r288](https://huggingface.co/google/videoprism-lvt-base-f16r288)

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.

## VideoPrismConfig[[transformers.VideoPrismConfig]]

#### transformers.VideoPrismConfig[[transformers.VideoPrismConfig]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/configuration_videoprism.py#L105)

**Parâmetros:**

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

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

Esta é a classe de configuração para armazenar a configuração de um VideoPrismClipModel. Ela é usada para instanciar um modelo Videoprism 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 [google/videoprism-lvt-base-f16r288](https://huggingface.co/google/videoprism-lvt-base-f16r288)

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 VideoPrismClipModel, VideoPrismConfig

>>> # Initializing a VideoPrismConfig with default values
>>> configuration = VideoPrismConfig()

>>> # Initializing a VideoPrismClipModel with the configuration
>>> model = VideoPrismClipModel(configuration)

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

## VideoPrismTokenizer[[transformers.VideoPrismTokenizer]]

#### transformers.VideoPrismTokenizer[[transformers.VideoPrismTokenizer]]

```python
transformers.VideoPrismTokenizer(vocab: str | list[tuple[str, float]] | None = None, eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', _spm_precompiled_charsmap = None, extra_ids = 100, additional_special_tokens = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/tokenization_videoprism.py#L33)

Constrói um tokenizador VideoPrism, que é essencialmente um tokenizador T5 sem seu pós-processador (que adiciona um token EOS no final da sequência).

Este tokenizer herda de [T5Tokenizer](/docs/transformers/main/pt/model_doc/t5#transformers.T5Tokenizer), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para mais informações sobre esses métodos.

#### get_sentinel_token_ids[[transformers.VideoPrismTokenizer.get_sentinel_token_ids]]

```python
get_sentinel_token_ids()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/tokenization_videoprism.py#L121)

Obtenha os IDs de tokens para tokens sentinel.

#### get_sentinel_tokens[[transformers.VideoPrismTokenizer.get_sentinel_tokens]]

```python
get_sentinel_tokens()
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/tokenization_videoprism.py#L115)

Obtenha a lista de tokens sentinel (tokens extra_id) de additional_special_tokens.

## VideoPrismProcessor[[transformers.VideoPrismProcessor]]

#### transformers.VideoPrismProcessor[[transformers.VideoPrismProcessor]]

```python
transformers.VideoPrismProcessor(video_processor = None, tokenizer = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/processing_videoprism.py#L42)

**Parâmetros:**

video_processor (`LlavaOnevisionVideoProcessor`) : O processador de vídeo é uma entrada obrigatória.

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

Constrói um VideoPrismProcessor que encapsula um processador de vídeo e um tokenizer em um único processador.

[VideoPrismProcessor](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismProcessor) oferece todas as funcionalidades de [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) e [VideoPrismTokenizer](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismTokenizer). Consulte [~LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) e [~VideoPrismTokenizer](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismTokenizer) para mais informações.

## VideoPrismVisionModel[[transformers.VideoPrismVisionModel]]

#### transformers.VideoPrismVisionModel[[transformers.VideoPrismVisionModel]]

```python
transformers.VideoPrismVisionModel(config: VideoPrismVisionConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L526)

**Parâmetros:**

config ([VideoPrismVisionConfig](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismVisionConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O encoder de visão VideoPrism puro, que produz estados ocultos brutos sem nenhum head específico no topo. Este modelo é o encoder de backbone usado em VideoPrismVideoModel.

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

```python
forward(pixel_values_videos: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool | None = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L547)

**Parâmetros:**

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 [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor). Veja [LlavaOnevisionVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([VideoPrismProcessor](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismProcessor) usa [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) para processar vídeos).

interpolate_pos_encoding (`bool`, *opcional*, padrão `False`) : Se deve interpolar as codificações de posição pré-treinadas.

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

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

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

- **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.
- **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.
- **last_temporal_hidden_state** (`torch.Tensor`, *opcional*) -- O último estado oculto do codificador temporal, tipicamente de forma `(batch_size * num_patches, num_frames, hidden_size)`.
- **last_spatial_hidden_state** (`torch.Tensor`, *opcional*) -- O último estado oculto do codificador espacial, tipicamente de forma `(batch_size * num_frames, num_patches, hidden_size)`.

Exemplo:

```python
```

## VideoPrismVideoModel[[transformers.VideoPrismVideoModel]]

#### transformers.VideoPrismVideoModel[[transformers.VideoPrismVideoModel]]

```python
transformers.VideoPrismVideoModel(config: VideoPrismVisionConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L717)

**Parâmetros:**

config ([VideoPrismVisionConfig](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismVisionConfig)) : 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.

Modelo de vídeo VideoPrism composto pelo backbone do codificador de visão com camadas auxiliares de codificador e uma cabeça de pooling de atenção no topo. Este modelo é usado em VideoPrismClipModel.

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

```python
forward(pixel_values_videos: Tensor, interpolate_pos_encoding: bool | None = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L735)

**Parâmetros:**

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor). Veja [LlavaOnevisionVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([VideoPrismProcessor](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismProcessor) usa [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) para processar vídeos).

interpolate_pos_encoding (`bool`, *opcional*, padrão `False`) : Se deve interpolar as codificações de posição pré-treinadas.

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

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

- **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.

## VideoPrismTextModel[[transformers.VideoPrismTextModel]]

#### transformers.VideoPrismTextModel[[transformers.VideoPrismTextModel]]

```python
transformers.VideoPrismTextModel(config: VideoPrismTextConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L658)

**Parâmetros:**

config ([VideoPrismTextConfig](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismTextConfig)) : 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 codificador de texto do VideoPrism em si, que produz os últimos estados ocultos sem nenhum cabeçalho específico no topo. Este modelo é usado no VideoPrismClipModel.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L673)

**Parâmetros:**

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

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)

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

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

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

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

- **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.

## VideoPrismClipModel[[transformers.VideoPrismClipModel]]

#### transformers.VideoPrismClipModel[[transformers.VideoPrismClipModel]]

```python
transformers.VideoPrismClipModel(config: VideoPrismConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L768)

**Parâmetros:**

config ([VideoPrismConfig](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismConfig)) : 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.

Modelo VideoPrism para aprendizado contrastivo de vídeo e texto. Este modelo consiste em um VideoPrismVideoModel e um VideoPrismTextModel e calcula pontuações de similaridade entre entradas de vídeo e texto.

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

```python
forward(pixel_values_videos: Tensor, input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool | None = False, temperature: float | None = None, return_loss: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L831)

**Parâmetros:**

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor). Veja [LlavaOnevisionVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([VideoPrismProcessor](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismProcessor) usa [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) para processar vídeos).

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)

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)

interpolate_pos_encoding (`bool`, *opcional*, padrão `False`) : Se deve interpolar as codificações de posição pré-treinadas.

temperature (`float`, *opcional*) : Um escalar de temperatura para escalar as pontuações de similaridade. Se não for fornecido, nenhum escalonamento é aplicado.

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

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

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

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

- **logits_per_video** (`torch.Tensor` de forma `(video_batch_size, text_batch_size)`) -- As pontuações de produto escalar escalonado entre `video_embeds` e `text_embeds`. Isso representa as pontuações de similaridade entre vídeo e texto.
- **logits_per_text** (`torch.Tensor` de forma `(text_batch_size, video_batch_size)`) -- As pontuações de produto escalar escalonado entre `text_embeds` e `video_embeds`. Isso representa as pontuações de similaridade texto-vídeo.
- **video_embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`) -- Os embeddings de vídeo obtidos ao aplicar a camada de projeção à saída agregada do [VideoPrismVideoModel](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismVideoModel).
- **text_embeds** (`torch.Tensor` de forma `(batch_size, output_dim)`) -- Os embeddings de texto obtidos aplicando a camada de projeção à saída agregada do [VideoPrismTextModel](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismTextModel).
- **video_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída de [VideoPrismVideoModel](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismVideoModel).
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *opcional*) -- A saída do [VideoPrismTextModel](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismTextModel).
- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `return_loss` é `True`) -- Perda contrastiva para similaridade vídeo-texto.

Exemplo:

```python
```

## VideoPrismForVideoClassification[[transformers.VideoPrismForVideoClassification]]

#### transformers.VideoPrismForVideoClassification[[transformers.VideoPrismForVideoClassification]]

```python
transformers.VideoPrismForVideoClassification(config: VideoPrismVisionConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L898)

**Parâmetros:**

config ([VideoPrismVisionConfig](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismVisionConfig)) : 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.

Modelo transformer do VideoPrism com uma cabeça de classificação de vídeo no topo (uma camada linear no topo do pooler de atenção).

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

```python
forward(pixel_values_videos: Tensor, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool | None = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videoprism/modeling_videoprism.py#L917)

**Parâmetros:**

pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor). Veja [LlavaOnevisionVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([VideoPrismProcessor](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismProcessor) usa [LlavaOnevisionVideoProcessor](/docs/transformers/main/pt/model_doc/llava_onevision#transformers.LlavaOnevisionVideoProcessor) para processar vídeos).

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada).

interpolate_pos_encoding (`bool`, *opcional*, padrão `False`) : Se deve interpolar as codificações de posição pré-treinadas.

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

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

O método forward de [VideoPrismForVideoClassification](/docs/transformers/main/pt/model_doc/videoprism#transformers.VideoPrismForVideoClassification) 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*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada estágio) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, patch_size, 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.

Exemplo:

```python
```