Transformers documentation

PP-DocLayoutV4

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2026-10-08.

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 prédisait un masque de segmentation par requête et ajustait un polygone dessus. PP-DocLayoutV4 supprime entièrement la branche 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, plutôt que 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-il lu avant j ? »), il existe une tête de successeur (ROOR : « j suit-il 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() les convertit en rangs en appliquant un seuil à la matrice des successeurs pour en faire un graphe orienté acyclique (DAG), en cassant 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() sont déjà triés par ordre de lecture. Chaque résultat contient polygon_points — un tenseur (num_boxes, 4, 2) des 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 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

AutoModel

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.

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

classe transformers.PPDocLayoutV4ForObjectDetection

< source >

( config: PPDocLayoutV4Config )

Paramètres

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

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

forward

< source >

( pixel_values: Tensorpixel_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → PPDocLayoutV4ForObjectDetectionOutput or tuple(torch.Tensor)

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 de pixels peuvent être obtenues à l'aide de image_processor_class. Voir 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 sélectionnées dans [0, 1]:
- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
Qu'est-ce que les masques d'attention ?
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 en 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 en fonction de la configuration (None) et des entrées.

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

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

classe transformers.PPDocLayoutV4Model

< source >

( config: PPDocLayoutV4Config )

Paramètres

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

forward

< source >

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 de pixels peuvent être obtenues à l'aide de image_processor_class. Voir 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 sélectionnées dans [0, 1]:
- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
Qu'est-ce que les masques d'attention ?
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 en 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 en fonction de la configuration (None) et des entrées.

La méthode forward du modèle 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 optionnelle.
successor_order_logits (torch.Tensor de forme (batch_size, config.num_queries, config.num_queries)) — Logits de successeur direct par paires (ROOR).

PPDocLayoutV4Config

classe transformers.PPDocLayoutV4Config

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Trueinitializer_range: float = 0.01initializer_bias_prior_prob: float | None = Nonelayer_norm_eps: float = 1e-05batch_norm_eps: float = 1e-05tie_word_embeddings: bool = Truebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefreeze_backbone_batch_norms: bool = Trueencoder_hidden_dim: int = 256encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048)feat_strides: list[int] | tuple[int, ...] = (8, 16, 32)encoder_layers: int = 1encoder_ffn_dim: int = 1024encoder_attention_heads: int = 8dropout: float | int = 0.0activation_dropout: float | int = 0.0encode_proj_layers: list[int] | tuple[int, ...] = (2,)positional_encoding_temperature: int = 10000encoder_activation_function: str = 'gelu'activation_function: str = 'silu'eval_size: list[int] | tuple[int, int] | None = Nonenormalize_before: bool = Falsehidden_expansion: float = 1.0num_queries: int = 300decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256)decoder_ffn_dim: int = 1024num_feature_levels: int = 3decoder_n_points: int = 4decoder_layers: int = 6decoder_attention_heads: int = 8decoder_activation_function: str = 'relu'attention_dropout: float | int = 0.0num_denoising: int = 100anchor_image_size: list[int] | tuple[int, int] | None = Nonedisable_custom_kernels: bool = Trueglobal_pointer_head_size: int = 64gp_dropout_value: float | int = 0.1hidden_size: int = 256num_coords: int = 10s2r_steps: int = 3s2r_damping: float = 0.5s2r_closure_weight_init: float = 0.0 )

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, par défaut 0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation par lot.
tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.
backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
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, 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) de 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, par défaut 0.0) — Le taux appliqué à toutes les couches de dropout.
activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
encode_proj_layers (list[int], facultatif, par défaut [2]) — Indices 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") — La 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) du 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. Doit être laissé à None pour reproduire l’implémentation de référence, qui calcule les embeddings de position dynamiquement.
normalize_before (bool, facultatif, par défaut False) — Détermine si la normalisation par couche doit être appliquée 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, 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 fonctionnalités pour chaque tête d’attention du 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, par défaut "relu") — La fonction d’activation non linéaire (fonction ou chaîne de caractères) du 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 de 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îtes englobantes. Si None, la génération automatique des ancres est appliquée.
disable_custom_kernels (bool, facultatif, valeur 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, 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 afin qu'un module de fusion non entraîné soit 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle du PaddlePaddle/PP-DocLayoutV4_safetensors

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

Exemples :

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

classe transformers.PPDocLayoutV4ImageProcessor

< source >

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

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éfinit 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 utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif, 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 effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
Returns 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 et non par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (int, kwargs, facultatif) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cette valeur devrait être définie comme un attribut du processeur dans les futurs modèles.

prétraiter

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
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 que mot-clé ne fonctionne pas. Par exemple, preprocess(images, masks=masks) est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, preprocess(images, image_like_inputs={"masks": masks}) peut être utilisé à la place.
do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

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

< source >

( outputsthreshold: float = 0.5target_sizes = None ) → list[Dict]

Paramètres

outputs (PPDocLayoutV4ForObjectDetectionOutput) — Sorties brutes du modèle.
threshold (float, facultatif, 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 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.

Update on GitHub

←PP-DocLayoutV3 PP-FormulaNet→