Transformers documentation
SLANeXt
Ce modèle a été contribué à Hugging Face Transformers le 2026-03-21.
SLANeXt
Aperçu
SLANeXt_wired et SLANeXt_wireless font partie d'une série de modèles légers dédiés à la reconnaissance de la structure des tableaux, axés sur la reconnaissance précise des structures de tableaux dans les documents et les scènes naturelles. Pour plus de détails sur le modèle de la série SLANeXt, veuillez consulter la documentation officielle.
Architecture du modèle
La série SLANeXt est une nouvelle génération de modèles de reconnaissance de structure de tableaux, développée de manière indépendante par l'équipe Vision de Baidu PaddlePaddle. SLANeXt se concentre sur la reconnaissance de la structure des tableaux et entraîne des poids dédiés séparément pour les tableaux filaires et sans fil. La capacité de reconnaissance pour tous les types de tableaux a été considérablement améliorée, en particulier pour les tableaux filaires.
Utilisation
Inférence avec une seule entrée
L’exemple ci-dessous montre comment détecter du texte avec PP-OCRV5_Mobile_Det à l’aide de AutoModel.
import requests
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForTableRecognition
model_path="PaddlePaddle/SLANeXt_wired_safetensors"
model = AutoModelForTableRecognition.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_table_recognition.jpg", stream=True).raw)
inputs = image_processor(images=image, return_tensors="pt").to(model.device)
outputs = model(**inputs)
results = image_processor.post_process_table_recognition(outputs)
print(result['structure'])
print(result['structure_score'])SLANeXtConfig
classe transformers.SLANeXtConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.models.slanext.configuration_slanext.SLANeXtVisionConfig | None = Nonepost_conv_in_channels: int = 256post_conv_out_channels: int = 512out_channels: int = 50hidden_size: int = 512max_text_length: int = 500 )
Paramètres
- vision_config (
dictou SLANeXtVisionConfig, facultatif) — Configuration de l'encodeur visuel. SiNone, un SLANeXtVisionConfig par défaut est utilisé. - post_conv_in_channels (
int, facultatif, valeur par défaut 256) — Nombre de canaux d'entrée pour la couche de convolution post-encodeur. - post_conv_out_channels (
int, facultatif, valeur par défaut : 512) — Nombre de canaux de sortie pour la couche de convolution post-encodeur. - out_channels (
int, facultatif, valeur par défaut : 50) — Taille du vocabulaire pour la tête de prédiction des jetons de structure de table, c'est-à-dire le nombre de jetons de structure distincts que le modèle peut prédire. - hidden_size (
int, facultatif, par défaut 512) — Dimension des états cachés dans la cellule GRU d'attention et les têtes de prédiction de structure/emplacement. - max_text_length (
int, facultatif, par défaut 500) — Nombre maximal d'étapes de décodage autorégressif (jetons) pour le décodeur de structure et de localisation.
Ceci est la classe de configuration destinée à stocker la configuration d'un SlanextModel. Elle est utilisée pour instancier un modèle Slanext en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de PaddlePaddle/SLANeXt_wired_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.
SLANeXtVisionConfig
classe transformers.SLANeXtVisionConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768output_channels: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int = 512patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0initializer_range: float = 1e-10qkv_bias: bool = Trueuse_abs_pos: bool = Trueuse_rel_pos: bool = Truewindow_size: int = 14global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11)mlp_dim: int = 3072 )
Paramètres
- hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - output_channels (
int, facultatif, par défaut 256) — Dimensionnalité des canaux de sortie dans le Patch Encoder. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - image_size (
int, facultatif, par défaut512) — La taille (résolution) de chaque image. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut16) — La taille (résolution) de chaque patch. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - layer_norm_eps (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - initializer_range (
float, facultatif, par défaut1e-10) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - qkv_bias (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - use_abs_pos (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser l'incorporation de position absolue. - use_rel_pos (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser l'incorporation de position relative. - window_size (
int, facultatif, valeur par défaut 14) — Taille de la fenêtre pour la position relative. - global_attn_indexes (
list[int], facultatif, par défaut[2, 5, 8, 11]) — Les index des couches d'attention globale. - mlp_dim (
int, facultatif, valeur par défaut 3072) — La dimensionnalité de la couche MLP dans l'encodeur Transformer.
Ceci est la classe de configuration destinée à stocker la configuration d'un SlanextModel. Elle est utilisée pour instancier un modèle Slanext en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de PaddlePaddle/SLANeXt_wired_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.
SLANeXtForTableRecognition
classe transformers.SLANeXtForTableRecognition
< source >( config: SLANeXtConfig )
Paramètres
- config (SLANeXtConfig) — 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 de reconnaissance de tableaux SLANeXt pour les tâches de reconnaissance de tableaux. Encapsule le modèle de base SLANeXtPreTrainedModel et renvoie des sorties compatibles avec l'API de reconnaissance de tableaux de Transformers.
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: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SLANeXtForTableRecognitionOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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 SLANeXtImageProcessor. Voir SLANeXtImageProcessor.call() pour plus de détails (processor_classutilise SLANeXtImageProcessor pour le traitement des images).
Retourne
SLANeXtForTableRecognitionOutput ou tuple(torch.Tensor)
Un SLANeXtForTableRecognitionOutput 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 (SLANeXtConfig) et des entrées.
La méthode forward de SLANeXtForTableRecognition 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
Moduleplutô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.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
head_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — États cachés de SLANeXtSLAHead à chaque étape de prédiction, variant jusqu'à un maximum deself.config.max_text_lengthétats (selon les sorties anticipées).head_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Attentions de la SLANeXtSLAHead à chaque étape de prédiction, variant jusqu'à un maximum deself.config.max_text_lengthattentions (selon les sorties anticipées).
SLANeXtBackbone
SLANeXtSLAHead
SLANeXtImageProcessor
classe transformers.SLANeXtImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'height' -- 512, 'width': 512}) : Définit les dimensions d'entrée maximales pour le modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautTrue) — 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut[0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut appliquer un bourrage (padding) à 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, par défaut{'height' -- 512, 'width': 512}) : 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. Sipad_sizen'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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.
Construit un processeur d’image SLANeXtImageProcessor.
Initialiser le vocabulaire du décodeur pour la reconnaissance de la structure des tableaux.
Construit un dictionnaire de caractères qui associe les jetons de structure de table HTML (par exemple, <thead>, <tr>, <td>, attributs colspan/
rowspan) à des indices entiers. Le dictionnaire inclut les jetons spéciaux "sos" (début de séquence) et "eos" (fin de séquence). Les jetons fusionnés <td></td> sont utilisés à la place des jetons <td> autonomes lorsque cela est applicable.
post_process_table_recognition
< source >( outputs ) → dict
Paramètres
- outputs (
SLANeXtForTableRecognitionOutput) — Sorties brutes du modèle SLANeXt. Le champlast_hidden_statecontient les distributions de probabilité prédites sur le vocabulaire de structure à chaque étape de décodage, avec la forme(batch_size, max_text_length, num_classes).
Retourne
dict
Un dictionnaire contenant :
- structure (
list[str]) : La structure de la table HTML prédite, sous forme de liste de jetons, encadrée par les balises<html>,<body>et<table>. - structure_score (
float) : Score de confiance moyen sur l’ensemble des jetons prédits.
Post-traitez les sorties brutes du modèle pour décoder la structure de table prédite en une séquence de jetons HTML.
Convertit les distributions de probabilité prédites par le modèle sur le vocabulaire de structure en une séquence de jetons HTML représentant la structure du tableau. Les jetons décodés sont encapsulés dans les balises <html>, <body> et <table> pour former une structure de tableau HTML complète.