# XLM

[XLM](https://huggingface.co/papers/1901.07291) mendemonstrasikan pra-pelatihan lintas bahasa dengan dua pendekatan, yaitu pelatihan tanpa pengawasan pada satu bahasa dan pelatihan dengan pengawasan pada lebih dari satu bahasa dengan tujuan model bahasa lintas bahasa. Model XLM mendukung tujuan pemodelan bahasa kausal, pemodelan bahasa yang disamarkan, dan pemodelan bahasa terjemahan (sebuah ekstensi dari tujuan pemodelan bahasa yang disamarkan [BERT](./bert) ke beberapa input bahasa).

Anda dapat menemukan semua checkpoint XLM asli di bawah organisasi [Facebook AI community](https://huggingface.co/FacebookAI?search_models=xlm-mlm).

> [!TIP]
> Klik pada model XLM di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan XLM ke berbagai tugas lintas bahasa seperti klasifikasi, penerjemahan, dan penjawab pertanyaan.

Contoh di bawah ini menunjukkan cara memprediksi token `<mask>` dengan [Pipeline](/docs/transformers/v5.23.0/id/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModel) dan dari baris perintah.

```python
from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="facebook/xlm-roberta-xl",
    device=0
)
pipeline("Bonjour, je suis un modèle <mask>.")
```

```python
import torch

from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
)
model = AutoModelForMaskedLM.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
    device_map="auto",
)
inputs = tokenizer("Hello, I'm a <mask> model.", return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits.argmax(dim=-1)

predicted_token = tokenizer.decode(predictions[0][inputs["input_ids"][0] == tokenizer.mask_token_id])
print(f"Predicted token: {predicted_token}")
```

## XLMConfig[[transformers.XLMConfig]]

#### transformers.XLMConfig[[transformers.XLMConfig]]

```python
transformers.XLMConfig(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 = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int | None = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True)
```

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

**Parameter:**

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

emb_dim (`int`, *opsional*, defaultnya `2048`) : Dimensi dari embeddings dan hidden states.

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

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

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

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

gelu_activation (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan *gelu* untuk aktivasi alih-alih *relu*.

sinusoidal_embeddings (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan sinusoidal positional embeddings alih-alih absolute positional embeddings.

causal (`bool`, *opsional*, defaultnya `False`) : Apakah model harus berperilaku secara kausal atau tidak. Model kausal menggunakan mask perhatian segitiga agar hanya memperhatikan konteks di sisi kiri, bukan konteks bidireksional.

asm (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan lapisan proyeksi log softmax adaptif alih-alih lapisan linear untuk lapisan prediksi.

n_langs (`int`, *opsional*, default 1) : Jumlah bahasa yang ditangani oleh model. Atur ke 1 untuk model monolingual.

use_lang_emb (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan embedding bahasa. Beberapa model menggunakan embedding bahasa tambahan, lihat [halaman model multibahasa](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings) untuk informasi tentang cara menggunakannya.

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

embed_init_std (`float`, *opsional*, default 2048^-0.5) : Standar deviasi dari truncated_normal_initializer untuk menginisialisasi matriks embedding.

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

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

unk_index (`int`, *opsional*, defaultnya 3) : Indeks token yang tidak diketahui dalam kosakata.

mask_index (`int`, *opsional*, defaultnya 5) : Indeks token masking dalam kosakata.

is_encoder (`bool`, *opsional*, defaultnya `True`) : Apakah model yang diinisialisasi harus berupa encoder atau decoder transformer seperti yang dijelaskan dalam Vaswani et al.

summary_type (`string`, *opsional*, defaultnya "first") : 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_proj_to_labels (`bool`, *opsional*, defaultnya `True`) : Digunakan dalam model klasifikasi urutan dan pilihan ganda. Apakah output proyeksi harus memiliki `config.num_labels` atau `config.hidden_size` kelas.

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

mask_token_id (`int`, *opsional*, default 0) : Parameter yang tidak bergantung pada model untuk mengidentifikasi token yang dimasker saat menghasilkan teks dalam konteks MLM.

lang_id (`int`, *opsional*, default 1) : ID bahasa yang digunakan oleh model. Parameter ini digunakan saat menghasilkan teks dalam bahasa tertentu.

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

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

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `1`) : 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 XLMModel. Kelas ini digunakan untuk membuat instans model Xlm sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [FacebookAI/xlm-mlm-en-2048](https://huggingface.co/FacebookAI/xlm-mlm-en-2048)

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 XLMConfig, XLMModel

>>> # Initializing a XLM configuration
>>> configuration = XLMConfig()

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

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

## XLMTokenizer[[transformers.XLMTokenizer]]

#### transformers.XLMTokenizer[[transformers.XLMTokenizer]]

```python
transformers.XLMTokenizer(vocab_file, merges_file, unk_token = '<unk>', bos_token = '<s>', sep_token = '</s>', pad_token = '<pad>', cls_token = '</s>', mask_token = '<special1>', additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'], lang2id = None, id2lang = None, do_lowercase_and_remove_accent = True, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L134)

**Parameter:**

vocab_file (`str`) : File kosakata.

merges_file (`str`) : Menggabungkan file.

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.

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

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

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

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

mask_token (`str`, *opsional*, defaultnya `"<special1>"`) : Token yang digunakan untuk memasker nilai. Ini adalah token yang digunakan saat melatih model ini dengan masked language modeling. Ini adalah token yang akan coba diprediksi oleh model.

additional_special_tokens (`List[str]`, *opsional*, defaultnya `['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']`) : Daftar token khusus tambahan.

lang2id (`Dict[str, int]`, *opsional*) : Kamus yang memetakan pengidentifikasi string bahasa ke ID mereka.

id2lang (`Dict[int, str]`, *opsional*) : Kamus yang memetakan ID bahasa ke pengenal string-nya.

do_lowercase_and_remove_accent (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengubah menjadi huruf kecil dan menghilangkan aksen saat melakukan tokenisasi.

Konstruksi tokenizer XLM. Berbasis pada Byte-Pair Encoding. Proses tokenisasi adalah sebagai berikut:

- Pra-pemrosesan dan tokenisasi Moses untuk sebagian besar bahasa yang didukung.
- Tokenisasi spesifik bahasa untuk Mandarin (Jieba), Jepang (KyTea), dan Thai (PyThaiNLP).
- Secara opsional, mengubah semua teks input menjadi huruf kecil dan menormalisasikannya.
- Argumen `special_tokens` dan fungsi `set_special_tokens` dapat digunakan untuk menambahkan simbol tambahan (seperti "__classify__") ke dalam kosakata.
- Atribut `lang2id` memetakan bahasa yang didukung oleh model dengan ID-nya jika disediakan (dipasang secara otomatis untuk kosakata pra-terlatih).
- Atribut `id2lang` melakukan pemetaan terbalik jika disediakan (diatur secara otomatis untuk kosakata pralatih).

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

#### build_inputs_with_special_tokens[[transformers.XLMTokenizer.build_inputs_with_special_tokens]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L475)

**Parameter:**

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

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

**Mengembalikan:** `List[int]`

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

Bangun input model dari satu urutan atau sepasang urutan untuk tugas klasifikasi urutan dengan menggabungkan dan menambahkan token khusus. Urutan XLM memiliki format berikut:

- satu urutan: `<s> X </s>`
- pasangan sekuens: `<s> A </s> B </s>`

#### get_special_tokens_mask[[transformers.XLMTokenizer.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/models/xlm/tokenization_xlm.py#L502)

**Parameter:**

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

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

already_has_special_tokens (`bool`, *opsional*, defaultnya `False`) : Apakah daftar token sudah diformat dengan token khusus untuk model.

**Mengembalikan:** `List[int]`

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. Metode ini dipanggil saat menambahkan token khusus menggunakan metode `prepare_for_model` tokenizer.

#### create_token_type_ids_from_sequences[[transformers.XLMTokenizer.create_token_type_ids_from_sequences]]

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

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

**Parameter:**

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

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

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

ID tipe token sesuai dengan pola yang dikonfigurasi.

Buat mask dari dua urutan yang diteruskan untuk digunakan dalam tugas klasifikasi pasangan urutan.

Metode ini secara dinamis membangun ID tipe token berdasarkan atribut konfigurasi tokenizer:
- `token_type_ids_pattern`: Pola yang digunakan ("all_zeros" atau "bert_style")
- `token_type_ids_include_special_tokens`: Apakah token khusus diperhitungkan dalam perhitungan panjang

Contoh:
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.XLMTokenizer.save_vocabulary]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/tokenization_xlm.py#L530)

## Output khusus XLM[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

#### transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

```python
transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput(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, 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/xlm/modeling_xlm.py#L638)

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

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.

Kelas dasar untuk keluaran model question answering yang menggunakan `XLMSQuADHead`.

## XLMModel[[transformers.XLMModel]]

#### transformers.XLMModel[[transformers.XLMModel]]

```python
transformers.XLMModel(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L667)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 Xlm 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.XLMModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L735)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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.

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:** [BaseModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.BaseModelOutput) atau `tuple(torch.Tensor)`

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

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

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

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

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

## XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

#### transformers.XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

```python
transformers.XLMWithLMHeadModel(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L913)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 model XLM 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.XLMWithLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L957)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk pemodelan bahasa. Perhatikan bahwa label **digeser** di dalam model, yaitu Anda dapat mengatur `labels = input_ids` Indeks dipilih dalam `[-100, 0, ..., config.vocab_size]` Semua label yang diatur ke `-100` diabaikan (dipertahankan), kerugian hanya dihitung untuk label dalam `[0, ..., config.vocab_size]`

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:** [MaskedLMOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) atau `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` diberikan) -- Masked language modeling (MLM) loss.
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMWithLMHeadModel.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

#### transformers.XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

```python
transformers.XLMForSequenceClassification(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1038)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 XLM 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.XLMForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L1050)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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

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:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) atau `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss klasifikasi (atau regresi jika config.num_labels==1).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, config.num_labels)`) -- Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh klasifikasi label tunggal:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> 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 = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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, XLMForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", 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 = XLMForSequenceClassification.from_pretrained(
...     "FacebookAI/xlm-mlm-en-2048", 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
```

## XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

#### transformers.XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

```python
transformers.XLMForMultipleChoice(config: XLMConfig, *inputs, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1446)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 Xlm dengan kepala klasifikasi pilihan ganda di atasnya (lapisan linear di atas output yang dipooling 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.XLMForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L1457)

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

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)

langs (`torch.LongTensor` dengan bentuk `(batch_size, num_choices, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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)

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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

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:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [XLMForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMForMultipleChoice) 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).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForMultipleChoice.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForTokenClassification[[transformers.XLMForTokenClassification]]

#### transformers.XLMForTokenClassification[[transformers.XLMForTokenClassification]]

```python
transformers.XLMForTokenClassification(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1361)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 Xlm 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.XLMForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L1373)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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

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

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:** [TokenClassifierOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [XLMForTokenClassification](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMForTokenClassification) 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).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForTokenClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

#### transformers.XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

```python
transformers.XLMForQuestionAnsweringSimple(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1144)

**Parameter:**

config ([XLMConfig](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMConfig)) : 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 XLM 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.XLMForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = 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/xlm/modeling_xlm.py#L1154)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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.

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:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/id/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) atau `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Total span extraction loss adalah jumlah dari Cross-Entropy untuk posisi awal dan akhir.
- **start_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor awal span (sebelum SoftMax).
- **end_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`) -- Skor akhir span (sebelum SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnsweringSimple.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

#### transformers.XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

```python
transformers.XLMForQuestionAnswering(config: XLMConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlm/modeling_xlm.py#L1243)

**Parameter:**

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

Xlm transformer 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.XLMForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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, 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/xlm/modeling_xlm.py#L1253)

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

langs (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Urutan paralel token yang digunakan untuk menunjukkan bahasa dari setiap token dalam input. Indeks adalah id bahasa yang dapat diperoleh dari nama bahasa dengan menggunakan dua pemetaan konversi yang disediakan dalam konfigurasi model (hanya disediakan untuk model multibahasa). Secara lebih spesifik, pemetaan *nama bahasa ke id bahasa* ada di `model.config.lang2id` (yang merupakan kamus string ke int) dan pemetaan *id bahasa ke nama bahasa* ada di `model.config.id2lang` (kamus int ke string). Lihat contoh penggunaan yang dirinci dalam [dokumentasi multibahasa](../multilingual).

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

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

lengths (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Panjang setiap kalimat yang dapat digunakan untuk menghindari pelaksanaan perhatian pada indeks token padding. Anda juga dapat menggunakan *attention_mask* untuk hasil yang sama (lihat di atas), dipertahankan di sini untuk kompatibilitas. Indeks yang dipilih dalam `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *opsional*) : Instance dari `EncoderDecoderCache` yang berisi keadaan KV yang sudah dihitung sebelumnya. Dapat digunakan untuk mempercepat decoding berurutan.

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.

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:** [XLMForQuestionAnsweringOutput](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [XLMForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/xlm#transformers.XLMForQuestionAnswering) 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.
- **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, XLMForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

