# FLAVA ## Aperçu Le modèle FLAVA a été proposé dans [FLAVA: A Foundational Language And Vision Alignment Model](https://huggingface.co/papers/2112.04482) par Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach et Douwe Kiela, et a été accepté à CVPR 2022. L’article vise à créer un modèle de fondation unique et unifié, capable de traiter des tâches multimodales couvrant la vision, le langage ainsi que la combinaison des deux. L'abstract de l'article est le suivant : *Les modèles de vision et de vision-langage de pointe s'appuient sur un pré-entraînement visio-linguistique à grande échelle pour obtenir de bonnes performances sur une variété de tâches en aval. En général, ces modèles sont soit inter-modaux (contrastifs), soit multi-modaux (avec une fusion en amont), mais rarement les deux à la fois ; et ils ciblent souvent des modalités ou des tâches spécifiques. Une direction prometteuse consisterait à utiliser un modèle universel holistique unique, en tant que « fondation », qui cible toutes les modalités à la fois — un véritable modèle de fondation pour la vision et le langage devrait exceller dans les tâches de vision, les tâches de langage, ainsi que les tâches inter- et multi-modales de vision et de langage. Nous présentons FLAVA comme un tel modèle et démontrons des performances impressionnantes sur une large gamme de 35 tâches couvrant ces modalités cibles.* Ce modèle a été contribué par [aps](https://huggingface.co/aps). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/multimodal/tree/main/examples/flava). ## FlavaConfig[[transformers.FlavaConfig]] #### transformers.FlavaConfig[[transformers.FlavaConfig]] ```python transformers.FlavaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, image_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, multimodal_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, image_codebook_config: dict[str, typing.Any] | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_size: int = 768, layer_norm_eps: float = 1e-12, projection_dim: int = 768, init_codebook: bool = True, logit_scale_init_value: float = 2.6592, initializer_range: float = 0.02, ce_ignore_index: int = -100, mim_weight: float = 1.0, mlm_weight: float = 1.0, global_contrastive_weight: float = 1.0, itm_weight: float = 1.0, mmm_image_weight: float = 1.0, mmm_text_weight: float = 1.0, global_backprop_contrastive: bool = True, skip_unmasked_multimodal_encoder: bool = True, return_loss: bool = True, tie_word_embeddings: bool = True, initializer_factor: float = 1.0) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L185) **Paramètres :** image_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [FlavaImageConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageConfig). text_config (`Union[dict[str, Any], ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte. multimodal_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser [FlavaMultimodalConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalConfig). image_codebook_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser `FlavaCodebookConfig`. hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées. layer_norm_eps (`float`, *facultatif*, par défaut `1e-12`) : L'épsilon utilisé par les couches de normalisation par couche. projection_dim (`int`, *facultatif*, valeur par défaut `768`) : Dimension des couches de projection du texte et de la vision. init_codebook (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut initialiser le codebook logit_scale_init_value (`float`, *facultatif*, valeur par défaut 2.6592) : La valeur initiale du paramètre *logit_scale*. La valeur par défaut est celle utilisée dans l'implémentation originale de FLAVA/CLIP. 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. ce_ignore_index (`int`, *facultatif*, valeur par défaut : -100) : Index de l'entropie croisée à ignorer. mim_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la perte unimodale MIM (Masked Image Modeling) mlm_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la perte unimodale de MLM (Masked Language Modeling) global_contrastive_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la perte d'alignement croisé contrastif global. itm_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la perte multimodale de correspondance image-texte. mmm_image_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la partie image de la perte MMM. mmm_text_weight (`float`, *facultatif*, valeur par défaut 1.0) : Poids à attribuer à la partie texte de la perte MMM. global_backprop_contrastive (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser la rétropropagation globale à travers tous les workers dans la perte contrastive. skip_unmasked_multimodal_encoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ignorer l'exécution de l'encodeur multimodal non masqué dont les sorties ne sont pas utilisées par les pertes FLAVA. return_loss (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner la perte ou non tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. 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). Ceci est la classe de configuration destinée à stocker la configuration d'un FlavaModel. Elle est utilisée pour instancier un modèle Flava 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 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 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 FlavaConfig, FlavaModel, FlavaForPreTraining >>> # Initializing a FlavaConfig with style configuration >>> configuration = FlavaConfig() >>> # Initializing a FlavaModel and FlavaForPreTraining model (with random weights) from the style configuration >>> model = FlavaModel(configuration) >>> model_pre = FlavaForPreTraining(configuration) >>> # Accessing the model configuration >>> configuration = model.config >>> configuration_pre = model_pre.config ``` ## FlavaTextConfig[[transformers.FlavaTextConfig]] #### transformers.FlavaTextConfig[[transformers.FlavaTextConfig]] ```python transformers.FlavaTextConfig(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, type_vocab_size: int = 2, max_position_embeddings: int = 512, 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.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, qkv_bias: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L71) **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`. type_vocab_size (`int`, *facultatif*, par défaut `2`) : La taille du vocabulaire des `token_type_ids`. max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. 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.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. 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. 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 FlavaModel. Elle est utilisée pour instancier un modèle Flava 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 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 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 FlavaTextConfig, FlavaTextModel >>> # Initializing a FlavaTextModel with style configuration >>> configuration = FlavaTextConfig() >>> # Initializing a FlavaTextModel model (with random weights) from the style configuration >>> model = FlavaTextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaImageConfig[[transformers.FlavaImageConfig]] #### transformers.FlavaImageConfig[[transformers.FlavaImageConfig]] ```python transformers.FlavaImageConfig(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 = 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.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, mask_token: bool = True, vocab_size: int = 8192) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L29) **Paramètres :** 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.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. 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. 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 `16`) : La taille (résolution) de chaque patch. num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée. qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. mask_token (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un jeton de masque ou non. Utilisé dans la perte MIM (Masked Image Modeling) pour FLAVA. vocab_size (`int`, *facultatif*, valeur par défaut `8192`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. Ceci est la classe de configuration destinée à stocker la configuration d'un FlavaModel. Elle est utilisée pour instancier un modèle Flava 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 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 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 FlavaImageConfig, FlavaImageModel >>> # Initializing a FlavaImageModel with style configuration >>> configuration = FlavaImageConfig() >>> # Initializing a FlavaImageModel model (with random weights) from the style configuration >>> model = FlavaImageModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]] #### transformers.FlavaMultimodalConfig[[transformers.FlavaMultimodalConfig]] ```python transformers.FlavaMultimodalConfig(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 = 768, num_hidden_layers: int = 6, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, qkv_bias: bool = True, use_cls_token: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L109) **Paramètres :** hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées. num_hidden_layers (`int`, *facultatif*, valeur par défaut `6`) : 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.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. 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. qkv_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. use_cls_token (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un jeton CLS supplémentaire pour les configurations multimodales. Généralement requis par le modèle FLAVA. Ceci est la classe de configuration destinée à stocker la configuration d'un FlavaModel. Elle est utilisée pour instancier un modèle Flava 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 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 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 FlavaMultimodalConfig, FlavaMultimodalModel >>> # Initializing a FlavaMultimodalModel with style configuration >>> configuration = FlavaMultimodalConfig() >>> # Initializing a FlavaMultimodalModel model (with random weights) from the style configuration >>> model = FlavaMultimodalModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]] #### transformers.FlavaImageCodebookConfig[[transformers.FlavaImageCodebookConfig]] ```python transformers.FlavaImageCodebookConfig(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, num_groups: int = 4, input_channels: int = 3, num_blocks_per_group: int = 2, hidden_size: int = 256, vocab_size: int = 8192, freeze: bool = True, initializer_range: float = 0.02) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/configuration_flava.py#L147) **Paramètres :** num_groups (`int`, *facultatif*, valeur par défaut : 4) : Nombre de groupes à créer. Ce paramètre n'affecte pas le modèle pour le moment et est utilisé pour certains calculs et estimations internes. input_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée. num_blocks_per_group (`int`, *facultatif*, par défaut 2) : Nombre de blocs basés sur des convolutions par groupe. hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées. vocab_size (`int`, *facultatif*, valeur par défaut `8192`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. freeze (`bool`, par défaut `True`) : Indique s'il faut figer les poids du modèle. 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 FlavaModel. Elle est utilisée pour instancier un modèle Flava 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 [facebook/flava-full](https://huggingface.co/facebook/flava-full) 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 FlavaImageCodebookConfig, FlavaImageCodebook >>> # Initializing a FlavaImageCodebook with style configuration >>> configuration = FlavaImageCodebookConfig() >>> # Initializing a FlavaImageCodebook model (with random weights) from the style configuration >>> model = FlavaImageCodebook(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## FlavaProcessor[[transformers.FlavaProcessor]] #### transformers.FlavaProcessor[[transformers.FlavaProcessor]] ```python transformers.FlavaProcessor(image_processor = None, tokenizer = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/processing_flava.py#L23) **Paramètres :** image_processor (`FlavaImageProcessor`) : le processeur d’images est une entrée obligatoire. tokenizer (`BertTokenizer`) : le tokenizer est une entrée obligatoire. Construit un FlavaProcessor qui encapsule un processeur d’images et un tokenizer en un seul processeur. [FlavaProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaProcessor) offre toutes les fonctionnalités de [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) et de [BertTokenizer](/docs/transformers/main/fr/model_doc/lxmert#transformers.BertTokenizer). Consultez [~FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) et [~BertTokenizer](/docs/transformers/main/fr/model_doc/lxmert#transformers.BertTokenizer) pour plus d’informations. #### __appel__[[transformers.FlavaProcessor.__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. ## FlavaImageProcessor[[transformers.FlavaImageProcessor]] #### transformers.FlavaImageProcessor[[transformers.FlavaImageProcessor]] ```python transformers.FlavaImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_flava.py#L213) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. return_image_mask (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'image. Peut être remplacé par le paramètre `return_image_mask` dans `preprocess`. input_size_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `14`) : Nombre de patches dans l'image dans les directions de la hauteur et de la largeur. 14x14 = 196 patches au total. Peut être remplacé par le paramètre `input_size_patches` dans `preprocess`. total_mask_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `75`) : Nombre total de patches qui doivent être masqués. Peut être remplacé par le paramètre `total_mask_patches` dans `preprocess`. mask_group_min_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `16`) : Nombre minimal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_min_patches` dans `preprocess`. mask_group_max_patches (`int`, *kwargs*, *facultatif*) : Nombre maximal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_max_patches` dans `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut `0.3`) : Ratio d'aspect minimal de la fenêtre de masque. Peut être remplacé par le paramètre `mask_group_min_aspect_ratio` dans `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *facultatif*) : Ratio d'aspect maximal de la fenêtre du masque. Peut être remplacé par le paramètre `mask_group_max_aspect_ratio` dans `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les valeurs de pixels du codebook. codebook_do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'entrée pour le codebook. Peut être remplacé par le paramètre `codebook_do_resize` dans `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : redimensionne l'entrée du codebook à la taille donnée. Peut être remplacé par le paramètre `codebook_size` dans `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *facultatif*, valeur par défaut `PILImageResampling.LANCZOS`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image du codebook. Avec torchvision < 0.27, LANCZOS n'est pas pris en charge pour les Tensors torch et BICUBIC est utilisé comme alternative la plus proche. Peut être remplacé par le paramètre `codebook_resample` dans `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut recadrer l'entrée pour le codebook au centre. Si la taille de l'entrée est inférieure à `codebook_crop_size` le long d'un des bords, l'image est d'abord rembourrée avec des 0, puis recadrée au centre. Peut être remplacé par le paramètre `codebook_do_center_crop` dans `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : Taille de sortie souhaitée pour l'entrée du codebook lors de l'application d'un recadrage centré. Peut être remplacée par le paramètre `codebook_crop_size` dans `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'entrée pour le codebook à l'aide de l'échelle spécifiée `codebook_rescale_factor`. Peut être remplacé par le paramètre `codebook_do_rescale` dans `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `1/255`) : Définit le facteur d'échelle à utiliser lors du rééchelonnement de l'image du codebook. Peut être remplacé par le paramètre `codebook_rescale_factor` dans `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut mapper les valeurs de pixels de l'entrée du codebook vers (1 - 2e)x + e. Peut être remplacé par le paramètre `codebook_do_map_pixels` dans `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée pour le codebook à l'aide de `codebook_image_mean` et `codebook_image_std`. Peut être remplacé par le paramètre `codebook_do_normalize` dans `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0, 0, 0]`) : La séquence des moyennes pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_mean` dans `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0.5, 0.5, 0.5]`) : La séquence des écarts-types pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_std` dans `preprocess`. Construit un processeur d’images FlavaImageProcessor. #### prétraiter[[transformers.FlavaImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_flava.py#L250) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 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`. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. return_image_mask (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'image. Peut être remplacé par le paramètre `return_image_mask` dans `preprocess`. input_size_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `14`) : Nombre de patches dans l'image dans les directions de la hauteur et de la largeur. 14x14 = 196 patches au total. Peut être remplacé par le paramètre `input_size_patches` dans `preprocess`. total_mask_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `75`) : Nombre total de patches qui doivent être masqués. Peut être remplacé par le paramètre `total_mask_patches` dans `preprocess`. mask_group_min_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `16`) : Nombre minimal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_min_patches` dans `preprocess`. mask_group_max_patches (`int`, *kwargs*, *facultatif*) : Nombre maximal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_max_patches` dans `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut `0.3`) : Ratio d'aspect minimal de la fenêtre de masque. Peut être remplacé par le paramètre `mask_group_min_aspect_ratio` dans `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *facultatif*) : Ratio d'aspect maximal de la fenêtre du masque. Peut être remplacé par le paramètre `mask_group_max_aspect_ratio` dans `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les valeurs de pixels du codebook. codebook_do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'entrée pour le codebook. Peut être remplacé par le paramètre `codebook_do_resize` dans `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : redimensionne l'entrée du codebook à la taille donnée. Peut être remplacé par le paramètre `codebook_size` dans `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *facultatif*, valeur par défaut `PILImageResampling.LANCZOS`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image du codebook. Avec torchvision < 0.27, LANCZOS n'est pas pris en charge pour les Tensors torch et BICUBIC est utilisé comme alternative la plus proche. Peut être remplacé par le paramètre `codebook_resample` dans `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut recadrer l'entrée pour le codebook au centre. Si la taille de l'entrée est inférieure à `codebook_crop_size` le long d'un des bords, l'image est d'abord rembourrée avec des 0, puis recadrée au centre. Peut être remplacé par le paramètre `codebook_do_center_crop` dans `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : Taille de sortie souhaitée pour l'entrée du codebook lors de l'application d'un recadrage centré. Peut être remplacée par le paramètre `codebook_crop_size` dans `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'entrée pour le codebook à l'aide de l'échelle spécifiée `codebook_rescale_factor`. Peut être remplacé par le paramètre `codebook_do_rescale` dans `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `1/255`) : Définit le facteur d'échelle à utiliser lors du rééchelonnement de l'image du codebook. Peut être remplacé par le paramètre `codebook_rescale_factor` dans `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut mapper les valeurs de pixels de l'entrée du codebook vers (1 - 2e)x + e. Peut être remplacé par le paramètre `codebook_do_map_pixels` dans `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée pour le codebook à l'aide de `codebook_image_mean` et `codebook_image_std`. Peut être remplacé par le paramètre `codebook_do_normalize` dans `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0, 0, 0]`) : La séquence des moyennes pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_mean` dans `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0.5, 0.5, 0.5]`) : La séquence des écarts-types pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_std` dans `preprocess`. **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. ## FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]] #### transformers.FlavaImageProcessorPil[[transformers.FlavaImageProcessorPil]] ```python transformers.FlavaImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_pil_flava.py#L227) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. return_image_mask (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'image. Peut être remplacé par le paramètre `return_image_mask` dans `preprocess`. input_size_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `14`) : Nombre de patches dans l'image dans les directions de la hauteur et de la largeur. 14x14 = 196 patches au total. Peut être remplacé par le paramètre `input_size_patches` dans `preprocess`. total_mask_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `75`) : Nombre total de patches qui doivent être masqués. Peut être remplacé par le paramètre `total_mask_patches` dans `preprocess`. mask_group_min_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `16`) : Nombre minimal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_min_patches` dans `preprocess`. mask_group_max_patches (`int`, *kwargs*, *facultatif*) : Nombre maximal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_max_patches` dans `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut `0.3`) : Ratio d'aspect minimal de la fenêtre de masque. Peut être remplacé par le paramètre `mask_group_min_aspect_ratio` dans `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *facultatif*) : Ratio d'aspect maximal de la fenêtre du masque. Peut être remplacé par le paramètre `mask_group_max_aspect_ratio` dans `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les valeurs de pixels du codebook. codebook_do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'entrée pour le codebook. Peut être remplacé par le paramètre `codebook_do_resize` dans `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : redimensionne l'entrée du codebook à la taille donnée. Peut être remplacé par le paramètre `codebook_size` dans `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *facultatif*, valeur par défaut `PILImageResampling.LANCZOS`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image du codebook. Avec torchvision < 0.27, LANCZOS n'est pas pris en charge pour les Tensors torch et BICUBIC est utilisé comme alternative la plus proche. Peut être remplacé par le paramètre `codebook_resample` dans `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut recadrer l'entrée pour le codebook au centre. Si la taille de l'entrée est inférieure à `codebook_crop_size` le long d'un des bords, l'image est d'abord rembourrée avec des 0, puis recadrée au centre. Peut être remplacé par le paramètre `codebook_do_center_crop` dans `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : Taille de sortie souhaitée pour l'entrée du codebook lors de l'application d'un recadrage centré. Peut être remplacée par le paramètre `codebook_crop_size` dans `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'entrée pour le codebook à l'aide de l'échelle spécifiée `codebook_rescale_factor`. Peut être remplacé par le paramètre `codebook_do_rescale` dans `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `1/255`) : Définit le facteur d'échelle à utiliser lors du rééchelonnement de l'image du codebook. Peut être remplacé par le paramètre `codebook_rescale_factor` dans `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut mapper les valeurs de pixels de l'entrée du codebook vers (1 - 2e)x + e. Peut être remplacé par le paramètre `codebook_do_map_pixels` dans `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée pour le codebook à l'aide de `codebook_image_mean` et `codebook_image_std`. Peut être remplacé par le paramètre `codebook_do_normalize` dans `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0, 0, 0]`) : La séquence des moyennes pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_mean` dans `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0.5, 0.5, 0.5]`) : La séquence des écarts-types pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_std` dans `preprocess`. Construit un processeur d’images FlavaImageProcessor. #### prétraiter[[transformers.FlavaImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/image_processing_pil_flava.py#L264) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 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`. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. return_image_mask (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'image. Peut être remplacé par le paramètre `return_image_mask` dans `preprocess`. input_size_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `14`) : Nombre de patches dans l'image dans les directions de la hauteur et de la largeur. 14x14 = 196 patches au total. Peut être remplacé par le paramètre `input_size_patches` dans `preprocess`. total_mask_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `75`) : Nombre total de patches qui doivent être masqués. Peut être remplacé par le paramètre `total_mask_patches` dans `preprocess`. mask_group_min_patches (`int`, *kwargs*, *facultatif*, valeur par défaut `16`) : Nombre minimal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_min_patches` dans `preprocess`. mask_group_max_patches (`int`, *kwargs*, *facultatif*) : Nombre maximal de patches qui doivent être masqués. Peut être remplacé par le paramètre `mask_group_max_patches` dans `preprocess`. mask_group_min_aspect_ratio (`float`, *kwargs*, *facultatif*, valeur par défaut `0.3`) : Ratio d'aspect minimal de la fenêtre de masque. Peut être remplacé par le paramètre `mask_group_min_aspect_ratio` dans `preprocess`. mask_group_max_aspect_ratio (`float`, *kwargs*, *facultatif*) : Ratio d'aspect maximal de la fenêtre du masque. Peut être remplacé par le paramètre `mask_group_max_aspect_ratio` dans `preprocess`. return_codebook_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer les valeurs de pixels du codebook. codebook_do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'entrée pour le codebook. Peut être remplacé par le paramètre `codebook_do_resize` dans `preprocess`. `codebook_size`. codebook_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : redimensionne l'entrée du codebook à la taille donnée. Peut être remplacé par le paramètre `codebook_size` dans `preprocess`. codebook_resample (`PILImageResampling`, *kwargs*, *facultatif*, valeur par défaut `PILImageResampling.LANCZOS`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image du codebook. Avec torchvision < 0.27, LANCZOS n'est pas pris en charge pour les Tensors torch et BICUBIC est utilisé comme alternative la plus proche. Peut être remplacé par le paramètre `codebook_resample` dans `preprocess`. codebook_do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut recadrer l'entrée pour le codebook au centre. Si la taille de l'entrée est inférieure à `codebook_crop_size` le long d'un des bords, l'image est d'abord rembourrée avec des 0, puis recadrée au centre. Peut être remplacé par le paramètre `codebook_do_center_crop` dans `preprocess`. codebook_crop_size (`dict[str, *kwargs*, int]`, *facultatif*, valeur par défaut `{"height" : 224, "width": 224}`) : Taille de sortie souhaitée pour l'entrée du codebook lors de l'application d'un recadrage centré. Peut être remplacée par le paramètre `codebook_crop_size` dans `preprocess`. codebook_do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'entrée pour le codebook à l'aide de l'échelle spécifiée `codebook_rescale_factor`. Peut être remplacé par le paramètre `codebook_do_rescale` dans `preprocess`. codebook_rescale_factor (`int`, *kwargs* ou `float`, *facultatif*, valeur par défaut `1/255`) : Définit le facteur d'échelle à utiliser lors du rééchelonnement de l'image du codebook. Peut être remplacé par le paramètre `codebook_rescale_factor` dans `preprocess`. codebook_do_map_pixels (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut mapper les valeurs de pixels de l'entrée du codebook vers (1 - 2e)x + e. Peut être remplacé par le paramètre `codebook_do_map_pixels` dans `preprocess`. codebook_do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée pour le codebook à l'aide de `codebook_image_mean` et `codebook_image_std`. Peut être remplacé par le paramètre `codebook_do_normalize` dans `preprocess`. codebook_image_mean (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0, 0, 0]`) : La séquence des moyennes pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_mean` dans `preprocess`. codebook_image_std (`Optional[Union[float, *kwargs*, Iterable[float]]]`, *facultatif*, par défaut `[0.5, 0.5, 0.5]`) : La séquence des écarts-types pour chaque canal, à utiliser lors de la normalisation des images pour le codebook. Peut être remplacé par le paramètre `codebook_image_std` dans `preprocess`. **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. ## FlavaForPreTraining[[transformers.FlavaForPreTraining]] #### transformers.FlavaForPreTraining[[transformers.FlavaForPreTraining]] ```python transformers.FlavaForPreTraining(config: FlavaConfig, image_codebook: typing.Optional[torch.nn.Module] = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1502) **Paramètres :** config ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) : 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. image_codebook (`torch.nn.Module`, *facultatif*) : Si une valeur est transmise, le codebook d’images sera défini sur celle-ci. Sinon, il sera initialisé à l’aide de l’image_codebook_config défini dans la config, en tant que premier paramètre. Le modèle FLAVA pour la préformation, qui renvoie des pertes, des plongements, des logits et des sorties de transformeur. 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.FlavaForPreTraining.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, input_ids_masked: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, codebook_pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_unmasked_multimodal_encoder: bool | None = None, mlm_labels: typing.Optional[torch.Tensor] = None, mim_labels: typing.Optional[torch.Tensor] = None, itm_labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, return_loss: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1551) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, text_seq_len)`) : Indices des jetons de la séquence d'entrée 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. [Que sont les identifiants d'entrée ?](../glossary#input-ids) input_ids_masked (`torch.LongTensor` de forme `(batch_size, text_seq_len)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Il s'agit de la version masquée de la tâche d'origine, à utiliser avec le MLM. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer) en combinaison avec `DataCollatorForMaskedLanguageModeling`. 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 de pixels peuvent être obtenues à l’aide de [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor). Voir [FlavaImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([FlavaProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaProcessor) utilise [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) pour le traitement des images). codebook_pixel_values (`torch.Tensor` de forme `(batch_size, num_image_patches, patch_size, patch_size, 3)`, *facultatif*) : Valeurs des pixels des patches d'image utilisés pour calculer les étiquettes du codebook d'image pour le modélisation d'image masquée. attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` de forme `(batch_size, text_seq_len)`, *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) bool_masked_pos (`torch.BoolTensor` de forme `(batch_size, image_num_patches)`) : Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). 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) image_attention_mask (`torch.Tensor` de forme `(batch_size, image_num_patches)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices de jetons de bourrage, spécifiquement pour les images. 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) skip_unmasked_multimodal_encoder (`*bool*`, *facultatif*) : Ignore tous les calculs pour l'encodeur multimodal sur les entrées non masquées. La pré-formation de FLAVA n'a pas besoin, pour le moment, des embeddings ou des sorties multimodales non masquées. mlm_labels (`torch.LongTensor` de forme `(batch_size, text_seq_len)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation masquée de langage et multimodale de gauche à droite (prédiction du mot suivant). Les indices doivent être dans `[-100, 0, ..., text_config.vocab_size - 1]` (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, ..., text_config.vocab_size - 1]`. mim_labels (`torch.LongTensor` de forme `(batch_size, image_num_patches)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation masquée d'image et multimodale. Les indices doivent être dans `[-100, 0, ..., image_config.vocab_size - 1]`. 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, ..., image_config.vocab_size - 1]`. S'ils ne sont pas fournis, ils sont générés automatiquement à l'aide du codebook d'image assigné au modèle. Par défaut, il utilise [FlavaImageCodebook](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageCodebook). Consultez [FlavaImageCodebook](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageCodebook) pour comprendre comment générer mim_labels. itm_labels (`torch.LongTensor` de forme `(batch_size, 1)`, *facultatif*) : Étiquettes pour le calcul de la perte d'adéquation image-texte. 0 signifie que les paires ne correspondent pas et 1 signifie qu'elles correspondent. Les paires avec 0 seront également ignorées pour le calcul des pertes MMM et contrastives globales. 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*, valeur par défaut `True`) : Indique s'il faut retourner les états cachés de toutes les couches. Consultez `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. return_loss (`bool`, *facultatif*, par défaut None) : Indique s'il faut renvoyer la perte calculée ou non. **Retourne :** `FlavaForPreTrainingOutput` ou `tuple(torch.Tensor)` Un `FlavaForPreTrainingOutput` 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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) et les entrées. La méthode forward de [FlavaForPreTraining](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaForPreTraining) 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 `return_loss` est True) -- Perte totale calculée pour ce modèle. - **loss_info** (`~models.flava.modeling_flava.FlavaLosses`, *facultatif*) -- Informations détaillées sur les pertes de pré-entraînement de FLAVA. Consultez la description de la classe `FlavaLosses` pour connaître les clés disponibles. - **image_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- Les embeddings d'image, qui correspondent essentiellement à la sortie agrégée de [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). - **image_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- La sortie du [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). - **text_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids` est présent) -- Les embeddings de texte, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **text_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `input_ids` est présent) -- La sortie du [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids` et `pixel_values` sont présents et que `skip_unmasked_multimodal_encoder` est `None` ou `False`) -- Les embeddings multimodaux, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_output** (`BaseModelOutputWithPooling`, renvoyé lorsque `input_ids` et `pixel_values` sont présents et que `skip_unmasked_multimodal_encoder` est `None` ou `False`) -- La sortie du [FlavaMultimodalModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalModel). - **image_masked_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- Les embeddings d'image, qui correspondent essentiellement à la sortie agrégée de [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). Utilise `bool_masked_pos` pour créer des images masquées. - **image_masked_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- La sortie du [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). Utilise `bool_masked_pos` pour créer des images masquées. - **text_masked_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids_masked` est présent) -- Les embeddings de texte, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **text_masked_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `input_ids_masked` sont présents) -- La sortie du [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_masked_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids` et `pixel_values` sont présents) -- Les embeddings multimodaux, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_masked_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `input_ids_masked` et `pixel_values` sont présents) -- La sortie du [FlavaMultimodalModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalModel). - **mim_logits** (`torch.Tensor` de forme `(batch_size, num_image_patches, image_vocab_size)` ou de forme `(total_masked_patches, image_vocab_size)` , *facultatif*, renvoyé lorsque `pixel_values` sont présents et que `input_ids_masked` ne le sont pas) -- Les logits pour la perte unimodale MIM. Utilise `bool_masked_pos` pour obtenir les patches masqués. La sortie aplatie est renvoyée lorsque `bool_masked_pos` masque certains des patches. - **mlm_logits** (`torch.Tensor` de forme `(batch_size, text_seq_length, text_vocab_size)` ou de forme `(total_masked_seq_length, text_vocab_size)`, *facultatif*, renvoyé lorsque `input_ids_masked` sont présents et que `pixel_values` ne le sont pas) -- Les logits pour la perte unimodale MLM. La sortie aplatie est renvoyée lorsque certains jetons de `input_ids_masked` sont masqués. - **itm_logits** (`torch.Tensor` de forme `(batch_size, 2)`, *facultatif*, renvoyé lorsque `input_ids_masked` et `pixel_values` sont présents) -- Les logits pour la perte ITM. Notez que la perte ITM est calculée sur les paires masquées dans FLAVA. - **contrastive_logits_per_image** (`torch.Tensor` de forme `(image_batch_size, text_batch_size)`) -- Les scores de produit scalaire normalisés entre `image_embeddings` et `text_embeddings`, mais passés respectivement par les couches `image_projection` et `text_projection` de FLAVA. Cela représente les scores de similarité image-texte. Ce calcul est effectué sur des images et des textes non masqués. - **contrastive_logits_per_text** (`torch.Tensor` de forme `(text_batch_size, image_batch_size)`) -- Les scores de produit scalaire normalisés entre `text_embeddings` et `image_embeddings`, mais passés respectivement par les couches `text_projection` et `image_projection` de FLAVA. Ce calcul est effectué sur des images et des textes non masqués. - **mmm_image_logits** (`torch.Tensor` de forme `(batch_size, num_image_patches, image_vocab_size)` ou de forme`(total_masked_patches, image_vocab_size)`, *facultatif*, renvoyé lorsque `pixel_values` et `input_ids_masked` sont présents) -- Les logits pour la perte multimodale d'image MMM. Utilise `bool_masked_pos` pour obtenir les patches masqués. La sortie aplatie est renvoyée lorsque `bool_masked_pos` masque certains des patches. - **mmm_text_logits** (`torch.Tensor` de forme `(batch_size, text_seq_length, text_vocab_size)` ou de forme `(total_masked_seq_length, text_vocab_size)`, *facultatif*, renvoyé lorsque `pixel_values` et `input_ids_masked` sont présents) -- Les logits pour la perte multimodale de texte MMM. La sortie aplatie est renvoyée lorsque certains jetons de `input_ids_masked` sont masqués. Exemples : ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import FlavaForPreTraining, AutoProcessor >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> model = FlavaForPreTraining.from_pretrained("facebook/flava-full") >>> processor = AutoProcessor.from_pretrained("facebook/flava-full") >>> text = ["a photo of a cat"] >>> inputs = processor( ... images=[image], ... text=text, ... return_masks=True, ... return_codebook_pixels=True, ... padding=True, ... max_length=77, ... return_tensors="pt", ... ) >>> output = model(**inputs) ``` ## FlavaModel[[transformers.FlavaModel]] #### transformers.FlavaModel[[transformers.FlavaModel]] ```python transformers.FlavaModel(config: FlavaConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L935) **Paramètres :** config ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) : 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. Le modèle Flava 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.FlavaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_attention_mask: typing.Optional[torch.Tensor] = None, skip_multimodal_encoder: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool = True, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1078) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, image_num_patches + text_seq_len)`) : Indices des jetons de la séquence d'entrée 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. [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 de pixels peuvent être obtenues à l’aide de [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor). Voir [FlavaImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([FlavaProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaProcessor) utilise [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) 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) token_type_ids (`torch.LongTensor` de forme `(batch_size, image_num_patches + text_seq_len)`, *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) bool_masked_pos (`torch.BoolTensor` de forme `(batch_size, image_num_patches)`) : Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). 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) image_attention_mask (`torch.Tensor` de forme `(batch_size, image_num_patches)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage pour les entrées d'image. Valeurs du masque sélectionnées dans `[0, 1]` : - 1 pour les valeurs de pixels réelles (c.-à-d. **non masquées**), - 0 pour les valeurs de pixels de bourrage (c.-à-d. **masquées**). skip_multimodal_encoder (`*bool*`, *facultatif*) : Ignore tous les calculs pour l'encodeur multimodal. Utile si l'encodage multimodal n'est pas utilisé. 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*, valeur par défaut `True`) : Indique s'il faut retourner les états cachés de toutes les couches. Consultez `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 :** `FlavaModelOutput` ou `tuple(torch.Tensor)` Un `FlavaModelOutput` 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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) et les entrées. La méthode forward de [FlavaModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaModel) surcharge 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. - **image_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- Les embeddings d'image, qui correspondent essentiellement à la sortie agrégée de [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). - **image_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `pixel_values` sont présents) -- La sortie du [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel). - **text_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids` est présent) -- Les embeddings de texte, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **text_output** (`BaseModelOutputWithPooling`, *facultatif*, renvoyé lorsque `input_ids` est présent) -- La sortie du [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_embeddings** (`torch.Tensor` de forme `(batch_size, output_dim)`, *facultatif*, renvoyé lorsque `input_ids` et `pixel_values` sont présents et que `skip_multimodal_encoder` est `None` ou `False`) -- Les embeddings multimodaux, qui correspondent essentiellement à la sortie agrégée de [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel). - **multimodal_output** (`BaseModelOutputWithPooling`, renvoyé lorsque `input_ids` et `pixel_values` sont présents et que `skip_multimodal_encoder` est `None` ou `False`) -- La sortie du [FlavaMultimodalModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalModel). Exemples : ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, FlavaModel >>> model = FlavaModel.from_pretrained("facebook/flava-full") >>> processor = AutoProcessor.from_pretrained("facebook/flava-full") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(text=["a photo of a cat"], images=image, return_tensors="pt", padding=True) >>> outputs = model(**inputs) >>> image_embeddings = outputs.image_embeddings >>> text_embeddings = outputs.text_embeddings >>> multimodal_embeddings = outputs.multimodal_embeddings >>> outputs.image_embeddings.shape torch.Size([1, 197, 768]) >>> text_embeddings.shape torch.Size([1, 7, 768]) >>> multimodal_embeddings.shape torch.Size([1, 205, 768]) ``` #### get_text_features[[transformers.FlavaModel.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L981) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, text_seq_length)`) : Indices des jetons de la séquence d'entrée 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. [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) token_type_ids (`torch.LongTensor` de forme `(batch_size, text_seq_length)`, *facultatif*) : Indices de 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) 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) **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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) 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 AutoProcessor, FlavaModel >>> model = FlavaModel.from_pretrained("{0}") >>> processor = AutoProcessor.from_pretrained("{0}") >>> inputs = processor( ... text=["a photo of a cat", "a photo of a dog"], max_length=77, padding="max_length", return_tensors="pt" ... ) >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.FlavaModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1032) **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 [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor). Voir [FlavaImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([FlavaProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaProcessor) utilise [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) pour le traitement des images). bool_masked_pos (`torch.BoolTensor` de forme `(batch_size, image_num_patches)`) : Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). interpolate_pos_encoding (`bool`, *facultatif*) : Indique s'il faut interpoler les encodages de position pré-entraînés. 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) **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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) 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 AutoProcessor, FlavaModel >>> from transformers.image_utils import load_image >>> model = FlavaModel.from_pretrained("{0}") >>> processor = AutoProcessor.from_pretrained("{0}") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_features = model.get_image_features(**inputs) ``` ## FlavaImageCodebook[[transformers.FlavaImageCodebook]] #### transformers.FlavaImageCodebook[[transformers.FlavaImageCodebook]] ```python transformers.FlavaImageCodebook(config: FlavaImageCodebookConfig, **kwargs: Any) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1289) **Paramètres :** config ([FlavaImageCodebookConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageCodebookConfig)) : 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. Le modèle de codebook d'images de FLAVA, inspiré de l'encodeur original de DALL-E. Il produit des états cachés bruts et peut être utilisé pour générer des jetons d'image pour une image donnée, en s'appuyant sur le vocabulaire de DALL-E. Il sert à générer des étiquettes pour MIM. Utilisez `get_codebook_indices` pour obtenir les jetons d'image d'une image. 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.FlavaImageCodebook.forward]] ```python forward(pixel_values: Tensor, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1374) #### get_codebook_indices[[transformers.FlavaImageCodebook.get_codebook_indices]] ```python get_codebook_indices(pixel_values: Tensor) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1340) #### get_codebook_probs[[transformers.FlavaImageCodebook.get_codebook_probs]] ```python get_codebook_probs(pixel_values: Tensor) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L1370) ## FlavaTextModel[[transformers.FlavaTextModel]] #### transformers.FlavaTextModel[[transformers.FlavaTextModel]] ```python transformers.FlavaTextModel(config: FlavaTextConfig, add_pooling_layer: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L759) **Paramètres :** config ([FlavaTextConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextConfig)) : 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. add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling Le modèle de texte Flava 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.FlavaTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = 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/flava/modeling_flava.py#L787) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, text_seq_length)`) : Indices des jetons de la séquence d'entrée 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. [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) token_type_ids (`torch.LongTensor` de forme `(batch_size, text_seq_length)`, *facultatif*) : Indices de 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) 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) 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 :** [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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) et les entrées. La méthode forward du modèle [FlavaTextModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaTextModel) surcharge 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. ## FlavaImageModel[[transformers.FlavaImageModel]] #### transformers.FlavaImageModel[[transformers.FlavaImageModel]] ```python transformers.FlavaImageModel(config: FlavaImageConfig, add_pooling_layer: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L677) **Paramètres :** config ([FlavaImageConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageConfig)) : 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. add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling Le modèle Flava 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.FlavaImageModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool | None = None, attention_mask: typing.Optional[torch.Tensor] = 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/flava/modeling_flava.py#L707) **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 [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor). Voir [FlavaImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([FlavaProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaProcessor) utilise [FlavaImageProcessor](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageProcessor) pour le traitement des images). bool_masked_pos (`torch.BoolTensor` de forme `(batch_size, image_num_patches)`) : Positions masquées booléennes. Indique quels patches sont masqués (1) et lesquels ne le sont pas (0). interpolate_pos_encoding (`bool`, *facultatif*) : Indique s'il faut interpoler les encodages de position pré-entraînés. 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) 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 :** [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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) et les entrées. La méthode forward du modèle [FlavaImageModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaImageModel) 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. ## FlavaMultimodalModel[[transformers.FlavaMultimodalModel]] #### transformers.FlavaMultimodalModel[[transformers.FlavaMultimodalModel]] ```python transformers.FlavaMultimodalModel(config: FlavaMultimodalConfig, add_pooling_layer = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flava/modeling_flava.py#L855) **Paramètres :** config ([FlavaMultimodalConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalConfig)) : 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. add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling Le modèle Flava 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.FlavaMultimodalModel.forward]] ```python forward(hidden_states: Tensor, attention_mask: typing.Optional[torch.Tensor] = 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/flava/modeling_flava.py#L879) **Paramètres :** hidden_states (`torch.Tensor` de forme `(batch_size, image_num_patches + text_seq_len, hidden_size)`) : Les états cachés concaténés des encodeurs unimodaux. 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) 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 :** [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 ([FlavaConfig](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaConfig)) et les entrées. La méthode forward du modèle [FlavaMultimodalModel](/docs/transformers/main/fr/model_doc/flava#transformers.FlavaMultimodalModel) 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.