# PP-DocLayoutV4

## Aperçu

**PP-DocLayoutV4** est un modèle d'analyse de mise en page de documents de bout en bout qui prédit, en une seule passe avant, la nature de chaque élément de mise en page, le quadrilatère qui l'encadre et les logits à partir desquels l'ordre de lecture est décodé.

## Architecture du modèle

PP-DocLayoutV4 conserve le squelette RT-DETR de son prédécesseur — un backbone HGNetV2, un encodeur hybride AIFI et un décodeur déformable — et modifie trois éléments :

- **Quadrilatères plutôt que masques.** [PPDocLayoutV3ForObjectDetection](/docs/transformers/main/fr/model_doc/pp_doclayout_v3#transformers.PPDocLayoutV3ForObjectDetection) prédisait un masque de segmentation par requête et y ajustait un polygone. PP-DocLayoutV4 supprime entièrement la branche de masque et régresse directement un quadrilatère à quatre points, encodé sous la forme `[center_x, center_y, dx1, dy1, ..., dx4, dy4]` dans l’espace sigmoïde. Cela gère les documents inclinés et déformés en perspective sans le coût d’une tête de masque, et la caractéristique d’ossature de pas 4 n’est plus nécessaire.
- **Têtes par couche non partagées.** Chaque couche du décodeur possède sa propre tête de boîte et de classification, au lieu de partager une seule tête avec l'encodeur.
- **Deux têtes d'ordre de lecture et une étape de fusion.** En plus de la tête d'ordre relatif de V3 (antisymétrique : « `i` est-elle lue avant `j` ? »), il existe une tête de successeur (ROOR : « `j` suit-elle directement `i` ? »). `PPDocLayoutV4S2RFusion` intègre une fermeture transitive amortie de la matrice des successeurs dans les logits d'ordre relatif.

L’ordre de lecture n’est pas décodé à l’intérieur du modèle. `PPDocLayoutV4ForObjectDetection` renvoie les `relative_order_logits` et `successor_order_logits` bruts, et [post_process_object_detection()](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) les convertit en rangs en appliquant un seuillage à la matrice des successeurs pour en faire un graphe orienté acyclique (DAG), en résolvant les cycles, en triant chaque composante connexe de manière topologique et en ordonnant les composantes selon leurs votes d’ordre relatif.

## Utilisation

Les résultats renvoyés par [post_process_object_detection()](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) sont déjà triés par ordre de lecture. Chaque résultat contient `polygon_points` — un tenseur de forme `(num_boxes, 4, 2)` représentant les coins régressés dans l'ordre haut-gauche, haut-droite, bas-droite, bas-gauche — ainsi que `boxes`, le rectangle aligné sur les axes englobant chaque quadrilatère, et `order_seq`, le rang à base 0 de chaque boîte. L'exemple [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel) ci-dessous affiche directement `order_seq` ; les autres affichent la position à base 1 dans la liste triée, qui est `order_seq + 1` sauf si une requête a été conservée sous plusieurs étiquettes.

[Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) conserve l'ordre de lecture dans l'ordre de la liste renvoyée, mais aplatit chaque détection en un score, un libellé et une boîte englobante entière. Utilisez le chemin [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel) ci-dessous pour obtenir les quadrilatères et `order_seq`.

```python
from transformers import pipeline
from transformers.image_utils import load_image

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV4_safetensors")
results = layout_detector(image)
for idx, res in enumerate(results):
    print(f"Order {idx + 1}: {res}")
```

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from transformers.image_utils import load_image

model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto")
image_processor = AutoImageProcessor.from_pretrained(model_path)

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
inputs = image_processor(images=image, return_tensors="pt").to(device=model.device, dtype=model.dtype)

outputs = model(**inputs)
results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]])
for result in results:
    for score, label_id, box, quad, rank in zip(
        result["scores"], result["labels"], result["boxes"], result["polygon_points"], result["order_seq"]
    ):
        box = [round(i, 2) for i in box.tolist()]
        print(f"Order {rank.item()}: {model.config.id2label[label_id.item()]}, score: {score.item():.2f}, box: {box}")
        print(f"         corners: {[[round(x, 2) for x in point] for point in quad.tolist()]}")
```

### Inférence par lots

Passez une liste d'images et une taille cible par image. L'ordre de lecture est décodé pour chaque image.

```python
from transformers import AutoImageProcessor, AutoModelForObjectDetection
from transformers.image_utils import load_image

model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto")
image_processor = AutoImageProcessor.from_pretrained(model_path)

image = load_image("https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg")
inputs = image_processor(images=[image, image], return_tensors="pt").to(device=model.device, dtype=model.dtype)

outputs = model(**inputs)
results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]] * 2)
for result in results:
    print("result:")
    for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])):
        box = [round(i, 2) for i in box.tolist()]
        print(f"Order {idx + 1}: {model.config.id2label[label_id.item()]}, score: {score.item():.2f}, box: {box}")
```

## PPDocLayoutV4ForObjectDetection[[transformers.PPDocLayoutV4ForObjectDetection]]

#### transformers.PPDocLayoutV4ForObjectDetection[[transformers.PPDocLayoutV4ForObjectDetection]]

```python
transformers.PPDocLayoutV4ForObjectDetection(config: PPDocLayoutV4Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1650)

**Paramètres :**

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

Modèle PP-DocLayoutV4 (composé d'un backbone et d'un encodeur-décodeur) produisant des quadrilatères, des logits de classes et des logits d'ordre de lecture, pour des tâches telles que l'analyse de la mise en page de documents.

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

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

#### forward[[transformers.PPDocLayoutV4ForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1668)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

pixel_mask (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les pixels réels (c.-à-d. **non masqués**), - 0 pour les pixels de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *facultatif*) : Tuple composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Non pris en charge : PP-DocLayoutV4 est uniquement destiné à l'inférence dans Transformers.

**Retourne :** `PPDocLayoutV4ForObjectDetectionOutput` ou `tuple(torch.Tensor)`

Un `PPDocLayoutV4ForObjectDetectionOutput` 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 (`None`) et les entrées.

La méthode forward de [PPDocLayoutV4ForObjectDetection](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ForObjectDetection) 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.

- **logits** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_labels)`) -- Logits de classification (sans objet nul) pour toutes les requêtes.
- **pred_boxes** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_coords)`) -- Quadrilatères normalisés pour toutes les requêtes, encodés sous la forme `[center_x, center_y, dx1, dy1, ..., dx4, dy4]` où les décalages des coins sont décalés de `+0.5`. Utilisez [post_process_object_detection()](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection) pour récupérer les coins non normalisés et leurs boîtes englobantes.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_queries, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
- **intermediate_hidden_states** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
- **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, config.num_coords)`) -- Points de référence intermédiaires empilés (quadrilatères affinés de chaque couche du décodeur).
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **init_reference_points** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_coords)`) -- Points de référence quadratiques initiaux transmis au décodeur du Transformer.
- **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_labels)`) -- Logits de classe des propositions de l'encodeur sélectionnées en tant que requêtes du décodeur.
- **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_coords)`) -- Quadruplets des propositions de l'encodeur sélectionnés en tant que requêtes du décodeur.
- **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Logits de classe de chaque proposition de l'encodeur.
- **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_coords)`) -- Logits des quadrants de chaque proposition de l'encodeur.
- **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage.
- **relative_order_logits** (`torch.Tensor` de forme `(batch_size, config.num_queries, config.num_queries)`) -- Logits de l'ordre de lecture relatif par paires, après la fusion S2R facultative. Une valeur positive de `relative_order_logits[i, j]` signifie que la requête `i` est lue avant la requête `j`.
- **successor_order_logits** (`torch.Tensor` de forme `(batch_size, config.num_queries, config.num_queries)`) -- Logits de successeur direct par paires (ROOR). Une valeur positive de `successor_order_logits[i, j]` signifie que la requête `j` suit directement la requête `i`.

Exemples :

```python
>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> from PIL import Image
>>> import httpx
>>> from io import BytesIO

>>> url = "https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/layout_demo.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> model_path = "PaddlePaddle/PP-DocLayoutV4_safetensors"
>>> image_processor = AutoImageProcessor.from_pretrained(model_path)
>>> model = AutoModelForObjectDetection.from_pretrained(model_path)

>>> inputs = image_processor(images=[image], return_tensors="pt")
>>> outputs = model(**inputs)

>>> # results are already sorted by reading order
>>> results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]])
>>> for result in results:
...     for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])):
...         box = [round(i, 2) for i in box.tolist()]
...         print(f"Order {idx + 1}: {model.config.id2label[label_id.item()]}: {score.item():.2f} {box}")
Order 1: text: 0.99 [336.07, 182.04, 894.17, 652.62]
Order 2: paragraph_title: 0.98 [336.45, 681.88, 868.78, 796.91]
Order 3: text: 0.99 [334.01, 840.84, 889.11, 1452.29]
Order 4: text: 0.99 [920.65, 183.62, 1476.75, 462.75]
Order 5: text: 0.99 [919.55, 482.55, 1479.85, 763.41]
Order 6: text: 0.98 [919.34, 844.48, 1481.28, 1219.44]
Order 7: text: 0.98 [920.84, 1238.61, 1467.66, 1374.54]
Order 8: text: 0.90 [334.24, 1612.85, 1478.79, 1730.92]
Order 9: text: 0.95 [334.25, 1755.98, 1467.34, 1845.6]
Order 10: text: 0.65 [337.14, 1909.47, 659.78, 1938.2]
Order 11: footnote: 0.78 [338.73, 2114.87, 1448.16, 2172.06]
Order 12: number: 0.98 [106.08, 2257.42, 134.76, 2281.3]
Order 13: footer: 0.93 [339.27, 2255.7, 984.16, 2282.81]
```

## PPDocLayoutV4Model[[transformers.PPDocLayoutV4Model]]

#### transformers.PPDocLayoutV4Model[[transformers.PPDocLayoutV4Model]]

```python
transformers.PPDocLayoutV4Model(config: PPDocLayoutV4Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1328)

**Paramètres :**

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

Modèle PP-DocLayoutV4 (composé d'un backbone et d'un encodeur-décodeur) produisant des états cachés bruts sans aucune tête au sommet.

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

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

#### forward[[transformers.PPDocLayoutV4Model.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/modeling_pp_doclayout_v4.py#L1466)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

pixel_mask (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans `[0, 1]` : - 1 pour les pixels réels (c.-à-d. **non masqués**), - 0 pour les pixels de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_outputs (`torch.Tensor`, *facultatif*) : Tuple composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Non pris en charge : PP-DocLayoutV4 est uniquement destiné à l'inférence dans Transformers.

**Retourne :** `PPDocLayoutV4ModelOutput` ou `tuple(torch.Tensor)`

Un `PPDocLayoutV4ModelOutput` 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 (`None`) et les entrées.

La méthode forward du modèle [PPDocLayoutV4Model](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4Model) 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, num_queries, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
- **intermediate_hidden_states** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
- **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, config.num_coords)`) -- Points de référence intermédiaires empilés (quadrilatères affinés de chaque couche du décodeur).
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple[torch.Tensor]`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **init_reference_points** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_coords)`) -- Points de référence quadratiques initiaux transmis au décodeur du Transformer.
- **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_labels)`) -- Logits de classe des propositions de l'encodeur sélectionnées en tant que requêtes du décodeur.
- **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_coords)`) -- Quadruplets des propositions de l'encodeur sélectionnés en tant que requêtes du décodeur.
- **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Logits de classe de chaque proposition de l'encodeur.
- **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_coords)`) -- Logits des quadrants de chaque proposition de l'encodeur.
- **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage.
- **logits** (`torch.Tensor` de forme `(batch_size, num_queries, config.num_labels)`) -- Logits de classification de la dernière couche du décodeur.
- **relative_order_logits** (`torch.Tensor` de forme `(batch_size, config.num_queries, config.num_queries)`) -- Logits de l'ordre de lecture relatif par paires, après la fusion S2R facultative.
- **successor_order_logits** (`torch.Tensor` de forme `(batch_size, config.num_queries, config.num_queries)`) -- Logits de successeur direct par paires (ROOR).

## PPDocLayoutV4Config[[transformers.PPDocLayoutV4Config]]

#### transformers.PPDocLayoutV4Config[[transformers.PPDocLayoutV4Config]]

```python
transformers.PPDocLayoutV4Config(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, 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, is_encoder_decoder: bool = True, initializer_range: float = 0.01, initializer_bias_prior_prob: float | None = None, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, tie_word_embeddings: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] = (8, 16, 32), encoder_layers: int = 1, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, dropout: float | int = 0.0, activation_dropout: float | int = 0.0, encode_proj_layers: list[int] | tuple[int, ...] = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: list[int] | tuple[int, int] | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256), decoder_ffn_dim: int = 1024, num_feature_levels: int = 3, decoder_n_points: int = 4, decoder_layers: int = 6, decoder_attention_heads: int = 8, decoder_activation_function: str = 'relu', attention_dropout: float | int = 0.0, num_denoising: int = 100, anchor_image_size: list[int] | tuple[int, int] | None = None, disable_custom_kernels: bool = True, global_pointer_head_size: int = 64, gp_dropout_value: float | int = 0.1, hidden_size: int = 256, num_coords: int = 10, s2r_steps: int = 3, s2r_damping: float = 0.5, s2r_closure_weight_init: float = 0.0)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/configuration_pp_doclayout_v4.py#L30)

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

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

initializer_bias_prior_prob (`float`, *facultatif*) : La probabilité a priori utilisée par l'initialiseur de biais pour initialiser les biais de `enc_score_head` et `class_embed`. Si `None`, la valeur par défaut est `1 / (num_labels + 1)`.

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

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

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base.

freeze_backbone_batch_norms (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut figer les couches de normalisation par lot dans le backbone.

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

encoder_in_channels (`list`, *facultatif*, valeur par défaut `[512, 1024, 2048]`) : Entrées de caractéristiques multi-niveaux pour l'encodeur.

feat_strides (`list[int]`, *facultatif*, par défaut `[8, 16, 32]`) : Pas utilisés dans chaque carte de caractéristiques.

encoder_layers (`int`, *facultatif*, valeur par défaut `1`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

encoder_ffn_dim (`int`, *facultatif*, par défaut `1024`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

encoder_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour toutes les couches de dropout.

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

encode_proj_layers (`list[int]`, *facultatif*, valeur par défaut `[2]`) : Index des couches projetées à utiliser dans l'encodeur.

positional_encoding_temperature (`int`, *facultatif*, valeur par défaut 10000) : Le paramètre de température utilisé pour créer les encodages positionnels.

encoder_activation_function (`str`, *facultatif*, par défaut `"gelu"`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur et le pooler. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"silu"` et `"gelu_new"` sont pris en charge.

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

eval_size (`tuple[int, int]`, *facultatif*) : Hauteur et largeur utilisées pour calculer la hauteur et la largeur effectives des embeddings de position après prise en compte du pas (stride). Doit être laissé à `None` pour reproduire l'implémentation de référence, qui calcule les embeddings de position dynamiquement.

normalize_before (`bool`, *facultatif*, valeur par défaut `False`) : Détermine s'il faut appliquer la normalisation de couche dans la couche d'encodeur du transformer avant les modules d'auto-attention et de réseau de neurones à propagation avant.

hidden_expansion (`float`, *facultatif*, valeur par défaut 1.0) : Ratio d'expansion pour agrandir la taille de la dimension de RepVGGBlock et CSPRepLayer.

num_queries (`int`, *facultatif*, valeur par défaut 300) : Nombre de requêtes d'objets.

decoder_in_channels (`list`, *facultatif*, valeur par défaut `[256, 256, 256]`) : Dimensions des caractéristiques multi-niveaux pour le décodeur

decoder_ffn_dim (`int`, *facultatif*, valeur par défaut 1024) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.

num_feature_levels (`int`, *facultatif*, valeur par défaut : 3) : Le nombre de niveaux de caractéristiques d'entrée.

decoder_n_points (`int`, *facultatif*, valeur par défaut : 4) : Le nombre de clés échantillonnées à chaque niveau de fonction pour chaque tête d'attention dans le décodeur.

decoder_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

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

decoder_activation_function (`str`, *facultatif*, valeur par défaut `"relu"`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"silu"` et `"gelu_new"` sont pris en charge.

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

num_denoising (`int`, *facultatif*, valeur par défaut 100) : Nombre total de tâches ou requêtes de débruitage à utiliser pour le débruitage contrastif.

anchor_image_size (`tuple[int, int]`, *facultatif*) : Hauteur et largeur de l'image d'entrée utilisée lors de l'évaluation pour générer les ancres de boîte englobante. Si la valeur est None, la génération automatique des ancres est appliquée.

disable_custom_kernels (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut désactiver les noyaux personnalisés.

global_pointer_head_size (`int`, *facultatif*, valeur par défaut : 64) : La taille de la tête de pointeur global.

gp_dropout_value (`float`, *facultatif*, valeur par défaut 0,1) : La probabilité de dropout dans la tête de pointeur global.

hidden_size (`int`, *facultatif*, valeur par défaut : 256) : Dimension des couches du décodeur, à l'exclusion de l'encodeur hybride. Peut également être lu comme `d_model`, le nom utilisé par la lignée RT-DETR dont ce modèle est issu.

num_coords (`int`, *facultatif*, valeur par défaut 10) : Taille de la paramétrisation de la boîte prédite par les têtes de bbox. PP-DocLayoutV4 régresse un quadrilatère à quatre points encodé sous la forme `[center_x, center_y, dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4]` dans l'espace sigmoïde, où les décalages des coins sont décalés de `+0.5`. Seule la valeur `10` est prise en charge.

s2r_steps (`int`, *facultatif*, valeur par défaut 3) : Nombre d'étapes de propagation utilisées pour approximer la fermeture transitive de la matrice des successeurs.

s2r_damping (`float`, *facultatif*, valeur par défaut 0,5) : Facteur d'amortissement appliqué à chaque étape de propagation supplémentaire de la fermeture transitive.

s2r_closure_weight_init (`float`, *facultatif*, valeur par défaut 0.0) : Valeur initiale de la porte apprenable qui pondère le terme de fermeture. La valeur par défaut est `0.0`, de sorte qu'un module de fusion non entraîné est numériquement identique à l'utilisation des logits d'ordre relatif seuls.

Ceci est la classe de configuration destinée à stocker la configuration d'un PPDocLayoutV4Model. Elle est utilisée pour instancier un modèle Pp Doclayout V4 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 [PaddlePaddle/PP-DocLayoutV4_safetensors](https://huggingface.co/PaddlePaddle/PP-DocLayoutV4_safetensors)

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

Exemples :

```python
>>> from transformers import PPDocLayoutV4Config, PPDocLayoutV4ForObjectDetection

>>> # Initializing a PP-DocLayoutV4 configuration
>>> configuration = PPDocLayoutV4Config()

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

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

## PPDocLayoutV4ImageProcessor[[transformers.PPDocLayoutV4ImageProcessor]]

#### transformers.PPDocLayoutV4ImageProcessor[[transformers.PPDocLayoutV4ImageProcessor]]

```python
transformers.PPDocLayoutV4ImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/image_processing_pp_doclayout_v4.py#L36)

**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' : 800, 'width': 800}`) : Décrit les dimensions d'entrée maximales pour le 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 `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

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

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

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

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0, 0, 0]`) : 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 `[1, 1, 1]`) : É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. Renvoie des tenseurs empilés si défini sur `'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. Renvoie des tenseurs empilés si défini sur `'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.

Retourne des tenseurs empilés si défini sur `'pt'`, sinon retourne une liste de tenseurs. --

Construit un processeur d’images PPDocLayoutV4ImageProcessor.

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 cette valeur devrait être définie comme un attribut du processeur dans les futurs modèles.

#### prétraiter[[transformers.PPDocLayoutV4ImageProcessor.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']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)

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

image_like_kwargs (`dict[str, Any]`, *facultatif*) : Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant qu'argument nommé ne fonctionne pas. Par exemple, `preprocess(images, masks=masks)` est l'option recommandée, mais cela peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, vous pouvez utiliser à la place `preprocess(images, image_like_inputs={"masks": masks})`.

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.

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

Prétraitez une image ou un lot d'images.

#### post_process_object_detection[[transformers.PPDocLayoutV4ImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_doclayout_v4/image_processing_pp_doclayout_v4.py#L121)

**Paramètres :**

outputs (`PPDocLayoutV4ForObjectDetectionOutput`) : Sorties brutes du modèle.

threshold (`float`, *facultatif*, valeur par défaut 0,5) : Seuil de score pour conserver les prédictions de détection d'objets.

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]`) : Tenseur de forme `(batch_size, 2)` ou liste de tuples (`(height, width)`) indiquant la taille cible de chaque image du lot.

**Retourne :** `list[Dict]`

Une liste de dictionnaires, un par image, chacun contenant les `scores`, `labels`, `boxes`, `polygon_points` et `order_seq` prédits par le modèle. Les prédictions sont triées par ordre de lecture, de sorte que `order_seq` est non décroissant (une requête sélectionnée sous plusieurs étiquettes conserve un seul rang).

Convertit la sortie brute de [PPDocLayoutV4ForObjectDetection](/docs/transformers/main/fr/model_doc/pp_doclayout_v4#transformers.PPDocLayoutV4ForObjectDetection) en quadrilatères finaux, en boîtes englobantes au format `(top_left_x, top_left_y, bottom_right_x, bottom_right_y)` et en rangs d’ordre de lecture. Prend uniquement en charge PyTorch.