Hugging Face's logo

Transformers documentation

VideoPrism

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans les papiers HF le 2024-02-20 et contribué à Hugging Face Transformers le 2026-06-19.

FlashAttention

VideoPrism

Le modèle VideoPrism a été proposé dans l'article VideoPrism: A Foundational Visual Encoder for Video Understanding par Google DeepMind (article de blog).

VideoPrism est un encodeur vidéo à usage général qui traite diverses tâches de compréhension vidéo avec un modèle unique figé. Le modèle est pré-entraîné sur un corpus hétérogène à grande échelle contenant 36 millions de paires vidéo-légende de haute qualité et 582 millions de clips vidéo avec un texte parallèle bruité (par exemple, des transcriptions ASR). L’approche de pré-entraînement améliore l’auto-encodage masqué grâce à une distillation globale-locale des embeddings sémantiques vidéo et à un schéma de mélange de jetons, permettant au modèle de se concentrer principalement sur la modalité vidéo tout en exploitant le texte associé aux vidéos. VideoPrism atteint des performances de pointe sur 31 des 33 benchmarks de compréhension vidéo, répartis en quatre grands groupes de tâches, allant de la réponse à des questions sur des vidéos web à la vision par ordinateur pour la science.

drawing

Vous pouvez trouver tous les points de contrôle originaux de VideoPrism dans la collection VideoPrism.

Remarques :

  • VideoPrism utilise une architecture d'encodeur spatio-temporel factorisé, traitant les vidéos à l'aide de transformeurs spatiaux et temporels distincts.
  • Le modèle prend en charge l'apprentissage contrastif vidéo-texte via VideoPrismClipModel, qui combine un encodeur vidéo et un encodeur texte. VideoPrismConfig doit être utilisé avec ce modèle.
  • Pour les tâches de classification de vidéos, utilisez VideoPrismForVideoClassification, qui ajoute une tête de classification au-dessus de l’encodeur vidéo. VideoPrismVisionConfig doit être utilisé avec ce modèle.
  • L’encodeur visuel peut être utilisé de manière autonome via VideoPrismVisionModel pour extraire des caractéristiques vidéo. VideoPrismVisionConfig doit être utilisé avec ce modèle.
  • La résolution d'entrée par défaut est de 288x288 pixels, avec 16 images par clip vidéo pour les modèles de base et 8 images pour les grands modèles. Définissez interpolate_pos_encoding=True pour utiliser les modèles avec une résolution personnalisée et un nombre d'images par clip personnalisé.

Ce modèle a été contribué par MHRDYN7 et examiné par vasqu & zucchini-nlp. Le code d'origine peut être trouvé ici.

Exemple d'utilisation

L'extrait ci-dessous montre comment charger le modèle VideoPrismVisionModel pour l'extraction de caractéristiques à l'aide de la classe AutoModel.

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

classe transformers.VideoPrismVisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneimage_size: int | list[int] | tuple[int, int] = 288num_frames: int = 16tubelet_size: list[int] | tuple[int, ...] = (1, 18, 18)num_channels: int = 3hidden_size: int = 768num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu_python'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06qkv_bias: bool = Truenum_spatial_layers: int = 12num_temporal_layers: int = 4attn_logit_softcapping: float = 50.0num_auxiliary_layers: int = 2apply_l2norm: bool = True )

Paramètres

  • image_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 288) — La taille (résolution) de chaque image.
  • num_frames (int, facultatif, valeur par défaut : 16) — Le nombre d'images de la vidéo d'entrée.
  • tubelet_size (List[int], facultatif, par défaut [1, 18, 18]) — La taille du patch tubelet.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • hidden_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 3072) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut gelu_python) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • qkv_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.
  • num_spatial_layers (int, facultatif, par défaut 12) — Nombre de blocs de transformateur spatial.
  • num_temporal_layers (int, facultatif, valeur par défaut : 4) — Nombre de blocs de transformer temporels.
  • attn_logit_softcapping (float, facultatif, valeur par défaut 50.0) — Constante de softcapping pour les logits d'attention.
  • num_auxiliary_layers (int, facultatif, valeur par défaut : 2) — Nombre de couches auxiliaires. Utilisé dans VideoPrismVideoModel, qui fait partie de VideoPrismClipModel.
  • apply_l2norm (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer une normalisation L2 à la sortie. Cette option est utilisée dans VideoPrismVideoModel, qui fait partie de VideoPrismClipModel.

Ceci est la classe de configuration destinée à stocker la configuration d'un VideoPrismClipModel. Elle est utilisée pour instancier un modèle Videoprism en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de google/videoprism-base-f16r288

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

VideoPrismTextConfig

classe transformers.VideoPrismTextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 32000hidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12max_position_embeddings: int = 64hidden_act: str = 'relu'layer_norm_eps: float = 1e-06pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Noneattention_probs_dropout_prob: float | int = 0.0apply_l2norm: bool = Trueqkv_bias: bool = Truehidden_dropout_prob: float = 0.0initializer_range: float = 0.02attn_logit_softcapping: float = 50.0 )

Paramètres

  • vocab_size (int, facultatif, par défaut 32000) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 3072) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 12) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • max_position_embeddings (int, facultatif, par défaut 64) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • hidden_act (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • pad_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • apply_l2norm (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer une normalisation L2 à la sortie de VideoPrismTextEncoder.
  • qkv_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.
  • hidden_dropout_prob (float, facultatif, valeur par défaut 0.0) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • attn_logit_softcapping (float, facultatif, valeur par défaut 50.0) — Constante de softcapping pour les logits d'attention.

Ceci est la classe de configuration destinée à stocker la configuration d'un VideoPrismClipModel. Elle est utilisée pour instancier un modèle Videoprism en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de google/videoprism-lvt-base-f16r288

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

VideoPrismConfig

classe transformers.VideoPrismConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

Paramètres

  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone visuel.

Ceci est la classe de configuration destinée à stocker la configuration d'un VideoPrismClipModel. Elle est utilisée pour instancier un modèle Videoprism en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de google/videoprism-lvt-base-f16r288

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.VideoPrismTokenizer

< >

( vocab: str | list[tuple[str, float]] | None = Noneeos_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'_spm_precompiled_charsmap = Noneextra_ids = 100additional_special_tokens = None**kwargs )

Construit un tokeniseur VideoPrism, qui est essentiellement un tokeniseur T5 sans son postprocesseur (qui ajoute un jeton EOS à la fin de la séquence).

Ce tokenizer hérite de T5Tokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

get_sentinel_token_ids

< >

( )

Obtenez les identifiants de jetons pour les jetons sentinelles.

get_sentinel_tokens

< >

( )

Obtenez la liste des jetons sentinel (jetons extra_id) à partir de additional_special_tokens.

VideoPrismProcessor

classe transformers.VideoPrismProcessor

< >

( video_processor = Nonetokenizer = None )

Paramètres

  • video_processor (LlavaOnevisionVideoProcessor) — Le processeur vidéo est une entrée obligatoire.
  • tokenizer (VideoPrismTokenizer) — Le tokenizer est une entrée obligatoire.

Construit un VideoPrismProcessor qui encapsule un processeur vidéo et un tokeniseur en un seul processeur.

VideoPrismProcessor offre toutes les fonctionnalités de LlavaOnevisionVideoProcessor et de VideoPrismTokenizer. Consultez ~LlavaOnevisionVideoProcessor et ~VideoPrismTokenizer pour plus d'informations.

VideoPrismVisionModel

classe transformers.VideoPrismVisionModel

< >

( config: VideoPrismVisionConfig )

Paramètres

  • config (VideoPrismVisionConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le codeur visuel VideoPrism brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle est le codeur de base utilisé dans VideoPrismVideoModel.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( pixel_values_videos: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool | None = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithSpatialAndTemporalStates or tuple(torch.Tensor)

Paramètres

  • pixel_values_videos (torch.Tensor de forme (batch_size, num_frames, num_channels, frame_size, frame_size), facultatif) — Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels pour les vidéos peuvent être obtenues à l’aide de LlavaOnevisionVideoProcessor. Voir LlavaOnevisionVideoProcessor.call() pour plus de détails (VideoPrismProcessor utilise LlavaOnevisionVideoProcessor pour le traitement des vidéos).
  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.

Retourne

BaseModelOutputWithSpatialAndTemporalStates ou tuple(torch.Tensor)

Un BaseModelOutputWithSpatialAndTemporalStates ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (VideoPrismConfig) et des entrées.

La méthode forward du modèle VideoPrismVisionModel redéfinit la méthode spéciale __call__.

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

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

  • last_temporal_hidden_state (torch.Tensor, facultatif) — Le dernier état caché de l’encodeur temporel, généralement de forme (batch_size * num_patches, num_frames, hidden_size).

  • last_spatial_hidden_state (torch.Tensor, facultatif) — Le dernier état caché de l’encodeur spatial, généralement de forme (batch_size * num_frames, num_patches, hidden_size).

Exemple :

VideoPrismVideoModel

classe transformers.VideoPrismVideoModel

< >

( config: VideoPrismVisionConfig )

Paramètres

  • config (VideoPrismVisionConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle vidéo VideoPrism composé du backbone d'encodeur visuel avec des couches d'encodeur auxiliaires et d'une tête de pooling par attention au sommet. Ce modèle est utilisé dans VideoPrismClipModel.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( pixel_values_videos: Tensorinterpolate_pos_encoding: bool | None = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values_videos (torch.Tensor de forme (batch_size, num_frames, num_channels, frame_size, frame_size)) — Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels pour les vidéos peuvent être obtenues à l’aide de LlavaOnevisionVideoProcessor. Voir LlavaOnevisionVideoProcessor.call() pour plus de détails (VideoPrismProcessor utilise LlavaOnevisionVideoProcessor pour le traitement des vidéos).
  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (VideoPrismConfig) et des entrées.

La méthode forward du modèle VideoPrismVideoModel redéfinit la méthode spéciale __call__.

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

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

VideoPrismTextModel

classe transformers.VideoPrismTextModel

< >

( config: VideoPrismTextConfig )

Paramètres

  • config (VideoPrismTextConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le codeur de texte VideoPrism brut, qui produit les derniers états cachés sans aucune tête spécifique au sommet. Ce modèle est utilisé dans VideoPrismClipModel.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • position_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (VideoPrismConfig) et des entrées.

La méthode forward du modèle VideoPrismTextModel redéfinit la méthode spéciale __call__.

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

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

VideoPrismClipModel

classe transformers.VideoPrismClipModel

< >

( config: VideoPrismConfig )

Paramètres

  • config (VideoPrismConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle VideoPrism pour l'apprentissage contrastif vidéo-texte. Ce modèle est composé d'un VideoPrismVideoModel et d'un VideoPrismTextModel, et calcule des scores de similarité entre les entrées vidéo et texte.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( pixel_values_videos: Tensorinput_ids: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool | None = Falsetemperature: float | None = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VideoPrismClipOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values_videos (torch.Tensor de forme (batch_size, num_frames, num_channels, frame_size, frame_size)) — Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels pour les vidéos peuvent être obtenues à l’aide de LlavaOnevisionVideoProcessor. Voir LlavaOnevisionVideoProcessor.call() pour plus de détails (VideoPrismProcessor utilise LlavaOnevisionVideoProcessor pour le traitement des vidéos).
  • input_ids (torch.Tensor de forme (batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.
  • temperature (float, facultatif) — Un scalaire de température pour mettre à l'échelle les scores de similarité. S'il n'est pas fourni, aucune mise à l'échelle n'est appliquée.
  • return_loss (bool, facultatif) — Indique s'il faut renvoyer la perte contrastive.

Retourne

VideoPrismClipOutput ou tuple(torch.Tensor)

Un VideoPrismClipOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (VideoPrismConfig) et des entrées.

La méthode forward du modèle VideoPrismClipModel redéfinit la méthode spéciale __call__.

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

  • logits_per_video (torch.Tensor de forme (video_batch_size, text_batch_size)) — Les scores de produit scalaire normalisé entre video_embeds et text_embeds. Cela représente les scores de similarité vidéo-texte.
  • logits_per_text (torch.Tensor de forme (text_batch_size, video_batch_size)) — Les scores de produit scalaire normalisé entre text_embeds et video_embeds. Cela représente les scores de similarité texte-vidéo.
  • video_embeds (torch.Tensor de forme (batch_size, output_dim)) — Les embeddings vidéo obtenus en appliquant la couche de projection à la sortie agrégée de VideoPrismVideoModel.
  • text_embeds (torch.Tensor de forme (batch_size, output_dim)) — Les embeddings de texte obtenus en appliquant la couche de projection à la sortie agrégée de VideoPrismTextModel.
  • video_model_output (~modeling_outputs.BaseModelOutputWithPooling, facultatif) — La sortie de VideoPrismVideoModel.
  • text_model_output (~modeling_outputs.BaseModelOutputWithPooling, facultatif) — La sortie du VideoPrismTextModel.
  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque return_loss est True) — Perte contrastive pour la similarité vidéo-texte.

Exemple :

VideoPrismForVideoClassification

classe transformers.VideoPrismForVideoClassification

< >

( config: VideoPrismVisionConfig )

Paramètres

  • config (VideoPrismVisionConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Transformateur de modèle VideoPrism avec une tête de classification vidéo au sommet (une couche linéaire au-dessus du pooler d'attention).

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( pixel_values_videos: Tensorlabels: typing.Optional[torch.LongTensor] = Noneinterpolate_pos_encoding: bool | None = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ImageClassifierOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values_videos (torch.Tensor de forme (batch_size, num_frames, num_channels, frame_size, frame_size)) — Les tenseurs correspondant à la vidéo d’entrée. Les valeurs de pixels pour les vidéos peuvent être obtenues à l’aide de LlavaOnevisionVideoProcessor. Voir LlavaOnevisionVideoProcessor.call() pour plus de détails (VideoPrismProcessor utilise LlavaOnevisionVideoProcessor pour le traitement des vidéos).
  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).
  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.

Retourne

ImageClassifierOutput ou tuple(torch.Tensor)

Un ImageClassifierOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (VideoPrismConfig) et des entrées.

La méthode forward de VideoPrismForVideoClassification redéfinit la méthode spéciale __call__.

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

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).

  • logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque étape) de forme (batch_size, sequence_length, hidden_size). États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, patch_size, sequence_length).

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

Exemple :

Update on GitHub

←VideoMAE ViViT→