# LayoutLMV2 ## Aperçu Le modèle LayoutLMV2 a été proposé dans [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://huggingface.co/papers/2012.14740) par Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou. LayoutLMV2 améliore [LayoutLM](layoutlm) afin d'obtenir des résultats de pointe sur plusieurs benchmarks de compréhension d'images de documents : - extraction d'informations à partir de documents scannés : le jeu de données [FUNSD](https://guillaumejaume.github.io/FUNSD/) (une collection de 199 formulaires annotés comprenant plus de 30 000 mots), le jeu de données [CORD](https://github.com/clovaai/cord) (une collection de 800 reçus pour l'entraînement, 100 pour la validation et 100 pour le test), le jeu de données [SROIE](https://rrc.cvc.uab.es/?ch=13) (une collection de 626 reçus pour l'entraînement et 347 reçus pour le test) et le jeu de données [Kleister-NDA](https://github.com/applicaai/kleister-nda) (une collection d'accords de confidentialité issus de la base de données EDGAR, incluant 254 documents pour l'entraînement, 83 documents pour la validation et 203 documents pour le test). - classification d'images de documents : le jeu de données [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/) (un ensemble de 400 000 images appartenant à l'une des 16 classes). - question-réponse visuelle sur documents : le jeu de données [DocVQA](https://huggingface.co/papers/2007.00398) (un ensemble de 50 000 questions définies sur plus de 12 000 images de documents). L'abstract de l'article est le suivant : *La pré-entraînement du texte et de la mise en page s'est avérée efficace dans une variété de tâches de compréhension de documents visuellement riches, grâce à son architecture de modèle efficace et à l'avantage offert par les documents numérisés ou numériques à grande échelle non étiquetés. Dans cet article, nous présentons LayoutLMv2, qui pré-entraîne le texte, la mise en page et l'image dans un cadre multimodal, en exploitant de nouvelles architectures de modèles et de nouvelles tâches de pré-entraînement. Plus précisément, LayoutLMv2 n'utilise pas seulement la tâche existante de modélisation visuelle-langagière masquée, mais aussi les nouvelles tâches d'alignement texte-image et d'appariement texte-image à l'étape de pré-entraînement, permettant ainsi un meilleur apprentissage de l'interaction inter-modalité. Parallèlement, il intègre un mécanisme d'auto-attention spatialement conscient dans l'architecture Transformer, afin que le modèle puisse pleinement comprendre la relation positionnelle relative entre les différents blocs de texte. Les résultats expérimentaux montrent que LayoutLMv2 surpasse des lignes de base solides et atteint de nouveaux résultats de l'état de l'art sur une large variété de tâches de compréhension de documents visuellement riches en aval, notamment FUNSD (0.7895 -> 0.8420), CORD (0.9493 -> 0.9601), SROIE (0.9524 -> 0.9781), Kleister-NDA (0.834 -> 0.852), RVL-CDIP (0.9443 -> 0.9564) et DocVQA (0.7295 -> 0.8672). Le modèle LayoutLMv2 pré-entraîné est publiquement disponible à cette URL https.* LayoutLMv2 dépend de `detectron2`, `torchvision` et `tesseract`. Exécutez la commande suivante pour les installer : ```bash python -m pip install 'git+https://github.com/facebookresearch/detectron2.git' python -m pip install torchvision tesseract ``` (Si vous développez pour LayoutLMv2, notez que le passage des doctests nécessite également l’installation de ces paquets.) ## Conseils d'utilisation - La principale différence entre LayoutLMv1 et LayoutLMv2 est que ce dernier intègre des embeddings visuels lors de la pré-entraînement (alors que LayoutLMv1 n’ajoute des embeddings visuels que lors de l’ajustement fin). - LayoutLMv2 ajoute à la fois un biais d'attention relatif 1D et un biais d'attention spatial 2D aux scores d'attention dans les couches d'auto-attention. Les détails se trouvent à la page 5 de l'[article](https://huggingface.co/papers/2012.14740). - Des notebooks de démonstration sur l'utilisation du modèle LayoutLMv2 sur RVL-CDIP, FUNSD, DocVQA et CORD sont disponibles [ici](https://github.com/NielsRogge/Transformers-Tutorials). - LayoutLMv2 utilise le package [Detectron2](https://github.com/facebookresearch/detectron2/) de Facebook AI pour son backbone visuel. Consultez [ce lien](https://detectron2.readthedocs.io/en/latest/tutorials/install.html) pour les instructions d’installation. - En plus de `input_ids`, [forward()](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Model.forward) s'attend à deux entrées supplémentaires, à savoir `image` et `bbox`. L'entrée `image` correspond à l'image du document d'origine dans laquelle apparaissent les jetons de texte. Le modèle s'attend à ce que chaque image de document ait une taille de 224x224. Cela signifie que si vous avez un lot d'images de documents, `image` doit être un tenseur de forme (batch_size, 3, 224, 224). Il peut s'agir d'un `torch.Tensor` ou d'un `Detectron2.structures.ImageList`. Vous n'avez pas besoin de normaliser les canaux, car le modèle s'en charge. Il est important de noter que l'architecture visuelle s'attend à des canaux BGR plutôt qu'à des canaux RGB, car tous les modèles de Detectron2 sont pré-entraînés en utilisant le format BGR. L'entrée `bbox` correspond aux boîtes englobantes (c'est-à-dire les positions 2D) des jetons de texte d'entrée. C'est identique à [LayoutLMModel](/docs/transformers/main/fr/model_doc/layoutlm#transformers.LayoutLMModel). Ces boîtes peuvent être obtenues à l'aide d'un moteur OCR externe tel que [Tesseract](https://github.com/tesseract-ocr/tesseract) de Google (un [Python wrapper](https://pypi.org/project/pytesseract/) est disponible). Chaque boîte englobante doit être au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit. Notez qu'il faut d'abord normaliser les boîtes englobantes sur une échelle de 0 à 1000. Pour normaliser, vous pouvez utiliser la fonction suivante : ```python def normalize_bbox(bbox, width, height): return [ int(1000 * (bbox[0] / width)), int(1000 * (bbox[1] / height)), int(1000 * (bbox[2] / width)), int(1000 * (bbox[3] / height)), ] ``` Ici, `width` et `height` correspondent à la largeur et à la hauteur du document d’origine dans lequel le jeton apparaît (avant le redimensionnement de l’image). Ils peuvent être obtenus à l’aide de la bibliothèque Python Image Library (PIL), par exemple, comme suit : ```python from PIL import Image image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ) width, height = image.size ``` Cependant, ce modèle intègre un tout nouveau [LayoutLMv2Processor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) qui permet de préparer directement les données pour le modèle (y compris l'application de l'OCR en interne). De plus amples informations sont disponibles dans la section « Utilisation » ci-dessous. - En interne, [LayoutLMv2Model](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Model) transmet l'entrée `image` à travers son backbone visuel pour obtenir une carte de caractéristiques de résolution plus faible, dont la forme est égale à l'attribut `image_feature_pool_shape` de [LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config). Cette carte de caractéristiques est ensuite aplatie pour obtenir une séquence de jetons d'image. Comme la taille de la carte de caractéristiques est de 7x7 par défaut, on obtient 49 jetons d'image. Ceux-ci sont ensuite concaténés avec les jetons de texte et transmis à l'encodeur Transformer. Cela signifie que les derniers états cachés du modèle auront une longueur de 512 + 49 = 561, si vous rembourrez les jetons de texte jusqu'à la longueur maximale. Plus généralement, les derniers états cachés auront une forme de `seq_length` + `image_feature_pool_shape[0]` * `config.image_feature_pool_shape[1]`. - Lors de l’appel de [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained), un avertissement est affiché, accompagnant d’une longue liste de noms de paramètres non initialisés. Ce n’est pas un problème, car ces paramètres correspondent aux statistiques de normalisation par lot, qui prendront des valeurs lors de l’ajustement fin sur un jeu de données personnalisé. - Si vous souhaitez entraîner le modèle dans un environnement distribué, assurez-vous d’appeler `synchronize_batch_norm` sur le modèle afin de synchroniser correctement les couches de normalisation par lot du squelette visuel. En outre, il existe LayoutXLM, qui est une version multilingue de LayoutLMv2. Plus d'informations sont disponibles sur [la page de documentation de LayoutXLM](layoutxlm). ## Ressources Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec LayoutLMv2. Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante. - Un notebook sur la façon de [réentraîner LayoutLMv2 pour la classification de texte sur le jeu de données RVL-CDIP](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/RVL-CDIP/Fine_tuning_LayoutLMv2ForSequenceClassification_on_RVL_CDIP.ipynb). - Voir aussi : [Guide de la tâche de classification de texte](../tasks/sequence_classification) - Un notebook sur la façon de [réentraîner LayoutLMv2 pour la réponse à des questions sur le jeu de données DocVQA](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/DocVQA/Fine_tuning_LayoutLMv2ForQuestionAnswering_on_DocVQA.ipynb). - Voir aussi : [Guide de la tâche de réponse aux questions](../tasks/question_answering) - Voir aussi : [Guide de la tâche de réponse à des questions sur des documents](../tasks/document_question_answering) - Un notebook sur la façon de [réentraîner LayoutLMv2 pour la classification de jetons sur le jeu de données CORD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/CORD/Fine_tuning_LayoutLMv2ForTokenClassification_on_CORD.ipynb). - Un notebook sur la façon de [réentraîner LayoutLMv2 pour la classification de jetons sur le jeu de données FUNSD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Fine_tuning_LayoutLMv2ForTokenClassification_on_FUNSD_using_HuggingFace_Trainer.ipynb). - Voir aussi : [Guide de la tâche de classification de jetons](../tasks/token_classification) ## Utilisation : LayoutLMv2Processor La façon la plus simple de préparer les données pour le modèle est d’utiliser [LayoutLMv2Processor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), qui combine en interne un processeur d’images ([LayoutLMv2ImageProcessor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor)) et un tokeniseur ([LayoutLMv2Tokenizer](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) ou [LayoutLMv2TokenizerFast](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer)). Le processeur d’images gère la modalité image, tandis que le tokeniseur gère la modalité texte. Un processeur combine les deux, ce qui est idéal pour un modèle multimodal comme LayoutLMv2. Notez que vous pouvez toujours utiliser les deux séparément, si vous ne souhaitez traiter qu’une seule modalité. ```python from transformers import LayoutLMv2ImageProcessor, LayoutLMv2Processor, LayoutLMv2TokenizerFast image_processor = LayoutLMv2ImageProcessor() # apply_ocr is set to True by default tokenizer = LayoutLMv2TokenizerFast.from_pretrained("microsoft/layoutlmv2-base-uncased") processor = LayoutLMv2Processor(image_processor, tokenizer) ``` En résumé, on peut fournir une image de document (et éventuellement des données supplémentaires) à [LayoutLMv2Processor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), qui créera alors les entrées attendues par le modèle. En interne, le processeur utilise d'abord [LayoutLMv2ImageProcessor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) pour appliquer l'OCR sur l'image afin d'obtenir une liste de mots et des boîtes englobantes normalisées, ainsi que pour redimensionner l'image à une taille donnée afin d'obtenir l'entrée `image`. Les mots et les boîtes englobantes normalisées sont ensuite transmis à [LayoutLMv2Tokenizer](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) ou [LayoutLMv2TokenizerFast](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer), qui les convertit en `input_ids`, `attention_mask`, `token_type_ids` et `bbox` au niveau des jetons. Facultativement, on peut fournir des étiquettes de mots au processeur, qui sont alors transformées en `labels` au niveau des jetons. [LayoutLMv2Processor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) utilise [PyTesseract](https://pypi.org/project/pytesseract/), un wrapper Python autour du moteur OCR Tesseract de Google, en interne. Notez que vous pouvez toujours utiliser votre propre moteur OCR et fournir vous-même les mots et les boîtes normalisées. Cela nécessite d'initialiser [LayoutLMv2ImageProcessor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) avec `apply_ocr` défini sur `False`. Au total, le processeur prend en charge 5 cas d'utilisation. Nous les listons ci-dessous. Notez que chacun de ces cas d'utilisation fonctionne aussi bien pour des entrées en lot que pour des entrées non en lot (nous les illustrons pour des entrées non en lot). **Cas d’usage 1 : classification d’images de documents (entraînement, inférence) + classification de jetons (inférence), apply_ocr = True** C'est le cas le plus simple, dans lequel le processeur (en réalité le processeur d'images) effectuera une OCR sur l'image afin d'obtenir les mots et les boîtes englobantes normalisées. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") encoding = processor( image, return_tensors="pt" ) # you can also add all tokenizer parameters here such as padding, truncation print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Cas d'utilisation 2 : classification d'images de documents (entraînement, inférence) + classification de jetons (inférence), apply_ocr=False** Si l’on souhaite effectuer soi-même la reconnaissance optique de caractères (OCR), il est possible d’initialiser le processeur d’images avec `apply_ocr` défini sur `False`. Dans ce cas, il faut fournir soi-même les mots et les boîtes englobantes (normalisées) correspondantes au processeur. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Cas d'usage 3 : classification de jetons (entraînement), apply_ocr=False** Pour les tâches de classification de jetons (telles que FUNSD, CORD, SROIE, Kleister-NDA), il est également possible de fournir les étiquettes de mots correspondantes afin d'entraîner un modèle. Le processeur convertira ensuite ces étiquettes en `labels` au niveau des jetons. Par défaut, il n'étiquette que le premier mot de base d'un mot, et attribue -100 aux mots de base restants, ce qui correspond à l'`ignore_index` de CrossEntropyLoss de PyTorch. Si vous souhaitez que tous les mots de base d'un mot soient étiquetés, vous pouvez initialiser le tokeniseur avec `only_label_first_subword` défini sur `False`. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes word_labels = [1, 2] encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'labels', 'image']) ``` **Cas d'usage 4 : question-réponse visuelle (inférence), apply_ocr=True** Pour les tâches de réponse à des questions visuelles (comme DocVQA), vous pouvez fournir une question au processeur. Par défaut, le processeur applique l’OCR sur l’image et crée [CLS] question tokens [SEP] word tokens [SEP]. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" encoding = processor(image, question, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Cas d'usage 5 : question-réponse visuelle (inférence), apply_ocr=False** Pour les tâches de réponse à des questions visuelles (comme DocVQA), vous pouvez fournir une question au processeur. Si vous souhaitez effectuer vous-même la reconnaissance optique de caractères (OCR), vous pouvez fournir vos propres mots et boîtes englobantes (normalisées) au processeur. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, question, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` ## LayoutLMv2Config[[transformers.LayoutLMv2Config]] #### transformers.LayoutLMv2Config[[transformers.LayoutLMv2Config]] ```python transformers.LayoutLMv2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, max_2d_position_embeddings: int = 1024, max_rel_pos: int = 128, rel_pos_bins: int = 32, fast_qkv: bool = True, max_rel_2d_pos: int = 256, rel_2d_pos_bins: int = 64, convert_sync_batchnorm: bool = True, image_feature_pool_shape: list[int] | tuple[int, ...] = (7, 7, 256), coordinate_size: int = 128, shape_size: int = 128, has_relative_attention_bias: bool = True, has_spatial_attention_bias: bool = True, has_visual_segment_embedding: bool = False, detectron2_config_args: dict | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/configuration_layoutlmv2.py#L29) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `30522`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées. num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention. max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. type_vocab_size (`int`, *facultatif*, par défaut `2`) : La taille du vocabulaire des `token_type_ids`. 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. max_2d_position_embeddings (`int`, *facultatif*, valeur par défaut 1024) : La valeur maximale avec laquelle l'incorporation de position 2D pourrait être utilisée. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par ex. 1024). max_rel_pos (`int`, *facultatif*, valeur par défaut : 128) : Nombre maximal de positions relatives à utiliser dans le mécanisme d'auto-attention. rel_pos_bins (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de bins de position relative à utiliser dans le mécanisme d'auto-attention. fast_qkv (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser une seule matrice pour les requêtes, les clés et les valeurs dans les couches d'auto-attention. max_rel_2d_pos (`int`, *facultatif*, valeur par défaut : 256) : Nombre maximal de positions 2D relatives dans le mécanisme d'auto-attention. rel_2d_pos_bins (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de bins de position relative 2D dans le mécanisme d'auto-attention. convert_sync_batchnorm (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir les couches de normalisation par lot en couches de normalisation par lot synchronisées. image_feature_pool_shape (`list[int]`, *facultatif*, par défaut `[7, 7, 256]`) : La forme de la carte de caractéristiques moyennée. coordinate_size (`int`, *facultatif*, par défaut 128) : Dimension des embeddings de coordonnées. shape_size (`int`, *facultatif*, par défaut 128) : Dimension des embeddings de largeur et de hauteur. has_relative_attention_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais d'attention relatif dans le mécanisme d'auto-attention. has_spatial_attention_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais d'attention spatiale dans le mécanisme d'auto-attention. has_visual_segment_embedding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter des embeddings de segments visuels. detectron2_config_args (`dict`, *facultatif*) : Dictionnaire contenant les arguments de configuration de l'ossature visuelle de Detectron2. Consultez [ce fichier](https://github.com/microsoft/unilm/blob/master/layoutlmft/layoutlmft/models/layoutlmv2/detectron2_config.py) pour plus de détails sur les valeurs par défaut. Il s'agit de la classe de configuration destinée à stocker la configuration d'un LayoutLMv2Model. Elle est utilisée pour instancier un modèle Layoutlmv2 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 [microsoft/layoutlmv2-base-uncased](https://huggingface.co/microsoft/layoutlmv2-base-uncased) 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 LayoutLMv2Config, LayoutLMv2Model >>> # Initializing a LayoutLMv2 microsoft/layoutlmv2-base-uncased style configuration >>> configuration = LayoutLMv2Config() >>> # Initializing a model (with random weights) from the microsoft/layoutlmv2-base-uncased style configuration >>> model = LayoutLMv2Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] #### transformers.LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] ```python transformers.LayoutLMv2ImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_layoutlmv2.py#L118) **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*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : 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*, valeur par défaut `None`) : Facteur de remise à l'échelle à 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. apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.apply_ocr`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`. ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`. tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`. Construit un processeur d’images LayoutLMv2ImageProcessor. #### prétraiter[[transformers.LayoutLMv2ImageProcessor.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/layoutlmv2/image_processing_layoutlmv2.py#L131) **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. apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.apply_ocr`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`. ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`. tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `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. ## LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] #### transformers.LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] ```python transformers.LayoutLMv2ImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_pil_layoutlmv2.py#L121) **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*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : 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*, valeur par défaut `None`) : Facteur de remise à l'échelle à 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. apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.apply_ocr`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`. ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`. tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`. Construit un processeur d’images LayoutLMv2ImageProcessor. #### prétraiter[[transformers.LayoutLMv2ImageProcessorPil.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/layoutlmv2/image_processing_pil_layoutlmv2.py#L134) **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. apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.apply_ocr`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`. ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`. tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `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. ## LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] #### transformers.LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] ```python transformers.LayoutLMv2Tokenizer(vocab: str | dict[str, int] | None = None, do_lower_case = True, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', cls_token_box = [0, 0, 0, 0], sep_token_box = [1000, 1000, 1000, 1000], pad_token_box = [0, 0, 0, 0], pad_token_label = -100, only_label_first_subword = True, tokenize_chinese_chars = True, strip_accents = None, model_max_length = 512, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L112) **Paramètres :** vocab_file (`str`) : Fichier contenant le vocabulaire. do_lower_case (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation. unk_token (`str`, *facultatif*, valeur par défaut `"[UNK]"`) : le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton. sep_token (`str`, *facultatif*, valeur par défaut `"[SEP]"`) : le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux. pad_token (`str`, *facultatif*, par défaut `"[PAD]"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes. cls_token (`str`, *facultatif*, par défaut `"[CLS]"`) : le jeton de classifieur utilisé lors de la classification de séquence (classification de la séquence entière plutôt que la classification par jeton). C'est le premier jeton de la séquence lorsqu'elle est construite avec des jetons spéciaux. mask_token (`str`, *facultatif*, valeur par défaut `"[MASK]"`) : Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le masquage de langage. C'est le jeton que le modèle cherchera à prédire. cls_token_box (`List[int]`, *facultatif*, par défaut `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [CLS]. sep_token_box (`List[int]`, *facultatif*, par défaut `[1000, 1000, 1000, 1000]`) : La boîte englobante à utiliser pour le jeton spécial [SEP]. pad_token_box (`List[int]`, *facultatif*, par défaut `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [PAD]. pad_token_label (`int`, *facultatif*, valeur par défaut : -100) : L'étiquette à utiliser pour les jetons de bourrage. La valeur par défaut est -100, qui correspond à `ignore_index` de CrossEntropyLoss de PyTorch. only_label_first_subword (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut étiqueter uniquement le premier sous-mot, lorsque des étiquettes de mots sont fournies. tokenize_chinese_chars (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non tokeniser les caractères chinois. Il est probable qu'il faille désactiver cette option pour le japonais (voir [cet article](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *facultatif*) : Indique s'il faut supprimer toutes les accents. Si cette option n'est pas spécifiée, elle est déterminée par la valeur de `lowercase` (comme dans LayoutLMv2 d'origine). Construire un tokeniseur « rapide » pour LayoutLMv2 (basé sur la bibliothèque *tokenizers* de HuggingFace). Fondé sur WordPiece. Ce tokenizer hérite de [PreTrainedTokenizerFast](/docs/transformers/main/fr/main_classes/tokenizer#transformers.TokenizersBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes. #### __appel__[[transformers.LayoutLMv2Tokenizer.__call__]] ```python __call__(text: str | list[str] | list[list[str]], text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L243) **Paramètres :** text (`str`, `List[str]`, `List[List[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères, une liste de chaînes de caractères (mots d'un seul exemple ou questions d'un lot d'exemples) ou une liste de listes de chaînes de caractères (lot de mots). text_pair (`List[str]`, `List[List[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence doit être une liste de chaînes de caractères (chaînes pré-tokenisées). boxes (`List[List[int]]`, `List[List[List[int]]]`) : Boîtes englobantes au niveau des mots. Chaque boîte englobante doit être normalisée sur une échelle de 0 à 1000. word_labels (`List[int]`, `List[List[int]]`, *facultatif*) : Étiquettes entières au niveau des mots (pour les tâches de classification de jetons telles que FUNSD, CORD). add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes : - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes : - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle). max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée. stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta). return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids) return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement. return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/main/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`. return_length (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées. verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements. - ****kwargs** : transmis à la méthode `self.tokenize()` Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquence(s) ou une ou plusieurs paire(s) de séquences avec des boîtes englobantes normalisées au niveau du mot et des étiquettes facultatives. #### save_vocabulary[[transformers.LayoutLMv2Tokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546) ## LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] #### transformers.LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] ```python transformers.LayoutLMv2Processor(image_processor = None, tokenizer = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L24) **Paramètres :** image_processor (`LayoutLMv2ImageProcessor`) : le processeur d'images est une entrée obligatoire. tokenizer (`LayoutLMv2Tokenizer`) : le tokenizer est une entrée obligatoire. Construit un LayoutLMv2Processor qui encapsule un processeur d’images et un tokenizer en un seul processeur. [LayoutLMv2Processor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) offre toutes les fonctionnalités de [LayoutLMv2ImageProcessor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) et de [LayoutLMv2Tokenizer](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer). Consultez [~LayoutLMv2ImageProcessor](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) et [~LayoutLMv2Tokenizer](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) pour plus d’informations. #### __appel__[[transformers.LayoutLMv2Processor.__call__]] ```python __call__(images, text: str | list[str] | list[list[str]] = None, text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L28) **Paramètres :** images (``) : Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `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. text_pair (`str, list[str] or list[int]`, *facultatif*) : Deuxième séquence facultative à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de tokens obtenus à l'aide de la méthode `convert_tokens_to_ids`). boxes (`list[list[int]] or list[list[list[int]]]`, *facultatif*) : Boîtes englobantes au niveau des mots. Chaque boîte englobante doit être normalisée sur une échelle de 0 à 1000. word_labels (`list[int] or list[list[int]]`, *facultatif*) : Étiquettes entières au niveau des mots (pour les tâches de classification de jetons telles que FUNSD, CORD). add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons `bos` ou `eos`. padding (bool, str ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes : - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes). truncation (bool, str ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, valeur par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes : - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle). max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée. stride (`int`, *facultatif*, valeur par défaut `0`) : Si défini à un nombre en même temps que `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur du matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta). return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids) return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement. return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/main/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`. return_length (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les longueurs des entrées encodées. verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements. return_tensors (`Union[str, ~utils.generic.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. **Retourne :** `~tokenization_utils_base.BatchEncoding` - **data** (`dict`, *facultatif*) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). - **encodage** (`tokenizers.Encoding` ou `Sequence[tokenizers.Encoding]`, *facultatif*) -- Si le tokenizer est un fast tokenizer qui fournit des informations supplémentaires, telles que la correspondance entre l'espace des mots/caractères et l'espace des jetons, l'instance `tokenizers.Encoding` ou la liste d'instances (pour les lots) contient ces informations. - **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. - **prepend_batch_axis** (`bool`, *facultatif*, par défaut `False`) -- Indique s'il faut ajouter un axe de lot lors de la conversion en tenseurs (voir `tensor_type` ci-dessus). Notez que ce paramètre n'a un effet que si le paramètre `tensor_type` est défini, *sinon il n'a aucun effet*. - **n_sequences** (`int`, *facultatif*) -- Le nombre de séquences d'entrée représentées par chaque encodage (`None` pour inconnu, `1` pour une séquence unique et `2` pour une paire de séquences). ## LayoutLMv2Model[[transformers.LayoutLMv2Model]] #### transformers.LayoutLMv2Model[[transformers.LayoutLMv2Model]] ```python transformers.LayoutLMv2Model(config: LayoutLMv2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L551) **Paramètres :** config ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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 Layoutlmv2 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.LayoutLMv2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L663) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) bbox (`torch.LongTensor` de forme `((batch_size, sequence_length), 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit. image (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` dont `tensors` est de forme `(batch_size, num_channels, height, width)`) : Lot d'images de documents. 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, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) 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) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. **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 ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) et les entrées. La méthode forward du modèle [LayoutLMv2Model](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Model) 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. Exemples : ```python >>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> encoding = processor(image, return_tensors="pt") >>> outputs = model(**encoding) >>> last_hidden_states = outputs.last_hidden_state >>> last_hidden_states.shape torch.Size([1, 342, 768]) ``` ## LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] #### transformers.LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] ```python transformers.LayoutLMv2ForSequenceClassification(config: LayoutLMv2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L792) **Paramètres :** config ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle LayoutLMv2 doté d'une tête de classification de séquences (une couche linéaire appliquée à la concaténation de l'état caché final du jeton [CLS], des embeddings visuels initiaux moyennés et des embeddings visuels finaux moyennés, par exemple pour des tâches de classification d'images de documents telles que le jeu de données [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/)). 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.LayoutLMv2ForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L806) **Paramètres :** input_ids (`torch.LongTensor` de forme `batch_size, sequence_length`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. 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) bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit. image (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` dont `tensors` est de forme `(batch_size, num_channels, height, width)`) : Lot d'images de documents. 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, sequence_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.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.max_position_embeddings - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée). **Retourne :** [SequenceClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)` Un [SequenceClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) et les entrées. La méthode forward de [LayoutLMv2ForSequenceClassification](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForSequenceClassification) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1). - **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque 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. Exemple : ```python >>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> dataset = load_dataset("aharley/rvl_cdip", split="train", streaming=True) >>> data = next(iter(dataset)) >>> image = data["image"].convert("RGB") >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForSequenceClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=dataset.info.features["label"].num_classes ... ) >>> encoding = processor(image, return_tensors="pt") >>> sequence_label = torch.tensor([data["label"]]) >>> outputs = model(**encoding, labels=sequence_label) >>> loss, logits = outputs.loss, outputs.logits >>> predicted_idx = logits.argmax(dim=-1).item() >>> predicted_answer = dataset.info.features["label"].names[4] >>> predicted_idx, predicted_answer # results are not good without further fine-tuning (7, 'advertisement') ``` ## LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] #### transformers.LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] ```python transformers.LayoutLMv2ForTokenClassification(config: LayoutLMv2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L986) **Paramètres :** config ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle LayoutLMv2 doté d'une tête de classification de jetons (une couche linéaire appliquée à la partie texte des états cachés), par exemple pour des tâches d'étiquetage de séquences (extraction d'informations) telles que [FUNSD](https://guillaumejaume.github.io/FUNSD/), [SROIE](https://rrc.cvc.uab.es/?ch=13), [CORD](https://github.com/clovaai/cord) et [Kleister-NDA](https://github.com/applicaai/kleister-nda). 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.LayoutLMv2ForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1000) **Paramètres :** input_ids (`torch.LongTensor` de forme `batch_size, sequence_length`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. 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) bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit. image (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` dont `tensors` est de forme `(batch_size, num_channels, height, width)`) : Lot d'images de documents. 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, sequence_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.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.max_position_embeddings - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. **Retourne :** [TokenClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)` Un [TokenClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) et les entrées. La méthode forward de [LayoutLMv2ForTokenClassification](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification. - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores de classification (avant SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque 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. Exemple : ```python >>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> datasets = load_dataset("nielsr/funsd", split="test") >>> labels = datasets.features["ner_tags"].feature.names >>> id2label = {v: k for v, k in enumerate(labels)} >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") >>> model = LayoutLMv2ForTokenClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=len(labels) ... ) >>> data = datasets[0] >>> image = Image.open(data["image_path"]).convert("RGB") >>> words = data["words"] >>> boxes = data["bboxes"] # make sure to normalize your bounding boxes >>> word_labels = data["ner_tags"] >>> encoding = processor( ... image, ... words, ... boxes=boxes, ... word_labels=word_labels, ... padding="max_length", ... truncation=True, ... return_tensors="pt", ... ) >>> outputs = model(**encoding) >>> logits, loss = outputs.logits, outputs.loss >>> predicted_token_class_ids = logits.argmax(-1) >>> predicted_tokens_classes = [id2label[t.item()] for t in predicted_token_class_ids[0]] >>> predicted_tokens_classes[:5] # results are not good without further fine-tuning ['I-HEADER', 'I-HEADER', 'I-QUESTION', 'I-HEADER', 'I-QUESTION'] ``` ## LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] #### transformers.LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] ```python transformers.LayoutLMv2ForQuestionAnswering(config: LayoutLMv2Config, has_visual_segment_embedding = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1121) **Paramètres :** config ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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. has_visual_segment_embedding (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter des embeddings de segments visuels. Le transformateur Layoutlmv2 avec une tête de classification de segments au sommet pour les tâches de question-réponse extractives comme SQuAD (une couche linéaire au sommet de la sortie des états cachés pour calculer `span start logits` et `span end logits`). 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.LayoutLMv2ForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1139) **Paramètres :** input_ids (`torch.LongTensor` de forme `batch_size, sequence_length`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. 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) bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit. image (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` dont `tensors` est de forme `(batch_size, num_channels, height, width)`) : Lot d'images de documents. 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, sequence_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.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.max_position_embeddings - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. start_positions (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (`sequence_length`). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. end_positions (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) de la fin de l'intervalle étiqueté, utilisées pour calculer la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (`sequence_length`). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. **Retourne :** [QuestionAnsweringModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` Un [QuestionAnsweringModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) et les entrées. La méthode forward de [LayoutLMv2ForQuestionAnswering](/docs/transformers/main/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForQuestionAnswering) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- La perte totale d'extraction de spans est la somme d'une entropie croisée pour les positions de début et de fin. - **start_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Scores de début de segment (avant SoftMax). - **end_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Scores de fin de segment (avant SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque 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. Exemple : Dans l'exemple ci-dessous, nous fournissons une image (de textes) au modèle LayoutLMv2 et lui posons une question. Il nous renvoie une prédiction de ce qu'il considère comme la réponse (le segment de texte correspondant à la réponse, extrait des textes analysés dans l'image). ```python >>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed >>> import torch >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> question = "When is coffee break?" >>> encoding = processor(image, question, return_tensors="pt") >>> outputs = model(**encoding) >>> predicted_start_idx = outputs.start_logits.argmax(-1).item() >>> predicted_end_idx = outputs.end_logits.argmax(-1).item() >>> predicted_start_idx, predicted_end_idx (30, 191) >>> predicted_answer_tokens = encoding.input_ids.squeeze()[predicted_start_idx : predicted_end_idx + 1] >>> predicted_answer = processor.tokenizer.decode(predicted_answer_tokens) >>> predicted_answer # results are not good without further fine-tuning '44 a. m. to 12 : 25 p. m. 12 : 25 to 12 : 58 p. m. 12 : 58 to 4 : 00 p. m. 2 : 00 to 5 : 00 p. m. coffee break coffee will be served for men and women in the lobby adjacent to exhibit area. please move into exhibit area. ( exhibits open ) trrf general session ( part | ) presiding : lee a. waller trrf vice president " introductory remarks " lee a. waller, trrf vice presi - dent individual interviews with trrf public board members and sci - entific advisory council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public refrigerated warehousing industry is looking for. plus questions from' ``` ```python >>> target_start_index = torch.tensor([7]) >>> target_end_index = torch.tensor([14]) >>> outputs = model(**encoding, start_positions=target_start_index, end_positions=target_end_index) >>> predicted_answer_span_start = outputs.start_logits.argmax(-1).item() >>> predicted_answer_span_end = outputs.end_logits.argmax(-1).item() >>> predicted_answer_span_start, predicted_answer_span_end (30, 191) ```