# InstructBLIP ## Aperçu Le modèle InstructBLIP a été proposé dans [InstructBLIP: Towards General-purpose Vision-Language Models with Instruction Tuning](https://huggingface.co/papers/2305.06500) par Wenliang Dai, Junnan Li, Dongxu Li, Anthony Meng Huat Tiong, Junqi Zhao, Weisheng Wang, Boyang Li, Pascale Fung, Steven Hoi. InstructBLIP exploite l'architecture [BLIP-2](blip-2) pour l'ajustement visuel par instructions. L'abstract de l'article est le suivant : *Des modèles de langage à usage général, capables de résoudre diverses tâches du domaine du langage, ont émergé grâce au pipeline de pré-entraînement et d’instruction-tuning. Toutefois, la construction de modèles vision-langage à usage général reste un défi, en raison de la divergence accrue des tâches introduite par l’entrée visuelle supplémentaire. Bien que le pré-entraînement vision-langage ait fait l’objet d’études approfondies, l’instruction-tuning vision-langage demeure relativement peu exploré. Dans cet article, nous menons une étude systématique et exhaustive sur l’instruction-tuning vision-langage, fondée sur les modèles BLIP-2 pré-entraînés. Nous rassemblons une grande variété de 26 jeux de données publics, les transformons au format d’instruction-tuning et les classons en deux clusters : l’un pour l’instruction-tuning sur les données retenues (held-in), l’autre pour l’évaluation zéro-shot sur les données exclues (held-out). De plus, nous introduisons l’extraction de caractéristiques visuelles consciente des instructions, une méthode cruciale qui permet au modèle d’extraire des caractéristiques informatives adaptées à l’instruction donnée. Les modèles InstructBLIP résultants atteignent des performances zéro-shot de l’état de l’art sur les 13 jeux de données held-out, surpassant nettement BLIP-2 et le modèle plus volumineux Flamingo. Nos modèles obtiennent également des performances de l’état de l’art lorsqu’ils sont affinés sur des tâches aval individuelles (par exemple, 90,7 % de précision sur ScienceQA IMG). Enfin, nous démontrons qualitativement les avantages d’InstructBLIP par rapport aux modèles multimodaux concurrents.* drawing Architecture d'InstructBLIP. Issue de l'article original. Ce modèle a été contribué par [nielsr](https://huggingface.co/nielsr). Le code d'origine peut être trouvé [ici](https://github.com/salesforce/LAVIS/tree/main/projects/instructblip). ## Conseils d'utilisation InstructBLIP utilise la même architecture que [BLIP-2](blip-2) avec une petite mais importante différence : il transmet également le prompt texte (instruction) au Q-Former. > [!NOTE] > Les modèles BLIP publiés après la version v4.46 émettront des avertissements concernant l'ajout de `processor.num_query_tokens = {{num_query_tokens}}` et l'extension de la couche d'embeddings du modèle pour ajouter le jeton spécial ``. 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 BLIP ajoutera le nombre de jetons de requête requis par image et étendra le texte avec autant de placeholders `` qu'il y aura de jetons de requête. Généralement, il s'agit d'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, comme `model.config.num_query_tokens`, et l'expansion des embeddings du modèle peut être réalisée en suivant [ce lien](https://gist.github.com/zucchini-nlp/e9f20b054fa322f84ac9311d9ab67042). ## InstructBlipConfig[[transformers.InstructBlipConfig]] #### transformers.InstructBlipConfig[[transformers.InstructBlipConfig]] ```python transformers.InstructBlipConfig(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, qformer_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_query_tokens: int = 32, image_token_index: int | None = None, initializer_factor: float = 1.0, initializer_range: float = 0.02) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/configuration_instructblip.py#L106) **Paramètres :** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel. qformer_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [InstructBlipQFormerConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipQFormerConfig). text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. num_query_tokens (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de jetons de requête transmis au Transformer. image_token_index (`int`, *facultatif*) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée. initializer_factor (`float`, *facultatif*, par défaut `1.0`) : Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation). initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. Ceci est la classe de configuration destinée à stocker la configuration d'un InstructBlipModel. Elle est utilisée pour instancier un modèle Instructblip 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 [Salesforce/instructblip-flan-t5-xl](https://huggingface.co/Salesforce/instructblip-flan-t5-xl) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import ( ... InstructBlipVisionConfig, ... InstructBlipQFormerConfig, ... OPTConfig, ... InstructBlipConfig, ... InstructBlipForConditionalGeneration, ... ) >>> # Initializing a InstructBlipConfig with Salesforce/instructblip-flan-t5-xl style configuration >>> configuration = InstructBlipConfig() >>> # Initializing a InstructBlipForConditionalGeneration (with random weights) from the Salesforce/instructblip-flan-t5-xl style configuration >>> model = InstructBlipForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> # We can also initialize a InstructBlipConfig from a InstructBlipVisionConfig, InstructBlipQFormerConfig and any PreTrainedConfig >>> # Initializing InstructBLIP vision, InstructBLIP Q-Former and language model configurations >>> vision_config = InstructBlipVisionConfig() >>> qformer_config = InstructBlipQFormerConfig() >>> text_config = OPTConfig() >>> config = InstructBlipConfig(vision_config=vision_config, qformer_config=qformer_config, text_config=text_config) ``` ## InstructBlipVisionConfig[[transformers.InstructBlipVisionConfig]] #### transformers.InstructBlipVisionConfig[[transformers.InstructBlipVisionConfig]] ```python transformers.InstructBlipVisionConfig(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, hidden_size: int = 1408, intermediate_size: int = 6144, num_hidden_layers: int = 39, num_attention_heads: int = 16, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 14, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/configuration_instructblip.py#L29) **Paramètres :** hidden_size (`int`, *facultatif*, valeur par défaut `1408`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `6144`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `39`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `224`) : La taille (résolution) de chaque image. patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `14`) : La taille (résolution) de chaque patch. hidden_act (`str`, *facultatif*, par défaut `gelu`) : 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*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. initializer_range (`float`, *facultatif*, valeur par défaut `1e-10`) : L'écart-type de truncated_normal_initializer pour l'initialisation de toutes les matrices de poids. qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. Ceci est la classe de configuration destinée à stocker la configuration d'un InstructBlipModel. Elle est utilisée pour instancier un modèle Instructblip 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 [Salesforce/instructblip-flan-t5-xl](https://huggingface.co/Salesforce/instructblip-flan-t5-xl) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import InstructBlipVisionConfig, InstructBlipVisionModel >>> # Initializing a InstructBlipVisionConfig with Salesforce/instructblip-flan-t5-xl style configuration >>> configuration = InstructBlipVisionConfig() >>> # Initializing a InstructBlipVisionModel (with random weights) from the Salesforce/instructblip-flan-t5-xl style configuration >>> model = InstructBlipVisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## InstructBlipQFormerConfig[[transformers.InstructBlipQFormerConfig]] #### transformers.InstructBlipQFormerConfig[[transformers.InstructBlipQFormerConfig]] ```python transformers.InstructBlipQFormerConfig(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 = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, cross_attention_frequency: int = 2, encoder_hidden_size: int = 1408) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/configuration_instructblip.py#L64) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `30522`) : 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. 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. intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : 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*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention. max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. layer_norm_eps (`float`, *facultatif*, par défaut `1e-12`) : L'épsilon utilisé par les couches de normalisation par couche. pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. cross_attention_frequency (`int`, *facultatif*, valeur par défaut : 2) : La fréquence d'ajout de l'attention croisée aux couches du Transformer. encoder_hidden_size (`int`, *facultatif*, valeur par défaut 1408) : La taille cachée des états cachés pour l'attention croisée. Ceci est la classe de configuration destinée à stocker la configuration d'un InstructBlipModel. Elle est utilisée pour instancier un modèle Instructblip 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 [Salesforce/instructblip-flan-t5-xl](https://huggingface.co/Salesforce/instructblip-flan-t5-xl) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> from transformers import InstructBlipQFormerConfig, InstructBlipQFormerModel >>> # Initializing a InstructBLIP Salesforce/instructblip-flan-t5-xl style configuration >>> configuration = InstructBlipQFormerConfig() >>> # Initializing a model (with random weights) from the Salesforce/instructblip-flan-t5-xl style configuration >>> model = InstructBlipQFormerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## InstructBlipProcessor[[transformers.InstructBlipProcessor]] #### transformers.InstructBlipProcessor[[transformers.InstructBlipProcessor]] ```python transformers.InstructBlipProcessor(image_processor, tokenizer, qformer_tokenizer, num_query_tokens = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/processing_instructblip.py#L45) **Paramètres :** image_processor (`BlipImageProcessor`) : le processeur d'images est une entrée obligatoire. tokenizer (`GPT2Tokenizer`) : le tokenizer est une entrée obligatoire. qformer_tokenizer (`AutoTokenizer`) : une instance de ['PreTrainedTokenizer`]. Le tokenizer du Q-Former est une entrée obligatoire. num_query_tokens (`int`, *facultatif*) : " Nombre de jetons utilisés par le Qformer en tant que requêtes, doit être identique à celui de la configuration du modèle. Construit un InstructBlipProcessor qui encapsule un processeur d’images, un tokeniseur et un tokeniseur qformer en un seul processeur. [InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor) offre toutes les fonctionnalités de [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor), [GPT2Tokenizer](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2Tokenizer) et `{qformer_tokenizer_class}`. Consultez [~BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor), [~GPT2Tokenizer](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2Tokenizer) et `~{qformer_tokenizer_class}` pour plus d’informations. #### __appel__[[transformers.InstructBlipProcessor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/processing_instructblip.py#L63) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. ## InstructBlipVisionModel[[transformers.InstructBlipVisionModel]] #### transformers.InstructBlipVisionModel[[transformers.InstructBlipVisionModel]] ```python transformers.InstructBlipVisionModel(config: InstructBlipVisionConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L392) #### forward[[transformers.InstructBlipVisionModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L412) **Paramètres :** 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 [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor). Voir [BlipImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor) utilise [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor) pour le traitement des images). interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) et les entrées. La méthode forward du modèle [InstructBlipVisionModel](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipVisionModel) 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)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## InstructBlipQFormerModel[[transformers.InstructBlipQFormerModel]] #### transformers.InstructBlipQFormerModel[[transformers.InstructBlipQFormerModel]] ```python transformers.InstructBlipQFormerModel(config: InstructBlipQFormerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L760) Querying Transformer (Q-Former), utilisé dans InstructBLIP. Légèrement modifié par rapport à BLIP-2, car il prend également l'instruction en entrée. #### forward[[transformers.InstructBlipQFormerModel.forward]] ```python forward(input_ids: LongTensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, query_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L799) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage est ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) query_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : États cachés à utiliser dans le calcul de l'attention. En cas d'attention croisée, ils seront utilisés pour la requête (c'est-à-dire que la clé et la valeur utiliseront encoder_hidden_states). encoder_hidden_states (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisée dans l'attention croisée si le modèle est configuré comme un décodeur. encoder_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage de l'entrée de l'encodeur. Ce masque est utilisé dans l'attention croisée si le modèle est configuré comme un décodeur. Valeurs du masque sélectionnées dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. **Retourne :** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) et les entrées. La méthode forward du modèle [InstructBlipQFormerModel](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipQFormerModel) 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)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` et `config.add_cross_attention=True` sont passés ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisé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](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. ## InstructBlipModel[[transformers.InstructBlipModel]] #### transformers.InstructBlipModel[[transformers.InstructBlipModel]] ```python transformers.InstructBlipModel(config: InstructBlipConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L867) **Paramètres :** config ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle de base InstructBLIP composé d'un modèle de langage, d'un qformer et d'un encodeur visuel. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.InstructBlipModel.forward]] ```python forward(pixel_values: Tensor, qformer_input_ids: Tensor, qformer_attention_mask: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L919) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor). Voir [BlipImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor) utilise [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor) pour le traitement des images). qformer_input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire du Q-Former. Des jetons d'entrée peuvent être fournis en option pour servir de prompt texte, que le modèle Q-Former encodera. Les indices peuvent être obtenus à l'aide de [InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor). Consultez [InstructBlipProcessor.__call__()](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) qformer_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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) input_ids (`torch.Tensor` 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.LongTensor` 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Quelles sont les identifiants d'entrée du décodeur ?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Pertinent uniquement si un modèle de langage encodeur-décodeur (comme T5) est utilisé. 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, par rapport à la matrice de recherche d'intégration interne du modèle. interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés. **Retourne :** `InstructBlipForConditionalGenerationModelOutput` ou `tuple(torch.Tensor)` Un `InstructBlipForConditionalGenerationModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) et les entrées. La méthode forward du modèle [InstructBlipModel](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipModel) 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`, *facultatif*, renvoyé lorsque `labels` est fourni, `torch.Tensor` de forme `(1,)`) -- Perte de modélisation du langage issue du modèle de langage. - **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 du modèle de langage. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- Sorties de l'encodeur visuel. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *facultatif*) -- Sorties du Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` ou `Seq2SeqLMOutput`) -- Sorties du modèle de langage. #### get_placeholder_mask[[transformers.InstructBlipModel.get_placeholder_mask]] ```python get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L904) Obtient le masque de jetons multimodaux à partir de `input_ids` ou de `inputs_embeds`. ## InstructBlipForConditionalGeneration[[transformers.InstructBlipForConditionalGeneration]] #### transformers.InstructBlipForConditionalGeneration[[transformers.InstructBlipForConditionalGeneration]] ```python transformers.InstructBlipForConditionalGeneration(config: InstructBlipConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L1028) **Paramètres :** config ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle InstructBLIP pour générer du texte à partir d'une image et d'un prompt texte facultatif. Le modèle est composé d'un encodeur visuel, d'un Querying Transformer (Q-Former) et d'un modèle de langage. On peut éventuellement passer `input_ids` au modèle, qui servent de prompt de texte, afin de faire en sorte que le modèle de langage poursuive le prompt. Sinon, le modèle de langage commence à générer du texte à partir du jeton [BOS] (beginning-of-sequence). Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.InstructBlipForConditionalGeneration.forward]] ```python forward(pixel_values: Tensor, qformer_input_ids: Tensor, qformer_attention_mask: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L1174) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor). Voir [BlipImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor) utilise [BlipImageProcessor](/docs/transformers/main/fr/model_doc/blip#transformers.BlipImageProcessor) pour le traitement des images). qformer_input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire du Q-Former. Des jetons d'entrée peuvent être fournis en option pour servir de prompt texte, que le modèle Q-Former encodera. Les indices peuvent être obtenus à l'aide de [InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor). Consultez [InstructBlipProcessor.__call__()](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) qformer_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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) input_ids (`torch.Tensor` 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.LongTensor` 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Quelles sont les identifiants d'entrée du décodeur ?](../glossary#decoder-input-ids) decoder_attention_mask (`torch.BoolTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Pertinent uniquement si un modèle de langage encodeur-décodeur (comme T5) est utilisé. 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, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation du langage. Les indices doivent être dans `[-100, 0, ..., config.vocab_size - 1]`. Toutes les étiquettes définies sur `-100` sont ignorées (masquées) ; la perte n'est calculée que pour les étiquettes comprises dans `[0, ..., config.vocab_size]` interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés. 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 fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** `InstructBlipForConditionalGenerationModelOutput` ou `tuple(torch.Tensor)` Un `InstructBlipForConditionalGenerationModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) et les entrées. La méthode forward de [InstructBlipForConditionalGeneration](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipForConditionalGeneration) 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`, *facultatif*, renvoyé lorsque `labels` est fourni, `torch.Tensor` de forme `(1,)`) -- Perte de modélisation du langage issue du modèle de langage. - **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 du modèle de langage. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- Sorties de l'encodeur visuel. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *facultatif*) -- Sorties du Q-Former (Querying Transformer). - **language_model_outputs** (`CausalLMOutputWithPast` ou `Seq2SeqLMOutput`) -- Sorties du modèle de langage. Exemples : ```python >>> from transformers import InstructBlipProcessor, InstructBlipForConditionalGeneration >>> import torch >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> model = InstructBlipForConditionalGeneration.from_pretrained("Salesforce/instructblip-vicuna-7b") >>> processor = InstructBlipProcessor.from_pretrained("Salesforce/instructblip-vicuna-7b") >>> device = "cuda" if torch.cuda.is_available() else "cpu" >>> model.to(device) >>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/lavis_confusing_pictures.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())).convert("RGB") >>> prompt = "What is unusual about this image?" >>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device) >>> outputs = model.generate( ... **inputs, ... do_sample=False, ... num_beams=5, ... max_length=256, ... min_length=1, ... top_p=0.9, ... repetition_penalty=1.5, ... length_penalty=1.0, ... temperature=1, ... ) >>> generated_text = processor.batch_decode(outputs, skip_special_tokens=True)[0].strip() >>> print(generated_text) The unusual aspect of this image is that a man is ironing clothes on the back of a yellow SUV, which is parked in the middle of a busy city street. This is an unconventional approach to ironing clothes, as it requires the man to balance himself and his ironing equipment on top of the vehicle while navigating through traffic. Additionally, the presence of taxis and other vehicles in the scene further emphasizes the unusual nature of this situation. ``` #### generate[[transformers.InstructBlipForConditionalGeneration.generate]] ```python generate(pixel_values: Tensor, qformer_input_ids: typing.Optional[torch.LongTensor] = None, qformer_attention_mask: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **generate_kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L1313) **Paramètres :** pixel_values (`torch.Tensor` de forme (batch_size, num_channels, height, width)) : Images d'entrée à traiter. qformer_input_ids (`torch.LongTensor` de forme (batch_size, sequence_length), *facultatif*) : La séquence utilisée comme invite à fournir au module Q-Former. qformer_attention_mask (`torch.LongTensor` de forme (batch_size, sequence_length), *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. input_ids (`torch.LongTensor` de forme (batch_size, sequence_length), *facultatif*) : La séquence utilisée comme invite pour la génération. attention_mask (`torch.LongTensor` de forme (batch_size, sequence_length), *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Représentation intégrée des entrées. Doit être de type float, et non des jetons int. interpolate_pos_encoding (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut interpoler le codage positionnel des embeddings d'image. **Retourne :** `captions (list)` Une liste de chaînes de caractères de longueur batch_size * num_captions. Remplace la fonction `generate` pour pouvoir utiliser le modèle comme générateur conditionnel. #### get_image_features[[transformers.InstructBlipForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, qformer_input_ids: LongTensor, qformer_attention_mask: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool | None = False, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/instructblip/modeling_instructblip.py#L1091) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. qformer_input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire du Q-Former. Des jetons d'entrée peuvent être fournis en option pour servir de prompt texte, que le modèle Q-Former encodera. Les indices peuvent être obtenus à l'aide de [InstructBlipProcessor](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor). Consultez [InstructBlipProcessor.__call__()](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipProcessor.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) qformer_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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) interpolate_pos_encoding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut interpoler les encodages de position pré-entraînés. **Retourne :** `BaseModelOutputWithVisionQformerOutputs` ou `tuple(torch.Tensor)` Un `BaseModelOutputWithVisionQformerOutputs` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([InstructBlipConfig](/docs/transformers/main/fr/model_doc/instructblip#transformers.InstructBlipConfig)) et les 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)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **vision_outputs** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- Sorties de l'encodeur visuel. - **qformer_outputs** (`~modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions`, *facultatif*) -- Sorties du Q-Former (Querying Transformer). Exemple : ```python >>> from PIL import Image >>> from transformers import AutoProcessor, InstructBlipForConditionalGeneration >>> model = InstructBlipForConditionalGeneration.from_pretrained("Salesforce/instructblip-flan-t5-xl") >>> processor = AutoProcessor.from_pretrained("Salesforce/instructblip-flan-t5-xl") >>> 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] ```