# PP-DocLayoutV2 ## Aperçu **PP-DocLayoutV2** est un modèle léger dédié à l’analyse de la mise en page, se concentrant spécifiquement sur la détection, la classification et la prédiction de l’ordre de lecture des éléments. ## Architecture du modèle PP-DocLayoutV2 est composé de deux réseaux connectés séquentiellement. Le premier est un modèle de détection basé sur RT-DETR qui effectue la détection et la classification des éléments de mise en page. Les boîtes englobantes et les étiquettes de classes détectées sont ensuite transmises à un réseau pointeur ultérieur, chargé de l'ordonnancement de ces éléments de mise en page. ## Utilisation ### Inférence avec une seule entrée L'exemple ci-dessous montre comment générer du texte avec PP-DocLayoutV2 en utilisant [Pipeline](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.Pipeline) ou [AutoModel](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModel). ```python import requests from PIL import Image from transformers import pipeline image = Image.open(requests.get("https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_layout_demo.jpg", stream=True).raw) layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV2_safetensors") result = layout_detector(image) print(result) ``` ```python import requests from PIL import Image from transformers import AutoImageProcessor, AutoModelForObjectDetection model_path = "PaddlePaddle/PP-DocLayoutV2_safetensors" model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto") image_processor = AutoImageProcessor.from_pretrained(model_path) image = Image.open(requests.get("https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_layout_demo.jpg", stream=True).raw) inputs = image_processor(images=image, return_tensors="pt").to(model.device) outputs = model(**inputs) results = image_processor.post_process_object_detection(outputs, target_sizes=[image.size[::-1]]) for result in results: print(result["scores"]) print(result["labels"]) print(result["boxes"]) for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])): score, label = score.item(), label_id.item() box = [round(i, 2) for i in box.tolist()] print(f"Order {idx + 1}: {model.config.id2label[label]}: {score:.2f} {box}") ``` ### Inférence par lots Voici comment faire avec PP-DocLayoutV2 en utilisant [Pipeline](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.Pipeline) ou le [AutoModel](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModel) : ```python import requests from PIL import Image from transformers import pipeline image = Image.open(requests.get("https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_layout_demo.jpg", stream=True).raw) layout_detector = pipeline("object-detection", model="PaddlePaddle/PP-DocLayoutV2_safetensors") result = layout_detector([image, image]) print(result[0]) print(result[1]) ``` ```python import requests from PIL import Image from transformers import AutoImageProcessor, AutoModelForObjectDetection model_path = "PaddlePaddle/PP-DocLayoutV2_safetensors" model = AutoModelForObjectDetection.from_pretrained(model_path, device_map="auto") image_processor = AutoImageProcessor.from_pretrained(model_path) image = Image.open(requests.get("https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_layout_demo.jpg", stream=True).raw) inputs = image_processor(images=[image, image], return_tensors="pt").to(model.device) target_sizes = [image.size[::-1], image.size[::-1]] outputs = model(**inputs) results = image_processor.post_process_object_detection(outputs, target_sizes=target_sizes) for result in results: print("result:") for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])): score, label = score.item(), label_id.item() box = [round(i, 2) for i in box.tolist()] print(f"Order {idx + 1}: {model.config.id2label[label]}: {score:.2f} {box}") ``` ## PPDocLayoutV2Config[[transformers.PPDocLayoutV2Config]] #### transformers.PPDocLayoutV2Config[[transformers.PPDocLayoutV2Config]] ```python transformers.PPDocLayoutV2Config(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, backbone_config: transformers.configuration_utils.PreTrainedConfig | dict | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] | None = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] | None = (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, ...] | None = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: list[int] | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, d_model: int = 256, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] | None = (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, label_noise_ratio: float = 0.5, box_noise_scale: float = 1.0, learn_initial_query: bool = False, anchor_image_size: list[int] | None = None, disable_custom_kernels: bool = True, class_thresholds: list[float] | None = None, class_order: list[int] | None = None, reading_order_config: transformers.configuration_utils.PreTrainedConfig | dict | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/configuration_pp_doclayout_v2.py#L106) **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`, `prior_prob` est calculé comme `prior_prob = 1 / (num_labels + 1)` lors de l'initialisation des poids du modèle. 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. backbone_config (`Union[~configuration_utils.PreTrainedConfig, dict]`, *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*, valeur par défaut 256) : Dimension des couches dans l'encodeur hybride. 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 total de couches utilisées par l'encodeur. 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). 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. d_model (`int`, *facultatif*, par défaut `256`) : Taille des couches d'encodeur et de la couche pooler. 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. label_noise_ratio (`float`, *facultatif*, valeur par défaut 0,5) : La fraction d'étiquettes de débruitage auxquelles du bruit aléatoire doit être ajouté. box_noise_scale (`float`, *facultatif*, valeur par défaut 1.0) : Échelle ou amplitude du bruit à ajouter aux boîtes englobantes. learn_initial_query (`bool`, *facultatif*, par défaut `False`) : Indique si les embeddings de requête initiaux du décodeur doivent être appris pendant l'entraînement 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. class_thresholds (`list[float]`, *facultatif*) : Les seuils pour chaque étiquette. class_order (`list[int]`, *facultatif*) : La priorité pour chaque étiquette. reading_order_config (`dict`, *facultatif*) : La configuration d'un `PPDocLayoutV2ReadingOrder`. Ceci est la classe de configuration destinée à stocker la configuration d'un Pp Doclayout V2Model. Elle est utilisée pour instancier un modèle Pp Doclayout V2 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-DocLayoutV2_safetensors](https://huggingface.co/PaddlePaddle/PP-DocLayoutV2_safetensors) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> from transformers import PPDocLayoutV2Config, PPDocLayoutV2ForObjectDetection >>> # Initializing a PP-DocLayoutV2 configuration >>> configuration = PPDocLayoutV2Config() >>> # Initializing a model (with random weights) from the configuration >>> model = PPDocLayoutV2ForObjectDetection(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## PPDocLayoutV2ForObjectDetection[[transformers.PPDocLayoutV2ForObjectDetection]] #### transformers.PPDocLayoutV2ForObjectDetection[[transformers.PPDocLayoutV2ForObjectDetection]] ```python transformers.PPDocLayoutV2ForObjectDetection(config: PPDocLayoutV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L2344) **Paramètres :** config ([PPDocLayoutV2Config](/docs/transformers/v5.23.0/fr/model_doc/pp_doclayout_v2#transformers.PPDocLayoutV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle PP-DocLayoutV2 (composé d'un backbone et d'un encodeur-décodeur) qui produit des bounding boxes, des logits et des order_logits à décoder ensuite en scores, classes et leur ordre de lecture. Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.PPDocLayoutV2ForObjectDetection.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L2370) **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. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image. decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, num_queries, hidden_size)`, *facultatif*) : Facultativement, au lieu d’initialiser les requêtes avec un tenseur de zéros, vous pouvez choisir de passer directement une représentation intégrée. labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : 'class_labels' et 'boxes' (les étiquettes de classes et les boîtes englobantes d'une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un `torch.LongTensor` de longueur `(number of bounding boxes in the image,)` et les boîtes un `torch.Tensor` de forme `(number of bounding boxes in the image, 4)`. **Retourne :** `PPDocLayoutV2ForObjectDetectionOutput` ou `tuple(torch.Tensor)` Un `PPDocLayoutV2ForObjectDetectionOutput` 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 [PPDocLayoutV2ForObjectDetection](/docs/transformers/v5.23.0/fr/model_doc/pp_doclayout_v2#transformers.PPDocLayoutV2ForObjectDetection) 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, num_classes + 1)`) -- Logits de classification (y compris no-object) pour toutes les requêtes. - **pred_boxes** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Coordonnées des boîtes normalisées pour toutes les requêtes, représentées sous la forme (center_x, center_y, width, height). Ces valeurs sont normalisées dans [0, 1], par rapport à la taille de chaque image individuelle du lot (en ignorant tout padding éventuel). Vous pouvez utiliser [post_process_object_detection()](/docs/transformers/v5.23.0/fr/model_doc/rt_detr#transformers.RTDetrImageProcessor.post_process_object_detection) pour récupérer les boîtes englobantes non normalisées (absolues). - **order_logits** (`tuple` de `torch.Tensor` de forme `(batch_size, num_queries, num_queries)`) -- Logits d'ordre pour toutes les requêtes. La première dimension de chaque tenseur correspond à la taille du lot. La deuxième dimension correspond au nombre de requêtes. - **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_logits** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, config.num_labels)`) -- Logits intermédiares empilés (logits de chaque couche du décodeur). - **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur). - **intermediate_predicted_corners** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur). - **initial_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence initiaux empilés (points de référence initiaux 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, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer. - **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites dans l'encodeur. - **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites dans l'encodeur. - **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan). - **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites à la première étape. - **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage Exemples : ```python >>> from transformers import AutoModelForObjectDetection, AutoImageProcessor >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> import torch >>> url = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/paddle_layout_demo.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> model_path = "PaddlePaddle/PP-DocLayoutV2_safetensors" >>> image_processor = AutoImageProcessor.from_pretrained(model_path) >>> model = AutoModelForObjectDetection.from_pretrained(model_path) >>> # prepare image for the model >>> inputs = image_processor(images=[image], return_tensors="pt") >>> # forward pass >>> outputs = model(**inputs) >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax) >>> results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]])) >>> # print outputs >>> for result in results: ... for idx, (score, label_id, box) in enumerate(zip(result["scores"], result["labels"], result["boxes"])): ... score, label = score.item(), label_id.item() ... box = [round(i, 2) for i in box.tolist()] ... print(f"Order {idx + 1}: {model.config.id2label[label]}: {score:.2f} {box}") Order 1: text: 0.99 [335.39, 184.26, 896.49, 654.48] Order 2: paragraph_title: 0.97 [337.14, 683.49, 869.42, 798.27] Order 3: text: 0.99 [335.71, 843.04, 891.17, 1454.15] Order 4: text: 0.99 [920.42, 185.53, 1476.39, 464.25] Order 5: text: 0.98 [920.62, 483.75, 1480.52, 765.34] Order 6: text: 0.98 [920.58, 846.75, 1481.94, 1220.53] Order 7: text: 0.97 [921.12, 1239.27, 1468.87, 1377.33] Order 8: footnote: 0.82 [334.58, 1614.67, 1483.84, 1731.61] Order 9: text: 0.51 [334.58, 1614.67, 1483.84, 1731.61] Order 10: footnote: 0.83 [334.7, 1757.26, 1471.07, 1845.33] Order 11: text: 0.87 [336.65, 1910.28, 661.33, 1939.92] Order 12: footnote: 0.95 [336.16, 2114.52, 1450.28, 2171.74] Order 13: number: 0.87 [106.04, 2257.37, 136.05, 2281.98] Order 14: footer: 0.93 [338.6, 2255.94, 985.67, 2283.57] ``` ## PPDocLayoutV2Model[[transformers.PPDocLayoutV2Model]] #### transformers.PPDocLayoutV2Model[[transformers.PPDocLayoutV2Model]] ```python transformers.PPDocLayoutV2Model(config: PPDocLayoutV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L2017) **Paramètres :** config ([PPDocLayoutV2Config](/docs/transformers/v5.23.0/fr/model_doc/pp_doclayout_v2#transformers.PPDocLayoutV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle PP-DocLayoutV2 (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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.PPDocLayoutV2Model.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L2138) **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. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image. labels (`list[Dict]` de longueur `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : 'class_labels' et 'boxes' (les étiquettes de classes et les boîtes englobantes d'une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un `torch.LongTensor` de longueur `(number of bounding boxes in the image,)` et les boîtes un `torch.Tensor` de forme `(number of bounding boxes in the image, 4)`. **Retourne :** `PPDocLayoutV2ModelOutput` ou `tuple(torch.Tensor)` Un `PPDocLayoutV2ModelOutput` 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 [PPDocLayoutV2Model](/docs/transformers/v5.23.0/fr/model_doc/pp_doclayout_v2#transformers.PPDocLayoutV2Model) 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_logits** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, sequence_length, config.num_labels)`) -- Logits intermédiares empilés (logits de chaque couche du décodeur). - **intermediate_reference_points** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur). - **intermediate_predicted_corners** (`torch.Tensor` de forme `(batch_size, config.decoder_layers, num_queries, 4)`) -- Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur). - **initial_reference_points** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Points de référence initiaux utilisés pour la première 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, 4)`) -- Points de référence initiaux transmis au décodeur du Transformer. - **enc_topk_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à l'étape de l'encodeur. Sortie de la classification binaire des boîtes englobantes (c'est-à-dire premier plan et arrière-plan). - **enc_topk_bboxes** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`) -- Logits des coordonnées des boîtes englobantes prédites à l'étape de l'encodeur. - **enc_outputs_class** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Scores des boîtes englobantes prédites, où les `config.two_stage_num_proposals` boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan). - **enc_outputs_coord_logits** (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`, *facultatif*, renvoyé lorsque `config.with_box_refine=True` et `config.two_stage=True`) -- Logits des coordonnées des boîtes englobantes prédites à la première étape. - **denoising_meta_values** (`dict`, *facultatif*) -- Dictionnaire supplémentaire pour les valeurs liées au débruitage. Exemples : ```python >>> from transformers import AutoImageProcessor, PPDocLayoutV2Model >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("PekingU/PPDocLayoutV2_r50vd") >>> model = PPDocLayoutV2Model.from_pretrained("PekingU/PPDocLayoutV2_r50vd") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state >>> list(last_hidden_states.shape) [1, 300, 256] ``` ## PPDocLayoutV2ReadingOrder[[transformers.PPDocLayoutV2ReadingOrder]] #### transformers.PPDocLayoutV2ReadingOrder[[transformers.PPDocLayoutV2ReadingOrder]] ```python transformers.PPDocLayoutV2ReadingOrder(config: PPDocLayoutV2ReadingOrderConfig) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L803) **Paramètres :** config (`PPDocLayoutV2ReadingOrderConfig`) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle PP-DocLayoutV2 ReadingOrder. Ce modèle est composé d'un encodeur et d'une tête GlobalPointer. Il prend en entrée des caractéristiques de mise en page et produit des logits représentant les relations d'ordre relatif entre les éléments, qui sont utilisées pour déterminer la séquence de lecture finale. Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.PPDocLayoutV2ReadingOrder.forward]] ```python forward(boxes, labels = None, mask = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/modeling_pp_doclayout_v2.py#L823) **Paramètres :** boxes (`torch.Tensor` de forme `(batch_size, sequence_length, 4)`) : Coordonnées des boîtes englobantes des éléments de mise en page détectés **sur l'échelle [0, 1000]**. Le format est `[x_min, y_min, x_max, y_max]`. Le tenseur contient généralement des boîtes valides triées, suivies d'un remplissage par zéro. labels (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Les indices de classes **remappés** pour chaque élément de la mise en page. Il ne s'agit pas nécessairement des identifiants bruts des classes de détection, mais d'indices mappés via `config.class_order` (par exemple, en associant texte/titre/figure à des identifiants de catégories d'ordre de lecture spécifiques). mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque booléen ou binaire indiquant les éléments détectés valides après filtrage par seuil. - True : élément de mise en page valide. - False : élément de bourrage/vide. Utilisé pour déterminer la longueur de la séquence (`num_pred`) du mécanisme de pointeur. La méthode forward de [PPDocLayoutV2ReadingOrder](/docs/transformers/v5.23.0/fr/model_doc/pp_doclayout_v2#transformers.PPDocLayoutV2ReadingOrder) 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. ## PPDocLayoutV2ImageProcessor[[transformers.PPDocLayoutV2ImageProcessor]] #### transformers.PPDocLayoutV2ImageProcessor[[transformers.PPDocLayoutV2ImageProcessor]] ```python transformers.PPDocLayoutV2ImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pp_doclayout_v2/image_processing_pp_doclayout_v2.py#L34) **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. 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. 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*, valeur par défaut `256`) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la rétrocompatibilité, 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. 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. 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. 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. 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. 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. 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. 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. 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. 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 PPDocLayoutV2ImageProcessor. 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.PPDocLayoutV2ImageProcessor.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: *) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/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.