# MarkupLM

## Ikhtisar

Model MarkupLM diusulkan dalam [MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding](https://huggingface.co/papers/2110.08518) oleh Junlong Li, Yiheng Xu, Lei Cui, Furu Wei. MarkupLM adalah BERT, tetapi diterapkan pada halaman HTML alih-alih dokumen teks mentah. Model ini mengintegrasikan lapisan embedding tambahan untuk meningkatkan kinerja, serupa dengan [LayoutLM](layoutlm).

Model ini dapat digunakan untuk tugas seperti menjawab pertanyaan di halaman web atau ekstraksi informasi dari halaman web. Model ini memperoleh hasil state-of-the-art pada 2 benchmark penting:

- [WebSRC](https://x-lance.github.io/WebSRC/), dataset untuk Pemahaman Membaca Struktural Berbasis Web (sedikit mirip SQuAD tetapi untuk halaman web)
- [SWDE](https://www.researchgate.net/publication/221299838_From_one_tree_to_a_forest_a_unified_solution_for_structured_web_data_extraction), sebuah dataset
untuk ekstraksi informasi dari halaman web (pada dasarnya pengenalan entitas bernama pada halaman web)

Abstrak dari makalah tersebut adalah sebagai berikut:

*Prapelatihan multimodal dengan teks, tata letak, dan gambar telah mencapai kemajuan signifikan untuk Pemahaman Dokumen Kaya Visual (VrDU), terutama dokumen bertata letak tetap seperti gambar dokumen hasil pindaian. Namun, masih terdapat sejumlah besar dokumen digital di mana informasi tata letaknya tidak tetap dan perlu dirender secara interaktif dan dinamis untuk visualisasi, sehingga pendekatan prapelatihan berbasis tata letak yang ada tidak mudah diterapkan. Dalam makalah ini, kami mengusulkan MarkupLM untuk tugas pemahaman dokumen dengan bahasa markup sebagai tulang punggung, seperti dokumen berbasis HTML/XML, di mana informasi teks dan markup dipelajari secara bersama-sama. Hasil eksperimen menunjukkan bahwa MarkupLM yang telah dipelajari secara prapelatihan secara signifikan melampaui model baseline kuat yang ada pada beberapa tugas pemahaman dokumen. Model prapelatihan dan kode akan tersedia secara publik.*

Model ini disumbangkan oleh [nielsr](https://huggingface.co/nielsr). Kode aslinya dapat ditemukan [di sini](https://github.com/microsoft/unilm/tree/master/markuplm).

## Tips penggunaan

- Selain `input_ids`, [forward()](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMModel.forward) mengharapkan 2 input tambahan, yaitu `xpath_tags_seq` dan `xpath_subs_seq`.
Ini adalah tag XPATH dan subskrip masing-masing untuk setiap token dalam urutan input.
- Anda dapat menggunakan [MarkupLMProcessor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMProcessor) untuk menyiapkan semua data untuk model. Lihat [panduan penggunaan](#usage-markuplmprocessor) untuk informasi lebih lanjut.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/markuplm_architecture.jpg"
alt="drawing" width="600"/>

 Arsitektur MarkupLM. Diambil dari paper aslinya.

## Penggunaan: MarkupLMProcessor

Cara termudah untuk menyiapkan data untuk model adalah dengan menggunakan [MarkupLMProcessor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMProcessor), yang secara internal menggabungkan feature extractor ([MarkupLMFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMFeatureExtractor)) dan tokenizer ([MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) atau [MarkupLMTokenizerFast](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer)). Feature extractor digunakan untuk mengekstrak semua node dan xpath dari string HTML, yang kemudian diberikan ke tokenizer, yang mengubahnya menjadi input level token dari model (`input_ids` dll.). Perhatikan bahwa Anda masih dapat menggunakan feature extractor dan tokenizer secara terpisah, jika Anda hanya ingin menangani salah satu dari dua tugas tersebut.

```python
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizerFast

feature_extractor = MarkupLMFeatureExtractor()
tokenizer = MarkupLMTokenizerFast.from_pretrained("microsoft/markuplm-base")
processor = MarkupLMProcessor(feature_extractor, tokenizer)
```

Singkatnya, seseorang dapat memberikan string HTML (dan mungkin data tambahan) ke [MarkupLMProcessor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMProcessor), dan pemroses tersebut akan membuat input yang diharapkan oleh model. Secara internal, pemroses pertama kali menggunakan [MarkupLMFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMFeatureExtractor) untuk mendapatkan daftar node dan xpath yang sesuai. Node dan xpath tersebut kemudian diberikan ke [MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) atau [MarkupLMTokenizerFast](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer), yang mengubahnya menjadi `input_ids`, `attention_mask`, `token_type_ids`, `xpath_subs_seq`, `xpath_tags_seq` pada tingkat token. Secara opsional, seseorang dapat memberikan label node ke pemroses, yang kemudian diubah menjadi `labels` pada tingkat token.

[MarkupLMFeatureExtractor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMFeatureExtractor) menggunakan [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/), sebuah pustaka Python untuk mengambil data dari file HTML dan XML, di baliknya. Perhatikan bahwa Anda tetap dapat menggunakan solusi parsing pilihan Anda sendiri, dan menyediakan node serta xpath Anda sendiri ke [MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) atau [MarkupLMTokenizerFast](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer).

Secara total, terdapat 5 kasus penggunaan yang didukung oleh prosesor. Di bawah ini, kami mencantumkan semuanya. Perhatikan bahwa masing-masing kasus penggunaan ini berfungsi untuk input berbatch maupun non-berbatch (kami mengilustrasikannya untuk input non-berbatch).

**Kasus penggunaan 1: klasifikasi halaman web (pelatihan, inferensi) + klasifikasi token (inferensi), parse_html = True**

Ini adalah kasus paling sederhana, di mana prosesor akan menggunakan ekstraktor fitur untuk mendapatkan semua node dan xpath dari HTML.

```python
from transformers import MarkupLMProcessor

processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

html_string = """
 <!DOCTYPE html>
 <html>
 <head>
 <title>Hello world</title>
 </head>
 <body>
 <h1>Welcome</h1>
 <p>Here is my website.</p>
 </body>
 </html>"""

# note that you can also add provide all tokenizer parameters here such as padding, truncation
encoding = processor(html_string, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])
```

**Kasus penggunaan 2: klasifikasi halaman web (pelatihan, inferensi) + klasifikasi token (inferensi), parse_html=False**

Jika semua node dan xpath sudah diperoleh, fitur ekstraktor tidak diperlukan. Dalam hal itu, node dan xpath yang sesuai harus diberikan sendiri ke prosesor, dan pastikan untuk mengatur `parse_html` menjadi `False`.

```python
from transformers import MarkupLMProcessor

processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
encoding = processor(nodes=nodes, xpaths=xpaths, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])
```

**Kasus penggunaan 3: klasifikasi token (pelatihan), parse_html=False**

Untuk tugas klasifikasi token (seperti [SWDE](https://paperswithcode.com/dataset/swde), seseorang juga dapat menyediakan label node yang sesuai untuk melatih model. Prosesor kemudian akan mengonversi label tersebut menjadi `labels` pada tingkat token. Secara default, hanya wordpiece pertama dari sebuah kata yang diberi label, sedangkan wordpiece lainnya diberi label -100, yang merupakan `ignore_index` dari CrossEntropyLoss PyTorch. Jika Anda ingin semua wordpiece dari sebuah kata diberi label, Anda dapat menginisialisasi tokenizer dengan `only_label_first_subword` diatur ke `False`.

```python
from transformers import MarkupLMProcessor

processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
node_labels = [1, 2, 2, 1]
encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq', 'labels'])
```

**Kasus penggunaan 4: menjawab pertanyaan halaman web (inferensi), parse_html=True**

Untuk tugas menjawab pertanyaan pada halaman web, Anda dapat memberikan pertanyaan ke prosesor. Secara default, prosesor akan menggunakan ekstraktor fitur untuk mendapatkan semua node dan xpath, serta membuat [CLS] token pertanyaan [SEP] token kata [SEP].

```python
from transformers import MarkupLMProcessor

processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

html_string = """
 <!DOCTYPE html>
 <html>
 <head>
 <title>Hello world</title>
 </head>
 <body>
 <h1>Welcome</h1>
 <p>My name is Niels.</p>
 </body>
 </html>"""

question = "What's his name?"
encoding = processor(html_string, questions=question, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])
```

**Kasus penggunaan 5: menjawab pertanyaan halaman web (inferensi), parse_html=False**

Untuk tugas menjawab pertanyaan (seperti WebSRC), Anda dapat memberikan pertanyaan ke prosesor. Jika Anda telah mengekstrak semua node dan xpath sendiri, Anda dapat memberikannya langsung ke prosesor. Pastikan untuk mengatur `parse_html` ke `False`.

```python
from transformers import MarkupLMProcessor

processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
question = "What's his name?"
encoding = processor(nodes=nodes, xpaths=xpaths, questions=question, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])
```

## Sumber daya

- [Notebook demo](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/MarkupLM)
- [Panduan tugas klasifikasi teks](../tasks/sequence_classification)
- [Panduan tugas klasifikasi token](../tasks/token_classification)
- [Panduan tugas question answering](../tasks/question_answering)

## MarkupLMConfig[[transformers.MarkupLMConfig]]

#### transformers.MarkupLMConfig[[transformers.MarkupLMConfig]]

```python
transformers.MarkupLMConfig(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, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, max_xpath_tag_unit_embeddings: int = 256, max_xpath_subs_unit_embeddings: int = 1024, tag_pad_id: int = 216, subs_pad_id: int = 1001, xpath_unit_hidden_size: int = 32, max_depth: int = 50, use_cache: bool = True, classifier_dropout: float | int | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/configuration_markuplm.py#L24)

**Parameter:**

vocab_size (`int`, *opsional*, defaultnya `30522`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

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

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.

intermediate_size (`int`, *opsional*, defaultnya `3072`) : Dimensi dari representasi MLP.

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

hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.

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

max_position_embeddings (`int`, *opsional*, defaultnya `512`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

type_vocab_size (`int`, *opsional*, defaultnya `2`) : Ukuran kosakata dari `token_type_ids`.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

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

pad_token_id (`int`, *opsional*, defaultnya `0`) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*, defaultnya `0`) : Token id yang digunakan untuk awal-stream dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `2`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

max_xpath_tag_unit_embeddings (`int`, *opsional*, defaultnya 256) : Nilai maksimum yang mungkin digunakan oleh unit embedding tag xpath. Biasanya, atur ini ke nilai yang cukup besar sebagai antisipasi (misalnya, 256).

max_xpath_subs_unit_embeddings (`int`, *opsional*, default 1024) : Nilai maksimum yang mungkin digunakan oleh unit embedding subscript xpath. Biasanya, atur ini ke nilai yang cukup besar sebagai antisipasi (misalnya, 1024).

tag_pad_id (`int`, *opsional*, defaultnya 216) : id dari token padding dalam tag xpath.

subs_pad_id (`int`, *opsional*, default 1001) : id dari token padding dalam subskrip xpath.

xpath_unit_hidden_size (`int`, *opsional*, defaultnya 32) : Ukuran tersembunyi dari setiap unit di xpath.

max_depth (`int`, *opsional*, defaultnya 50) : Kedalaman maksimum dalam xpath.

use_cache (`bool`, *opsional*, defaultnya `True`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder.

classifier_dropout (`Union[float, int]`, *opsional*) : Rasio dropout untuk klasifikator.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi MarkupLMModel. Kelas ini digunakan untuk membuat instans model Markuplm sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi [microsoft/markuplm-base](https://huggingface.co/microsoft/markuplm-base)

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.

Contoh:

```python
>>> from transformers import MarkupLMModel, MarkupLMConfig

>>> # Initializing a MarkupLM microsoft/markuplm-base style configuration
>>> configuration = MarkupLMConfig()

>>> # Initializing a model from the microsoft/markuplm-base style configuration
>>> model = MarkupLMModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MarkupLMFeatureExtractor[[transformers.MarkupLMFeatureExtractor]]

#### transformers.MarkupLMFeatureExtractor[[transformers.MarkupLMFeatureExtractor]]

```python
transformers.MarkupLMFeatureExtractor(**kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/feature_extraction_markuplm.py#L32)

Membangun feature extractor MarkupLM. Hal ini dapat digunakan untuk mendapatkan daftar node dan xpath yang bersesuaian dari string HTML.

Feature extractor ini mewarisi dari `PreTrainedFeatureExtractor()` yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

#### __call__[[transformers.MarkupLMFeatureExtractor.__call__]]

```python
__call__(html_strings)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/feature_extraction_markuplm.py#L98)

**Parameter:**

html_strings (`str`, `list[str]`) : String HTML atau batch string HTML yang akan diekstrak nodanya beserta xpath yang bersesuaian.

**Mengembalikan:** [BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature)

[BatchFeature](/docs/transformers/v5.23.0/id/main_classes/feature_extractor#transformers.BatchFeature) dengan bidang berikut:

- **nodes** -- Node.
- **xpaths** -- xpaths yang sesuai.

Metode utama untuk menyiapkan satu atau beberapa string HTML untuk model.

Contoh:

```python
>>> from transformers import MarkupLMFeatureExtractor

>>> page_name_1 = "page1.html"
>>> page_name_2 = "page2.html"
>>> page_name_3 = "page3.html"

>>> with open(page_name_1) as f:
...     single_html_string = f.read()

>>> feature_extractor = MarkupLMFeatureExtractor()

>>> # single example
>>> encoding = feature_extractor(single_html_string)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])

>>> # batched example

>>> multi_html_strings = []

>>> with open(page_name_2) as f:
...     multi_html_strings.append(f.read())
>>> with open(page_name_3) as f:
...     multi_html_strings.append(f.read())

>>> encoding = feature_extractor(multi_html_strings)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])
```

## MarkupLMTokenizer[[transformers.MarkupLMTokenizer]]

#### transformers.MarkupLMTokenizer[[transformers.MarkupLMTokenizer]]

```python
transformers.MarkupLMTokenizer(tags_dict, vocab: str | dict[str, int] | list[tuple[str, float]] | None = None, merges: str | list[str] | None = None, errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = False, max_depth = 50, max_width = 1000, pad_width = 1001, pad_token_label = -100, only_label_first_subword = True, trim_offsets = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L91)

**Parameter:**

vocab (`str` atau `dict[str, int]`, *opsional*) : Kamus kosakata kustom. Jika tidak disediakan, kosakata dimuat dari `vocab_file`.

merges (`str` atau `list[str]`, *opsional*) : Daftar merges kustom. Jika tidak disediakan, merges dimuat dari `merges_file`.

errors (`str`, *opsional*, defaultnya `"replace"`) : Paradigma yang diikuti saat mendekode byte menjadi UTF-8. Lihat [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) untuk informasi lebih lanjut.

bos_token (`str`, *opsional*, defaultnya `"<s>"`) : Token awal urutan yang digunakan selama pra-pelatihan. Dapat digunakan sebagai token klasifikator urutan. Saat membangun urutan menggunakan token khusus, ini bukan token yang digunakan untuk awal urutan. Token yang digunakan adalah `cls_token`.

eos_token (`str`, *opsional*, defaultnya `"</s>"`) : Token akhir urutan. Saat membangun urutan menggunakan token khusus, ini bukan token yang digunakan untuk akhir urutan. Token yang digunakan adalah `sep_token`.

sep_token (`str`, *opsional*, defaultnya `"</s>"`) : Token pemisah, yang digunakan saat membangun urutan dari beberapa urutan, misalnya dua urutan untuk klasifikasi urutan atau untuk teks dan pertanyaan untuk penjawaban pertanyaan. Token ini juga digunakan sebagai token terakhir dari urutan yang dibangun dengan token khusus.

cls_token (`str`, *opsional*, defaultnya `"<s>"`) : Token klasifikator yang digunakan saat melakukan klasifikasi urutan (klasifikasi seluruh urutan, bukan klasifikasi per-token). Ini adalah token pertama dari urutan saat dibangun dengan token khusus.

unk_token (`str`, *opsional*, defaultnya `"<unk>"`) : Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini.

pad_token (`str`, *opsional*, defaultnya `"<pad>"`) : Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda.

mask_token (`str`, *opsional*, defaultnya `"<mask>"`) : Token yang digunakan untuk memask nilai. Ini adalah token yang digunakan saat melatih model ini dengan pemodelan bahasa ter-mask. Ini adalah token yang akan coba diprediksi oleh model.

add_prefix_space (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan spasi awal ke input. Hal ini memungkinkan kata pembuka diperlakukan sama seperti kata lainnya. (Tokenizer RoBERTa mendeteksi awal kata berdasarkan spasi sebelumnya).

Konstruksi tokenizer MarkupLM. Berbasis byte-level Byte-Pair-Encoding (BPE).

[MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) dapat digunakan untuk mengubah string HTML menjadi `input_ids`, `attention_mask`, `token_type_ids`, `xpath_tags_seq`, dan `xpath_tags_seq` pada level token. Tokenizer ini mewarisi dari [TokenizersBackend](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend) yang berisi sebagian besar metode utama dan memastikan bahwa backend `tokenizers` selalu diinstansiasi.

Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

#### build_inputs_with_special_tokens[[transformers.MarkupLMTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L952)

**Parameter:**

token_ids_0 (`list[int]`) : Daftar ID tempat token khusus akan ditambahkan.

token_ids_1 (`list[int]`, *opsional*) : Daftar ID kedua opsional untuk pasangan sekuens.

**Mengembalikan:** `list[int]`

Daftar [ID input](../glossary#input-ids) dengan token khusus yang sesuai.

Bangun input model dari satu urutan atau sepasang urutan untuk tugas klasifikasi urutan dengan menggabungkan dan menambahkan token khusus. Urutan RoBERTa memiliki format berikut:
- satu urutan: `<s> X </s>`
- pasangan sekuens: `<s> A </s></s> B </s>`

#### get_special_tokens_mask[[transformers.MarkupLMTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1337)

**Parameter:**

token_ids_0 : Daftar ID untuk sekuens (yang mungkin sudah diformat).

token_ids_1 : Tidak digunakan ketika `already_has_special_tokens=True`. Harus None dalam kasus tersebut.

already_has_special_tokens : Apakah urutan sudah diformat dengan token khusus.

**Mengembalikan:** Daftar bilangan bulat dalam rentang [0, 1]

1 untuk token khusus, 0 untuk token urutan.

Ambil id urutan dari daftar token yang tidak memiliki token khusus yang ditambahkan.

Untuk tokenizer yang cepat, data collator memanggil ini dengan `already_has_special_tokens=True` untuk membangun mask di atas urutan yang sudah diformat. Dalam kasus tersebut, kami menghitung mask dengan memeriksa keanggotaan dalam `all_special_ids`.

#### create_token_type_ids_from_sequences[[transformers.MarkupLMTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L975)

**Parameter:**

token_ids_0 (`list[int]`) : Daftar ID.

token_ids_1 (`list[int]`, *opsional*) : Daftar ID kedua opsional untuk pasangan sekuens.

**Mengembalikan:** `list[int]`

Daftar nol.

Buat mask dari dua urutan yang diteruskan untuk digunakan dalam tugas klasifikasi pasangan urutan. RoBERTa tidak menggunakan id tipe token, oleh karena itu daftar nol dikembalikan.

#### save_vocabulary[[transformers.MarkupLMTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L997)

## MarkupLMTokenizerFast[[transformers.MarkupLMTokenizer]]

#### transformers.MarkupLMTokenizer[[transformers.MarkupLMTokenizer]]

```python
transformers.MarkupLMTokenizer(tags_dict, vocab: str | dict[str, int] | list[tuple[str, float]] | None = None, merges: str | list[str] | None = None, errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = False, max_depth = 50, max_width = 1000, pad_width = 1001, pad_token_label = -100, only_label_first_subword = True, trim_offsets = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L91)

**Parameter:**

vocab (`str` atau `dict[str, int]`, *opsional*) : Kamus kosakata kustom. Jika tidak disediakan, kosakata dimuat dari `vocab_file`.

merges (`str` atau `list[str]`, *opsional*) : Daftar merges kustom. Jika tidak disediakan, merges dimuat dari `merges_file`.

errors (`str`, *opsional*, defaultnya `"replace"`) : Paradigma yang diikuti saat mendekode byte menjadi UTF-8. Lihat [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) untuk informasi lebih lanjut.

bos_token (`str`, *opsional*, defaultnya `"<s>"`) : Token awal urutan yang digunakan selama pra-pelatihan. Dapat digunakan sebagai token klasifikator urutan. Saat membangun urutan menggunakan token khusus, ini bukan token yang digunakan untuk awal urutan. Token yang digunakan adalah `cls_token`.

eos_token (`str`, *opsional*, defaultnya `"</s>"`) : Token akhir urutan. Saat membangun urutan menggunakan token khusus, ini bukan token yang digunakan untuk akhir urutan. Token yang digunakan adalah `sep_token`.

sep_token (`str`, *opsional*, defaultnya `"</s>"`) : Token pemisah, yang digunakan saat membangun urutan dari beberapa urutan, misalnya dua urutan untuk klasifikasi urutan atau untuk teks dan pertanyaan untuk penjawaban pertanyaan. Token ini juga digunakan sebagai token terakhir dari urutan yang dibangun dengan token khusus.

cls_token (`str`, *opsional*, defaultnya `"<s>"`) : Token klasifikator yang digunakan saat melakukan klasifikasi urutan (klasifikasi seluruh urutan, bukan klasifikasi per-token). Ini adalah token pertama dari urutan saat dibangun dengan token khusus.

unk_token (`str`, *opsional*, defaultnya `"<unk>"`) : Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini.

pad_token (`str`, *opsional*, defaultnya `"<pad>"`) : Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda.

mask_token (`str`, *opsional*, defaultnya `"<mask>"`) : Token yang digunakan untuk memask nilai. Ini adalah token yang digunakan saat melatih model ini dengan pemodelan bahasa ter-mask. Ini adalah token yang akan coba diprediksi oleh model.

add_prefix_space (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan spasi awal ke input. Hal ini memungkinkan kata pembuka diperlakukan sama seperti kata lainnya. (Tokenizer RoBERTa mendeteksi awal kata berdasarkan spasi sebelumnya).

Konstruksi tokenizer MarkupLM. Berbasis byte-level Byte-Pair-Encoding (BPE).

[MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) dapat digunakan untuk mengubah string HTML menjadi `input_ids`, `attention_mask`, `token_type_ids`, `xpath_tags_seq`, dan `xpath_tags_seq` pada level token. Tokenizer ini mewarisi dari [TokenizersBackend](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend) yang berisi sebagian besar metode utama dan memastikan bahwa backend `tokenizers` selalu diinstansiasi.

Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

#### batch_encode_plus[[transformers.MarkupLMTokenizer.batch_encode_plus]]

```python
batch_encode_plus(batch_text_or_text_pairs: list[str] | list[tuple[str, str]] | list[list[str]], is_pair: bool | None = None, xpaths: list[list[list[int]]] | None = None, node_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L453)

add_special_tokens (`bool`, *opsional*, defaultnya `True`): Menentukan apakah token khusus akan ditambahkan saat mengkodekan urutan. Ini akan menggunakan fungsi `PretrainedTokenizerBase.build_inputs_with_special_tokens` yang mendasarinya, yang mendefinisikan token mana yang secara otomatis ditambahkan ke id input. Ini berguna jika Anda ingin menambahkan token `bos` atau `eos` secara otomatis. padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`): Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:

- `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
- `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
- `False` atau `'do_not_pad'` (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`): Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:

- `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.
- `'only_first'`: Potong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- `'only_second'`: Potong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
max_length (`int`, *opsional*): Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding.

Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang predefined jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan. stride (`int`, *opsional*, default 0): Jika disetel ke sebuah angka bersama dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan berisi beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih. is_split_into_words (`bool`, *opsional*, default `False`): Apakah input sudah di-pre-tokenize (misalnya, dipecah menjadi kata). Jika disetel ke `True`, tokenizer mengasumsikan input sudah dipecah menjadi kata (misalnya, dengan memecahnya pada spasi) yang akan ditokenize. Ini berguna untuk NER atau klasifikasi token. pad_to_multiple_of (`int`, *opsional*): Jika disetel, akan mem-padded urutan ke kelipatan dari nilai yang diberikan. Memerlukan `padding` untuk diaktifkan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta). padding_side (`str`, *opsional*): Sisi di mana model harus memiliki padding diterapkan. Harus dipilih antara ['right', 'left']. Nilai default dipilih dari atribut kelas dengan nama yang sama. return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*): Jika disetel, akan mengembalikan tensor alih-alih daftar integer python. Nilai yang dapat diterima adalah:

- `'pt'`: Mengembalikan objek PyTorch `torch.Tensor`.
- `'np'`: Mengembalikan objek Numpy `np.ndarray`.

add_special_tokens (`bool`, *opsional*, defaultnya `True`): Apakah akan mengkodekan sekuens dengan token khusus relatif terhadap modelnya. padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`): Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:

- `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
- `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
- `False` atau `'do_not_pad'` (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`): Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:

- `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.
- `'only_first'`: Potong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- `'only_second'`: Potong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
- `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
max_length (`int`, *opsional*): Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan. stride (`int`, *opsional*, default 0): Jika disetel ke sebuah angka bersama dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan berisi beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih. is_split_into_words (`bool`, *opsional*, default `False`): Apakah input sudah dipretokenisasi (misalnya dipecah menjadi kata). Setel ini ke `True` jika Anda melewatkan input yang sudah dipretokenisasi untuk menghindari tokenisasi tambahan. pad_to_multiple_of (`int`, *opsional*): Jika disetel, akan melakukan padding urutan ke kelipatan dari nilai yang diberikan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi `>= 7.5` (Volta). return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*): Jika disetel, akan mengembalikan tensor alih-alih daftar integer python. Nilai yang dapat diterima adalah:

- `'pt'`: Mengembalikan objek PyTorch `torch.Tensor`.
- `'np'`: Mengembalikan objek Numpy `np.ndarray`.

#### build_inputs_with_special_tokens[[transformers.MarkupLMTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L952)

**Parameter:**

token_ids_0 (`list[int]`) : Daftar ID tempat token khusus akan ditambahkan.

token_ids_1 (`list[int]`, *opsional*) : Daftar ID kedua opsional untuk pasangan sekuens.

**Mengembalikan:** `list[int]`

Daftar [ID input](../glossary#input-ids) dengan token khusus yang sesuai.

Bangun input model dari satu urutan atau sepasang urutan untuk tugas klasifikasi urutan dengan menggabungkan dan menambahkan token khusus. Urutan RoBERTa memiliki format berikut:
- satu urutan: `<s> X </s>`
- pasangan sekuens: `<s> A </s></s> B </s>`

#### create_token_type_ids_from_sequences[[transformers.MarkupLMTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L975)

**Parameter:**

token_ids_0 (`list[int]`) : Daftar ID.

token_ids_1 (`list[int]`, *opsional*) : Daftar ID kedua opsional untuk pasangan sekuens.

**Mengembalikan:** `list[int]`

Daftar nol.

Buat mask dari dua urutan yang diteruskan untuk digunakan dalam tugas klasifikasi pasangan urutan. RoBERTa tidak menggunakan id tipe token, oleh karena itu daftar nol dikembalikan.

#### encode_plus[[transformers.MarkupLMTokenizer.encode_plus]]

```python
encode_plus(text: str | list[str], text_pair: list[str] | None = None, xpaths: list[list[int]] | None = None, node_labels: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L518)

**Parameter:**

text (`str`, `list[str]`, `list[list[str]]`) : Urutan pertama yang akan dikodekan. Ini bisa berupa string, daftar string, atau daftar dari daftar string.

text_pair (`list[str]` atau `list[int]`, *opsional*) : Urutan kedua opsional untuk dienkod. Ini bisa berupa daftar string (kata-kata dari satu contoh) atau daftar dari daftar string (kata-kata dari batch contoh).

add_special_tokens (`bool`, *opsional*, default `True`) : Menentukan apakah token khusus akan ditambahkan saat meng-encode urutan. Hal ini akan menggunakan fungsi `PretrainedTokenizerBase.build_inputs_with_special_tokens` yang mendasarinya, yang mendefinisikan token apa saja yang secara otomatis ditambahkan ke input ids. Ini berguna jika Anda ingin menambahkan token `bos` atau `eos` secara otomatis.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

stride (`int`, *opsional*, default 0) : Jika diatur ke sebuah angka bersamaan dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan memuat beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.

is_split_into_words (`bool`, *opsional*, default `False`) : Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata-kata). Jika disetel ke `True`, tokenizer mengasumsikan input sudah dipecah menjadi kata-kata (misalnya, dengan memisahkannya berdasarkan spasi) yang kemudian akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, sekuens akan di-*pad* menjadi kelipatan dari nilai yang diberikan. Memerlukan `padding` untuk diaktifkan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta).

padding_side (`str`, *opsional*) : Sisi tempat model harus menerapkan padding. Harus dipilih dari ['right', 'left']. Nilai default diambil dari atribut kelas dengan nama yang sama.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor alih-alih daftar bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

add_special_tokens (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengkodekan sekuens dengan token khusus yang relatif terhadap modelnya.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (`bool`, `str` atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsional*, default `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang melebihi ukuran input maksimum yang diizinkan oleh model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

stride (`int`, *opsional*, default 0) : Jika diatur ke sebuah angka bersamaan dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan memuat beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.

is_split_into_words (`bool`, *opsional*, defaultnya `False`) : Apakah input sudah dipretokenisasi (misalnya dipecah menjadi kata). Atur ini ke `True` jika Anda melewatkan input yang sudah dipretokenisasi untuk menghindari tokenisasi tambahan.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, akan melakukan padding pada urutan hingga menjadi kelipatan dari nilai yang diberikan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi `>= 7.5` (Volta).

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor alih-alih daftar bilangan bulat python. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` Numpy.

Menerapkan tokenisasi dan menyiapkan satu atau sepasang sekuens untuk model. .. warning:: Metode ini tidak lagi didukung, gunakan `__call__` sebagai gantinya.

#### get_xpath_seq[[transformers.MarkupLMTokenizer.get_xpath_seq]]

```python
get_xpath_seq(xpath)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/tokenization_markuplm.py#L253)

Diberikan ekspresi xpath dari satu node tertentu (seperti "/html/body/div/li[1]/div/span[2]"), kembalikan daftar ID tag dan subskrip yang sesuai, dengan mempertimbangkan kedalaman maksimum.

## MarkupLMProcessor[[transformers.MarkupLMProcessor]]

#### transformers.MarkupLMProcessor[[transformers.MarkupLMProcessor]]

```python
transformers.MarkupLMProcessor(feature_extractor, tokenizer)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/processing_markuplm.py#L25)

**Parameter:**

feature_extractor (`feature_extractor_class`) : Feature extractor adalah input yang wajib.

tokenizer (`MarkupLMTokenizer`) : Tokenizer adalah input yang wajib.

Membangun MarkupLMProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[MarkupLMProcessor](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMProcessor) menyediakan semua fungsionalitas dari `feature_extractor_class` dan [MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer). Lihat `~feature_extractor_class` dan [~MarkupLMTokenizer](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMTokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.MarkupLMProcessor.__call__]]

```python
__call__(html_strings = None, nodes = None, xpaths = None, node_labels = None, questions = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/processing_markuplm.py#L31)

**Parameter:**

html_strings (`str` atau `list[str]`, *opsional*) : String HTML mentah untuk diurai dan diproses. Ketika `parse_html=True` (default), string-string ini diurai untuk mengekstrak node dan xpath secara otomatis. Jika diberikan, `nodes`, `xpaths`, dan `node_labels` tidak boleh diberikan. Wajib diisi ketika `parse_html=True`.

nodes (`list[list[str]]`, *opsional*) : Node HTML yang sudah diekstrak sebelumnya sebagai daftar dari daftar, di mana setiap daftar dalam berisi konten teks dari node untuk satu dokumen. Wajib diisi ketika `parse_html=False`. Tidak boleh diberikan ketika `parse_html=True`.

xpaths (`list[list[str]]`, *opsional*) : Ekspresi XPath yang sudah diekstrak sebelumnya dan sesuai dengan node. Harus berupa daftar dari daftar dengan struktur yang sama seperti `nodes`, di mana setiap XPath mengidentifikasi lokasi node yang sesuai dalam pohon HTML. Wajib diisi ketika `parse_html=False`. Tidak boleh diberikan ketika `parse_html=True`.

node_labels (`list[list[int]]`, *opsional*) : Label untuk node, biasanya digunakan untuk tugas pelatihan atau fine-tuning. Harus berupa daftar dari daftar dengan struktur yang sama seperti `nodes`, di mana setiap label sesuai dengan satu node. Opsional dan hanya digunakan ketika `parse_html=False`.

questions (`str` atau `list[str]`, *opsional*) : String pertanyaan untuk tugas question-answering. Jika diberikan, tokenizer memproses pertanyaan sebagai urutan pertama dan node sebagai urutan kedua (text_pair). Jika satu string diberikan, string tersebut dikonversi menjadi list agar sesuai dengan dimensi batch dari HTML yang di-parse.

add_special_tokens (`bool`, *opsional*, default `True`) : Menentukan apakah token khusus akan ditambahkan saat meng-encode urutan. Hal ini akan menggunakan fungsi `PretrainedTokenizerBase.build_inputs_with_special_tokens` yang mendasarinya, yang mendefinisikan token apa saja yang secara otomatis ditambahkan ke input ids. Ini berguna jika Anda ingin menambahkan token `bos` atau `eos` secara otomatis.

padding (bool, str atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:  - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

truncation (bool, str atau [TruncationStrategy](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *optional*) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:  - `True` atau `'longest_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_first'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `'only_second'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari pasangan jika sepasang urutan (atau batch pasangan) diberikan. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang urutan yang lebih besar dari ukuran input maksimum yang diizinkan model).

max_length (`int`, *opsional*) : Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke `None`, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

stride (`int`, *opsional*, defaultnya `0`) : Jika diatur ke angka bersama dengan `max_length`, token yang meluap yang dikembalikan saat `return_overflowing_tokens=True` akan berisi beberapa token dari akhir urutan terpotong yang dikembalikan untuk menyediakan beberapa tumpang tindih antara urutan terpotong dan urutan yang meluap. Nilai argumen ini menentukan jumlah token yang tumpang tindih.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, urutan akan di-*pad* menjadi kelipatan dari nilai yang diberikan. Memerlukan `padding` untuk diaktifkan. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi `>= 7.5` (Volta).

return_token_type_ids (`bool`, *opsional*) : Apakah akan mengembalikan token type ID. Jika dibiarkan pada nilai default, akan mengembalikan token type ID sesuai default tokenizer tertentu, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu token type ID?](../glossary#token-type-ids)

return_attention_mask (`bool`, *opsional*) : Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, attention mask akan dikembalikan sesuai dengan default tokenizer yang bersangkutan, yang didefinisikan oleh atribut `return_outputs`.  [Apa itu attention mask?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan urutan token yang meluap. Jika sepasang urutan id input (atau batch dari pasangan) diberikan dengan `truncation_strategy = longest_first` atau `True`, error akan dilemparkan alih-alih mengembalikan token yang meluap.

return_special_tokens_mask (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan informasi mask token khusus.

return_offsets_mapping (`bool`, *opsional*, default `False`) : Apakah akan mengembalikan `(char_start, char_end)` untuk setiap token. Ini hanya tersedia pada fast tokenizer yang mewarisi dari [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend); jika menggunakan tokenizer Python, metode ini akan melempar `NotImplementedError`.

return_length (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan panjang dari input yang dikodekan.

verbose (`bool`, *opsional*, default `True`) : Apakah akan mencetak informasi dan peringatan yang lebih banyak.

return_tensors (`Union[str, ~utils.generic.TensorType]`, *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek PyTorch `torch.Tensor`. - `'np'`: Mengembalikan objek NumPy `np.ndarray`.

**Mengembalikan:** `~tokenization_utils_base.BatchEncoding`

- **data** (`dict`, *opsional*) -- Kamus berisi daftar/array/tensor yang dikembalikan oleh metode `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', dll.).
- **encoding** (`tokenizers.Encoding` atau `Sequence[tokenizers.Encoding]`, *opsional*) -- Jika tokenizer adalah fast tokenizer yang mengoutputkan informasi tambahan seperti pemetaan dari ruang kata/karakter ke ruang token, instance `tokenizers.Encoding` atau daftar instance (untuk batch) menyimpan informasi ini.
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
- **prepend_batch_axis** (`bool`, *opsional*, default `False`) -- Apakah akan menambahkan sumbu batch saat mengonversi ke tensor (lihat `tensor_type` di atas). Perhatikan bahwa parameter ini berpengaruh jika parameter `tensor_type` disetel, *tidak berpengaruh jika tidak*.
- **n_sequences** (`int`, *opsional*) -- Jumlah urutan input yang direpresentasikan oleh setiap encoding (`None` untuk tidak diketahui, `1` untuk satu urutan, dan `2` untuk sepasang urutan).

## MarkupLMModel[[transformers.MarkupLMModel]]

#### transformers.MarkupLMModel[[transformers.MarkupLMModel]]

```python
transformers.MarkupLMModel(config: MarkupLMConfig, add_pooling_layer = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L497)

**Parameter:**

config ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) : 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.

add_pooling_layer (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan lapisan pooling

Model Markuplm polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

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.MarkupLMModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, xpath_tags_seq: typing.Optional[torch.LongTensor] = None, xpath_subs_seq: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L521)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

xpath_tags_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID tag untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

xpath_subs_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID subskrip untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

**Mengembalikan:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) dan input.

Metode forward dari [MarkupLMModel](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMModel) 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.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **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.

Contoh:

```python
>>> from transformers import AutoProcessor, MarkupLMModel

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = MarkupLMModel.from_pretrained("microsoft/markuplm-base")

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"

>>> encoding = processor(html_string, return_tensors="pt")

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 4, 768]
```

## MarkupLMForSequenceClassification[[transformers.MarkupLMForSequenceClassification]]

#### transformers.MarkupLMForSequenceClassification[[transformers.MarkupLMForSequenceClassification]]

```python
transformers.MarkupLMForSequenceClassification(config: MarkupLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L802)

**Parameter:**

config ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) : 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.

MarkupLM Model transformer dengan kepala klasifikasi/regresi urutan di atasnya (lapisan linear di atas output yang dipool) misalnya untuk tugas GLUE.

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.MarkupLMForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, xpath_tags_seq: typing.Optional[torch.Tensor] = None, xpath_subs_seq: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L819)

**Parameter:**

input_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

xpath_tags_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID tag untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

xpath_subs_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID subskrip untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`. Jika `config.num_labels == 1`, loss regresi dihitung (Mean-Square loss). Jika `config.num_labels > 1`, loss klasifikasi dihitung (Cross-Entropy).

**Mengembalikan:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau `tuple(torch.Tensor)`

[SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) dan input.

Metode forward dari [MarkupLMForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMForSequenceClassification) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **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.

Contoh:

```python
>>> from transformers import AutoProcessor, AutoModelForSequenceClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"
>>> encoding = processor(html_string, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits
```

## MarkupLMForTokenClassification[[transformers.MarkupLMForTokenClassification]]

#### transformers.MarkupLMForTokenClassification[[transformers.MarkupLMForTokenClassification]]

```python
transformers.MarkupLMForTokenClassification(config: MarkupLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L709)

**Parameter:**

config ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) : 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 MarkupLM dengan head `token_classification` di atasnya.

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.MarkupLMForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, xpath_tags_seq: typing.Optional[torch.Tensor] = None, xpath_subs_seq: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L725)

**Parameter:**

input_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

xpath_tags_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID tag untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

xpath_subs_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID subskrip untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian klasifikasi token. Indeks harus berada dalam `[0, ..., config.num_labels - 1]`.

**Mengembalikan:** [MaskedLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) atau `tuple(torch.Tensor)`

[MaskedLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) dan input.

Metode forward dari [MarkupLMForTokenClassification](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMForTokenClassification) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` diberikan) -- Masked language modeling (MLM) loss.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **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.

Contoh:

```python
>>> from transformers import AutoProcessor, AutoModelForTokenClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False
>>> model = AutoModelForTokenClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> nodes = ["hello", "world"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span"]
>>> node_labels = [1, 2]
>>> encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits
```

## MarkupLMForQuestionAnswering[[transformers.MarkupLMForQuestionAnswering]]

#### transformers.MarkupLMForQuestionAnswering[[transformers.MarkupLMForQuestionAnswering]]

```python
transformers.MarkupLMForQuestionAnswering(config: MarkupLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L603)

**Parameter:**

config ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) : 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.

Transformer Markuplm dengan kepala klasifikasi span di atasnya untuk tugas question-answering ekstraktif seperti SQuAD (lapisan linear di atas output hidden-states untuk menghitung `span start logits` dan `span end logits`).

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.MarkupLMForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, xpath_tags_seq: typing.Optional[torch.Tensor] = None, xpath_subs_seq: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/markuplm/modeling_markuplm.py#L615)

**Parameter:**

input_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

xpath_tags_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID tag untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

xpath_subs_seq (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length, config.max_depth)`, *opsional*) : ID subskrip untuk setiap token dalam urutan input, di-pad hingga config.max_depth.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token segmen untuk menunjukkan bagian pertama dan kedua dari input. Indeks dipilih dalam `[0, 1]`:  - 0 sesuai dengan token *sentence A*, - 1 sesuai dengan token *sentence B*.  [Apa itu token type IDs?](../glossary#token-type-ids)

position_ids (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

start_positions (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk posisi (indeks) awal span berlabel untuk menghitung kerugian klasifikasi token. Posisi dibatasi pada panjang sekuens (`sequence_length`). Posisi di luar sekuens tidak diperhitungkan dalam perhitungan kerugian.

end_positions (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk posisi (indeks) akhir span berlabel untuk menghitung kerugian klasifikasi token. Posisi di-clamp ke panjang sekuens (`sequence_length`). Posisi di luar sekuens tidak diperhitungkan dalam perhitungan kerugian.

**Mengembalikan:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) atau `tuple(torch.Tensor)`

[QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MarkupLMConfig](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMConfig)) dan input.

Metode forward dari [MarkupLMForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/markuplm#transformers.MarkupLMForQuestionAnswering) 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.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Total span extraction loss adalah jumlah dari Cross-Entropy untuk posisi awal dan akhir.
- **start_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor awal span (sebelum SoftMax).
- **end_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor akhir span (sebelum SoftMax).
- **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.

Contoh:

```python
>>> from transformers import AutoProcessor, MarkupLMForQuestionAnswering
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base-finetuned-websrc")
>>> model = MarkupLMForQuestionAnswering.from_pretrained("microsoft/markuplm-base-finetuned-websrc")

>>> html_string = "<html> <head> <title>My name is Niels</title> </head> </html>"
>>> question = "What's his name?"

>>> encoding = processor(html_string, questions=question, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = encoding.input_ids[0, answer_start_index : answer_end_index + 1]
>>> processor.decode(predict_answer_tokens).strip()
'Niels'
```

