# SLANet

## Aperçu

**SLANet** et **SLANet_plus** 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 la série de modèles SLANet, veuillez consulter la [documentation officielle](https://www.paddleocr.ai/latest/en/version3.x/module_usage/table_structure_recognition.html).

## Architecture du modèle

SLANet est un modèle de reconnaissance de la structure des tableaux développé par l'équipe Vision de Baidu PaddlePaddle. Le modèle améliore considérablement la précision et la vitesse d'inférence de la reconnaissance de la structure des tableaux en adoptant un réseau backbone léger et compatible CPU, PP-LCNet, un module de fusion de caractéristiques de bas et haut niveau, CSP-PAN, et un module de décodage de caractéristiques, SLA Head, qui aligne les informations structurelles et positionnelles.

## Utilisation

### Inférence avec une seule entrée

L’exemple ci-dessous montre comment détecter du texte avec SLANet à l’aide de [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel).

```python
from io import BytesIO

from huggingface_hub.utils import httpx
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForTableRecognition

model_path="PaddlePaddle/SLANet_plus_safetensors"
model = AutoModelForTableRecognition.from_pretrained(model_path, device_map="auto")
image_processor = AutoImageProcessor.from_pretrained(model_path)

image = Image.open(BytesIO(httpx.get(image_url).content))
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'])
```

## SLANetConfig[[transformers.SLANetConfig]]

#### transformers.SLANetConfig[[transformers.SLANetConfig]]

```python
transformers.SLANetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, post_conv_out_channels: int = 96, out_channels: int = 50, hidden_size: int = 256, max_text_length: int = 500, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, hidden_act: str = 'hardswish', csp_kernel_size: int = 5, csp_num_blocks: int = 1)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/configuration_slanet.py#L31)

**Paramètres :**

post_conv_out_channels (`int`, *facultatif*, valeur par défaut 96) : 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*, valeur par défaut 256) : Dimension des états cachés dans la cellule GRU d'attention et les têtes de prédiction de structure/localisation.

max_text_length (`int`, *facultatif*, valeur par défaut : 500) : Nombre maximal d'étapes de décodage autorégressif (jetons) pour le décodeur de structure et de localisation.

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

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

csp_kernel_size (`int`, *facultatif*, valeur par défaut : 5) : La taille du noyau de la couche Cross Stage Partial (CSP).

csp_num_blocks (`int`, *facultatif*, valeur par défaut : 1) : Nombre de blocs au sein de la couche Cross Stage Partial (CSP).

Ceci est la classe de configuration destinée à stocker la configuration d'un SlanetModel. Elle est utilisée pour instancier un modèle Slanet 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/SLANet_plus_safetensors](https://huggingface.co/PaddlePaddle/SLANet_plus_safetensors)

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

## SLANetForTableRecognition[[transformers.SLANetForTableRecognition]]

#### transformers.SLANetForTableRecognition[[transformers.SLANetForTableRecognition]]

```python
transformers.SLANetForTableRecognition(config: SLANetConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/modeling_slanet.py#L455)

**Paramètres :**

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

Modèle de reconnaissance de tableaux SLANet pour les tâches de reconnaissance de tableaux. Encapsule le modèle de base SLANetPreTrainedModel et renvoie des sorties compatibles avec l'API de reconnaissance de tableaux de Transformers.

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

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

#### forward[[transformers.SLANetForTableRecognition.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/modeling_slanet.py#L464)

**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 [SLANeXtImageProcessor](/docs/transformers/main/fr/model_doc/slanext#transformers.SLANeXtImageProcessor). Voir [SLANeXtImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [SLANeXtImageProcessor](/docs/transformers/main/fr/model_doc/slanext#transformers.SLANeXtImageProcessor) pour le traitement des images).

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

Un `SLANetForTableRecognitionOutput` 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 ([SLANetConfig](/docs/transformers/main/fr/model_doc/slanet#transformers.SLANetConfig)) et les entrées.

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

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, num_channels, height, width)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **head_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- États cachés de SLANetSLAHead à chaque étape de prédiction, variant jusqu'à un maximum de `self.config.max_text_length` états (selon les sorties anticipées).
- **head_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Attentions de SLANetSLAHead à chaque étape de prédiction, variant jusqu'à un maximum de `self.config.max_text_length` attentions (selon les sorties anticipées).

## SLANetBackbone[[transformers.SLANetBackbone]]

#### transformers.SLANetBackbone[[transformers.SLANetBackbone]]

```python
transformers.SLANetBackbone(config: SLANetConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/modeling_slanet.py#L428)

#### forward[[transformers.SLANetBackbone.forward]]

```python
forward(hidden_states: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/modeling_slanet.py#L436)

**Paramètres :**

hidden_states (`torch.Tensor`) : entrée de la couche de forme `(batch, seq_len, embed_dim)`

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

Un `BaseModelOutputWithNoAttention` 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 ([SLANetConfig](/docs/transformers/main/fr/model_doc/slanet#transformers.SLANetConfig)) et les entrées.

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

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, num_channels, height, width)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

## SLANetSLAHead[[transformers.SLANetSLAHead]]

#### transformers.SLANetSLAHead[[transformers.SLANetSLAHead]]

```python
transformers.SLANetSLAHead(config: dict | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanet/modeling_slanet.py#L138)