# SLANeXt ## Visão geral **SLANeXt_wired** e **SLANeXt_wireless** fazem parte de uma série de modelos leves dedicados ao reconhecimento de estruturas 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 SLANeXt, consulte a [documentação oficial](https://www.paddleocr.ai/latest/en/version3.x/module_usage/table_structure_recognition.html). ## Arquitetura do Modelo A série SLANeXt é uma nova geração de modelos de reconhecimento de estrutura de tabelas desenvolvida independentemente pela equipe de visão do PaddlePaddle, da Baidu. O SLANeXt se concentra no reconhecimento de estrutura de tabelas e treina pesos dedicados para tabelas com e sem bordas separadamente. A capacidade de reconhecimento para todos os tipos de tabelas foi significativamente aprimorada, especialmente para tabelas com bordas. ## Uso ### Inferência com entrada única O exemplo abaixo demonstra como detectar texto com PP-OCRV5_Mobile_Det usando o [AutoModel](/docs/transformers/main/pt/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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/configuration_slanext.py#L70) **Parâmetros:** vision_config (`dict` ou [SLANeXtVisionConfig](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtVisionConfig), *opcional*) : Configuração para o codificador de visão. Se `None`, um [SLANeXtVisionConfig](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtVisionConfig) padrão é usado. post_conv_in_channels (`int`, *opcional*, padrão 256) : Número de canais de entrada para a camada de convolução pós-encoder. post_conv_out_channels (`int`, *opcional*, padrão 512) : 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 512) : 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. Esta é a classe de configuração para armazenar a configuração de um SlanextModel. Ela é usada para instanciar um modelo Slanext 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/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_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. ## 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/configuration_slanext.py#L30) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. output_channels (`int`, *opcional*, padrão 256) : Dimensionalidade dos canais de saída no Patch Encoder. num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. image_size (`int`, *opcional*, padrão `512`) : O tamanho (resolução) de cada imagem. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch. hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. initializer_range (`float`, *opcional*, padrão `1e-10`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values. use_abs_pos (`bool`, *opcional*, padrão `True`) : Se deve usar incorporação de posição absoluta. use_rel_pos (`bool`, *opcional*, padrão `True`) : Se deve usar incorporação de posição relativa. window_size (`int`, *opcional*, padrão 14) : Tamanho da janela para posição relativa. global_attn_indexes (`list[int]`, *opcional*, padrão `[2, 5, 8, 11]`) : Os índices das camadas de atenção global. mlp_dim (`int`, *opcional*, padrão 3072) : A dimensionalidade da camada MLP no codificador Transformer. Esta é a classe de configuração para armazenar a configuração de um SlanextModel. Ela é usada para instanciar um modelo Slanext 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/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_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. ## SLANeXtForTableRecognition[[transformers.SLANeXtForTableRecognition]] #### transformers.SLANeXtForTableRecognition[[transformers.SLANeXtForTableRecognition]] ```python transformers.SLANeXtForTableRecognition(config: SLANeXtConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/modeling_slanext.py#L618) **Parâmetros:** config ([SLANeXtConfig](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtConfig)) : 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 SLANeXt para tarefas de reconhecimento de tabelas. Encapsula o núcleo SLANeXtPreTrainedModel 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.SLANeXtForTableRecognition.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/modeling_slanext.py#L625) **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:** `SLANeXtForTableRecognitionOutput` ou `tuple(torch.Tensor)` Um `SLANeXtForTableRecognitionOutput` 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 ([SLANeXtConfig](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtConfig)) e das entradas. O método forward de [SLANeXtForTableRecognition](/docs/transformers/main/pt/model_doc/slanext#transformers.SLANeXtForTableRecognition) 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, sequence_length, hidden_size)`) -- 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, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **head_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Hidden-states do SLANeXtSLAHead em cada etapa de previsão, variando 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 SLANeXtSLAHead em cada etapa de previsão, variando até no máximo `self.config.max_text_length` atenções (dependendo das saídas antecipadas). ## SLANeXtBackbone[[transformers.SLANeXtBackbone]] #### transformers.SLANeXtBackbone[[transformers.SLANeXtBackbone]] ```python transformers.SLANeXtBackbone(config: dict | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/modeling_slanext.py#L522) ## SLANeXtSLAHead[[transformers.SLANeXtSLAHead]] #### transformers.SLANeXtSLAHead[[transformers.SLANeXtSLAHead]] ```python transformers.SLANeXtSLAHead(config: dict | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/modeling_slanext.py#L546) ## SLANeXtImageProcessor[[transformers.SLANeXtImageProcessor]] #### transformers.SLANeXtImageProcessor[[transformers.SLANeXtImageProcessor]] ```python transformers.SLANeXtImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/image_processing_slanext.py#L38) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 512, 'width': 512}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 512, 'width': 512}`): O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que qualquer tamanho de imagem fornecido para pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. Constrói um processador de imagem SLANeXtImageProcessor. #### init_decoder[[transformers.SLANeXtImageProcessor.init_decoder]] ```python init_decoder() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/image_processing_slanext.py#L170) Inicialize o vocabulário do decodificador para o reconhecimento da estrutura da tabela. Cria um dicionário de caracteres que mapeia tokens de estrutura de tabela HTML (por exemplo, ``, ``, ``, atributos colspan/ rowspan) para índices inteiros. O dicionário inclui os tokens especiais `"sos"` (início da sequência) e `"eos"` (fim da sequência). Tokens `` mesclados são usados no lugar de tokens `` isolados quando aplicável. #### post_process_table_recognition[[transformers.SLANeXtImageProcessor.post_process_table_recognition]] ```python post_process_table_recognition(outputs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/slanext/image_processing_slanext.py#L206) **Parâmetros:** outputs (`SLANeXtForTableRecognitionOutput`) : Saídas brutas do modelo SLANeXt. O campo `last_hidden_state` contém as distribuições de probabilidade previstas sobre o vocabulário de estrutura em cada etapa de decodificação, com forma `(batch_size, max_text_length, num_classes)`. **Retorna:** `dict` Um dicionário contendo: - **estrutura** (`list[str]`): A estrutura da tabela HTML prevista como uma lista de tokens, envolvida pelas tags ``, `` e ``. - **structure_score** (`float`): A pontuação média de confiança entre todos os tokens previstos. Pós-processe as saídas brutas do modelo para decodificar a estrutura da tabela prevista em uma sequência de tokens HTML. Converte as distribuições de probabilidade previstas pelo modelo sobre o vocabulário da estrutura em uma sequência de tokens HTML que representa a estrutura da tabela. Os tokens decodificados são encapsulados com as tags ``, `` e `
` para formar uma estrutura de tabela HTML completa.