Hugging Face's logo

Transformers documentation

LayoutLMV2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2020-12-29 et ajouté à Hugging Face Transformers le 2021-08-30.

LayoutLMV2

Aperçu

Le modèle LayoutLMV2 a été proposé dans LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding 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 pour 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 (une collection de 199 formulaires annotés comprenant plus de 30 000 mots), le jeu de données 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 (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 (une collection d’accords de non-divulgation 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 (une collection de 400 000 images appartenant à l'une des 16 classes).
  • réponse à des questions sur des documents visuels : le jeu de données DocVQA (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 des documents scannés ou numériques à grande échelle non étiquetés. Dans cet article, nous présentons LayoutLMv2 en pré-entraînant le texte, la mise en page et l'image dans un cadre multimodal, où de nouvelles architectures de modèles et des tâches de pré-entraînement sont exploitées. 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, où l'interaction inter-modalité est mieux apprise. Parallèlement, il intègre également 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 fortes et atteint de nouveaux résultats de l'état de l'art sur une grande variété de tâches de compréhension de documents visuellement riches en aval, y compris 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 https URL.

LayoutLMv2 dépend de detectron2, torchvision et tesseract. Exécutez ce qui suit pour les installer :

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 pendant la pré-formation (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 peuvent être trouvés à la page 5 de l'article.
  • Des notebooks de démonstration sur l'utilisation du modèle LayoutLMv2 sur RVL-CDIP, FUNSD, DocVQA et CORD sont disponibles ici.
  • LayoutLMv2 utilise le package Detectron2 de Facebook AI pour son backbone visuel. Consultez ce lien pour les instructions d’installation.
  • En plus de input_ids, 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 se trouvent 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 soit d'un torch.Tensor, soit 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'ossature 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. Ces boîtes peuvent être obtenues à l'aide d'un moteur OCR externe tel que Tesseract de Google (un enveloppe Python 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 pour qu'elles soient sur une échelle de 0 à 1000. Pour normaliser, vous pouvez utiliser la fonction suivante :
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 :

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 qui permet de préparer directement les données pour le modèle (y compris l’application de l’OCR en interne). Plus d’informations sont disponibles dans la section « Utilisation » ci-dessous.

  • En interne, LayoutLMv2Model envoie 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. 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 envoyés à travers 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(), un avertissement est affiché avec 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.

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.

Text Classification
Question Answering
Token Classification

Utilisation : LayoutLMv2Processor

La façon la plus simple de préparer les données pour le modèle est d’utiliser LayoutLMv2Processor, qui combine en interne un processeur d’images (LayoutLMv2ImageProcessor) et un tokeniseur (LayoutLMv2Tokenizer ou LayoutLMv2TokenizerFast). 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é.

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, et il créera les entrées attendues par le modèle. En interne, le processeur utilise d'abord 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 ou LayoutLMv2TokenizerFast, 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 transformées en labels au niveau des jetons.

LayoutLMv2Processor utilise PyTesseract, un wrapper Python autour du moteur OCR Tesseract de Google, en interne. Notez que vous pouvez toujours utiliser votre propre moteur OCR de choix et fournir vous-même les mots et les boîtes normalisées. Cela nécessite d’initialiser LayoutLMv2ImageProcessor avec apply_ocr défini sur False.

Au total, le processeur prend en charge 5 cas d'utilisation. Nous les listons tous ci-dessous. Notez que chacun de ces cas d'utilisation fonctionne pour les entrées en lot comme pour les 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 pour obtenir les mots et les boîtes englobantes normalisées.

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, on peut 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.

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 wordpiece d’un mot et attribue -100 aux wordpieces restants, ce qui correspond à l’ignore_index de CrossEntropyLoss de PyTorch. Si vous souhaitez que tous les wordpieces d’un mot soient étiquetés, vous pouvez initialiser le tokenizer avec only_label_first_subword défini sur False.

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] jetons de question [SEP] jetons de mot [SEP].

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 l’OCR vous-même, vous pouvez fournir vos propres mots et boîtes englobantes (normalisées) au processeur.

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

classe transformers.LayoutLMv2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0max_2d_position_embeddings: int = 1024max_rel_pos: int = 128rel_pos_bins: int = 32fast_qkv: bool = Truemax_rel_2d_pos: int = 256rel_2d_pos_bins: int = 64convert_sync_batchnorm: bool = Trueimage_feature_pool_shape: list[int] | tuple[int, ...] = (7, 7, 256)coordinate_size: int = 128shape_size: int = 128has_relative_attention_bias: bool = Truehas_spatial_attention_bias: bool = Truehas_visual_segment_embedding: bool = Falsedetectron2_config_args: dict | None = None )

Paramètres

  • vocab_size (int, facultatif, 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 du MLP.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], facultatif, 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, par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • max_position_embeddings (int, facultatif, 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-12) — L'épsilon utilisé par les couches de normalisation de couche.
  • pad_token_id (int, facultatif, 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’embedding de position 2D pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 1024).
  • max_rel_pos (int, facultatif, valeur par défaut 128) — Le 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, clés et valeurs dans les couches d'auto-attention.
  • max_rel_2d_pos (int, facultatif, valeur par défaut 256) — Le nombre maximal de positions relatives 2D 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, 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, 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 ou non utiliser un biais d'attention spatiale dans le mécanisme d'auto-attention.
  • has_visual_segment_embedding (bool, facultatif, 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 du backbone visuel Detectron2. Consultez ce fichier pour plus de détails sur les valeurs par défaut.

Ceci est 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, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import 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

classe transformers.LayoutLMv2ImageProcessor

< >

( **kwargs: *<class 'transformers.models.layoutlmv2.image_processing_layoutlmv2.LayoutLMv2ImageProcessorKwargs'> )

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éfinit les dimensions maximales de l'entrée du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, 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 de l’une des valeurs de l’enum 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 appliqué à 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 effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à 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 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 (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • 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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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 est 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, 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 de la méthode preprocess.
  • tesseract_config (str, kwargs, facultatif) — Tous les drapeaux de configuration personnalisés supplémentaires qui sont transmis au paramètre config lors de l’appel de Tesseract. Par exemple : ‘—psm 6’. Peut être remplacé par le paramètre tesseract_config de la méthode preprocess.

Construit un processeur d’images LayoutLMv2ImageProcessor.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.layoutlmv2.image_processing_layoutlmv2.LayoutLMv2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez 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éfinit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en 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) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum 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 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 effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à 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 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 (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • 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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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 est 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, 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 de la méthode preprocess.
  • tesseract_config (str, kwargs, facultatif) — Tous les drapeaux de configuration personnalisés supplémentaires qui sont transmis au paramètre config lors de l’appel de Tesseract. Par exemple : ‘—psm 6’. Peut être remplacé par le paramètre tesseract_config de 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

classe transformers.LayoutLMv2ImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.layoutlmv2.image_processing_pil_layoutlmv2.LayoutLMv2ImageProcessorKwargs'> )

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éfinit les dimensions maximales de l'entrée du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, 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 de l’une des valeurs de l’enum 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 appliqué à 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 effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à 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 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 (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • 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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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 est 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, 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 de la méthode preprocess.
  • tesseract_config (str, kwargs, facultatif) — Tous les drapeaux de configuration personnalisés supplémentaires qui sont transmis au paramètre config lors de l’appel de Tesseract. Par exemple : ‘—psm 6’. Peut être remplacé par le paramètre tesseract_config de la méthode preprocess.

Construit un processeur d’images LayoutLMv2ImageProcessor.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.layoutlmv2.image_processing_pil_layoutlmv2.LayoutLMv2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez 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éfinit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en 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) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum 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 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 effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à 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 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 (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • 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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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 est 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, 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 de la méthode preprocess.
  • tesseract_config (str, kwargs, facultatif) — Tous les drapeaux de configuration personnalisés supplémentaires qui sont transmis au paramètre config lors de l’appel de Tesseract. Par exemple : ‘—psm 6’. Peut être remplacé par le paramètre tesseract_config de 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

classe transformers.LayoutLMv2Tokenizer

< >

( vocab: str | dict[str, int] | None = Nonedo_lower_case = Trueunk_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 = -100only_label_first_subword = Truetokenize_chinese_chars = Truestrip_accents = Nonemodel_max_length = 512**kwargs )

Paramètres

  • vocab_file (str) — Fichier contenant le vocabulaire.
  • do_lower_case (bool, facultatif, par défaut True) — Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation.
  • unk_token (str, facultatif, 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, 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 regroupement 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, 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 modélisation de langage masquée. 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, 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 probablement préférable de désactiver cette option pour le japonais (voir ce problème).
  • 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). Basé sur WordPiece.

Ce tokenizer hérite de PreTrainedTokenizerFast, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__call__

< >

( text: str | list[str] | list[list[str]]text_pair: list[str] | list[list[str]] | None = Noneboxes: list[list[int]] | list[list[list[int]]] | None = Noneword_labels: list[int] | list[list[int]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs )

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, 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, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à 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 tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • '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 tronquera 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 tronquera 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 par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou 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/le remplissage à une longueur maximale sera désactivé.

  • stride (int, facultatif, valeur par défaut 0) — Si défini à un nombre avec 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. 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 sont 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 ?

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

  • return_overflowing_tokens (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner 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 retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.
  • return_offsets_mapping (bool, facultatif, par défaut False) — Indique s'il faut renvoyer (char_start, char_end) pour chaque jeton.

    Cela n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève 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équences ou une ou plusieurs paires de séquences avec des boîtes englobantes normalisées au niveau du mot et des étiquettes facultatives.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

LayoutLMv2Processor

classe transformers.LayoutLMv2Processor

< >

( image_processor = Nonetokenizer = None**kwargs )

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 offre toutes les fonctionnalités de LayoutLMv2ImageProcessor et de LayoutLMv2Tokenizer. Consultez ~LayoutLMv2ImageProcessor et ~LayoutLMv2Tokenizer pour plus d’informations.

__call__

< >

( imagestext: str | list[str] | list[list[str]] = Nonetext_pair: list[str] | list[list[str]] | None = Noneboxes: list[list[int]] | list[list[list[int]]] | None = Noneword_labels: list[int] | list[list[int]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = Falsemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs ) → ~tokenization_utils_base.BatchEncoding

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 de caractères (chaînes pré-tokenisées). Si vous passez 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 d’une chaîne tokenisée à 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, par défaut True) — Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela 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, facultatif, défaut False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à 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 tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • '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 tronquera 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 tronquera 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 par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou 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/le remplissage à une longueur maximale sera désactivé.

  • stride (int, facultatif, 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 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 est rembourré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 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 sont 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 ?

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

  • return_overflowing_tokens (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner 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 retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.
  • return_offsets_mapping (bool, facultatif, par défaut False) — Indique s'il faut renvoyer (char_start, char_end) pour chaque jeton.

    Cela n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève 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.
  • return_tensors (Union[str, ~utils.generic.TensorType], facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptables sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

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.).
  • encoding (tokenizers.Encoding ou Sequence[tokenizers.Encoding], facultatif) — Si le tokenizer est un fast tokenizer qui fournit des informations supplémentaires, comme 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 ou non ajouter un axe de lot lors de la conversion en tenseurs (voir tensor_type ci-dessus). Notez que ce paramètre a un effet 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 seule séquence et 2 pour une paire de séquences).

LayoutLMv2Model

classe transformers.LayoutLMv2Model

< >

( config: LayoutLMv2Config )

Paramètres

  • config (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() 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneimage: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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) à 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (LayoutLMv2Config) et des entrées.

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

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

classe transformers.LayoutLMv2ForSequenceClassification

< >

( config: LayoutLMv2Config )

Paramètres

  • config (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() pour charger les poids du modèle.

Modèle LayoutLMv2 avec une tête de classification de séquence au sommet (une couche linéaire au sommet de 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).

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneimage: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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) à 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

    Qu'est-ce que les identifiants de type de jeton ?

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

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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 ou tuple(torch.Tensor)

Un SequenceClassifierOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (LayoutLMv2Config) et des entrées.

La méthode forward de 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).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from 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

classe transformers.LayoutLMv2ForTokenClassification

< >

( config: LayoutLMv2Config )

Paramètres

  • config (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() pour charger les poids du modèle.

Modèle LayoutLMv2 avec une tête de classification de jetons au sommet (une couche linéaire au sommet de la partie texte des états cachés), par exemple pour des tâches d'étiquetage de séquences (extraction d'informations) telles que FUNSD, SROIE, CORD et Kleister-NDA.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneimage: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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) à 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

    Qu'est-ce que les identifiants de type de jeton ?

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

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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 ou tuple(torch.Tensor)

Un TokenClassifierOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (LayoutLMv2Config) et des entrées.

La méthode forward de 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).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from 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

classe transformers.LayoutLMv2ForQuestionAnswering

< >

( config: LayoutLMv2Confighas_visual_segment_embedding = True )

Paramètres

  • config (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() 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 les span start logits et les span end logits).

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = Noneimage: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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) à 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

    Qu'est-ce que les identifiants de type de jeton ?

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

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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 borné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 fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont borné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 ou tuple(torch.Tensor)

Un QuestionAnsweringModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (LayoutLMv2Config) et des entrées.

La méthode forward de 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 span 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).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

Dans l’exemple ci-dessous, nous fournissons au modèle LayoutLMv2 une image (de textes) et lui posons une question. Il nous renverra une prédiction de ce qu’il considère comme la réponse (le segment de la réponse au sein des textes extraits de l’image).

>>> 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'
>>> 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)
Update on GitHub

←LayoutLM LayoutLMV3→