# SLANeXt

## Resumen

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

## Arquitectura del modelo

La serie SLANeXt es una nueva generación de modelos de reconocimiento de estructura de tablas desarrollados de forma independiente por el equipo de visión de Baidu PaddlePaddle. SLANeXt se centra en el reconocimiento de la estructura de tablas y entrena pesos dedicados para tablas con y sin bordes por separado. La capacidad de reconocimiento para todos los tipos de tablas ha mejorado significativamente, especialmente para las tablas con bordes.

## Uso

### Inferencia con una sola entrada

El siguiente ejemplo demuestra cómo detectar texto con PP-OCRV5_Mobile_Det usando [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel).

```python
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[[transformers.SLANeXtConfig]]

#### transformers.SLANeXtConfig[[transformers.SLANeXtConfig]]

```python
transformers.SLANeXtConfig(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, vision_config: dict | transformers.models.slanext.configuration_slanext.SLANeXtVisionConfig | None = None, post_conv_in_channels: int = 256, post_conv_out_channels: int = 512, out_channels: int = 50, hidden_size: int = 512, max_text_length: int = 500)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/configuration_slanext.py#L70)

**Parámetros:**

vision_config (`dict` o [SLANeXtVisionConfig](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtVisionConfig), *opcional*) : Configuración para el codificador de visión. Si es `None`, se utiliza una [SLANeXtVisionConfig](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtVisionConfig) predeterminada.

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

post_conv_out_channels (`int`, *opcional*, valor predeterminado 512) : 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 512) : 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.

Esta es la clase de configuración para almacenar la configuración de un SlanextModel. Se utiliza para instanciar un modelo Slanext 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/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_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.

## SLANeXtVisionConfig[[transformers.SLANeXtVisionConfig]]

#### transformers.SLANeXtVisionConfig[[transformers.SLANeXtVisionConfig]]

```python
transformers.SLANeXtVisionConfig(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, hidden_size: int = 768, output_channels: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int = 512, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True, use_abs_pos: bool = True, use_rel_pos: bool = True, window_size: int = 14, global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11), mlp_dim: int = 3072)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/configuration_slanext.py#L30)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

output_channels (`int`, *opcional*, valor predeterminado 256) : Dimensionalidad de los canales de salida en el Patch Encoder.

num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

image_size (`int`, *opcional*, valor predeterminado `512`) : El tamaño (resolución) de cada imagen.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

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

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

initializer_range (`float`, *opcional*, valor predeterminado `1e-10`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a las consultas, claves y valores.

use_abs_pos (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar la incrustación de posición absoluta.

use_rel_pos (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar la incrustación de posición relativa.

window_size (`int`, *opcional*, valor predeterminado 14) : Tamaño de la ventana para la posición relativa.

global_attn_indexes (`list[int]`, *opcional*, valor predeterminado `[2, 5, 8, 11]`) : Los índices de las capas de atención global.

mlp_dim (`int`, *opcional*, valor predeterminado 3072) : La dimensionalidad de la capa MLP en el codificador Transformer.

Esta es la clase de configuración para almacenar la configuración de un SlanextModel. Se utiliza para instanciar un modelo Slanext 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/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_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.

## SLANeXtForTableRecognition[[transformers.SLANeXtForTableRecognition]]

#### transformers.SLANeXtForTableRecognition[[transformers.SLANeXtForTableRecognition]]

```python
transformers.SLANeXtForTableRecognition(config: SLANeXtConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/modeling_slanext.py#L618)

**Parámetros:**

config ([SLANeXtConfig](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtConfig)) : 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 SLANeXt para tareas de reconocimiento de tablas. Envuelve el núcleo SLANeXtPreTrainedModel 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.SLANeXtForTableRecognition.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/slanext/modeling_slanext.py#L625)

**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:** `SLANeXtForTableRecognitionOutput` o `tuple(torch.Tensor)`

Un `SLANeXtForTableRecognitionOutput` 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 ([SLANeXtConfig](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtConfig)) y las entradas.

El método forward de [SLANeXtForTableRecognition](/docs/transformers/v5.23.0/es/model_doc/slanext#transformers.SLANeXtForTableRecognition) 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, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve 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, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **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 SLANeXtSLAHead 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 SLANeXtSLAHead en cada paso de predicción, varía hasta un máximo de `self.config.max_text_length` atenciones (dependiendo de las salidas anticipadas).

## SLANeXtBackbone[[transformers.SLANeXtBackbone]]

#### transformers.SLANeXtBackbone[[transformers.SLANeXtBackbone]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/modeling_slanext.py#L522)

## SLANeXtSLAHead[[transformers.SLANeXtSLAHead]]

#### transformers.SLANeXtSLAHead[[transformers.SLANeXtSLAHead]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/modeling_slanext.py#L546)

## SLANeXtImageProcessor[[transformers.SLANeXtImageProcessor]]

#### transformers.SLANeXtImageProcessor[[transformers.SLANeXtImageProcessor]]

```python
transformers.SLANeXtImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/image_processing_slanext.py#L38)

**Parámetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB.

do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 512, 'width': 512}`): Describe las dimensiones máximas de entrada para el modelo.

default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen.

rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`.

do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`.

do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el mayor tamaño del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 512, 'width': 512}`): El tamaño en `{"height": int, "width" int}` al que rellener las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores.

disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador.

Construye un procesador de imágenes SLANeXtImageProcessor.

#### init_decoder[[transformers.SLANeXtImageProcessor.init_decoder]]

```python
init_decoder()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/image_processing_slanext.py#L170)

Inicialice el vocabulario del decodificador para el reconocimiento de la estructura de la tabla.

Crea un diccionario de caracteres que asigna a los tokens de estructura de tablas HTML (p. ej., `<thead>`, `<tr>`, `<td>`, atributos colspan/ rowspan) índices enteros. El diccionario incluye los tokens especiales `"sos"` (inicio de secuencia) y `"eos"` (fin de secuencia). Se utilizan tokens `<td></td>` fusionados en lugar de tokens `<td>` independientes cuando es aplicable.

#### post_process_table_recognition[[transformers.SLANeXtImageProcessor.post_process_table_recognition]]

```python
post_process_table_recognition(outputs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/slanext/image_processing_slanext.py#L206)

**Parámetros:**

outputs (`SLANeXtForTableRecognitionOutput`) : Salidas sin procesar del modelo SLANeXt. El campo `last_hidden_state` contiene las distribuciones de probabilidad predichas sobre el vocabulario de estructura en cada paso de decodificación, con forma `(batch_size, max_text_length, num_classes)`.

**Devuelve:** `dict`

Un diccionario que contiene:
- **estructura** (`list[str]`): La estructura de la tabla HTML predicha como una lista de tokens, envuelta con las etiquetas `<html>`, `<body>` y `<table>`.
- **structure_score** (`float`): Puntuación media de confianza en todos los tokens predichos.

Post-procesar las salidas crudas del modelo para decodificar la estructura de tabla predicha en una secuencia de tokens HTML.

Convierte las distribuciones de probabilidad predichas por el modelo sobre el vocabulario de estructura en una secuencia de tokens HTML que representa la estructura de la tabla. Los tokens decodificados se envuelven con las etiquetas `<html>`, `<body>` y `<table>` para formar una estructura de tabla HTML completa.

