# SLANeXt

## Ikhtisar

**SLANeXt_wired** dan **SLANeXt_wireless** merupakan bagian dari seri model ringan khusus untuk pengenalan struktur tabel, yang berfokus pada pengenalan struktur tabel secara akurat dalam dokumen dan adegan alami. Untuk detail lebih lanjut tentang model seri SLANeXt, silakan merujuk ke [dokumentasi resmi](https://www.paddleocr.ai/latest/en/version3.x/module_usage/table_structure_recognition.html).

## Arsitektur Model

Seri SLANeXt adalah generasi baru model pengenalan struktur tabel yang dikembangkan secara independen oleh Tim Visi PaddlePaddle Baidu. SLANeXt berfokus pada pengenalan struktur tabel, dan melatih bobot khusus secara terpisah untuk tabel berbingkai (wired) dan tabel tanpa bingkai (wireless). Kemampuan pengenalan untuk semua jenis tabel telah ditingkatkan secara signifikan, terutama untuk tabel berbingkai.

## Penggunaan

### Inferensi input tunggal

Contoh di bawah ini menunjukkan cara mendeteksi teks dengan PP-OCRV5_Mobile_Det menggunakan [AutoModel](/docs/transformers/v5.23.0/id/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)
```

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

**Parameter:**

vision_config (`dict` atau [SLANeXtVisionConfig](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtVisionConfig), *opsional*) : Konfigurasi untuk vision encoder. Jika `None`, [SLANeXtVisionConfig](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtVisionConfig) default akan digunakan.

post_conv_in_channels (`int`, *opsional*, default 256) : Jumlah saluran input untuk lapisan konvolusi pasca-encoder.

post_conv_out_channels (`int`, *opsional*, defaultnya 512) : Jumlah saluran keluaran untuk lapisan konvolusi pasca-encoder.

out_channels (`int`, *opsional*, default 50) : Ukuran kosakata untuk kepala prediksi token struktur tabel, yaitu jumlah token struktur berbeda yang dapat diprediksi oleh model.

hidden_size (`int`, *opsional*, defaultnya 512) : Dimensi dari hidden states dalam sel attention GRU dan kepala prediksi struktur/lokasi.

max_text_length (`int`, *opsional*, default 500) : Jumlah maksimum langkah decoding autoregresif (token) untuk decoder struktur dan lokasi.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari SlanextModel. Kelas ini digunakan untuk membuat instans model Slanext sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [PaddlePaddle/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_safetensors)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## 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)
```

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

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `768`) : Dimensi dari representasi tersembunyi.

output_channels (`int`, *opsional*, default 256) : Dimensi dari kanal output di Patch Encoder.

num_hidden_layers (`int`, *opsional*, defaultnya `12`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `12`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input.

image_size (`int`, *opsional*, defaultnya `512`) : Ukuran (resolusi) dari setiap gambar.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

initializer_range (`float`, *opsional*, defaultnya `1e-10`) : Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

qkv_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan bias ke queries, keys, dan values.

use_abs_pos (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan absolute position embedding.

use_rel_pos (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan relative position embedding.

window_size (`int`, *opsional*, default 14) : Ukuran jendela untuk posisi relatif.

global_attn_indexes (`list[int]`, *opsional*, defaultnya `[2, 5, 8, 11]`) : Indeks dari lapisan perhatian global.

mlp_dim (`int`, *opsional*, defaultnya 3072) : Dimensi dari lapisan MLP dalam encoder Transformer.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari SlanextModel. Kelas ini digunakan untuk membuat instans model Slanext sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [PaddlePaddle/SLANeXt_wired_safetensors](https://huggingface.co/PaddlePaddle/SLANeXt_wired_safetensors)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## SLANeXtForTableRecognition[[transformers.SLANeXtForTableRecognition]]

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

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

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

**Parameter:**

config ([SLANeXtConfig](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model pengenalan tabel SLANeXt untuk tugas pengenalan tabel. Membungkus inti SLANeXtPreTrainedModel dan mengembalikan output yang kompatibel dengan API pengenalan tabel Transformers.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

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

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [SLANeXtImageProcessor](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtImageProcessor). Lihat [SLANeXtImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [SLANeXtImageProcessor](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtImageProcessor) untuk memproses gambar).

**Mengembalikan:** `SLANeXtForTableRecognitionOutput` atau `tuple(torch.Tensor)`

`SLANeXtForTableRecognitionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([SLANeXtConfig](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtConfig)) dan input.

Metode forward dari [SLANeXtForTableRecognition](/docs/transformers/v5.23.0/id/model_doc/slanext#transformers.SLANeXtForTableRecognition) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **head_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Hidden-states dari SLANeXtSLAHead pada setiap langkah prediksi, bervariasi hingga maksimal `self.config.max_text_length` state (tergantung pada early exits).
- **head_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Atensi dari SLANeXtSLAHead pada setiap langkah prediksi, bervariasi hingga maksimal `self.config.max_text_length` atensi (tergantung pada early exits).

## SLANeXtBackbone[[transformers.SLANeXtBackbone]]

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

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

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

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

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

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengonversi gambar ke RGB.

do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'height' : 512, 'width': 512}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `2`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`.

do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar.

rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`.

do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.485, 0.456, 0.406]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.229, 0.224, 0.225]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`.

do_pad (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'height' : 512, 'width': 512}`): Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jika `pad_size` tidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor.

disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang.

Membangun pemroses gambar SLANeXtImageProcessor.

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

```python
init_decoder()
```

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

Inisialisasi kosakata decoder untuk pengenalan struktur tabel.

Membangun kamus karakter yang memetakan token struktur tabel HTML (misalnya, `<thead>`, `<tr>`, `<td>`, atribut colspan/rowspan) ke indeks integer. Kamus ini mencakup token khusus `"sos"` (start-of-sequence) dan `"eos"` (end-of-sequence). Token `<td></td>` yang digabungkan digunakan sebagai pengganti token `<td>` mandiri ketika berlaku.

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

```python
post_process_table_recognition(outputs)
```

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

**Parameter:**

outputs (`SLANeXtForTableRecognitionOutput`) : Output mentah dari model SLANeXt. Field `last_hidden_state` berisi distribusi probabilitas prediksi atas kosakata struktur pada setiap langkah decoding, dengan bentuk `(batch_size, max_text_length, num_classes)`.

**Mengembalikan:** `dict`

Kamus yang berisi:
- **struktur** (`list[str]`): Struktur tabel HTML yang diprediksi sebagai daftar token, dibungkus dengan tag `<html>`, `<body>`, dan `<table>`.
- **structure_score** (`float`): Skor kepercayaan rata-rata di seluruh token yang diprediksi.

Lakukan pascapemrosesan pada keluaran mentah model untuk mendekode struktur tabel yang diprediksi menjadi sekuens token HTML.

Mengubah distribusi probabilitas prediksi model di atas kosakata struktur menjadi urutan token HTML yang merepresentasikan struktur tabel. Token yang didekode dibungkus dengan tag `<html>`, `<body>`, dan `<table>` untuk membentuk struktur tabel HTML yang lengkap.

