# XLNet

## Ikhtisar

Model XLNet diusulkan dalam [XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://huggingface.co/papers/1906.08237) oleh Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le. XLnet adalah ekstensi dari model Transformer-XL yang dilatih sebelumnya menggunakan metode autoregressive untuk mempelajari konteks bidireksional dengan memaksimalkan kemungkinan yang diharapkan di atas semua permutasi urutan faktorisasi urutan input.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Dengan kemampuan untuk memodelkan konteks bidireksional, pra-pelatihan berbasis autoencoding denoising seperti BERT mencapai kinerja yang lebih baik daripada pendekatan pra-pelatihan yang berbasis pemodelan bahasa autoregresif. Namun, karena bergantung pada pengrusakan input dengan masker, BERT mengabaikan ketergantungan antara posisi yang dimasker dan mengalami ketidaksesuaian antara pra-pelatihan dan penyesuaian halus. Mengingat kelebihan dan kekurangan tersebut, kami mengusulkan XLNet, sebuah metode pra-pelatihan autoregresif yang digeneralisasi yang (1) memungkinkan pembelajaran konteks bidireksional dengan memaksimalkan kemungkinan yang diharapkan di atas semua permutasi urutan faktorisasi dan (2) mengatasi keterbatasan BERT berkat formulasi autoregresifnya. Selain itu, XLNet mengintegrasikan ide-ide dari Transformer-XL, model autoregresif terkini, ke dalam pra-pelatihan. Secara empiris, di bawah pengaturan eksperimen yang sebanding, XLNet melampaui BERT pada 20 tugas, sering kali dengan selisih yang besar, termasuk penjawab pertanyaan, inferensi bahasa alami, analisis sentimen, dan peringkat dokumen.*

Model ini disumbangkan oleh [thomwolf](https://huggingface.co/thomwolf). Kode aslinya dapat ditemukan [di sini](https://github.com/zihangdai/xlnet/).

## Tips penggunaan

- Pola perhatian spesifik dapat dikendalikan pada saat pelatihan dan pengujian menggunakan input `perm_mask`.
- Karena sulitnya melatih model auto-regresif penuh pada berbagai urutan faktorisasi, XLNet dilatih awal hanya menggunakan sub-set token output sebagai target yang dipilih dengan input `target_mapping`.
- Untuk menggunakan XLNet untuk decoding berurutan (yaitu bukan dalam pengaturan bi-directional penuh), gunakan input `perm_mask` dan `target_mapping` untuk mengontrol rentang perhatian dan output
- XLNet adalah salah satu dari sedikit model yang tidak memiliki batas panjang urutan.
- XLNet bukanlah model autoregresif tradisional, tetapi menggunakan strategi pelatihan yang dibangun di atasnya. Model ini mempermutasi token dalam kalimat, lalu memungkinkan model menggunakan n token terakhir untuk memprediksi token ke-n+1. Karena semua ini dilakukan dengan mask, kalimat sebenarnya dimasukkan ke dalam model dengan urutan yang benar, tetapi alih-alih mem-mask n token pertama untuk n+1, XLNet menggunakan mask yang menyembunyikan token-token sebelumnya dalam beberapa permutasi tertentu dari 1,…,panjang sekuens.
- XLNet juga menggunakan mekanisme rekurensi yang sama dengan Transformer-XL untuk membangun dependensi jangka panjang.

## Sumber daya

- [Panduan tugas klasifikasi teks](../tasks/sequence_classification)
- [Panduan tugas klasifikasi token](../tasks/token_classification)
- [Panduan tugas question answering](../tasks/question_answering)
- [Panduan tugas pemodelan bahasa kausal](../tasks/language_modeling)
- [Panduan tugas pilihan ganda](../tasks/multiple_choice)

## XLNetConfig[[transformers.XLNetConfig]]

#### transformers.XLNetConfig[[transformers.XLNetConfig]]

```python
transformers.XLNetConfig(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 = 32000, d_model: int = 1024, n_layer: int = 24, n_head: int = 16, d_inner: int = 4096, d_head: int | None = None, ff_activation: str = 'gelu', attn_type: str = 'bi', initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, dropout: float | int = 0.1, mem_len: int | None = 512, reuse_len: int | None = None, use_mems_eval: bool = True, use_mems_train: bool = False, bi_data: bool = False, clamp_len: int = -1, same_length: bool = False, summary_type: str = 'last', summary_use_proj: bool = True, summary_activation: str = 'tanh', summary_last_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, pad_token_id: int | None = 5, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/configuration_xlnet.py#L28)

**Parameter:**

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

d_model (`int`, *opsional*, defaultnya `1024`) : Ukuran lapisan encoder dan lapisan pooler.

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

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

d_inner (`int`, *opsional*, defaultnya `4096`) : Dimensi dari representasi MLP.

d_head (`int`, *opsional*) : Dimensi kepala perhatian. Jika None, nilainya akan secara default menjadi hidden_size // num_attention_heads

ff_activation (`str` atau `Callable`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi non-linear (fungsi atau string) di Jika string, `"gelu"`, `"relu"`, `"silu"` dan `"gelu_new"` didukung.

attn_type (`str`, *opsional*, defaultnya `"bi"`) : Jenis perhatian yang digunakan oleh model. Atur `"bi"` untuk XLNet, `"uni"` untuk Transformer-XL.

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.

dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio untuk semua lapisan dropout.

mem_len (`int` atau `None`, *opsional*) : Jumlah token yang akan di-cache. Pasangan kunci/nilai yang sudah dihitung sebelumnya pada langkah maju sebelumnya tidak akan dihitung ulang. Lihat [quickstart](https://huggingface.co/transformers/quickstart.html#using-the-past) untuk informasi lebih lanjut.

reuse_len (`int`, *opsional*) : Jumlah token dalam batch saat ini yang akan di-cache dan digunakan kembali di masa depan.

use_mems_eval (`bool`, *opsional*, defaultnya `True`) : Apakah model harus menggunakan mekanisme memori rekuren dalam mode evaluasi.

use_mems_train (`bool`, *opsional*, defaultnya `False`) : Apakah model harus menggunakan mekanisme memori rekuren dalam mode pelatihan. Untuk pra-pelatihan, disarankan untuk mengatur `use_mems_train` ke `True`. Untuk penyesuaian halus, disarankan untuk mengatur `use_mems_train` ke `False` seperti yang dibahas [di sini](https://github.com/zihangdai/xlnet/issues/41#issuecomment-505102587). Jika `use_mems_train` diatur ke `True`, Anda harus memastikan bahwa batch pelatihan diproses sebelumnya dengan benar, *misalnya* `batch_1 = [[This line is], [This is the]]` dan `batch_2 = [[ the first line], [ second line]]` dan bahwa semua batch memiliki ukuran yang sama.

bi_data (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan pipeline input bidireksional atau tidak. Biasanya diset ke `True` selama pretraining dan `False` selama finetuning.

clamp_len (`int`, *opsional*, default -1) : Membatasi semua jarak relatif yang lebih besar dari clamp_len. Mengatur atribut ini ke -1 berarti tidak ada pembatasan.

same_length (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan panjang perhatian yang sama untuk setiap token.

summary_type (`str`, *opsional*, defaultnya "last") : Argumen yang digunakan saat melakukan ringkasan urutan. Digunakan dalam model klasifikasi urutan dan pilihan ganda. Harus salah satu dari opsi berikut: - `"last"`: Ambil hidden state token terakhir (seperti XLNet). - `"first"`: Ambil hidden state token pertama (seperti BERT). - `"mean"`: Ambil rata-rata dari semua hidden state token. - `"cls_index"`: Sediakan Tensor posisi token klasifikasi (seperti GPT/GPT-2). - `"attn"`: Belum diimplementasikan saat ini, gunakan multi-head attention.

summary_use_proj (`bool`, *opsional*, defaultnya `True`) : Argumen yang digunakan saat melakukan ringkasan urutan. Digunakan dalam model klasifikasi urutan dan pilihan ganda. Menentukan apakah akan menambahkan proyeksi setelah ekstraksi vektor.

summary_activation (`str`, *opsional*) : Argumen yang digunakan saat melakukan ringkasan urutan. Digunakan dalam model klasifikasi urutan dan pilihan ganda. Berikan `"tanh"` untuk aktivasi tanh pada output, nilai lain akan menghasilkan tanpa aktivasi.

summary_last_dropout (`float`, *opsional*, default 0.1) : Digunakan dalam model klasifikasi urutan dan pilihan ganda. Rasio dropout yang digunakan setelah proyeksi dan aktivasi.

start_n_top (`int`, *opsional*, default 5) : Digunakan dalam skrip evaluasi SQuAD.

end_n_top (`int`, *opsional*, default 5) : Digunakan dalam skrip evaluasi SQuAD.

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

bos_token_id (`int`, *opsional*, defaultnya `1`) : 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.

tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari XLNetModel. Kelas ini digunakan untuk membuat instans model Xlnet berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [xlnet/xlnet-large-cased](https://huggingface.co/xlnet/xlnet-large-cased)

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 XLNetConfig, XLNetModel

>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)

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

## XLNetTokenizer[[transformers.XLNetTokenizer]]

#### transformers.XLNetTokenizer[[transformers.XLNetTokenizer]]

```python
transformers.XLNetTokenizer(vocab: str | list[tuple[str, float]] | None = None, unk_id: int = 0, do_lower_case = False, remove_space = True, keep_accents = False, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', sep_token = '<sep>', pad_token = '<pad>', cls_token = '<cls>', mask_token = '<mask>', _spm_precompiled_charsmap = None, additional_special_tokens = None, **kwargs)
```

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

**Parameter:**

vocab (`list of tuples`, *opsional*) : Daftar tuple (token, skor) untuk model Unigram. Jika tidak disediakan, daftar kosong akan digunakan.

unk_id (`int`, *opsional*, default 0) : ID token yang tidak dikenal dalam kosakata.

do_lower_case (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengubah input menjadi huruf kecil saat melakukan tokenisasi.

remove_space (`bool`, *opsional*, defaultnya `True`) : Apakah akan menghapus teks saat melakukan tokenisasi (menghapus spasi berlebih sebelum dan sesudah string).

keep_accents (`bool`, *opsional*, defaultnya `False`) : Apakah mempertahankan aksen saat melakukan tokenisasi.

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`.

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.

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

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

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

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.

additional_special_tokens (`list[str]`, *opsional*, defaultnya `["<eop>", "<eod>"]`) : Token khusus tambahan yang digunakan oleh tokenizer.

Konstruksi tokenizer XLNet (didukung oleh pustaka *tokenizers* HuggingFace). Berbasis pada [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).

Tokenizer ini mewarisi dari [TokenizersBackend](/docs/transformers/v5.23.0/id/main_classes/tokenizer#transformers.TokenizersBackend) yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

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

#### save_vocabulary[[transformers.XLNetTokenizer.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_tokenizers.py#L547)

## Output khusus XLNet[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

#### transformers.models.xlnet.modeling_xlnet.XLNetModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetModelOutput(last_hidden_state: Tensor, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L659)

**Parameter:**

last_hidden_state (`torch.Tensor` dengan bentuk `(batch_size, num_predict, hidden_size)`) : Urutan hidden-states pada lapisan terakhir model. `num_predict` sesuai dengan `target_mapping.shape[1]`. Jika `target_mapping` adalah `None`, maka `num_predict` sesuai dengan `sequence_length`.

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetModel](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L684)

**Parameter:**

loss (`torch.Tensor` dengan bentuk *(1,)*, *opsional*, dikembalikan ketika `labels` disediakan) : Loss pemodelan bahasa (untuk prediksi token berikutnya).

logits (`torch.Tensor` dengan bentuk `(batch_size, num_predict, config.vocab_size)`) : Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax). `num_predict` sesuai dengan `target_mapping.shape[1]`. Jika `target_mapping` adalah `None`, maka `num_predict` sesuai dengan `sequence_length`.

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetLMHeadModel](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetLMHeadModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L712)

**Parameter:**

loss (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `label` 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).

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForSequenceClassification).

#### transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L762)

**Parameter:**

loss (`torch.Tensor` dengan bentuk *(1,)*, *opsional*, dikembalikan ketika `labels` disediakan) : Klasifikasi loss.

logits (`torch.Tensor` dengan bentuk `(batch_size, num_choices)`) : *num_choices* adalah dimensi kedua dari tensor input. (lihat *input_ids* di atas). Skor klasifikasi (sebelum SoftMax).

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForMultipleChoice).

#### transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L737)

**Parameter:**

loss (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) : Loss klasifikasi.

logits (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) : Skor klasifikasi (sebelum SoftMax).

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari `XLNetForTokenClassificationOutput`.

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L789)

**Parameter:**

loss (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan) : Total loss ekstraksi span 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).

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetForQuestionAnsweringSimple](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple).

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L817)

**Parameter:**

loss (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan jika `start_positions` dan `end_positions` keduanya disediakan) : Loss klasifikasi sebagai jumlah dari loss klasifikasi token awal, token akhir (dan is_impossible jika disediakan).

start_top_log_probs (`torch.Tensor` dengan bentuk `(batch_size, config.start_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) : Probabilitas log untuk kemungkinan token awal teratas config.start_n_top (beam-search).

start_top_index (`torch.LongTensor` dengan bentuk `(batch_size, config.start_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) : Indeks untuk kemungkinan token awal teratas config.start_n_top (beam-search).

end_top_log_probs (`torch.Tensor` dengan bentuk `(batch_size, config.start_n_top * config.end_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) : Probabilitas log untuk `config.start_n_top * config.end_n_top` kemungkinan token akhir teratas (beam-search).

end_top_index (`torch.LongTensor` dengan bentuk `(batch_size, config.start_n_top * config.end_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) : Indeks untuk kemungkinan token akhir teratas `config.start_n_top * config.end_n_top` (beam-search).

cls_logits (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) : Probabilitas log untuk label `is_impossible` dari jawaban.

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.

hidden_states (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 dari model pada output setiap lapisan 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.

Jenis output dari [XLNetForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForQuestionAnswering).

## XLNetModel[[transformers.XLNetModel]]

#### transformers.XLNetModel[[transformers.XLNetModel]]

```python
transformers.XLNetModel(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L851)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet 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.XLNetModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L976)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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.

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetModelOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) atau `tuple(torch.Tensor)`

[XLNetModelOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetModel](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetModel) 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, num_predict, hidden_size)`) -- Urutan hidden-states pada lapisan terakhir model.

  `num_predict` bersesuaian dengan `target_mapping.shape[1]`. Jika `target_mapping` adalah `None`, maka `num_predict` bersesuaian dengan `sequence_length`.
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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.

## XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

#### transformers.XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

```python
transformers.XLNetLMHeadModel(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1215)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet dengan kepala pemodelan bahasa di atasnya (lapisan linear dengan bobot yang terikat ke embedding input).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1290)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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, num_predict)`, *opsional*) : Label untuk pemodelan bahasa yang disamarkan. `num_predict` sesuai dengan `target_mapping.shape[1]`. Jika `target_mapping` adalah `None`, maka `num_predict` sesuai dengan `sequence_length`. Label harus sesuai dengan kata-kata input yang disamarkan yang harus diprediksi dan bergantung pada `target_mapping`. Perhatikan bahwa untuk melakukan pemodelan bahasa auto-regresif standar, token ** harus ditambahkan ke `input_ids` (lihat fungsi `prepare_inputs_for_generation` dan contoh di bawah) Indeks dipilih dalam `[-100, 0, ..., config.vocab_size]` Semua label yang diatur ke `-100` diabaikan, loss hanya dihitung untuk label dalam `[0, ..., config.vocab_size]`

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

logits_to_keep (`Union[int, torch.Tensor]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_ids` (kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupa `torch.Tensor`, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan).

**Mengembalikan:** [XLNetLMHeadModelOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) atau `tuple(torch.Tensor)`

A [XLNetLMHeadModelOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetLMHeadModel](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetLMHeadModel) 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` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_predict, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).

  `num_predict` bersesuaian dengan `target_mapping.shape[1]`. Jika `target_mapping` adalah `None`, maka `num_predict` bersesuaian dengan `sequence_length`.
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 AutoTokenizer, XLNetLMHeadModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")

>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0  # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
...     0
... ]  # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]

>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
...     :, :, -1
... ] = 1.0  # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
...     outputs.logits
... )  # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
```

## XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

#### transformers.XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

```python
transformers.XLNetForSequenceClassification(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1462)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet dengan kepala klasifikasi/regresi urutan di atasnya (lapisan linear di atas output yang dipooling), 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.XLNetForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1475)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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).

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetForSequenceClassificationOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) atau `tuple(torch.Tensor)`

A [XLNetForSequenceClassificationOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetForSequenceClassification](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForSequenceClassification) 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 `label` diberikan) -- 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).
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 klasifikasi label tunggal:

```python
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Contoh klasifikasi multi-label:

```python
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained(
...     "xlnet/xlnet-large-cased", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

#### transformers.XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

```python
transformers.XLNetForMultipleChoice(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1694)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet dengan kepala klasifikasi pilihan ganda di atasnya (lapisan linear di atas output yang dipool dan softmax), misalnya untuk tugas RocStories/SWAG.

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1705)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, sequence_length)`) : Indeks token dari urutan input dalam kosakata. 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 ID?](../glossary#input-ids)

token_type_ids (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, 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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, num_choices, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_choices, 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, dibandingkan dengan matriks pencarian embedding internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung loss klasifikasi pilihan ganda. Indeks harus berada di `[0, ...,

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetForMultipleChoiceOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) atau `tuple(torch.Tensor)`

Sebuah [XLNetForMultipleChoiceOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForMultipleChoice) 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` disediakan) -- Loss klasifikasi.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_choices)`) -- *num_choices* adalah dimensi kedua dari tensor input. (lihat *input_ids* di atas).

  Skor klasifikasi (sebelum SoftMax).
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 AutoTokenizer, XLNetForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

#### transformers.XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

```python
transformers.XLNetForTokenClassification(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1586)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet dengan kepala klasifikasi token di atasnya (lapisan linear di atas keluaran hidden-states), misalnya untuk tugas Named-Entity-Recognition (NER).

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

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1597)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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 kerugian klasifikasi pilihan ganda. Indeks harus berada dalam `[0, ..., num_choices]` di mana *num_choices* adalah ukuran dimensi kedua dari tensor input. (lihat *input_ids* di atas)

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memory states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan. Memory states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetForTokenClassificationOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) atau `tuple(torch.Tensor)`

Sebuah [XLNetForTokenClassificationOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetForTokenClassification](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForTokenClassification) 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` disediakan) -- Loss klasifikasi.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`) -- Skor klasifikasi (sebelum SoftMax).
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 AutoTokenizer, XLNetForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

#### transformers.XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

```python
transformers.XLNetForQuestionAnsweringSimple(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1838)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 XLNet dengan kepala klasifikasi span di atasnya untuk tugas tanya-jawab ekstraktif seperti SQuAD (lapisan linear di atas keluaran 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.XLNetForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: 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, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1849)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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.

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) atau `tuple(torch.Tensor)`

Sebuah [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetForQuestionAnsweringSimple](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple) 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).
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

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

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

#### transformers.XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

```python
transformers.XLNetForQuestionAnswering(config: XLNetConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1959)

**Parameter:**

config ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) : 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 Xlnet dengan kepala klasifikasi span di atasnya untuk tugas tanya-jawab ekstraktif seperti SQuAD (lapisan linear di atas keluaran 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.XLNetForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: 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, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1973)

**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)

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)

mems (`list[torch.Tensor]` dengan panjang `config.n_layers`) : Mengandung hidden-states yang telah dihitung sebelumnya (lihat output `mems` di bawah). Dapat digunakan untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung. `use_mems` harus disetel ke `True` untuk memanfaatkan `mems`.

perm_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, sequence_length)`, *opsional*) : Mask untuk menunjukkan pola perhatian untuk setiap token input dengan nilai yang dipilih dari `[0, 1]`:  - jika `perm_mask[k, i, j] = 0`, i memperhatikan j dalam batch k; - jika `perm_mask[k, i, j] = 1`, i tidak memperhatikan j dalam batch k.  Jika tidak diset, setiap token memperhatikan semua token lainnya (perhatian bidireksional penuh). Hanya digunakan selama pretraining (untuk menentukan urutan faktorisasi) atau untuk decoding berurutan (generation).

target_mapping (`torch.Tensor` dengan bentuk `(batch_size, num_predict, sequence_length)`, *opsional*) : Mask untuk menunjukkan token output yang akan digunakan. Jika `target_mapping[k, i, j] = 1`, maka predict ke-i pada batch k berada pada token ke-j. Hanya digunakan selama pretraining untuk partial prediction atau untuk sequential decoding (generation).

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)

input_mask (`torch.Tensor` dengan bentuk `batch_size, sequence_length`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Negatif dari `attention_mask`, yaitu dengan 0 untuk token asli dan 1 untuk padding, yang dipertahankan untuk kompatibilitas dengan basis kode asli. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk token yang **dimask**, - 0 untuk token yang **tidak dimask**. Anda hanya dapat menggunakan salah satu dari `input_mask` dan `attention_mask`.

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.

is_impossible (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label apakah sebuah pertanyaan memiliki jawaban atau tidak (SQuAD 2.0)

cls_index (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk posisi (indeks) token klasifikasi yang digunakan sebagai input untuk menghitung plausibilitas jawaban.

p_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask opsional untuk token yang tidak boleh menjadi jawaban (misalnya [CLS], [PAD], ...). Nilai 1.0 berarti token harus di-mask. Nilai 0.0 berarti token tidak di-mask.

use_mems (`bool`, *opsional*) : Apakah akan menggunakan memori states untuk mempercepat decoding berurutan. Jika diatur ke `True`, model akan menggunakan hidden states dari forward passes sebelumnya untuk menghitung attention, yang dapat secara signifikan meningkatkan kinerja untuk tugas decoding berurutan.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [XLNetForQuestionAnsweringOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) atau `tuple(torch.Tensor)`

Sebuah [XLNetForQuestionAnsweringOutput](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([XLNetConfig](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetConfig)) dan input.

Metode forward dari [XLNetForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/xlnet#transformers.XLNetForQuestionAnswering) 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 jika `start_positions` dan `end_positions` keduanya disediakan) -- Klasifikasi loss sebagai jumlah dari klasifikasi loss token awal, token akhir (dan is_impossible jika disediakan).
- **start_top_log_probs** (`torch.Tensor` dengan bentuk `(batch_size, config.start_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) -- Probabilitas log untuk kemungkinan token awal teratas config.start_n_top (beam-search).
- **start_top_index** (`torch.LongTensor` dengan bentuk `(batch_size, config.start_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) -- Indeks untuk kemungkinan token awal teratas config.start_n_top (beam-search).
- **end_top_log_probs** (`torch.Tensor` dengan bentuk `(batch_size, config.start_n_top * config.end_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) -- Probabilitas log untuk `config.start_n_top * config.end_n_top` kemungkinan token akhir teratas (beam-search).
- **end_top_index** (`torch.LongTensor` dengan bentuk `(batch_size, config.start_n_top * config.end_n_top)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) -- Indeks untuk kemungkinan token akhir teratas `config.start_n_top * config.end_n_top` (beam-search).
- **cls_logits** (`torch.Tensor` dengan bentuk `(batch_size,)`, *opsional*, dikembalikan jika `start_positions` atau `end_positions` tidak disediakan) -- Probabilitas log untuk label `is_impossible` dari jawaban.
- **mems** (`list[torch.Tensor]` dengan panjang `config.n_layers`) -- Mengandung hidden-states yang telah dihitung sebelumnya. Dapat digunakan (lihat input `mems`) untuk mempercepat decoding berurutan. Token id yang sudah diberikan past-nya ke model ini tidak boleh diteruskan sebagai `input_ids` karena sudah dihitung.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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 AutoTokenizer, XLNetForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)

>>> loss = outputs.loss
```