# ALBERT

[ALBERT](https://huggingface.co/papers/1909.11942) dirancang untuk mengatasi keterbatasan memori dalam penskalaan dan pelatihan [BERT](./bert). Model ini menambahkan dua teknik pengurangan parameter. Pertama, parametrisasi embedding terfaktor, yang memisahkan matriks embedding kosakata yang lebih besar menjadi dua matriks yang lebih kecil sehingga Anda dapat meningkatkan ukuran tersembunyi tanpa menambah banyak parameter. Kedua, berbagi parameter lintas lapisan, yang memungkinkan lapisan untuk berbagi parameter sehingga menjaga jumlah parameter yang dapat dipelajari tetap rendah.

ALBERT dibuat untuk mengatasi masalah seperti -- keterbatasan memori GPU/TPU, waktu pelatihan yang lebih lama, dan degradasi model yang tidak terduga pada BERT. ALBERT menggunakan dua teknik pengurangan parameter untuk menurunkan konsumsi memori dan meningkatkan kecepatan pelatihan BERT:

- **Parametrisasi embedding terfaktor:** Matriks embedding kosakata besar diuraikan menjadi dua matriks yang lebih kecil, mengurangi konsumsi memori.
- **Perpindahan parameter lintas lapisan:** Alih-alih mempelajari parameter terpisah untuk setiap lapisan transformer, ALBERT membagikan parameter di antara lapisan, sehingga lebih jauh mengurangi jumlah bobot yang dapat dipelajari.

ALBERT menggunakan embedding posisi absolut (seperti BERT) sehingga padding diterapkan di sisi kanan. Ukuran embedding adalah 128. Sementara BERT menggunakan 768. ALBERT dapat memproses maksimum 512 token sekaligus.

Anda dapat menemukan semua checkpoint ALBERT asli di bawah organisasi [komunitas ALBERT](https://huggingface.co/albert).

> [!TIP]
> Klik pada model ALBERT di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan ALBERT ke berbagai tugas bahasa.

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="albert-base-v2",
    device=0
)
pipeline("Plants create [MASK] through a process known as photosynthesis.", top_k=5)
```

```python
import torch

from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
model = AutoModelForMaskedLM.from_pretrained(
    "albert/albert-base-v2",
    attn_implementation="sdpa",
    device_map="auto"
)

prompt = "Plants create energy through a process known as [MASK]."
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)
    mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]
    predictions = outputs.logits[0, mask_token_index]

top_k = torch.topk(predictions, k=5).indices.tolist()
for token_id in top_k[0]:
    print(f"Prediction: {tokenizer.decode([token_id])}")
```

## Catatan

- Input harus di-*pad* di sisi kanan karena BERT menggunakan *embedding* posisi absolut.
- Ukuran embedding `E` berbeda dari ukuran tersembunyi `H` karena embedding bersifat independen konteks (satu vektor embedding mewakili satu token) sedangkan keadaan tersembunyi bergantung pada konteks (satu keadaan tersembunyi mewakili urutan token). Matriks embedding juga lebih besar karena `V x E` di mana `V` adalah ukuran kosakata. Akibatnya, lebih logis jika `H >> E`. Jika `E < H`, model memiliki lebih sedikit parameter.

## Sumber daya

Sumber daya yang disediakan dalam bagian-bagian berikut terdiri dari daftar sumber daya resmi Hugging Face dan komunitas (ditandai dengan 🌎) untuk membantu Anda memulai dengan ALBERT. Jika Anda tertarik untuk mengirimkan sumber daya agar disertakan di sini, silakan buka Pull Request dan kami akan meninjaunya! Sumber daya tersebut sebaiknya mendemonstrasikan sesuatu yang baru, bukan menduplikasi sumber daya yang sudah ada.

- Periksa [panduan tugas klasifikasi teks](../tasks/sequence_classification) untuk cara menggunakan model.

- Bab [Klasifikasi token](https://huggingface.co/course/chapter7/2?fw=pt) dari Kursus 🤗 Hugging Face.
- Periksa [panduan tugas klasifikasi token](../tasks/token_classification) untuk cara menggunakan model.

- [AlbertForMaskedLM](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForMaskedLM) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/language_modeling.ipynb) ini.
- Bab [Masked language modeling](https://huggingface.co/course/chapter7/3?fw=pt) dari Kursus 🤗 Hugging Face.
- Periksa [panduan tugas pemodelan bahasa tersembunyi](../tasks/masked_language_modeling) untuk cara menggunakan model.

- [AlbertForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForQuestionAnswering) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/question_answering.ipynb) ini.
- Bab [Question answering](https://huggingface.co/course/chapter7/7?fw=pt) dari Kursus 🤗 Hugging Face.
- Periksa [panduan tugas Question answering](../tasks/question_answering) untuk cara menggunakan model.

**Pilihan ganda**

- [AlbertForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForMultipleChoice) didukung oleh [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multiple_choice.ipynb) ini.
- Periksa [Panduan tugas pilihan ganda](../tasks/multiple_choice) untuk cara menggunakan model.

## AlbertConfig[[transformers.AlbertConfig]]

#### transformers.AlbertConfig[[transformers.AlbertConfig]]

```python
transformers.AlbertConfig(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 = 30000, embedding_size: int = 128, hidden_size: int = 4096, num_hidden_layers: int = 12, num_hidden_groups: int = 1, num_attention_heads: int = 64, intermediate_size: int = 16384, inner_group_num: int = 1, hidden_act: str = 'gelu_new', hidden_dropout_prob: int | float = 0.0, attention_probs_dropout_prob: int | float = 0.0, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, classifier_dropout_prob: int | float = 0.1, pad_token_id: int | None = 0, bos_token_id: int | None = 2, eos_token_id: int | list[int] | None = 3, tie_word_embeddings: bool = True)
```

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

**Parameter:**

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

embedding_size (`int`, *opsional*, defaultnya `128`) : Dimensi dari embedding dan hidden states.

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

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

num_hidden_groups (`int`, *opsional*, default 1) : Jumlah grup untuk lapisan tersembunyi, parameter dalam grup yang sama dibagikan.

num_attention_heads (`int`, *opsional*, defaultnya `64`) : Jumlah attention heads untuk setiap lapisan attention dalam decoder Transformer.

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

inner_group_num (`int`, *opsional*, default 1) : Jumlah pengulangan internal dari attention dan ffn.

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

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

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

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

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

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

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

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

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

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

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `3`) : 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 AlbertModel. Kelas ini digunakan untuk membuat instans model Albert sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [albert/albert-xxlarge-v2](https://huggingface.co/albert/albert-xxlarge-v2)

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 AlbertConfig, AlbertModel

>>> # Initializing an ALBERT-xxlarge style configuration
>>> albert_xxlarge_configuration = AlbertConfig()

>>> # Initializing an ALBERT-base style configuration
>>> albert_base_configuration = AlbertConfig(
...     hidden_size=768,
...     num_attention_heads=12,
...     intermediate_size=3072,
... )

>>> # Initializing a model (with random weights) from the ALBERT-base style configuration
>>> model = AlbertModel(albert_xxlarge_configuration)

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

## AlbertTokenizer[[transformers.AlbertTokenizer]]

#### transformers.AlbertTokenizer[[transformers.AlbertTokenizer]]

```python
transformers.AlbertTokenizer(vocab: str | list[tuple[str, float]] | None = None, do_lower_case: bool = True, keep_accents: bool = False, bos_token: str = '[CLS]', eos_token: str = '[SEP]', unk_token: str = '<unk>', sep_token: str = '[SEP]', pad_token: str = '<pad>', cls_token: str = '[CLS]', mask_token: str = '[MASK]', _spm_precompiled_charsmap: str | None = None, add_prefix_space: bool = True, trim_offsets: bool = True, **kwargs)
```

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

**Parameter:**

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

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

bos_token (`str`, *opsional*, defaultnya `"[CLS]"`) : 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 `"[SEP]"`) : Token akhir urutan. .. note:: 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 merupakan 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.

add_prefix_space (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan spasi awal ke input. Hal ini memungkinkan kata pembuka diperlakukan sama seperti kata lainnya.

trim_offsets (`bool`, *opsional*, defaultnya `True`) : Apakah langkah pascaproses harus memangkas offset untuk menghindari penyertaan spasi.

vocab (`str` atau `list[tuple[str, float]]`, *opsional*) : Kosakata kustom dengan tuple `(token, score)`. Jika tidak disediakan, kosakata dimuat dari `vocab_file`.

vocab_file (`str`, *opsional*) : file [SentencePiece](https://github.com/google/sentencepiece) (umumnya berekstensi .model) yang berisi kosakata yang diperlukan untuk menginstansiasi tokenizer.

Konstruksi tokenizer ALBERT "fast" (didukung oleh pustaka *tokenizers* dari HuggingFace). Berbasis pada [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models). Tokenizer ini mewarisi dari [PreTrainedTokenizerFast](/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.AlbertTokenizer.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.AlbertTokenizer.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 spesifik Albert[[transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput]]

#### transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput[[transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput]]

```python
transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, prediction_logits: typing.Optional[torch.Tensor] = None, sop_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/albert/modeling_albert.py#L317)

**Parameter:**

loss (`*optional*`, dikembalikan saat `labels` disediakan, `torch.Tensor` dengan bentuk `(1,)`) : Total loss sebagai jumlah dari masked language modeling loss dan next sequence prediction (classification) loss.

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

sop_logits (`torch.Tensor` dengan bentuk `(batch_size, 2)`) : Skor prediksi dari kepala prediksi urutan berikutnya (klasifikasi) (skor kelanjutan True/False sebelum SoftMax).

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 dari 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 [AlbertForPreTraining](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForPreTraining).

## AlbertModel[[transformers.AlbertModel]]

#### transformers.AlbertModel[[transformers.AlbertModel]]

```python
transformers.AlbertModel(config: AlbertConfig, add_pooling_layer: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L337)

**Parameter:**

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

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

Model Albert 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.AlbertModel.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L369)

**Parameter:**

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

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

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

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

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

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

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

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

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

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

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

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

## AlbertForPreTraining[[transformers.AlbertForPreTraining]]

#### transformers.AlbertForPreTraining[[transformers.AlbertForPreTraining]]

```python
transformers.AlbertForPreTraining(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L417)

**Parameter:**

config ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) : 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 Albert dengan dua head di bagian atas seperti yang dilakukan selama pra-pelatihan: head `masked language modeling` dan head `sentence order prediction (classification)`.

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

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L442)

**Parameter:**

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

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

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

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

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

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada dalam `[-100, 0, ..., config.vocab_size]` (lihat docstring `input_ids`) Token dengan indeks yang diset ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam `[0, ..., config.vocab_size]`

sentence_order_label (`torch.LongTensor` dengan bentuk `(batch_size,)`, *opsional*) : Label untuk menghitung kerugian prediksi urutan berikutnya (klasifikasi). Input harus berupa pasangan urutan (lihat docstring `input_ids`). Indeks harus berada dalam `[0, 1]`. `0` menunjukkan urutan asli (urutan A, kemudian urutan B), `1` menunjukkan urutan yang ditukar (urutan B, kemudian urutan A).

**Mengembalikan:** [AlbertForPreTrainingOutput](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [AlbertForPreTraining](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForPreTraining) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Total loss sebagai jumlah dari masked language modeling loss dan next sequence prediction (klasifikasi) loss.
- **prediction_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).
- **sop_logits** (`torch.Tensor` dengan bentuk `(batch_size, 2)`) -- Skor prediksi dari head prediksi urutan berikutnya (klasifikasi) (skor kelanjutan True/False sebelum SoftMax).
- **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, AlbertForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForPreTraining.from_pretrained("albert/albert-base-v2")

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

>>> prediction_logits = outputs.prediction_logits
>>> sop_logits = outputs.sop_logits
```

## AlbertForMaskedLM[[transformers.AlbertForMaskedLM]]

#### transformers.AlbertForMaskedLM[[transformers.AlbertForMaskedLM]]

```python
transformers.AlbertForMaskedLM(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L547)

**Parameter:**

config ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) : 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 Albert dengan kepala `language modeling` 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.AlbertForMaskedLM.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L572)

**Parameter:**

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

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

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

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

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

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan. Indeks harus berada dalam `[-100, 0, ..., config.vocab_size]` (lihat docstring `input_ids`) Token dengan indeks yang diset ke `-100` diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam `[0, ..., config.vocab_size]`.

**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` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) dan input.

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

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-base-v2")
>>> model = AlbertForMaskedLM.from_pretrained("albert/albert-base-v2")

>>> # add mask_token
>>> inputs = tokenizer("The capital of [MASK] is Paris.", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
'france'
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
0.81
```

## AlbertForSequenceClassification[[transformers.AlbertForSequenceClassification]]

#### transformers.AlbertForSequenceClassification[[transformers.AlbertForSequenceClassification]]

```python
transformers.AlbertForSequenceClassification(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L646)

**Parameter:**

config ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) : 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 transformer Albert dengan kepala klasifikasi/regresi urutan di atasnya (lapisan linear di atas output yang dipool) misalnya untuk tugas GLUE.

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

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

#### forward[[transformers.AlbertForSequenceClassification.forward]]

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

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

**Parameter:**

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

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

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

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

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

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-xxlarge-v2")
>>> model = AlbertForSequenceClassification.from_pretrained("albert/albert-xxlarge-v2")

>>> 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 = AlbertForSequenceClassification.from_pretrained("albert/albert-xxlarge-v2", 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, AlbertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-xxlarge-v2")
>>> model = AlbertForSequenceClassification.from_pretrained("albert/albert-xxlarge-v2", 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 = AlbertForSequenceClassification.from_pretrained(
...     "albert/albert-xxlarge-v2", 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
```

## AlbertForMultipleChoice[[transformers.AlbertForMultipleChoice]]

#### transformers.AlbertForMultipleChoice[[transformers.AlbertForMultipleChoice]]

```python
transformers.AlbertForMultipleChoice(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L844)

**Parameter:**

config ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) : 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 Albert 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.AlbertForMultipleChoice.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L855)

**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.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) dan [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 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)

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)

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)

**Mengembalikan:** [AlbertForPreTrainingOutput](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [AlbertForMultipleChoice](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForMultipleChoice) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Total loss sebagai jumlah dari masked language modeling loss dan next sequence prediction (klasifikasi) loss.
- **prediction_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).
- **sop_logits** (`torch.Tensor` dengan bentuk `(batch_size, 2)`) -- Skor prediksi dari head prediksi urutan berikutnya (klasifikasi) (skor kelanjutan True/False sebelum SoftMax).
- **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, AlbertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-xxlarge-v2")
>>> model = AlbertForMultipleChoice.from_pretrained("albert/albert-xxlarge-v2")

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

## AlbertForTokenClassification[[transformers.AlbertForTokenClassification]]

#### transformers.AlbertForTokenClassification[[transformers.AlbertForTokenClassification]]

```python
transformers.AlbertForTokenClassification(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L718)

**Parameter:**

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

Transformers Albert 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.AlbertForTokenClassification.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L735)

**Parameter:**

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

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

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

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

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

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

**Mengembalikan:** [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 ([AlbertConfig](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertConfig)) dan input.

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

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-xxlarge-v2")
>>> model = AlbertForTokenClassification.from_pretrained("albert/albert-xxlarge-v2")

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

## AlbertForQuestionAnswering[[transformers.AlbertForQuestionAnswering]]

#### transformers.AlbertForQuestionAnswering[[transformers.AlbertForQuestionAnswering]]

```python
transformers.AlbertForQuestionAnswering(config: AlbertConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L776)

**Parameter:**

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

Transformers Albert 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.AlbertForQuestionAnswering.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/albert/modeling_albert.py#L787)

**Parameter:**

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

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

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

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

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

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

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

**Mengembalikan:** [AlbertForPreTrainingOutput](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.models.albert.modeling_albert.AlbertForPreTrainingOutput) atau `tuple(torch.Tensor)`

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

Metode forward dari [AlbertForQuestionAnswering](/docs/transformers/v5.23.0/id/model_doc/albert#transformers.AlbertForQuestionAnswering) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Total loss sebagai jumlah dari masked language modeling loss dan next sequence prediction (klasifikasi) loss.
- **prediction_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).
- **sop_logits** (`torch.Tensor` dengan bentuk `(batch_size, 2)`) -- Skor prediksi dari head prediksi urutan berikutnya (klasifikasi) (skor kelanjutan True/False sebelum SoftMax).
- **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, AlbertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("albert/albert-xxlarge-v2")
>>> model = AlbertForQuestionAnswering.from_pretrained("albert/albert-xxlarge-v2")

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