# SLANet

## Visão geral

**SLANet** e **SLANet_plus** fazem parte de uma série de modelos leves dedicados ao reconhecimento de estrutura de tabelas, com foco no reconhecimento preciso de estruturas de tabelas em documentos e cenas naturais. Para mais detalhes sobre o modelo da série SLANet, consulte a [documentação oficial](https://www.paddleocr.ai/latest/en/version3.x/module_usage/table_structure_recognition.html).

## Arquitetura do Modelo

SLANet é um modelo de reconhecimento de estrutura de tabela desenvolvido pela Baidu PaddlePaddle Vision Team. O modelo melhora significativamente a precisão e a velocidade de inferência do reconhecimento de estrutura de tabela ao adotar uma rede backbone leve e compatível com CPU, a PP-LCNet, um módulo de fusão de recursos de alto e baixo nível, o CSP-PAN, e um módulo de decodificação de recursos, o SLA Head, que alinha informações estruturais e posicionais.

## Uso

### Inferência com entrada única

O exemplo abaixo demonstra como detectar texto com SLANet usando o [AutoModel](/docs/transformers/main/pt/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)
```

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

**Parâmetros:**

post_conv_out_channels (`int`, *opcional*, padrão 96) : Número de canais de saída para a camada de convolução pós-encoder.

out_channels (`int`, *opcional*, padrão 50) : Tamanho do vocabulário para a cabeça de previsão de tokens de estrutura de tabela, ou seja, o número de tokens de estrutura distintos que o modelo pode prever.

hidden_size (`int`, *opcional*, padrão 256) : Dimensionalidade dos estados ocultos na célula GRU de atenção e nas cabeças de previsão de estrutura/localização.

max_text_length (`int`, *opcional*, padrão 500) : Número máximo de etapas de decodificação autoregressiva (tokens) para o decodificador de estrutura e localização.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone.

hidden_act (`str`, *opcional*, padrão `hardswish`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

csp_kernel_size (`int`, *opcional*, padrão 5) : O tamanho do kernel da camada Cross Stage Partial (CSP).

csp_num_blocks (`int`, *opcional*, padrão 1) : Número de blocos dentro da camada Cross Stage Partial (CSP).

Esta é a classe de configuração para armazenar a configuração de um SlanetModel. Ela é usada para instanciar um modelo Slanet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [PaddlePaddle/SLANet_plus_safetensors](https://huggingface.co/PaddlePaddle/SLANet_plus_safetensors)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## SLANetForTableRecognition[[transformers.SLANetForTableRecognition]]

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

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

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

**Parâmetros:**

config ([SLANetConfig](/docs/transformers/main/pt/model_doc/slanet#transformers.SLANetConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo de reconhecimento de tabelas SLANet para tarefas de reconhecimento de tabelas. Encapsula o núcleo SLANetPreTrainedModel e retorna saídas compatíveis com a API de reconhecimento de tabelas do Transformers.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [SLANeXtImageProcessor](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtImageProcessor). Veja [SLANeXtImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [SLANeXtImageProcessor](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtImageProcessor) para processar imagens).

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

Um `SLANetForTableRecognitionOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([SLANetConfig](/docs/transformers/main/pt/model_doc/slanet#transformers.SLANetConfig)) e das entradas.

O método forward de [SLANetForTableRecognition](/docs/transformers/main/pt/model_doc/slanet#transformers.SLANetForTableRecognition) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, num_channels, height, width)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **head_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Hidden-states do SLANetSLAHead em cada etapa de previsão, varia até no máximo `self.config.max_text_length` estados (dependendo de saídas antecipadas).
- **head_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Atenções do SLANetSLAHead em cada etapa de previsão, variando até no máximo `self.config.max_text_length` atenções (dependendo das saídas antecipadas).

## SLANetBackbone[[transformers.SLANetBackbone]]

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

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

[Origem](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'>)
```

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

**Parâmetros:**

hidden_states (`torch.Tensor`) : entrada da camada com forma `(batch, seq_len, embed_dim)`

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

Um `BaseModelOutputWithNoAttention` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([SLANetConfig](/docs/transformers/main/pt/model_doc/slanet#transformers.SLANetConfig)) e das entradas.

O método forward de [SLANetBackbone](/docs/transformers/main/pt/model_doc/slanet#transformers.SLANetBackbone) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, num_channels, height, width)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

## SLANetSLAHead[[transformers.SLANetSLAHead]]

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

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

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