# LayoutLMv3

## Aperçu

Le modèle LayoutLMv3 a été proposé dans [LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking](https://huggingface.co/papers/2204.08387) par Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei. LayoutLMv3 simplifie [LayoutLMv2](layoutlmv2) en utilisant des embeddings de patch (comme dans [ViT](vit)) au lieu de s’appuyer sur un backbone CNN, et pré-entraîne le modèle sur trois objectifs : le masked language modeling (MLM), le masked image modeling (MIM) et l’alignement mot-patch (WPA).

L'abstract de l'article est le suivant :

*Les techniques de pré-entraînement auto-supervisé ont réalisé des progrès remarquables en Document AI. La plupart des modèles pré-entraînés multimodaux utilisent un objectif de modélisation de langage masqué pour apprendre des représentations bidirectionnelles sur la modalité texte, mais ils diffèrent quant aux objectifs de pré-entraînement pour la modalité image. Cette divergence complique l’apprentissage de représentations multimodales. Dans cet article, nous proposons LayoutLMv3 afin de pré-entraîner des Transformers multimodaux pour le Document AI avec un masquage unifié du texte et de l’image. De plus, LayoutLMv3 est pré-entraîné avec un objectif d’alignement mot-patch pour apprendre l’alignement intermodal en prédisant si le patch d’image correspondant à un mot de texte est masqué. L’architecture et les objectifs d’entraînement simples et unifiés font de LayoutLMv3 un modèle pré-entraîné polyvalent pour les tâches de Document AI centrées sur le texte comme sur l’image. Les résultats expérimentaux montrent que LayoutLMv3 atteint des performances de l’état de l’art non seulement sur les tâches centrées sur le texte, telles que la compréhension de formulaires, la compréhension de reçus et la question-réponse visuelle sur documents, mais aussi sur les tâches centrées sur l’image, comme la classification d’images de documents et l’analyse de la mise en page de documents.*

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/layoutlmv3_architecture.png"
alt="drawing" width="600"/>

 Architecture de LayoutLMv3. Issue de l'article original.

Ce modèle a été contribué par [nielsr](https://huggingface.co/nielsr). Le code d'origine peut être trouvé [ici](https://github.com/microsoft/unilm/tree/master/layoutlmv3).

## Conseils d'utilisation

- En termes de traitement des données, LayoutLMv3 est identique à son prédécesseur [LayoutLMv2](layoutlmv2), à l'exception de ce qui suit :
  - Les images doivent être redimensionnées et normalisées avec les canaux au format RGB standard. En revanche, LayoutLMv2 normalise les images en interne et s'attend à ce que les canaux soient au format BGR.
  - Le texte est tokenisé à l’aide de l’encodage par paires de bytes (BPE), contrairement à WordPiece. En raison de ces différences dans le prétraitement des données, on peut utiliser [LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor), qui combine en interne un [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) (pour la modalité image) et un [LayoutLMv3Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer)/[LayoutLMv3TokenizerFast](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer) (pour la modalité texte) afin de préparer toutes les données pour le modèle.
- Concernant l'utilisation de [LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor), nous renvoyons vers le [guide d'utilisation](layoutlmv2#usage-layoutlmv2processor) de son prédécesseur.

## Ressources

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

LayoutLMv3 est quasi identique à LayoutLMv2, nous avons donc également inclus les ressources LayoutLMv2 que vous pouvez adapter pour les tâches LayoutLMv3. Pour ces notebooks, veillez à utiliser [LayoutLMv2Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) à la place lors de la préparation des données pour le modèle !

- Des notebooks de démonstration pour LayoutLMv3 sont disponibles [ici](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LayoutLMv3).
- Les scripts de démonstration peuvent être trouvés [ici](https://github.com/huggingface/transformers-research-projects/tree/main/layoutlmv3).

- [LayoutLMv2ForSequenceClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForSequenceClassification) est pris en charge par ce [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/RVL-CDIP/Fine_tuning_LayoutLMv2ForSequenceClassification_on_RVL_CDIP.ipynb).
- [Guide de la tâche de classification de texte](../tasks/sequence_classification)

- [LayoutLMv3ForTokenClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ForTokenClassification) est pris en charge par ce [script d’exemple](https://github.com/huggingface/transformers-research-projects/tree/main/layoutlmv3) et ce [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv3/Fine_tune_LayoutLMv3_on_FUNSD_(HuggingFace_Trainer).ipynb).
- Un [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Inference_with_LayoutLMv2ForTokenClassification.ipynb) expliquant comment effectuer une inférence avec [LayoutLMv2ForTokenClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification) et un [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/True_inference_with_LayoutLMv2ForTokenClassification_%2B_Gradio_demo.ipynb) expliquant comment effectuer une inférence lorsque les étiquettes ne sont pas disponibles avec [LayoutLMv2ForTokenClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification).
- Un [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Fine_tuning_LayoutLMv2ForTokenClassification_on_FUNSD_using_HuggingFace_Trainer.ipynb) expliquant comment affiner [LayoutLMv2ForTokenClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification) avec le 🤗 Trainer.
- [Guide de la tâche de classification de jetons](../tasks/token_classification)

- [LayoutLMv2ForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv2#transformers.LayoutLMv2ForQuestionAnswering) est pris en charge par ce [notebook](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/DocVQA/Fine_tuning_LayoutLMv2ForQuestionAnswering_on_DocVQA.ipynb).
- [Guide de la tâche de réponse aux questions](../tasks/question_answering)

**Réponse aux questions sur des documents**

- [Guide de la tâche de réponse à des questions sur des documents](../tasks/document_question_answering)

## LayoutLMv3Config[[transformers.LayoutLMv3Config]]

#### transformers.LayoutLMv3Config[[transformers.LayoutLMv3Config]]

```python
transformers.LayoutLMv3Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 50265, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_2d_position_embeddings: int = 1024, coordinate_size: int = 128, shape_size: int = 128, has_relative_attention_bias: bool = True, rel_pos_bins: int = 32, max_rel_pos: int = 128, rel_2d_pos_bins: int = 64, max_rel_2d_pos: int = 256, has_spatial_attention_bias: bool = True, text_embed: bool = True, visual_embed: bool = True, input_size: int = 224, num_channels: int = 3, patch_size: int | list[int] | tuple[int, int] = 16, classifier_dropout: float | int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/configuration_layoutlmv3.py#L24)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `50265`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

type_vocab_size (`int`, *facultatif*, par défaut `2`) : La taille du vocabulaire des `token_type_ids`.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

pad_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

max_2d_position_embeddings (`int`, *facultatif*, valeur par défaut 1024) : La valeur maximale avec laquelle l'incorporation de position 2D pourrait être utilisée. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par ex. 1024).

coordinate_size (`int`, *facultatif*, par défaut `128`) : Dimension des embeddings de coordonnées.

shape_size (`int`, *facultatif*, valeur par défaut `128`) : Dimension des embeddings de largeur et de hauteur.

has_relative_attention_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais d'attention relatif dans le mécanisme d'auto-attention.

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.

max_rel_pos (`int`, *facultatif*, valeur par défaut : 128) : Nombre maximal de positions relatives à utiliser 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.

max_rel_2d_pos (`int`, *facultatif*, valeur par défaut : 256) : Nombre maximal de positions 2D relatives dans le mécanisme d'auto-attention.

has_spatial_attention_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais d'attention spatiale dans le mécanisme d'auto-attention.

text_embed (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter des embeddings de texte.

visual_embed (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter des embeddings de patch.

input_size (`int`, *facultatif*, valeur par défaut `224`) : La taille (résolution) des images.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch.

classifier_dropout (`Union[float, int]`, *facultatif*) : Le taux de dropout pour le classifieur.

Ceci est la classe de configuration destinée à stocker la configuration d'un LayoutLMv3Model. Elle est utilisée pour instancier un modèle Layoutlmv3 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/layoutlmv3-base](https://huggingface.co/microsoft/layoutlmv3-base)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import LayoutLMv3Config, LayoutLMv3Model

>>> # Initializing a LayoutLMv3 microsoft/layoutlmv3-base style configuration
>>> configuration = LayoutLMv3Config()

>>> # Initializing a model (with random weights) from the microsoft/layoutlmv3-base style configuration
>>> model = LayoutLMv3Model(configuration)

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

## LayoutLMv3ImageProcessor[[transformers.LayoutLMv3ImageProcessor]]

#### transformers.LayoutLMv3ImageProcessor[[transformers.LayoutLMv3ImageProcessor]]

```python
transformers.LayoutLMv3ImageProcessor(**kwargs: *<class 'transformers.models.layoutlmv3.image_processing_layoutlmv3.LayoutLMv3ImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/image_processing_layoutlmv3.py#L124)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`.

ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`.

tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`.

Construit un processeur d’images LayoutLMv3ImageProcessor.

#### prétraiter[[transformers.LayoutLMv3ImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.layoutlmv3.image_processing_layoutlmv3.LayoutLMv3ImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/image_processing_layoutlmv3.py#L140)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`.

ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`.

tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

## LayoutLMv3ImageProcessorPil[[transformers.LayoutLMv3ImageProcessorPil]]

#### transformers.LayoutLMv3ImageProcessorPil[[transformers.LayoutLMv3ImageProcessorPil]]

```python
transformers.LayoutLMv3ImageProcessorPil(**kwargs: *<class 'transformers.models.layoutlmv3.image_processing_pil_layoutlmv3.LayoutLMv3ImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/image_processing_pil_layoutlmv3.py#L123)

**Paramètres :**

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`.

ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`.

tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`.

Construit un processeur d’images LayoutLMv3ImageProcessor.

#### prétraiter[[transformers.LayoutLMv3ImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *<class 'transformers.models.layoutlmv3.image_processing_pil_layoutlmv3.LayoutLMv3ImageProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/image_processing_pil_layoutlmv3.py#L139)

**Paramètres :**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`.

do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB.

do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle.

default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image.

rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`.

do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`.

do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs.

disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

apply_ocr (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut appliquer le moteur OCR Tesseract pour obtenir les mots et les boîtes englobantes normalisées. Peut être remplacé par le paramètre `apply_ocr` de la méthode `preprocess`.

ocr_lang (`str`, *kwargs*, *facultatif*) : La langue, spécifiée par son code ISO, à utiliser par le moteur OCR Tesseract. Par défaut, l'anglais est utilisé. Peut être remplacé par le paramètre `ocr_lang` dans la méthode `preprocess`.

tesseract_config (`str`, *kwargs*, *facultatif*) : Tout autre drapeau de configuration personnalisé supplémentaire qui est transmis au paramètre `config` lors de l'appel de Tesseract. Par exemple : '--psm 6'. Peut être remplacé par le paramètre `tesseract_config` dans la méthode `preprocess`.

**Retourne :** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

## LayoutLMv3Tokenizer[[transformers.LayoutLMv3Tokenizer]]

#### transformers.LayoutLMv3Tokenizer[[transformers.LayoutLMv3Tokenizer]]

```python
transformers.LayoutLMv3Tokenizer(errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = True, cls_token_box = [0, 0, 0, 0], sep_token_box = [0, 0, 0, 0], pad_token_box = [0, 0, 0, 0], pad_token_label = -100, only_label_first_subword = True, vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L114)

**Paramètres :**

errors (`str`, *facultatif*, valeur par défaut `"replace"`) : Paradigme à suivre lors du décodage des octets en UTF-8. Consultez [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) pour plus d'informations.

bos_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : Jeton de début de séquence utilisé lors du pré-entraînement. Peut être utilisé comme jeton de classifieur de séquence.

eos_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : Jeton de fin de séquence.

sep_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : 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.

cls_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : 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.

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.

pad_token (`str`, *facultatif*, par défaut `"<pad>"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

mask_token (`str`, *facultatif*, valeur par défaut `"<mask>"`) : Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le modélisation de langage masquée. C'est le jeton que le modèle cherchera à prédire.

add_prefix_space (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot.

cls_token_box (`list[int]`, *facultatif*, valeur 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 `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [SEP].

pad_token_box (`list[int]`, *facultatif*, par défaut `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [PAD].

pad_token_label (`int`, *facultatif*, valeur par défaut : -100) : L'étiquette à utiliser pour les jetons de bourrage. La valeur par défaut est -100, qui correspond à `ignore_index` de CrossEntropyLoss de PyTorch.

only_label_first_subword (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut étiqueter uniquement le premier sous-mot, lorsque des étiquettes de mots sont fournies.

vocab (`str` ou `dict[str, int]`, *facultatif*) : Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis `vocab_file` lors de l'utilisation de `from_pretrained`.

merges (`str` ou `list[str]`, *facultatif*) : Liste de fusions personnalisées. Si elle n'est pas fournie, les fusions sont chargées depuis `merges_file` lors de l'utilisation de `from_pretrained`.

Construit un tokenizer LayoutLMv3 (basé sur la bibliothèque *tokenizers* de HuggingFace). Fondé sur le BPE au niveau des octets.

Ce tokenizer hérite de [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette classe mère pour plus d’informations sur ces méthodes.

#### __appel__[[transformers.LayoutLMv3Tokenizer.__call__]]

```python
__call__(text: str | list[str] | list[list[str]], text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L240)

**Paramètres :**

text (`str`, `List[str]`, `List[List[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères, une liste de chaînes de caractères (mots d'un seul exemple ou questions d'un lot d'exemples) ou une liste de listes de chaînes de caractères (lot de mots).

text_pair (`List[str]`, `List[List[str]]`) : La séquence ou le lot de séquences à encoder. Chaque séquence doit être une liste de chaînes de caractères (chaînes pré-tokenisées).

boxes (`List[List[int]]`, `List[List[List[int]]]`) : Boîtes englobantes au niveau des mots. Chaque boîte englobante doit être normalisée sur une échelle de 0 à 1000.

word_labels (`List[int]`, `List[List[int]]`, *facultatif*) : Étiquettes entières au niveau des mots (pour les tâches de classification de jetons telles que FUNSD, CORD).

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`.

return_length  (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

- ****kwargs** : transmis à la méthode `self.tokenize()`

Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquence(s) ou une ou plusieurs paire(s) de séquences avec des boîtes englobantes normalisées au niveau du mot et des étiquettes facultatives.

#### save_vocabulary[[transformers.LayoutLMv3Tokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## LayoutLMv3TokenizerFast[[transformers.LayoutLMv3Tokenizer]]

#### transformers.LayoutLMv3Tokenizer[[transformers.LayoutLMv3Tokenizer]]

```python
transformers.LayoutLMv3Tokenizer(errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = True, cls_token_box = [0, 0, 0, 0], sep_token_box = [0, 0, 0, 0], pad_token_box = [0, 0, 0, 0], pad_token_label = -100, only_label_first_subword = True, vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L114)

**Paramètres :**

errors (`str`, *facultatif*, valeur par défaut `"replace"`) : Paradigme à suivre lors du décodage des octets en UTF-8. Consultez [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) pour plus d'informations.

bos_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : Jeton de début de séquence utilisé lors du pré-entraînement. Peut être utilisé comme jeton de classifieur de séquence.

eos_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : Jeton de fin de séquence.

sep_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : 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.

cls_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : 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.

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.

pad_token (`str`, *facultatif*, par défaut `"<pad>"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

mask_token (`str`, *facultatif*, valeur par défaut `"<mask>"`) : Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le modélisation de langage masquée. C'est le jeton que le modèle cherchera à prédire.

add_prefix_space (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot.

cls_token_box (`list[int]`, *facultatif*, valeur 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 `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [SEP].

pad_token_box (`list[int]`, *facultatif*, par défaut `[0, 0, 0, 0]`) : La boîte englobante à utiliser pour le jeton spécial [PAD].

pad_token_label (`int`, *facultatif*, valeur par défaut : -100) : L'étiquette à utiliser pour les jetons de bourrage. La valeur par défaut est -100, qui correspond à `ignore_index` de CrossEntropyLoss de PyTorch.

only_label_first_subword (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut étiqueter uniquement le premier sous-mot, lorsque des étiquettes de mots sont fournies.

vocab (`str` ou `dict[str, int]`, *facultatif*) : Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis `vocab_file` lors de l'utilisation de `from_pretrained`.

merges (`str` ou `list[str]`, *facultatif*) : Liste de fusions personnalisées. Si elle n'est pas fournie, les fusions sont chargées depuis `merges_file` lors de l'utilisation de `from_pretrained`.

Construit un tokenizer LayoutLMv3 (basé sur la bibliothèque *tokenizers* de HuggingFace). Fondé sur le BPE au niveau des octets.

Ce tokenizer hérite de [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette classe mère pour plus d’informations sur ces méthodes.

#### batch_encode_plus[[transformers.LayoutLMv3Tokenizer.batch_encode_plus]]

```python
batch_encode_plus(batch_text_or_text_pairs: list[str] | list[tuple[str, str]] | list[list[str]], is_pair: bool | None = None, boxes: list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L392)

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :

- `True` ou `'longest'` : effectuer le bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage 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 qu’un lot peut contenir des séquences de longueurs différentes).
truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :

- `True` ou `'longest_first'` : tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. La troncature s'effectue jeton par jeton, en retirant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie.
- `'only_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne 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 que le lot peut contenir des séquences dont la longueur dépasse 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 cette valeur n'est pas définie ou est définie 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 une valeur numérique est définie 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 remplie 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 ?](../glossary#token-type-ids) return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.

[Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement. return_special_tokens_mask (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non renvoyer les informations du masque des jetons spéciaux. return_offsets_mapping (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non renvoyer `(char_start, char_end)` pour chaque jeton.

Cette fonctionnalité n'est disponible que sur les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lève `NotImplementedError`. return_length (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non retourner les longueurs des entrées encodées. verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ou non afficher plus d'informations et d'avertissements. **kwargs : transmis à la méthode `self.tokenize()`

#### build_inputs_with_special_tokens[[transformers.LayoutLMv3Tokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0, token_ids_1 = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L835)

**Paramètres :**

token_ids_0 (`List[int]`) : Liste des ID auxquels les jetons spéciaux seront ajoutés.

token_ids_1 (`List[int]`, *facultatif*) : Liste facultative d'identifiants pour les paires de séquences.

**Retourne :** `List[int]`

Liste des [identifiants d'entrée](../glossary#input-ids) avec les jetons spéciaux appropriés.

Construire les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences, en les concaténant et en ajoutant des jetons spéciaux. Une séquence RoBERTa a le format suivant :

- séquence unique : `<s> X </s>`
- paire de séquences : `<s> A </s></s> B </s>`

#### encode_plus[[transformers.LayoutLMv3Tokenizer.encode_plus]]

```python
encode_plus(text: str | list[str], text_pair: list[str] | None = None, boxes: list[list[int]] | None = None, word_labels: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/tokenization_layoutlmv3.py#L457)

**Paramètres :**

text (`str`, `List[str]`, `List[List[str]]`) : La première séquence à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes de caractères ou d'une liste de listes de chaînes de caractères.

text_pair (`List[str]` ou `List[int]`, *facultatif*) : Séquence secondaire facultative à encoder. Il peut s'agir d'une liste de chaînes de caractères (mots d'un seul exemple) ou d'une liste de listes de chaînes de caractères (mots d'un lot d'exemples).

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`.

return_length  (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

- ****kwargs** : transmis à la méthode `self.tokenize()`

Tokenise et prépare pour le modèle une séquence ou une paire de séquences. .. warning:: Cette méthode est obsolète, `__call__` doit être utilisée à la place.

## LayoutLMv3Processor[[transformers.LayoutLMv3Processor]]

#### transformers.LayoutLMv3Processor[[transformers.LayoutLMv3Processor]]

```python
transformers.LayoutLMv3Processor(image_processor = None, tokenizer = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/processing_layoutlmv3.py#L24)

**Paramètres :**

image_processor (`LayoutLMv3ImageProcessor`) : le processeur d’images est une entrée obligatoire.

tokenizer (`LayoutLMv3Tokenizer`) : le tokenizer est une entrée obligatoire.

Construit un LayoutLMv3Processor qui encapsule un processeur d’images et un tokenizer en un seul processeur.

[LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor) offre toutes les fonctionnalités de [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) et de [LayoutLMv3Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer). Consultez [~LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) et [~LayoutLMv3Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Tokenizer) pour plus d’informations.

#### __appel__[[transformers.LayoutLMv3Processor.__call__]]

```python
__call__(images, text: str | list[str] | list[list[str]] = None, text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/processing_layoutlmv3.py#L28)

**Paramètres :**

images (``) : Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

text_pair (`str, list[str] or list[int]`, *facultatif*) : Deuxième séquence facultative à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de tokens obtenus à l'aide de la méthode `convert_tokens_to_ids`).

boxes (`list[list[int]] or list[list[list[int]]]`, *facultatif*) : Boîtes englobantes au niveau des mots. Chaque boîte englobante doit être normalisée sur une échelle de 0 à 1000.

word_labels (`list[int] or list[list[int]]`, *facultatif*) : Étiquettes entières au niveau des mots (pour les tâches de classification de jetons telles que FUNSD, CORD).

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons `bos` ou `eos`.

padding (bool, str ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (bool, str ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

stride (`int`, *facultatif*, valeur par défaut `0`) : Si défini à un nombre en même temps que `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur du matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`.

return_length (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

**Retourne :** `~tokenization_utils_base.BatchEncoding`

- **data** (`dict`, *facultatif*) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.).
- **encodage** (`tokenizers.Encoding` ou `Sequence[tokenizers.Encoding]`, *facultatif*) -- Si le tokenizer est un fast tokenizer qui fournit des informations supplémentaires, telles que la correspondance entre l'espace des mots/caractères et l'espace des jetons, l'instance `tokenizers.Encoding` ou la liste d'instances (pour les lots) contient ces informations.
- **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
- **prepend_batch_axis** (`bool`, *facultatif*, par défaut `False`) -- Indique s'il faut ajouter un axe de lot lors de la conversion en tenseurs (voir `tensor_type` ci-dessus). Notez que ce paramètre n'a un effet que si le paramètre `tensor_type` est défini, *sinon il n'a aucun effet*.
- **n_sequences** (`int`, *facultatif*) -- Le nombre de séquences d'entrée représentées par chaque encodage (`None` pour inconnu, `1` pour une séquence unique et `2` pour une paire de séquences).

## LayoutLMv3Model[[transformers.LayoutLMv3Model]]

#### transformers.LayoutLMv3Model[[transformers.LayoutLMv3Model]]

```python
transformers.LayoutLMv3Model(config: LayoutLMv3Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L537)

**Paramètres :**

config ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Layoutlmv3 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LayoutLMv3Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L620)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, token_sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Notez que `sequence_length = token_sequence_length + patch_sequence_length + 1`, où `1` correspond au jeton [CLS]. Consultez `pixel_values` pour `patch_sequence_length`. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Voir [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

bbox (`torch.LongTensor` de forme `(batch_size, token_sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d’entrée. Sélectionnées dans l’intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante et (x1, y1) représente la position du coin inférieur droit. Notez que `sequence_length = token_sequence_length + patch_sequence_length + 1`, où `1` correspond au jeton [CLS]. Voir `pixel_values` pour `patch_sequence_length`.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, token_sequence_length)`, *facultatif*) : Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` :  - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*.  Notez que `sequence_length = token_sequence_length + patch_sequence_length + 1` où `1` est pour le jeton [CLS]. Voir `pixel_values` pour `patch_sequence_length`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, token_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]`. Notez que `sequence_length = token_sequence_length + patch_sequence_length + 1` où `1` correspond au jeton [CLS]. Voir `pixel_values` pour `patch_sequence_length`. [Que sont les identifiants de position ?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` de forme `(batch_size, token_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 façon de convertir les indices *input_ids* en vecteurs associés que la matrice de recherche d'intégration interne du modèle.

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor). Voir [LayoutLMv3ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor) utilise [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) pour le traitement des images).

**Retourne :** [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)`

Un [BaseModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) et les entrées.

La méthode forward du modèle [LayoutLMv3Model](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Model) 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.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Exemples :

```python
>>> from transformers import AutoProcessor, AutoModel
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModel.from_pretrained("microsoft/layoutlmv3-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
```

## LayoutLMv3ForSequenceClassification[[transformers.LayoutLMv3ForSequenceClassification]]

#### transformers.LayoutLMv3ForSequenceClassification[[transformers.LayoutLMv3ForSequenceClassification]]

```python
transformers.LayoutLMv3ForSequenceClassification(config: LayoutLMv3Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1047)

**Paramètres :**

config ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle LayoutLMv3 avec une tête de classification de séquence au sommet (une couche linéaire au-dessus de l'état caché final du jeton [CLS]), par exemple pour des tâches de classification d'images de documents telles que le jeu de données [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LayoutLMv3ForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L1063)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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

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

bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit.

pixel_values (`torch.LongTensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor). Voir [LayoutLMv3ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor) utilise [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) pour le traitement des images).

**Retourne :** [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Un [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) et les entrées.

La méthode forward de [LayoutLMv3ForSequenceClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ForSequenceClassification) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1).
- **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Exemples :

```python
>>> from transformers import AutoProcessor, AutoModelForSequenceClassification
>>> from datasets import load_dataset
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/layoutlmv3-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
>>> sequence_label = torch.tensor([1])

>>> outputs = model(**encoding, labels=sequence_label)
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## LayoutLMv3ForTokenClassification[[transformers.LayoutLMv3ForTokenClassification]]

#### transformers.LayoutLMv3ForTokenClassification[[transformers.LayoutLMv3ForTokenClassification]]

```python
transformers.LayoutLMv3ForTokenClassification(config: LayoutLMv3Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L834)

**Paramètres :**

config ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle LayoutLMv3 avec une tête de classification de jetons au sommet (une couche linéaire au-dessus des états cachés finaux), par exemple pour des tâches d'étiquetage de séquences (extraction d'informations) telles que [FUNSD](https://guillaumejaume.github.io/FUNSD/), [SROIE](https://rrc.cvc.uab.es/?ch=13), [CORD](https://github.com/clovaai/cord) et [Kleister-NDA](https://github.com/applicaai/kleister-nda).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LayoutLMv3ForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L854)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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

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

pixel_values (`torch.LongTensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor). Voir [LayoutLMv3ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor) utilise [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) pour le traitement des images).

**Retourne :** [TokenClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)`

Un [TokenClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) et les entrées.

La méthode forward de [LayoutLMv3ForTokenClassification](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ForTokenClassification) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores de classification (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Exemples :

```python
>>> from transformers import AutoProcessor, AutoModelForTokenClassification
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base", num_labels=7)

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> word_labels = example["ner_tags"]

>>> encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt")

>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## LayoutLMv3ForQuestionAnswering[[transformers.LayoutLMv3ForQuestionAnswering]]

#### transformers.LayoutLMv3ForQuestionAnswering[[transformers.LayoutLMv3ForQuestionAnswering]]

```python
transformers.LayoutLMv3ForQuestionAnswering(config: LayoutLMv3Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L932)

**Paramètres :**

config ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le transformateur Layoutlmv3 avec une tête de classification de segments au sommet pour les tâches de question-réponse extractives comme SQuAD (une couche linéaire au sommet de la sortie des états cachés pour calculer `span start logits` et `span end logits`).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.LayoutLMv3ForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/layoutlmv3/modeling_layoutlmv3.py#L948)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices de jetons de segment indiquant les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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

start_positions (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (`sequence_length`). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte.

end_positions (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) de la fin de l'intervalle étiqueté, utilisées pour calculer la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (`sequence_length`). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte.

bbox (`torch.LongTensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*) : Boîtes englobantes des jetons de chaque séquence d'entrée. Sélectionnées dans l'intervalle `[0, config.max_2d_position_embeddings-1]`. Chaque boîte englobante doit être une version normalisée au format (x0, y0, x1, y1), où (x0, y0) correspond à la position du coin supérieur gauche de la boîte englobante, et (x1, y1) représente la position du coin inférieur droit.

pixel_values (`torch.LongTensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor). Voir [LayoutLMv3ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([LayoutLMv3Processor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Processor) utilise [LayoutLMv3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ImageProcessor) pour le traitement des images).

**Retourne :** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou `tuple(torch.Tensor)`

Un [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LayoutLMv3Config](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3Config)) et les entrées.

La méthode forward de [LayoutLMv3ForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/layoutlmv3#transformers.LayoutLMv3ForQuestionAnswering) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- La perte totale d'extraction de spans est la somme d'une entropie croisée pour les positions de début et de fin.
- **start_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Scores de début de segment (avant SoftMax).
- **end_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Scores de fin de segment (avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

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

Exemples :

```python
>>> from transformers import AutoProcessor, AutoModelForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForQuestionAnswering.from_pretrained("microsoft/layoutlmv3-base")

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

>>> encoding = processor(image, question, words, boxes=boxes, return_tensors="pt")
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])

>>> outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
```

