Hugging Face's logo

Transformers documentation

VipLlava

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
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 HF papers le 2023-12-01 et contribué à Hugging Face Transformers le 2023-12-13.

VipLlava

FlashAttention SDPA

Aperçu

Le modèle VipLlava a été proposé dans Making Large Multimodal Models Understand Arbitrary Visual Prompts par Mu Cai, Haotian Liu, Siva Karthik Mustikovela, Gregory P. Meyer, Yuning Chai, Dennis Park, Yong Jae Lee.

VipLlava améliore le protocole d’entraînement de Llava en marquant les images et en interagissant avec le modèle à l’aide d’indices naturels tels qu’une « boîte englobante rouge » ou une « flèche pointée » pendant l’entraînement.

L'abstract de l'article est le suivant :

Alors que les grands modèles multimodaux vision-langage existants se concentrent sur la compréhension d’images entières, un écart important subsiste en matière de compréhension spécifique à des régions. Les approches actuelles qui utilisent des coordonnées textuelles ou des encodages spatiaux échouent souvent à offrir une interface conviviale pour le promptage visuel. Pour relever ce défi, nous introduisons un nouveau modèle multimodal capable de décoder des prompts visuels arbitraires. Cela permet aux utilisateurs de marquer intuitivement des images et d’interagir avec le modèle à l’aide d’indices naturels tels qu’une « boîte englobante rouge » ou une « flèche pointée ». Notre conception simple superpose directement des marqueurs visuels sur l’image RGB, éliminant le besoin d’encodages de région complexes, tout en atteignant des performances de pointe sur des tâches de compréhension de régions comme Visual7W, PointQA et le benchmark Visual Commonsense Reasoning. De plus, nous présentons ViP-Bench, un benchmark complet pour évaluer la capacité des modèles à comprendre les prompts visuels à travers plusieurs dimensions, permettant ainsi des recherches futures dans ce domaine. Le code, les données et le modèle sont publiquement disponibles.

Le code original peut être trouvé ici.

Ce modèle a été contribué par Younes Belkada

Conseils d'utilisation

  • L'architecture est similaire à l'architecture de llava, à l'exception du projecteur multi-modal qui prend en entrée un ensemble d'états cachés visuels concaténés et qui comporte une couche de layernorm supplémentaire sur ce module.

  • Nous recommandons aux utilisateurs d'utiliser padding_side="left" lors du calcul de la génération par lots, car cela conduit à des résultats plus précis. Assurez-vous simplement d'appeler processor.tokenizer.padding_side = "left" avant de générer.

  • Notez que le modèle n'a pas été explicitement entraîné pour traiter plusieurs images dans le même prompt ; bien que cela soit techniquement possible, vous pouvez rencontrer des résultats imprécis.

Les modèles LLaVA publiés après la version v4.46 émettront des avertissements concernant l'ajout de processor.patch_size = {{patch_size}}, processor.num_additional_image_tokens = {{num_additional_image_tokens}} et processor.vision_feature_select_strategy = {{vision_feature_select_strategy}}. Il est vivement recommandé d'ajouter ces attributs au processeur si vous possédez le point de contrôle du modèle, ou d'ouvrir une PR s'il ne vous appartient pas. L'ajout de ces attributs signifie que LLaVA tentera de déduire le nombre de jetons d'image requis par image et d'étendre le texte avec autant de placeholders <image> qu'il y aura de jetons. En général, il y a environ 500 jetons par image, veillez donc à ce que le texte ne soit pas tronqué, car sinon une erreur se produira lors de la fusion des embeddings. Les attributs peuvent être obtenus à partir de la configuration du modèle, sous la forme de model.config.vision_config.patch_size ou de model.config.vision_feature_select_strategy. L'attribut num_additional_image_tokens doit être 1 si l'architecture visuelle ajoute un jeton CLS, ou 0 si rien d'autre n'est ajouté aux patches visuels.

  • Pour de meilleurs résultats, nous recommandons d’utiliser la méthode apply_chat_template() du processeur pour formater correctement votre invite. Pour ce faire, vous devez construire un historique de conversation ; transmettre une simple chaîne de caractères ne formatera pas votre invite. Dans les modèles de chat, chaque message de l’historique de conversation est un dictionnaire avec les clés « role » et « content ». La valeur de « content » doit être une liste de dictionnaires, pour les modalités « text » et « image », comme suit :
from transformers import AutoProcessor


processor = AutoProcessor.from_pretrained("llava-hf/vip-llava-7b-hf")

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "What’s shown in this image?"},
        ],
    },
    {
        "role": "assistant",
        "content": [{"type": "text", "text": "This image shows a red stop sign."},]
    },
    {

        "role": "user",
        "content": [
            {"type": "text", "text": "Describe the image in more details."},
        ],
    },
]

text_prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)

# Note that the template simply formats your prompt, you still have to tokenize it and obtain pixel values for your images
print(text_prompt)
"###Human: <image>\nWhat’s shown in this image?###Assistant: This image shows a red stop sign.###Human: Describe the image in more details.###Assistant:"
  • Si vous souhaitez construire vous-même un prompt de chat, voici la liste des formats de prompt acceptés par les points de contrôle VipLLaVa :
A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n<prompt>###Assistant:

Pour une conversation à plusieurs tours :

A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n<prompt1>###Assistant: <answer1>###Human: <prompt2>###Assistant:

VipLlavaConfig

classe transformers.VipLlavaConfig

< >

( 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 32000projector_hidden_act: str = 'gelu'projector_layernorm_eps: float = 1e-05vision_feature_layers: int | list[int] | tuple[int, ...] = (-2, -5, -8, -11, 6)image_seq_length: int = 576tie_word_embeddings: bool = False )

Paramètres

  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone visuel.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • image_token_index (int, facultatif, par défaut 32000) — L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée.
  • projector_hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation utilisée par le projecteur multimodal.
  • projector_layernorm_eps (float, facultatif, valeur par défaut 1e-05) — Épsilon de la normalisation par couche (layer norm) de la normalisation par couche du projecteur
  • vision_feature_layers (Union[int, list[int]], facultatif, valeur par défaut [-2, -5, -8, -11, 6]) — La couche de caractéristiques visuelles, ou la liste des couches à partir desquelles extraire les caractéristiques visuelles.
  • image_seq_length (int, facultatif, par défaut 576) — Longueur de séquence d'un embedding d'image.
  • tie_word_embeddings (bool, facultatif, valeur par défaut False) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Il s'agit de la classe de configuration permettant de stocker la configuration d'un VipLlavaModel. Elle est utilisée pour instancier un modèle Vipllava 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 llava-hf/vip-llava-7b-hf

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 VipLlavaForConditionalGeneration, VipLlavaConfig, CLIPVisionConfig, LlamaConfig

>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> # Initializing a VipLlava vipllava-7b style configuration
>>> configuration = VipLlavaConfig(vision_config, text_config)

>>> # Initializing a model from the vipllava-7b style configuration
>>> model = VipLlavaForConditionalGeneration(configuration)

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

VipLlavaModel

classe transformers.VipLlavaModel

< >

( config: VipLlavaConfig )

Paramètres

  • config (VipLlavaConfig) — 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 modèle VipLlava, qui se compose d'un backbone de vision et d'un modèle de langage, sans tête de modélisation du langage.

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] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layers: int | list[int] | None = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VipLlavaModelOutputWithPast 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 ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de CLIPImageProcessor. Voir CLIPImageProcessor.call() pour plus de détails (LlavaProcessor utilise CLIPImageProcessor pour le traitement des images).
  • 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 ?

  • position_ids (torch.LongTensor 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 ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • 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.
  • vision_feature_layers (Union[int, list[int]], facultatif) — La couche de caractéristiques visuelles, ou la liste des index des couches à sélectionner pour extraire les caractéristiques visuelles.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif : last_hidden_states, facultatif : hidden_states, facultatif : attentions) pooler_output de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

VipLlavaModelOutputWithPast ou tuple(torch.Tensor)

Un VipLlavaModelOutputWithPast 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 (VipLlavaConfig) et des entrées.

La méthode forward du modèle VipLlavaModel 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.

    Si past_key_values est utilisé, seule la dernière hidden-state des séquences de forme (batch_size, 1, hidden_size) est renvoyée.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

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

  • image_hidden_states (torch.Tensor, facultatif) — Un torch.Tensor de taille (batch_size, num_images, sequence_length, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.

get_image_features

< >

( pixel_values: Tensorvision_feature_layers: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, channels, height, width)) — Les tenseurs correspondant aux images d'entrée.
  • vision_feature_layers (Union[int, list[int]], facultatif) — La couche de caractéristiques visuelles, ou la liste des index des couches à sélectionner pour extraire les caractéristiques visuelles.

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 (VipLlavaConfig) et des entrées.

Obtient les derniers états cachés de l'image depuis la tour de vision et applique la projection multimodale.

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

get_placeholder_mask

< >

( input_ids: LongTensorinputs_embeds: Tensorimage_features: Tensor )

Obtient le masque de jetons multimodaux à partir de input_ids ou de inputs_embeds, et vérifie que le nombre de jetons correspond à la longueur des fonctionnalités multimodales. Si les longueurs diffèrent, une erreur est levée.

VipLlavaForConditionalGeneration

classe transformers.VipLlavaForConditionalGeneration

< >

( config: VipLlavaConfig )

Paramètres

  • config (VipLlavaConfig) — 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 modèle VIPLLAVA, qui se compose d'un backbone de vision et d'un modèle de langage.

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] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layers: int | list[int] | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → VipLlavaCausalLMOutputWithPast 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 ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de CLIPImageProcessor. Voir CLIPImageProcessor.call() pour plus de détails (LlavaProcessor utilise CLIPImageProcessor pour le traitement des images).
  • 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 ?

  • position_ids (torch.LongTensor 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 ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • 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.
  • vision_feature_layers (Union[int, list[int]], facultatif) — La couche de caractéristiques visuelles, ou la liste des index des couches à sélectionner pour extraire les caractéristiques visuelles.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [0, ..., config.vocab_size] ou -100 (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • logits_to_keep (Union[int, torch.Tensor], facultatif, valeur par défaut 0) — Si c'est un int, calcule les logits pour les logits_to_keep derniers jetons. Si 0, calcule les logits pour tous les input_ids (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un torch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif : last_hidden_states, facultatif : hidden_states, facultatif : attentions) pooler_output de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

VipLlavaCausalLMOutputWithPast ou tuple(torch.Tensor)

Un VipLlavaCausalLMOutputWithPast 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 (VipLlavaConfig) et des entrées.

La méthode forward de VipLlavaForConditionalGeneration 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 modélisation du langage (pour la prédiction du jeton suivant).

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

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

  • image_hidden_states (torch.Tensor, facultatif) — Un torch.Tensor de taille (batch_size, num_images, sequence_length, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.

Exemple :

>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, VipLlavaForConditionalGeneration

>>> model = VipLlavaForConditionalGeneration.from_pretrained("llava-hf/vip-llava-7b-hf", device_map="auto", dtype=torch.float16)
>>> processor = AutoProcessor.from_pretrained("llava-hf/vip-llava-7b-hf")

>>> prompt = "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions.###Human: <image>\n{}###Assistant:"
>>> question = "Can you please describe this image?"
>>> prompt = prompt.format(question)
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/compel-neg.png"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(text=text, images=image, return_tensors="pt").to(0, torch.float16)

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=20)
>>> processor.decode(generate_ids[0][len(inputs["input_ids"][0]):], skip_special_tokens=True)
The image features a brown and white cat sitting on a green surface, with a red ball in its

get_image_features

< >

( pixel_values: Tensorvision_feature_layers: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, channels, height, width)) — Les tenseurs correspondant aux images d'entrée.
  • vision_feature_layers (Union[int, list[int]], facultatif) — La couche de caractéristiques visuelles, ou la liste des index des couches à sélectionner pour extraire les caractéristiques visuelles.

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 (VipLlavaConfig) et des entrées.

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

Exemple :

>>> from PIL import Image
>>> from transformers import AutoProcessor, VipLlavaForConditionalGeneration

>>> model = VipLlavaForConditionalGeneration.from_pretrained("llava-hf/vip-llava-7b-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/vip-llava-7b-hf")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
Update on GitHub

←ViLT Modèles Vision Encoder Decoder→