Transformers documentation

LayoutLM

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans HF papers le 2019-12-31 et ajouté à Hugging Face Transformers le 2020-11-16.

LayoutLM

LayoutLM apprend conjointement le texte et la mise en page du document, plutôt que de se concentrer uniquement sur le texte. Il intègre des informations de position de mise en page et des caractéristiques visuelles des mots issues des images de documents.

Vous pouvez trouver tous les points de contrôle originaux de LayoutLM dans la collection LayoutLM.

Cliquez sur les modèles LayoutLM dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer LayoutLM à différentes tâches de vision et de langage.

L'exemple ci-dessous illustre la réponse aux questions avec la classe AutoModel.

AutoModel

Notes

Le LayoutLM d’origine n’a pas été conçu avec un flux de traitement unifié. Il s’attend plutôt à recevoir du texte prétraité (words) et des boîtes englobantes (boxes) provenant d’un moteur OCR externe (comme Pytesseract) et à les fournir en tant qu’entrées supplémentaires au tokenizer.
La méthode forward() s'attend à l'entrée bbox (boîtes englobantes des jetons d'entrée). Chaque boîte englobante doit être au format (x0, y0, x1, y1). (x0, y0) correspond au coin supérieur gauche de la boîte englobante et (x1, y1) correspond au coin inférieur droit. Les boîtes englobantes doivent être normalisées sur une échelle de 0 à 1000, comme indiqué ci-dessous.

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)),
    ]

width et height correspondent à la largeur et à la hauteur du document d'origine dans lequel le jeton apparaît. Ces valeurs peuvent être obtenues comme indiqué ci-dessous.

from PIL import Image


# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec LayoutLM. 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.

Lisez fine-tuning LayoutLM for document-understanding using Keras & Hugging Face Transformers pour en savoir plus.
Lisez fine-tune LayoutLM for document-understanding using only Hugging Face Transformers pour plus d’informations.
Reportez-vous à ce notebook pour un exemple pratique de la façon d’affiner LayoutLM.
Reportez-vous à ce notebook pour un exemple de la façon de fine-tuner LayoutLM pour la classification de séquences.
Reportez-vous à ce notebook pour un exemple de la façon de fine-tuner LayoutLM pour la classification de jetons.
Lisez Deploy LayoutLM with Hugging Face Inference Endpoints pour apprendre à déployer LayoutLM.

LayoutLMConfig

classe transformers.LayoutLMConfig

< source >

( 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 = 0eos_token_id: int | list[int] | None = Nonebos_token_id: int | None = Noneuse_cache: bool = Truemax_2d_position_embeddings: int = 1024tie_word_embeddings: bool = True )

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.
eos_token_id (Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
max_2d_position_embeddings (int, facultatif, valeur par défaut 1024) — La valeur maximale que l’embedding de position 2D pourrait atteindre. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 1024).
tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un LayoutLMModel. Elle est utilisée pour instancier un modèle Layoutlm 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/layoutlm-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.

Exemples :

>>> from transformers import LayoutLMConfig, LayoutLMModel

>>> # Initializing a LayoutLM configuration
>>> configuration = LayoutLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LayoutLMModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

LayoutLMTokenizer

classe transformers.BertTokenizer

< source >

( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs )

Paramètres

vocab (str ou dict[str, int], facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file.
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.
tokenize_chinese_chars (bool, facultatif, par défaut True) — Indique s'il faut ou non tokeniser les caractères chinois.
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 BERT d'origine).

Construire un tokenizer BERT (basé sur la bibliothèque tokenizers de HuggingFace). Basé sur WordPiece.

Ce tokenizer hérite de TokenizersBackend, 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

< source >

Paramètres

text (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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
text_pair (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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
text_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
text_pair_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
tokenizer_kwargs (dict[str, Any], facultatif) — Kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité.
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, 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.
is_split_into_words (bool, facultatif, par défaut False) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini à True, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et la tokenise. Cela est utile pour la NER ou la classification de tokens.
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).
padding_side (str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom.
return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
- 'pt' : Renvoie des objets torch.Tensor de PyTorch.
- 'np' : Renvoie des objets Numpy np.ndarray.
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()

Retourne

BatchEncoding

Un BatchEncoding avec les champs suivants :

input_ids — Liste des identifiants de jetons à fournir à un modèle.

Qu'est-ce que les identifiants d'entrée ?
token_type_ids — Liste des identifiants de type de jeton à fournir à un modèle (lorsque return_token_type_ids=True ou si “token_type_ids” est présent dans self.model_input_names).

Qu'est-ce que les identifiants de type de jeton ?
attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque return_attention_mask=True ou si “attention_mask” est présent dans self.model_input_names).

Qu'est-ce que les masques d'attention ?
overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).
num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).
special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque add_special_tokens=True et return_special_tokens_mask=True).
length — La longueur des entrées (lorsque return_length=True)

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.

LayoutLMModel

classe transformers.LayoutLMModel

< source >

( config: LayoutLMConfig )

Paramètres

config (LayoutLMConfig) — 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 Layoutlm 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

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = 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. Voir Aperçu pour la normalisation.
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 (LayoutLMConfig) et des entrées.

La méthode forward de LayoutLMModel 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 AutoTokenizer, LayoutLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

LayoutLMForMaskedLM

classe transformers.LayoutLMForMaskedLM

< source >

( config: LayoutLMConfig )

Paramètres

config (LayoutLMConfig) — 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 Layoutlm avec une tête de language modeling au sommet.”

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = 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'> ) → MaskedLMOutput 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. Voir Aperçu pour la normalisation.
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.
labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [-100, 0, ..., config.vocab_size] (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].

Retourne

MaskedLMOutput ou tuple(torch.Tensor)

Un MaskedLMOutput 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 (LayoutLMConfig) et des entrées.

La méthode forward de LayoutLMForMaskedLM 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 modélisation de langage masquée (MLM).
logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire 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.

Exemples :

>>> from transformers import AutoTokenizer, LayoutLMForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="pt")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

LayoutLMForSequenceClassification

classe transformers.LayoutLMForSequenceClassification

< source >

( config: LayoutLMConfig )

Paramètres

config (LayoutLMConfig) — 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 LayoutLM avec une tête de classification de séquence au sommet (une couche linéaire au-dessus de la sortie agrégée), par exemple pour des tâches de classification d'images de documents telles que le jeu de données RVL-CDIP.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = 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), 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. Voir Aperçu pour la normalisation.
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.
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 (LayoutLMConfig) et des entrées.

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

Exemples :

>>> from transformers import AutoTokenizer, LayoutLMForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> sequence_label = torch.tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForTokenClassification

classe transformers.LayoutLMForTokenClassification

< source >

( config: LayoutLMConfig )

Paramètres

config (LayoutLMConfig) — 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 LayoutLM avec une tête de classification de jetons au sommet (une couche linéaire au-dessus de la sortie des états cachés), par exemple pour des tâches d'étiquetage de séquences (extraction d'informations) telles que le jeu de données FUNSD et le jeu de données SROIE.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = 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), 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. Voir Aperçu pour la normalisation.
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.
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 (LayoutLMConfig) et des entrées.

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

Exemples :

>>> from transformers import AutoTokenizer, LayoutLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> token_labels = torch.tensor([1, 1, 0, 0]).unsqueeze(0)  # batch size of 1

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForQuestionAnswering

classe transformers.LayoutLMForQuestionAnswering

< source >

( config: LayoutLMConfighas_visual_segment_embedding = True )

Paramètres

config (LayoutLMConfig) — 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 transformer Layoutlm 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).

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Nonebbox: typing.Optional[torch.LongTensor] = 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), 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. Voir Aperçu pour la normalisation.
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.
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 (LayoutLMConfig) et des entrées.

La méthode forward de LayoutLMForQuestionAnswering 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 préparons une paire question + contexte pour le modèle LayoutLM. Il nous fournira une prédiction de ce qu'il considère comme la réponse (l'intervalle de la réponse au sein des textes extraits de l'image).

>>> from transformers import AutoTokenizer, LayoutLMForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="pt"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = torch.tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

Update on GitHub

←KOSMOS-2.5 LayoutLMV2→