# Utilitas untuk tokenizer

Halaman ini mencantumkan semua fungsi utilitas yang digunakan oleh tokenizer, terutama kelas [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) yang mengimplementasikan metode umum antara [PreTrainedTokenizer](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.PythonBackend) dan [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend).

Sebagian besar dari itu hanya berguna jika Anda sedang mempelajari kode tokenizer di pustaka tersebut.

## PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

#### transformers.PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

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

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

**Parameter:**

model_max_length (`int`, *opsional*) : Panjang maksimum (dalam jumlah token) untuk input ke model transformer. Ketika tokenizer dimuat dengan [from_pretrained()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), nilai ini akan diset ke nilai yang disimpan untuk model terkait di `max_model_input_sizes` (lihat di atas). Jika tidak ada nilai yang diberikan, nilai default akan menjadi VERY_LARGE_INTEGER (`int(1e30)`).

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.

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

chat_template (`str`, *opsional*) : String template Jinja yang akan digunakan untuk memformat daftar pesan chat. Lihat https://huggingface.co/docs/transformers/chat_templating untuk deskripsi lengkap.

model_input_names (`list[string]`, *opsional*) : Daftar input yang diterima oleh forward pass model (seperti `"token_type_ids"` atau `"attention_mask"`). Nilai default diambil dari atribut kelas dengan nama yang sama.

bos_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang mewakili awal dari sebuah kalimat.

eos_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang mewakili akhir dari sebuah kalimat.

unk_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang mewakili token di luar kosakata (out-of-vocabulary).

sep_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang memisahkan dua kalimat berbeda dalam input yang sama (dipakai, misalnya, oleh BERT).

pad_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang digunakan untuk membuat array token berukuran sama untuk keperluan batching. Token ini kemudian akan diabaikan oleh mekanisme perhatian atau perhitungan loss.

cls_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang mewakili kelas dari input (dipakai, misalnya, oleh BERT).

mask_token (`str` atau `tokenizers.AddedToken`, *opsional*) : Token khusus yang mewakili token ter-mask (digunakan oleh tujuan pra-pelatihan pemodelan bahasa ter-mask, seperti BERT). Akan diasosiasikan dengan `self.mask_token` dan `self.mask_token_id`.

extra_special_tokens (daftar `str` atau `tokenizers.AddedToken`, *opsional*) : Daftar token khusus tambahan yang spesifik untuk model. Tambahkan di sini untuk memastikan token-token tersebut dilewati saat decoding dengan `skip_special_tokens` yang diset ke True. Jika token-token tersebut tidak termasuk dalam kosakata, mereka akan ditambahkan di akhir kosakata.

split_special_tokens (`bool`, *opsional*, defaultnya `False`) : Apakah token khusus harus dipecah selama proses tokenisasi. Mengalihkan nilai akan memengaruhi status internal tokenizer. Perilaku default adalah tidak memecah token khusus. Ini berarti jika `<s>` adalah `bos_token`, maka `tokenizer.tokenize("<s>") = ['<s>`]. Sebaliknya, jika `split_special_tokens=True`, maka `tokenizer.tokenize("<s>")` akan menghasilkan `['<','s', '>']`.

Kelas dasar untuk semua backend tokenizer.

Atribut kelas (ditimpa oleh kelas turunan)

- **vocab_files_names** (`dict[str, str]`) -- Kamus yang menggunakan nama kata kunci `__init__` dari setiap file kosakata yang diperlukan oleh model sebagai kunci, dan nama file untuk menyimpan file terkait (string) sebagai nilai yang terkait.
- **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Kamus dari kamus, dengan kunci tingkat atas berupa nama kata kunci `__init__` dari setiap file kosakata yang diperlukan oleh model, dan kunci tingkat bawah berupa `short-cut-names` dari model pretrained, dengan nilai terkait berupa `url` ke file kosakata pretrained yang terkait.
- **model_input_names** (`list[str]`) -- Daftar input yang diharapkan pada forward pass model.
- **padding_side** (`str`) -- Nilai default untuk sisi tempat model harus menerapkan padding. Harus berupa `'right'` atau `'left'`.
- **truncation_side** (`str`) -- Nilai default untuk sisi tempat model harus menerapkan pemotongan. Harus berupa `'right'` atau `'left'`.

#### __call__[[transformers.PreTrainedTokenizerBase.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | 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, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**Parameter:**

text (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *opsional*) : Urutan atau batch dari urutan yang akan dikodekan sebagai teks target. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika urutan diberikan sebagai daftar string (pretokenized), Anda harus mengatur `is_split_into_words=True` (untuk menghilangkan ambiguitas dengan batch dari urutan).

tokenizer_kwargs (`dict[str, Any]`, *opsional*) : kwargs tambahan untuk diteruskan ke tokenizer. Nilai-nilai ini akan digabungkan dengan parameter eksplisit dan kwargs lainnya, dengan parameter eksplisit memiliki prioritas lebih tinggi.

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.

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*, default `False`) : Apakah akan mengembalikan panjang dari input yang dikodekan.

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

- ****kwargs** : diteruskan ke metode `self.tokenize()`

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

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

- **input_ids** -- Daftar id token yang akan diberikan ke model.

  [Apa itu input ID?](../glossary#input-ids)

- **token_type_ids** -- Daftar token type id yang akan diberikan ke model (ketika `return_token_type_ids=True` atau jika *"token_type_ids"* ada di `self.model_input_names`).

  [Apa itu token type ID?](../glossary#token-type-ids)

- **attention_mask** -- Daftar indeks yang menentukan token mana yang harus diperhatikan oleh model (ketika `return_attention_mask=True` atau jika *"attention_mask"* ada di `self.model_input_names`).

  [Apa itu attention mask?](../glossary#attention-mask)

- **overflowing_tokens** -- Daftar sekuens token yang meluap (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Jumlah token yang dipangkas (ketika `max_length` ditentukan dan `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Daftar angka 0 dan 1, di mana 1 menandakan token khusus yang ditambahkan dan 0 menandakan token urutan reguler (ketika `add_special_tokens=True` dan `return_special_tokens_mask=True`).
- **length** -- Panjang dari input (ketika `return_length=True`)

Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa urutan, atau satu atau beberapa pasangan urutan, untuk model.

#### add_special_tokens[[transformers.PreTrainedTokenizerBase.add_special_tokens]]

```python
add_special_tokens(special_tokens_dict: dict[str, str | AddedToken | Sequence[str | AddedToken]], replace_extra_special_tokens = True)
```

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

**Parameter:**

special_tokens_dict (dictionary *str* ke *str*, `tokenizers.AddedToken`, atau `Sequence[Union[str, AddedToken]]`) : Kunci harus berada dalam daftar atribut khusus yang sudah ditentukan: [`bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`]. Token hanya ditambahkan jika belum ada dalam kosakata (diuji dengan memeriksa apakah tokenizer memberikan indeks `unk_token` kepada token tersebut).

replace_extra_special_tokens (`bool`, *opsional*, default `True`) : Jika `True`, daftar token khusus tambahan yang ada akan diganti oleh daftar yang diberikan dalam `special_tokens_dict`. Sebaliknya, `extra_special_tokens` akan diperluas. Dalam kasus pertama, token tersebut TIDAK akan dihapus dari kosakata lengkap tokenizer - mereka hanya ditandai sebagai token non-khusus. Ingat, ini hanya memengaruhi token mana yang dilewati selama decoding, bukan `added_tokens_encoder` dan `added_tokens_decoder`. Ini berarti bahwa `extra_special_tokens` sebelumnya masih merupakan token yang ditambahkan, dan tidak akan dipecah oleh model.

**Mengembalikan:** `int`

Jumlah token yang ditambahkan ke dalam kosakata.

Tambahkan kamus token khusus (eos, pad, cls, dll.) ke encoder dan hubungkan ke atribut kelas. Jika token khusus TIDAK ada dalam kosakata, token tersebut akan ditambahkan ke kosakata (diindeks mulai dari indeks terakhir kosakata saat ini).

Saat menambahkan token baru ke dalam kosakata, Anda harus memastikan untuk juga mengubah ukuran matriks embedding token dari model agar matriks embedding-nya sesuai dengan tokenizer.

Untuk melakukan hal tersebut, silakan gunakan metode [resize_token_embeddings()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings).

Menggunakan `add_special_tokens` akan memastikan token khusus Anda dapat digunakan dalam beberapa cara:

- Token khusus dapat dilewati saat decoding menggunakan `skip_special_tokens = True`.
- Token khusus ditangani dengan cermat oleh tokenizer (tidak pernah dipecah), mirip dengan `AddedTokens`.
- Anda dapat dengan mudah merujuk ke token khusus menggunakan atribut kelas tokenizer seperti `tokenizer.cls_token`. Hal ini memudahkan pengembangan skrip pelatihan dan fine-tuning yang tidak bergantung pada model tertentu.

Jika memungkinkan, token khusus sudah didaftarkan untuk model pretrained yang disediakan (misalnya [BertTokenizer](/docs/transformers/v5.23.0/id/model_doc/lxmert#transformers.BertTokenizer) `cls_token` sudah didaftarkan sebagai `'[CLS]'` dan untuk XLM juga sudah didaftarkan sebagai `'</s>'`).

Contoh:

```python
# Let's see how to add a new classification token to GPT-2
tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2Model.from_pretrained("openai-community/gpt2")

special_tokens_dict = {"cls_token": "<CLS>"}

num_added_toks = tokenizer.add_special_tokens(special_tokens_dict)
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))

assert tokenizer.cls_token == "<CLS>"
```

#### add_tokens[[transformers.PreTrainedTokenizerBase.add_tokens]]

```python
add_tokens(new_tokens: str | AddedToken | Sequence[str | AddedToken], special_tokens: bool = False)
```

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

**Parameter:**

new_tokens (`str`, `tokenizers.AddedToken` atau urutan dari *str* atau `tokenizers.AddedToken`) : Token hanya ditambahkan jika belum ada dalam kosakata. `tokenizers.AddedToken` membungkus token string agar Anda dapat mempersonalisasi perilakunya: apakah token ini harus hanya cocok dengan satu kata, apakah token ini harus menghapus semua spasi potensial di sisi kiri, apakah token ini harus menghapus semua spasi potensial di sisi kanan, dan sebagainya.

special_tokens (`bool`, *opsional*, default `False`) : Menentukan apakah token tersebut bersifat khusus. Hal ini terutama mengubah perilaku normalisasi. Lihat detail `tokenizers.AddedToken` di pustaka tokenizers HuggingFace.

**Mengembalikan:** `int`

Jumlah token yang ditambahkan ke dalam kosakata.

#TODO hapus ini dari sini! PreTrainedTokenizerBase harus tidak bergantung pada AddedToken.

Tambahkan daftar token baru. Jika token baru tidak ada dalam kosakata, token tersebut akan ditambahkan ke akhir. Oleh karena itu, token yang ditambahkan dan token dari kosakata algoritma tokenisasi tidak diperlakukan dengan cara yang sama.

Tokenizer cepat dengan pre-tokenizer `Metaspace` yang menggunakan `prepend_scheme="always"` (misalnya NLLB) menambahkan `"▁"` ke teks yang mengikuti token yang ditambahkan. Setelah `tokenizer.add_tokens(["abcd"])`, `"abcdgym"` ditokenisasi menjadi `["abcd", "▁gym"]` dan didekode menjadi `"abcd gym"`. Jika token yang ditambahkan dapat muncul di dalam kata, ganti pre-tokenizer

ke `prepend_scheme="first"` sehingga hanya awal input yang diberi awalan:

```python
from tokenizers import pre_tokenizers

pre_tokenizer = tokenizer.backend_tokenizer.pre_tokenizer
tokenizer.backend_tokenizer.pre_tokenizer = pre_tokenizers.Metaspace(
    replacement=pre_tokenizer.replacement, prepend_scheme="first", split=pre_tokenizer.split
)
```

Contoh:

```python
# Let's see how to increase the vocabulary of Bert model and tokenizer
tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased")
model = BertModel.from_pretrained("google-bert/bert-base-uncased")

num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"])
print("We have added", num_added_toks, "tokens")
# Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer.
model.resize_token_embeddings(len(tokenizer))
```

#### apply_chat_template[[transformers.PreTrainedTokenizerBase.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | Callable] | None = None, documents: list[dict[str, str]] | None = None, chat_template: str | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, tokenize: bool = True, sanitize_control_tokens: bool = False, padding: bool | str | PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | TensorType | None = None, return_dict: bool = True, return_assistant_tokens_mask: bool = False, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**Parameter:**

conversation (Union[list[dict[str, str]], list[list[dict[str, str]]]]) : Daftar dict dengan kunci "role" dan "content", yang merepresentasikan riwayat chat sejauh ini.

tools (`list[Union[Dict, Callable]]`, *opsional*) : Daftar alat (fungsi callable) yang akan dapat diakses oleh model. Jika template tidak mendukung pemanggilan fungsi, argumen ini tidak akan berpengaruh. Setiap alat harus diberikan sebagai JSON Schema, yang mencantumkan nama, deskripsi, dan tipe argumen untuk alat tersebut. Lihat [panduan penggunaan alat](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools) kami untuk informasi lebih lanjut.

documents (`list[dict[str, str]]`, *opsional*) : Daftar dict yang merepresentasikan dokumen yang akan dapat diakses oleh model jika model tersebut sedang melakukan RAG (retrieval-augmented generation). Jika template tidak mendukung RAG, argumen ini tidak akan berpengaruh. Kami merekomendasikan agar setiap dokumen berupa dict yang berisi kunci "title" dan "text".

chat_template (`str`, *opsional*) : Template Jinja yang akan digunakan untuk konversi ini. Biasanya tidak perlu meneruskan apa pun ke argumen ini, karena template model akan digunakan secara default.

add_generation_prompt (bool, *optional*) : Jika ini diatur, prompt dengan token yang menandakan awal pesan asisten akan ditambahkan ke hasil yang telah diformat. Hal ini berguna ketika Anda ingin menghasilkan respons dari model. Perhatikan bahwa argumen ini akan diteruskan ke chat template, sehingga argumen ini harus didukung dalam template agar memiliki efek.

continue_final_message (bool atau str, *opsional*) : Jika ini diatur, chat akan diformat sedemikian rupa sehingga pesan terakhir dalam chat bersifat terbuka, tanpa token EOS. Model akan melanjutkan pesan ini alih-alih memulai pesan baru. Hal ini memungkinkan Anda untuk "prefill" sebagian respons model. Jika string diteruskan, string tersebut akan digunakan sebagai kunci untuk field yang akan dilanjutkan (misalnya "reasoning_content"). Tidak dapat digunakan bersamaan dengan `add_generation_prompt`.

tokenize (`bool`, defaultnya `True`) : Apakah akan melakukan tokenisasi pada output. Jika `False`, output akan berupa string.

sanitize_control_tokens (`bool`, defaultnya `False`) : Jika diatur, token kontrol yang muncul dalam pesan, alat, dokumen, atau variabel template yang diteruskan sebagai `**kwargs` akan dikodekan sebagai teks biasa, sehingga hanya token kontrol yang ditulis oleh template chat itu sendiri yang dikodekan sebagai token. Token kontrol adalah token khusus dari tokenizer, ditambah token yang ditambahkan dalam `tokenizer.chat_control_tokens`. Jika variabel tersebut tidak diatur, token kontrol disimpulkan dari token yang ditambahkan yang muncul dalam teks dan literal string template chat. Hanya token kontrol utuh yang disanitasi, sehingga jika template menggabungkan string dari input menjadi token kontrol (seperti `'<|' + message['role'] + '|>'`), string-string tersebut harus divalidasi secara terpisah. Kunci Dict juga tidak disanitasi.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `False`) : Pilih strategi untuk melakukan padding pada urutan yang dikembalikan (sesuai sisi padding dan indeks padding model) di antara: - `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`, defaultnya `False`) : Apakah akan memotong (truncate) urutan pada panjang maksimum. Tidak berpengaruh jika tokenize adalah `False`.

max_length (`int`, *opsional*) : Panjang maksimum (dalam token) yang digunakan untuk padding atau truncation. Tidak berpengaruh jika tokenize adalah `False`. Jika tidak ditentukan, atribut `max_length` dari tokenizer akan digunakan sebagai nilai default.

return_tensors (`str` atau [TensorType](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Tidak berpengaruh jika tokenize adalah `False`. Nilai yang dapat diterima adalah: - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan kamus dengan output bernama. Tidak berpengaruh jika tokenize adalah `False`.

tokenizer_kwargs (`dict[str : Any]`, *opsional*): kwargs tambahan untuk diteruskan ke tokenizer.

return_assistant_tokens_mask (`bool`, defaultnya `False`) : Apakah akan mengembalikan mask untuk token yang dihasilkan asisten. Untuk token yang dihasilkan oleh asisten, mask akan berisi 1. Untuk token user dan system, mask akan berisi 0. Fungsi ini hanya tersedia untuk chat template yang mendukungnya melalui kata kunci `{% generation %}`.

- ****kwargs** : kwargs tambahan untuk diteruskan ke template renderer. Akan dapat diakses oleh chat template.

**Mengembalikan:** `Union[list[int], Dict]`

Daftar id token yang mewakili chat yang telah ditokenisasi sejauh ini, termasuk token kontrol. Output ini siap untuk diteruskan ke model, baik secara langsung maupun melalui metode seperti `generate()`. Jika `return_dict` diset, akan mengembalikan dict dari output tokenizer.

Mengonversi daftar kamus dengan kunci `"role"` dan `"content"` menjadi daftar token id. Metode ini ditujukan untuk digunakan dengan model chat, dan akan membaca atribut chat_template tokenizer untuk menentukan format dan token kontrol yang akan digunakan saat mengonversi.

#### batch_decode[[transformers.PreTrainedTokenizerBase.batch_decode]]

```python
batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs)
```

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

**Parameter:**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Daftar id input yang telah ditokenisasi. Dapat diperoleh menggunakan metode `__call__`.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi tokenisasi atau tidak. Jika `None`, akan menggunakan nilai default `self.clean_up_tokenization_spaces`.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode decode spesifik model yang mendasarinya.

**Mengembalikan:** `list[str]`

Daftar kalimat yang telah didekode.

Konversi daftar dari daftar id token menjadi daftar string dengan memanggil decode.

Metode ini disediakan untuk kompatibilitas mundur. Metode `decode` sekarang menangani input berbatch secara native, sehingga Anda dapat menggunakan `decode` secara langsung alih-alih `batch_decode`.

#### clean_up_tokenization[[transformers.PreTrainedTokenizerBase.clean_up_tokenization]]

```python
clean_up_tokenization(text: str)
```

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

Bersihkan spasi tokenisasi dalam teks yang diberikan. Metode ini terutama untuk dukungan kode jarak jauh.

#### convert_ids_to_tokens[[transformers.PreTrainedTokenizerBase.convert_ids_to_tokens]]

```python
convert_ids_to_tokens(ids: int | list[int], skip_special_tokens: bool = False)
```

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

**Parameter:**

ids (`int` atau `list[int]`) : id token (atau id token) yang akan dikonversi menjadi token.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

**Mengembalikan:** `str` atau `list[str]`

Token yang telah didekodekan.

Mengonversi satu indeks atau rangkaian indeks dalam sebuah token atau rangkaian token, menggunakan kosakata dan token yang ditambahkan.

#### convert_tokens_to_ids[[transformers.PreTrainedTokenizerBase.convert_tokens_to_ids]]

```python
convert_tokens_to_ids(tokens: str | list[str])
```

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

**Parameter:**

tokens (`str` atau `list[str]`) : Satu atau beberapa token untuk dikonversi menjadi id token.

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

ID token atau daftar ID token.

Mengonversi string token (atau urutan token) menjadi satu id integer (atau urutan id), menggunakan kosakata.

#### convert_tokens_to_string[[transformers.PreTrainedTokenizerBase.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens: list[str])
```

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

**Parameter:**

tokens (`list[str]`) : Token untuk digabungkan menjadi string.

**Mengembalikan:** `str`

Token yang digabungkan.

Mengonversi urutan token dalam satu string. Cara paling sederhana adalah `" ".join(tokens)`, tetapi kita sering ingin menghapus artefak tokenisasi sub-kata pada saat yang sama.

#### decode[[transformers.PreTrainedTokenizerBase.decode]]

```python
decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs)
```

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

**Parameter:**

token_ids (`Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Satu urutan atau batch (daftar urutan) dari id input yang telah ditokenisasi. Dapat diperoleh menggunakan metode `__call__`.

skip_special_tokens (`bool`, *opsional*, default `False`) : Apakah token khusus akan dihapus saat decoding.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode decode spesifik model yang mendasarinya.

**Mengembalikan:** `Union[str, list[str]]`

String yang telah didekode untuk satu sekuens, atau daftar string yang telah didekode untuk batch sekuens.

Mengonversi rangkaian id menjadi string, atau daftar rangkaian menjadi daftar string, menggunakan tokenizer dan kosakata dengan opsi untuk menghapus token khusus dan merapikan spasi tokenisasi.

Mirip dengan melakukan `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

#### encode[[transformers.PreTrainedTokenizerBase.encode]]

```python
encode(text: TextInput | PreTokenizedInput | EncodedInput, text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, padding_side: str | None = None, return_tensors: str | TensorType | None = None, **kwargs)
```

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

**Parameter:**

text (`str`, `list[str]` atau `list[int]`) : Urutan pertama yang akan dikodekan. Ini bisa berupa string, daftar string (string yang ditokenisasi menggunakan metode `tokenize`) atau daftar bilangan bulat (id string yang ditokenisasi menggunakan metode `convert_tokens_to_ids`).

text_pair (`str`, `list[str]` atau `list[int]`, *opsional*) : Urutan kedua opsional untuk dienkod. Ini bisa berupa string, daftar string (string yang ditokenisasi menggunakan metode `tokenize`) atau daftar bilangan bulat (id string yang ditokenisasi menggunakan metode `convert_tokens_to_ids`).

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.

- ****kwargs** : Diteruskan ke metode `.tokenize()`.

**Mengembalikan:** `list[int]`, `torch.Tensor`, atau `np.ndarray`

ID tokenisasi dari teks.

Mengonversi string menjadi urutan id (bilangan bulat), menggunakan tokenizer dan kosakata.

Sama seperti melakukan `self.convert_tokens_to_ids(self.tokenize(text))`.

#### encode_message_with_chat_template[[transformers.PreTrainedTokenizerBase.encode_message_with_chat_template]]

```python
encode_message_with_chat_template(message: dict[str, str], conversation_history: list[dict[str, str]] | None = None, **kwargs)
```

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

**Parameter:**

message (`dict`) : Kamus dengan kunci "role" dan "content", yang mewakili pesan untuk ditokenisasi.

conversation_history (`list[dict]`, *opsional*) : Daftar dict dengan kunci "role" dan "content", yang merepresentasikan riwayat percakapan sejauh ini. Jika Anda melakukan tokenisasi pesan satu per satu, Anda harus meneruskan pesan-pesan sebelumnya dalam percakapan di sini.

- ****kwargs** : kwargs tambahan untuk diteruskan ke metode `apply_chat_template`.

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

Daftar id token yang mewakili pesan yang ditokenisasi.

Tokenisasi satu pesan. Metode ini adalah pembungkus praktis di sekitar `apply_chat_template` yang memungkinkan Anda menokenisasi pesan satu per satu. Ini berguna untuk hal-hal seperti streaming per token. Metode ini tidak dijamin sempurna. Untuk beberapa model, mungkin tidak mungkin untuk menokenisasi pesan tunggal secara robust. Misalnya, jika template chat menambahkan token setelah setiap pesan, tetapi juga memiliki prefiks yang ditambahkan ke seluruh chat, maka akan mustahil untuk membedakan token-pemula-chat dari token-pemula-pesan. Dalam kasus seperti ini, metode ini akan berusaha semaksimal mungkin untuk menemukan tokenisasi yang benar, tetapi mungkin tidak sempurna. **Catatan:** Metode ini tidak mendukung `add_generation_prompt`. Jika Anda ingin menambahkan prompt generasi, Anda harus melakukannya secara terpisah setelah menokenisasi percakapan.

#### from_pretrained[[transformers.PreTrainedTokenizerBase.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', trust_remote_code = False, **kwargs)
```

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

**Parameter:**

pretrained_model_name_or_path (`str` atau `os.PathLike`) : Bisa berupa:  - String, yaitu *model id* dari tokenizer yang sudah ditentukan dan dihosting di dalam repositori model di huggingface.co. - Path ke *direktori* yang berisi file kosakata yang diperlukan oleh tokenizer, misalnya yang disimpan menggunakan metode [save_pretrained()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), contohnya `./my_model_directory/`. - (**Deprecated**, tidak berlaku untuk semua kelas turunan) path ke satu file kosakata yang disimpan (hanya jika tokenizer hanya memerlukan satu file kosakata seperti Bert atau XLNet), contohnya `./my_model_directory/vocab.txt`.

cache_dir (`str` atau `os.PathLike`, *opsional*) : Path ke direktori tempat file kosakata tokenizer predefined yang diunduh harus di-cache jika cache standar tidak digunakan.

force_download (`bool`, *opsional*, default `False`) : Apakah akan memaksa (mengunduh ulang) file kosakata dan menimpa versi yang sudah di-cache jika ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Proxy digunakan pada setiap permintaan.

token (`str` atau *bool*, *opsional*) : Token yang akan digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

local_files_only (`bool`, *opsional*, default `False`) : Apakah hanya mengandalkan file lokal dan tidak mencoba mengunduh file apa pun.

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.

subfolder (`str`, *opsional*) : Jika file terkait berada di dalam subfolder dari repo model di huggingface.co (misalnya untuk facebook/rag-token-base), tentukan di sini.

inputs (argumen posisional tambahan, *opsional*) : Akan diteruskan ke metode `__init__` Tokenizer.

trust_remote_code (`bool`, *opsional*, default `False`) : Apakah model kustom yang didefinisikan di Hub dalam file modeling mereka sendiri diizinkan atau tidak. Opsi ini hanya harus disetel ke `True` untuk repositori yang Anda percaya dan yang kodenya telah Anda baca, karena opsi ini akan mengeksekusi kode yang ada di Hub pada mesin lokal Anda.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode `__init__` Tokenizer. Dapat digunakan untuk mengatur token khusus seperti `bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`. Lihat parameter di `__init__` untuk detail lebih lanjut.

Instansiasi [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (atau kelas turunan) dari tokenizer yang sudah ditentukan.

Menyampaikan `token=True` diperlukan ketika Anda ingin menggunakan model privat.

Contoh:

```python
# We can't instantiate directly the base class *PreTrainedTokenizerBase* so let's show our examples on a derived class: BertTokenizer
# Download vocabulary from huggingface.co and cache.
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")

# Download vocabulary from huggingface.co (user-uploaded) and cache.
tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased")

# If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/")

# If the tokenizer uses a single vocabulary file, you can point directly to this file
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/my_vocab.txt")

# You can link tokens to special vocabulary when instantiating
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased", unk_token="<unk>")
# You should be sure '<unk>' is in the vocabulary when doing that.
# Otherwise use tokenizer.add_special_tokens({'unk_token': '<unk>'}) instead)
assert tokenizer.unk_token == "<unk>"
```

#### get_chat_template[[transformers.PreTrainedTokenizerBase.get_chat_template]]

```python
get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None)
```

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

**Parameter:**

chat_template (`str`, *opsional*) : Template Jinja atau nama template yang akan digunakan untuk konversi ini. Biasanya tidak perlu meneruskan apa pun ke argumen ini, karena template model akan digunakan secara default.

tools (`list[Dict]`, *opsional*) : Daftar alat (fungsi callable) yang akan dapat diakses oleh model. Jika template tidak mendukung pemanggilan fungsi, argumen ini tidak akan berpengaruh. Setiap alat harus diberikan sebagai JSON Schema, yang mencantumkan nama, deskripsi, dan tipe argumen untuk alat tersebut. Lihat [panduan chat templating](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) kami untuk informasi lebih lanjut.

**Mengembalikan:** `str`

String template chat.

Ambil string template chat yang digunakan untuk melakukan tokenisasi pesan chat. Template ini digunakan secara internal oleh metode `apply_chat_template` dan juga dapat digunakan secara eksternal untuk mengambil template chat model guna pelacakan generasi yang lebih baik.

#### get_response_parser[[transformers.PreTrainedTokenizerBase.get_response_parser]]

```python
get_response_parser(response_template: dict | None = None, prefix: str | list[int] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

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

Kembalikan `ResponseParser` berstatus untuk mem-parsing respons yang di-stream secara bertahap. Menggunakan atribut `response_template` dari tokenizer kecuali jika ditimpa.

`prefix` (string, daftar token id, atau tensor 1D) wajib diisi: stream diinisialisasi dalam keadaan yang diimplikasikan oleh konteks chat-prompt (dipangkas dari kanan melewati `start_anchor` dari spesifikasi), sehingga chunk yang dihasilkan dan dikirim melalui `stream.feed()` akan diklasifikasikan dengan benar bahkan ketika chat template mengeluarkan konten giliran asisten (misalnya, `<think>\n`) yang dilanjutkan oleh model. Jika diabaikan, akan memicu error; jika stream benar-benar dimulai dari giliran asisten yang bersih, berikan `prefix=""` untuk memilih keluar.

`tools` (`list[Union[Dict, Callable]]`, *opsional*): tools yang tersedia untuk model, dalam format yang sama seperti yang diterima oleh `apply_chat_template`. Ketika diset, argumen tool-call akan di-cast menggunakan JSON schema dari tool yang dipanggil setiap kali region ditutup, sehingga event streaming `region_close` membawa argumen bertipe.

#### get_special_tokens_mask[[transformers.PreTrainedTokenizerBase.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`.

#### get_vocab[[transformers.PreTrainedTokenizerBase.get_vocab]]

```python
get_vocab()
```

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

**Mengembalikan:** `dict[str, int]`

Kosakata.

Mengembalikan kosakata sebagai kamus dari token ke indeks.

`tokenizer.get_vocab()[token]` setara dengan `tokenizer.convert_tokens_to_ids(token)` ketika `token` ada dalam vocab.

#### pad[[transformers.PreTrainedTokenizerBase.pad]]

```python
pad(encoded_inputs: BatchEncoding | list[BatchEncoding] | dict[str, EncodedInput] | dict[str, list[EncodedInput]] | list[dict[str, EncodedInput]], padding: bool | str | PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | TensorType | None = None, verbose: bool = True)
```

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

**Parameter:**

encoded_inputs ([BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding), list of [BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding), `dict[str, list[int]]`, `dict[str, list[list[int]]` atau `list[dict[str, list[int]]]`) : Input yang telah ditokenisasi. Dapat merepresentasikan satu input ([BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding) atau `dict[str, list[int]]`) atau batch dari input yang telah ditokenisasi (list of [BatchEncoding](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.BatchEncoding), *dict[str, list[list[int]]]* atau *list[dict[str, list[int]]]*) sehingga Anda dapat menggunakan metode ini selama pra-pemrosesan maupun dalam fungsi collate PyTorch Dataloader. Alih-alih `list[int]`, Anda dapat memiliki tensor (array numpy, atau tensor PyTorch), lihat catatan di atas untuk tipe pengembalian.

padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/v5.23.0/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, default `True`) : Pilih strategi untuk melakukan padding pada urutan yang dikembalikan (sesuai sisi padding dan indeks padding model) di antara: - `True` atau `'longest'` (default): Lakukan padding hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Lakukan padding 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'`: Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda).

max_length (`int`, *opsional*) : Panjang maksimum dari daftar yang dikembalikan dan secara opsional panjang padding (lihat di atas).

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, akan melakukan padding pada sekuens menjadi kelipatan dari nilai yang diberikan. 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_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_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.

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

Pad satu input terenkod atau batch dari input terenkod hingga panjang yang telah ditentukan atau hingga panjang urutan maksimum dalam batch.

Sisi padding (kiri/kanan) dan id token padding didefinisikan pada level tokenizer (dengan `self.padding_side`, `self.pad_token_id` dan `self.pad_token_type_id`).

Perlu diperhatikan bahwa dengan tokenizer cepat, menggunakan metode `__call__` lebih cepat daripada menggunakan metode untuk mengkodekan teks yang diikuti oleh pemanggilan metode `pad` untuk mendapatkan encoding yang di-pad.

Jika `encoded_inputs` yang diberikan berupa dictionary dari array numpy atau tensor PyTorch, hasilnya akan menggunakan tipe yang sama kecuali Anda menyediakan tipe tensor yang berbeda dengan `return_tensors`. Dalam kasus tensor PyTorch, Anda akan kehilangan perangkat spesifik dari tensor Anda.

#### parse_response[[transformers.PreTrainedTokenizerBase.parse_response]]

```python
parse_response(response: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor, schema: dict | None = None, prefix: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

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

**Parameter:**

response (`str`, token ids, tensor 1D/2D, atau daftar dari salah satu dari ini) : Output yang dihasilkan oleh model. Bisa berupa teks yang sudah didekode atau token ids, sebagai satu urutan (`str` / `list[int]` / array 1D / tensor 1D) atau batch (`list[str]` / `list[list[int]]` / array 2D / tensor 2D). Perhatikan bahwa ini harus hanya berisi output model, bukan teks prompt sebelumnya (teks tersebut masuk ke `prefix`).

schema (`dict`, *opsional*) : Template respons yang menunjukkan format output yang diharapkan dan bagaimana parsing harus dilakukan. Jika tidak disediakan, atribut `response_template` dari tokenizer akan digunakan.

prefix (`str`, token ids, tensor 1D/2D, atau daftar dari salah satu dari ini) : Prompt yang mendahului proses generasi. Hal ini diperlukan karena banyak template chat menulis sebagian pesan sebelumnya, sehingga kita perlu melihat prompt untuk melakukan parsing dengan benar. Untuk `response` yang di-batch, berikan satu prefix tunggal (di-broadcast ke setiap item) atau satu prefix per item.

tools (`list[Union[Dict, Callable]]`, *opsional*) : Tools yang tersedia untuk model, dalam format yang sama seperti yang diterima oleh `apply_chat_template`. Ketika diberikan, argumen tool-call akan di-cast menggunakan JSON schema dari tool yang dipanggil: `"7"` menjadi `7` untuk parameter integer, tetapi tetap `"7"` untuk parameter string.

**Mengembalikan:**

Sebuah pesan yang telah diurai berupa `dict` untuk satu sekuens, atau `list` dari dict tersebut untuk sebuah batch.

Mengonversi string output yang dibuat dengan menghasilkan teks dari model menjadi kamus pesan yang telah diurai. Metode ini ditujukan untuk digunakan dengan model chat, dan akan membaca atribut `response_template` dari tokenizer untuk mengontrol penguraian, kecuali argumen `schema` dilewatkan secara langsung.

Menerima satu urutan tunggal atau satu batch. Satu urutan tunggal (sebuah string, atau urutan 1D dari token id) mengembalikan satu pesan terurai berupa `dict`; sedangkan batch (sebuah list dari string, list dari urutan token-id, atau tensor/array 2D) mengembalikan `list` dari dict pesan terurai, satu untuk setiap item.

#### push_to_hub[[transformers.PreTrainedTokenizerBase.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822)

**Parameter:**

repo_id (`str`) : Nama repositori tempat Anda ingin mendorong tokenizer Anda. Nama ini harus mencakup nama organisasi Anda saat mendorong ke organisasi tertentu.

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload tokenizer"`.

commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat

private (`bool`, *opsional*) : Apakah akan membuat repo menjadi privat. Jika `None` (default), repo akan bersifat publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`bool` atau `str`, *opsional*) : Token yang akan digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True` (default), akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah.

create_pr (`bool`, *opsional*, default `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

max_shard_size (`int` atau `str`, *opsional*, default `"50GB"`) : Hanya berlaku untuk model. Ukuran maksimum untuk checkpoint sebelum dipecah menjadi shard. Setiap shard checkpoint akan memiliki ukuran lebih kecil dari nilai ini. Jika dinyatakan sebagai string, harus berupa angka diikuti satuan (seperti `"5MB"`).

tags (`list[str]`, *opsional*) : Daftar tag untuk didorong ke Hub.

Unggah file tokenizer ke 🤗 Model Hub.

Contoh:

```python
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")

# Push the tokenizer to your namespace with the name "my-finetuned-bert".
tokenizer.push_to_hub("my-finetuned-bert")

# Push the tokenizer to an organization with the name "my-finetuned-bert".
tokenizer.push_to_hub("huggingface/my-finetuned-bert")
```

#### register_for_auto_class[[transformers.PreTrainedTokenizerBase.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoTokenizer')
```

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

**Parameter:**

auto_class (`str` atau `type`, *opsional*, defaultnya `"AutoTokenizer"`) : Kelas auto untuk mendaftarkan tokenizer baru ini.

Daftarkan kelas ini dengan auto class tertentu. Ini hanya harus digunakan untuk tokenizer kustom, karena tokenizer yang ada di pustaka sudah dipetakan dengan `AutoTokenizer`.

#### save_chat_templates[[transformers.PreTrainedTokenizerBase.save_chat_templates]]

```python
save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool)
```

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

Menulis template chat ke direktori penyimpanan jika kita menggunakan format baru, dan menghapusnya dari konfigurasi tokenizer jika ada. Jika kita menggunakan format lama, tidak ada file yang ditulis, dan sebaliknya template ditulis ke konfigurasi tokenizer dalam format yang benar.

#### save_pretrained[[transformers.PreTrainedTokenizerBase.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, legacy_format: bool | None = None, filename_prefix: str | None = None, push_to_hub: bool = False, **kwargs)
```

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

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Path ke direktori tempat tokenizer akan disimpan.

legacy_format (`bool`, *opsional*) : Hanya berlaku untuk fast tokenizer. Jika tidak disetel (default), tokenizer akan disimpan dalam format JSON terpadu serta dalam format legacy jika ada, yaitu dengan kosakata spesifik tokenizer dan file added_tokens yang terpisah. Jika `False`, tokenizer hanya akan disimpan dalam format JSON terpadu. Format ini tidak kompatibel dengan tokenizer "slow" (yang tidak didukung oleh pustaka *tokenizers*), sehingga tokenizer tidak akan dapat dimuat dalam tokenizer "slow" yang sesuai. Jika `True`, tokenizer akan disimpan dalam format legacy. Jika tokenizer "slow" tidak ada, nilai error akan dilempar.

filename_prefix (`str`, *opsional*) : Prefiks yang akan ditambahkan ke nama file yang disimpan oleh tokenizer.

push_to_hub (`bool`, *opsional*, default `False`) : Apakah model akan didorong ke Hugging Face model hub setelah disimpan. Anda dapat menentukan repositori tujuan dengan `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

**Mengembalikan:** Tuple dari `str`

File yang disimpan.

Simpan status tokenizer lengkap.

Metode ini memastikan tokenizer lengkap dapat dimuat ulang menggunakan metode kelas `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Warning,None Ini tidak akan menyimpan modifikasi yang mungkin telah Anda terapkan pada tokenizer setelah instansiasi (misalnya, memodifikasi `tokenizer.do_lower_case` setelah pembuatan).

#### save_vocabulary[[transformers.PreTrainedTokenizerBase.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/tokenization_utils_base.py#L2224)

**Parameter:**

save_directory (`str`) : Direktori tempat menyimpan kosa kata.

filename_prefix (`str`, *opsional*) : Prefiks opsional untuk ditambahkan ke nama file yang disimpan.

**Mengembalikan:** `tuple(str)`

Path ke file yang disimpan.

Simpan hanya kosakata tokenizer (kosakata + token yang ditambahkan).

Metode ini tidak akan menyimpan konfigurasi dan pemetaan token khusus dari tokenizer. Gunakan `_save_pretrained()` untuk menyimpan seluruh state tokenizer.

#### tokenize[[transformers.PreTrainedTokenizerBase.tokenize]]

```python
tokenize(text: str, pair: str | None = None, add_special_tokens: bool = False, **kwargs)
```

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

**Parameter:**

text (`str`) : Urutan yang akan dikodekan.

pair (`str`, *opsional*) : Urutan kedua yang akan dikodekan bersama urutan pertama.

add_special_tokens (`bool`, *opsional*, default `False`) : Apakah akan menambahkan token khusus yang terkait dengan model yang sesuai.

kwargs (argumen kata kunci tambahan, *opsional*) : Akan diteruskan ke metode encode spesifik model yang mendasarinya. Lihat detail di [__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)

**Mengembalikan:** `list[str]`

Daftar token.

Mengonversi string menjadi urutan token, dengan mengganti token yang tidak dikenal menggunakan `unk_token`.

## Enum dan namedtuple[[transformers.tokenization_utils_base.TruncationStrategy]]

#### transformers.tokenization_utils_base.TruncationStrategy[[transformers.tokenization_utils_base.TruncationStrategy]]

```python
transformers.tokenization_utils_base.TruncationStrategy(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)
```

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

Nilai yang mungkin untuk argumen `truncation` di [PreTrainedTokenizerBase.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). Berguna untuk tab-completion di IDE.

#### transformers.CharSpan[[transformers.CharSpan]]

```python
transformers.CharSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

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

**Parameter:**

start (`int`) : Indeks karakter pertama dalam string asli.

end (`int`) : Indeks karakter yang mengikuti karakter terakhir dalam string asli.

Rentang karakter dalam string asli.

#### transformers.TokenSpan[[transformers.TokenSpan]]

```python
transformers.TokenSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

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

**Parameter:**

start (`int`) : Indeks token pertama dalam span.

end (`int`) : Indeks token yang mengikuti token terakhir dalam span.

Rentang token dalam string terenkod (daftar token).