# SLANet

## Resumen

**SLANet** y **SLANet_plus** forman parte de una serie de modelos ligeros dedicados al reconocimiento de la estructura de tablas, con el enfoque de reconocer con precisión las estructuras de tablas en documentos y escenas naturales. Para más detalles sobre la serie de modelos SLANet, consulte la [documentación oficial](https://www.paddleocr.ai/latest/en/version3.x/module_usage/table_structure_recognition.html).

## Arquitectura del modelo

SLANet es un modelo de reconocimiento de estructura de tablas desarrollado por el equipo de visión de Baidu PaddlePaddle. El modelo mejora significativamente la precisión y la velocidad de inferencia del reconocimiento de estructura de tablas al adoptar una red backbone ligera y apta para CPU, PP-LCNet, un módulo de fusión de características de bajo y alto nivel, CSP-PAN, y un módulo de decodificación de características, SLA Head, que alinea la información estructural y posicional.

## Uso

### Inferencia con una sola entrada

El siguiente ejemplo demuestra cómo detectar texto con SLANet usando [AutoModel](/docs/transformers/v5.23.0/es/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)
```

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

**Parámetros:**

post_conv_out_channels (`int`, *opcional*, valor predeterminado 96) : Número de canales de salida para la capa de convolución posterior al codificador.

out_channels (`int`, *opcional*, valor predeterminado: 50) : Tamaño del vocabulario para la cabeza de predicción de tokens de estructura de tabla, es decir, el número de tokens de estructura distintos que el modelo puede predecir.

hidden_size (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de los estados ocultos en la celda GRU de atención y en las cabezas de predicción de estructura/ubicación.

max_text_length (`int`, *opcional*, valor predeterminado: 500) : Número máximo de pasos de decodificación autoregresiva (tokens) para el decodificador de estructura y ubicación.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : La configuración del modelo de base.

hidden_act (`str`, *opcional*, valor predeterminado `hardswish`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

csp_kernel_size (`int`, *opcional*, valor predeterminado 5) : El tamaño del kernel de la capa Cross Stage Partial (CSP).

csp_num_blocks (`int`, *opcional*, valor predeterminado: 1) : Número de bloques dentro de la capa Cross Stage Partial (CSP).

Esta es la clase de configuración para almacenar la configuración de un SlanetModel. Se utiliza para instanciar un modelo Slanet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [PaddlePaddle/SLANet_plus_safetensors](https://huggingface.co/PaddlePaddle/SLANet_plus_safetensors)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## SLANetForTableRecognition[[transformers.SLANetForTableRecognition]]

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

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

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

**Parámetros:**

config ([SLANetConfig](/docs/transformers/v5.23.0/es/model_doc/slanet#transformers.SLANetConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo de reconocimiento de tablas SLANet para tareas de reconocimiento de tablas. Envuelve el núcleo SLANetPreTrainedModel y devuelve salidas compatibles con la API de reconocimiento de tablas de Transformers.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

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

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [SLANeXtImageProcessor](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtImageProcessor). Consulte [SLANeXtImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [SLANeXtImageProcessor](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtImageProcessor) para procesar las imágenes).

**Devuelve:** `SLANetForTableRecognitionOutput` o `tuple(torch.Tensor)`

Un `SLANetForTableRecognitionOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([SLANetConfig](/docs/transformers/v5.23.0/es/model_doc/slanet#transformers.SLANetConfig)) y las entradas.

El método forward de [SLANetForTableRecognition](/docs/transformers/v5.23.0/es/model_doc/slanet#transformers.SLANetForTableRecognition) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, num_channels, height, width)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **head_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Estados ocultos de SLANetSLAHead en cada paso de predicción, varía hasta un máximo de `self.config.max_text_length` estados (dependiendo de las salidas anticipadas).
- **head_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Atenciones de SLANetSLAHead en cada paso de predicción, varía hasta un máximo de `self.config.max_text_length` atenciones (dependiendo de las salidas anticipadas).

## SLANetBackbone[[transformers.SLANetBackbone]]

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

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

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

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

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

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

**Parámetros:**

hidden_states (`torch.Tensor`) : entrada de la capa con forma `(batch, seq_len, embed_dim)`

**Devuelve:** `BaseModelOutputWithNoAttention` o `tuple(torch.Tensor)`

Un `BaseModelOutputWithNoAttention` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([SLANetConfig](/docs/transformers/v5.23.0/es/model_doc/slanet#transformers.SLANetConfig)) y las entradas.

El método forward de [SLANetBackbone](/docs/transformers/v5.23.0/es/model_doc/slanet#transformers.SLANetBackbone) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, num_channels, height, width)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

## SLANetSLAHead[[transformers.SLANetSLAHead]]

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

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

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

