# VisionTextDualEncoder ## Aperçu Le [VisionTextDualEncoderModel](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderModel) permet d'initialiser un modèle d'encodeur dual vision-texte en utilisant n'importe quel modèle d'auto-encodage visuel pré-entraîné comme encodeur visuel (*par ex.* [ViT](vit), [BEiT](beit), [DeiT](deit)) et n'importe quel modèle d'auto-encodage textuel pré-entraîné comme encodeur texte (*par ex.* [RoBERTa](roberta), [BERT](bert)). Deux couches de projection sont ajoutées au-dessus des encodeurs visuel et textuel afin de projeter les embeddings de sortie dans un espace latent partagé. Les couches de projection étant initialisées aléatoirement, le modèle doit être affiné sur une tâche en aval. Ce modèle peut être utilisé pour aligner les embeddings vision-texte à l'aide d'un entraînement contrastif image-texte de type CLIP, puis exploité pour des tâches vision zéro-shot telles que la classification d'images ou la récupération. Dans [LiT: Zero-Shot Transfer with Locked-image Text Tuning](https://huggingface.co/papers/2111.07991), il est démontré que l’exploitation de modèles d’image et de texte pré-entraînés (verrouillés/gelés) pour l’apprentissage contrastif permet d’obtenir des améliorations significatives sur de nouvelles tâches de vision en zéro tirage, telles que la classification d’images ou la récupération. ## VisionTextDualEncoderConfig[[transformers.VisionTextDualEncoderConfig]] #### transformers.VisionTextDualEncoderConfig[[transformers.VisionTextDualEncoderConfig]] ```python transformers.VisionTextDualEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: transformers.configuration_utils.PreTrainedConfig | dict | None = None, vision_config: transformers.configuration_utils.PreTrainedConfig | dict | None = None, projection_dim: int = 512, logit_scale_init_value: int | float = 2.6592) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/configuration_vision_text_dual_encoder.py#L25) **Paramètres :** text_config (`Union[~configuration_utils.PreTrainedConfig, dict]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. vision_config (`Union[~configuration_utils.PreTrainedConfig, dict]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel. projection_dim (`int`, *facultatif*, valeur par défaut `512`) : Dimension des couches de projection du texte et de la vision. logit_scale_init_value (`Union[int, float]`, *facultatif*, valeur par défaut `2.6592`) : La valeur initiale du paramètre *logit_scale*. Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Vision Text Dual Encoder. Elle est utilisée pour instancier un modèle Vision Text Dual Encoder 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 [None](https://huggingface.co/None) 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 ViTConfig, BertConfig, VisionTextDualEncoderConfig, VisionTextDualEncoderModel >>> # Initializing a BERT and ViT configuration >>> config_vision = ViTConfig() >>> config_text = BertConfig() >>> config = VisionTextDualEncoderConfig(vision_config=config_vision, text_config=config_text, projection_dim=512) >>> # Initializing a BERT and ViT model (with random weights) >>> model = VisionTextDualEncoderModel(config=config) >>> # Accessing the model configuration >>> config_vision = model.config.vision_config >>> config_text = model.config.text_config >>> # Saving the model, including its configuration >>> model.save_pretrained("vit-bert") >>> # loading model and config from pretrained folder >>> vision_text_config = VisionTextDualEncoderConfig.from_pretrained("vit-bert") >>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert", config=vision_text_config) ``` #### from_vision_text_configs[[transformers.VisionTextDualEncoderConfig.from_vision_text_configs]] ```python from_vision_text_configs(vision_config: PreTrainedConfig, text_config: PreTrainedConfig, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/configuration_vision_text_dual_encoder.py#L64) **Retourne :** [VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig) Une instance d'un objet de configuration Instanciez un [VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig) (ou une classe dérivée) à partir de la configuration du modèle de texte et de la configuration du modèle de vision. ## VisionTextDualEncoderProcessor[[transformers.VisionTextDualEncoderProcessor]] #### transformers.VisionTextDualEncoderProcessor[[transformers.VisionTextDualEncoderProcessor]] ```python transformers.VisionTextDualEncoderProcessor(image_processor = None, tokenizer = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/processing_vision_text_dual_encoder.py#L27) **Paramètres :** image_processor (`image_processor_class`) : le processeur d'images est une entrée obligatoire. tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire. Construit un VisionTextDualEncoderProcessor qui encapsule un processeur d’images et un tokeniseur en un seul processeur. [VisionTextDualEncoderProcessor](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) propose toutes les fonctionnalités de `image_processor_class` et de `tokenizer_class`. Consultez `~image_processor_class` et `~tokenizer_class` pour plus d'informations. #### __appel__[[transformers.VisionTextDualEncoderProcessor.__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 = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **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. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *facultatif*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio. 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. ## VisionTextDualEncoderModel[[transformers.VisionTextDualEncoderModel]] #### transformers.VisionTextDualEncoderModel[[transformers.VisionTextDualEncoderModel]] ```python transformers.VisionTextDualEncoderModel(config: transformers.models.vision_text_dual_encoder.configuration_vision_text_dual_encoder.VisionTextDualEncoderConfig | None = None, vision_model: transformers.modeling_utils.PreTrainedModel | None = None, text_model: transformers.modeling_utils.PreTrainedModel | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L45) **Paramètres :** config ([VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig), *facultatif*) : 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. vision_model (`~modeling_utils.PreTrainedModel`, *facultatif*) : Le modèle de vision à utiliser. text_model (`~modeling_utils.PreTrainedModel`, *facultatif*) : Le modèle de texte à utiliser. Le modèle Vision Text Dual Encoder brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. 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.VisionTextDualEncoderModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, token_type_ids: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L171) **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](/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) 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 des pixels peuvent être obtenues à l'aide de `image_processor_class`. Voir `image_processor_class.__call__` pour plus de détails ([VisionTextDualEncoderProcessor](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) utilise `image_processor_class` 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 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) return_loss (`bool`, *facultatif*) : Indique s'il faut ou non retourner la perte contrastive. token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** `CLIPOutput` ou `tuple(torch.Tensor)` Un `CLIPOutput` 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 ([VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) et les entrées. La méthode forward de [VisionTextDualEncoderModel](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderModel) 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 `return_loss` est `True`) -- Perte contrastive pour la similarité image-texte. - **logits_per_image** (`torch.Tensor` de forme `(image_batch_size, text_batch_size)`) -- Les scores de produit scalaire normalisé entre `image_embeds` et `text_embeds`. Cela représente les scores de similarité image-texte. - **logits_per_text** (`torch.Tensor` de forme `(text_batch_size, image_batch_size)`) -- Les scores de produit scalaire normalisé entre `text_embeds` et `image_embeds`. Cela représente les scores de similarité texte-image. - **text_embeds** (`torch.Tensor` de forme `(batch_size, output_dim`) -- Les embeddings de texte obtenus en appliquant la couche de projection à la sortie agrégée de [CLIPTextModel](/docs/transformers/main/fr/model_doc/clip#transformers.CLIPTextModel). - **image_embeds** (`torch.Tensor` de forme `(batch_size, output_dim`) -- Les embeddings d'image obtenus en appliquant la couche de projection à la sortie agrégée de [CLIPVisionModel](/docs/transformers/main/fr/model_doc/clip#transformers.CLIPVisionModel). - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- La sortie du [CLIPTextModel](/docs/transformers/main/fr/model_doc/clip#transformers.CLIPTextModel). - **vision_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *facultatif*) -- La sortie du [CLIPVisionModel](/docs/transformers/main/fr/model_doc/clip#transformers.CLIPVisionModel). Exemples : ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import ( ... VisionTextDualEncoderModel, ... VisionTextDualEncoderProcessor, ... AutoImageProcessor, ... AutoTokenizer, ... ) >>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased") >>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224") >>> processor = VisionTextDualEncoderProcessor(image_processor, tokenizer) >>> model = VisionTextDualEncoderModel.from_vision_text_pretrained( ... "google/vit-base-patch16-224", "google-bert/bert-base-uncased" ... ) >>> # contrastive training >>> urls = [ ... "http://images.cocodataset.org/val2017/000000039769.jpg", ... "https://farm3.staticflickr.com/2674/5850229113_4fe05d5265_z.jpg", ... ] >>> with httpx.stream("GET", urls[0]) as response: ... image1 = Image.open(BytesIO(response.read())) >>> with httpx.stream("GET", urls[1]) as response: ... image2 = Image.open(BytesIO(response.read())) >>> images = [image1, image2] >>> inputs = processor( ... text=["a photo of a cat", "a photo of a dog"], images=images, return_tensors="pt", padding=True ... ) >>> outputs = model( ... input_ids=inputs.input_ids, ... attention_mask=inputs.attention_mask, ... pixel_values=inputs.pixel_values, ... return_loss=True, ... ) >>> loss, logits_per_image = outputs.loss, outputs.logits_per_image # this is the image-text similarity score >>> # save and load from pretrained >>> model.save_pretrained("vit-bert") >>> model = VisionTextDualEncoderModel.from_pretrained("vit-bert") >>> # inference >>> outputs = model(**inputs) >>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score >>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities ``` #### get_text_features[[transformers.VisionTextDualEncoderModel.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L105) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/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.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) **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 ([VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) 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. Exemples : ```python >>> import torch >>> from transformers import VisionTextDualEncoderModel, AutoTokenizer >>> model = VisionTextDualEncoderModel.from_pretrained("clip-italian/clip-italian") >>> tokenizer = AutoTokenizer.from_pretrained("clip-italian/clip-italian") >>> inputs = tokenizer(["una foto di un gatto", "una foto di un cane"], padding=True, return_tensors="pt") >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.VisionTextDualEncoderModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_text_dual_encoder/modeling_vision_text_dual_encoder.py#L142) **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 de pixels peuvent être obtenues à l'aide de `image_processor_class`. Voir `image_processor_class.__call__` pour plus de détails ([VisionTextDualEncoderProcessor](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderProcessor) utilise `image_processor_class` pour le traitement des images). **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 ([VisionTextDualEncoderConfig](/docs/transformers/main/fr/model_doc/vision-text-dual-encoder#transformers.VisionTextDualEncoderConfig)) 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. Exemples : ```python >>> import torch >>> from transformers import VisionTextDualEncoderModel, AutoImageProcessor >>> from transformers.image_utils import load_image >>> model = VisionTextDualEncoderModel.from_pretrained("clip-italian/clip-italian") >>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = image_processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_features = model.get_image_features(**inputs) ```