# Model

Kelas dasar [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) mengimplementasikan metode umum untuk memuat/menyimpan model, baik dari file atau direktori lokal, maupun dari konfigurasi model pretrained yang disediakan oleh pustaka (diunduh dari HuggingFace's Hub).

[PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) juga mengimplementasikan beberapa metode yang umum di antara semua model untuk:

- ubah ukuran embedding token input ketika token baru ditambahkan ke dalam kosakata

Metode lain yang umum untuk setiap model didefinisikan di [ModuleUtilsMixin](/docs/transformers/v5.23.0/id/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) dan [GenerationMixin](/docs/transformers/v5.23.0/id/main_classes/text_generation#transformers.GenerationMixin).

## PreTrainedModel[[transformers.PreTrainedModel]]

#### transformers.PreTrainedModel[[transformers.PreTrainedModel]]

```python
transformers.PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

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

Kelas dasar untuk semua model.

[PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel) menangani penyimpanan konfigurasi model serta menangani metode untuk memuat, mengunduh, dan menyimpan model, serta beberapa metode yang umum untuk semua model:

- resize embedding input

Atribut kelas (ditimpa oleh kelas turunan):

- **config_class** ([PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig)) -- Subkelas dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) yang digunakan sebagai kelas konfigurasi untuk arsitektur model ini.
- **base_model_prefix** (`str`) -- String yang menunjukkan atribut yang terkait dengan model dasar pada kelas turunan dari arsitektur yang sama yang menambahkan modul di atas model dasar.
- **main_input_name** (`str`) -- Nama input utama model (sering kali `input_ids` untuk model NLP, `pixel_values` untuk model visi, dan `input_values` untuk model ucapan).
- **can_record_outputs** (dict):

#### push_to_hub[[transformers.PreTrainedModel.push_to_hub]]

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

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

**Parameter:**

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

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan secara default menjadi `"Upload model"`.

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

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

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

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

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

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

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

Unggah file model ke 🤗 Model Hub.

Contoh:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

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

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

#### activation_checkpointing_disable[[transformers.PreTrainedModel.activation_checkpointing_disable]]

```python
activation_checkpointing_disable()
```

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

Menonaktifkan aktivasi checkpointing untuk model saat ini.

#### activation_checkpointing_enable[[transformers.PreTrainedModel.activation_checkpointing_enable]]

```python
activation_checkpointing_enable(activation_checkpointing_kwargs = None, every_n_layers: int = 1, offload: bool = False)
```

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

**Parameter:**

every_n_layers (`int`, *opsional*, default 1) : Buat checkpoint hanya setiap `every_n_layers` lapisan decoder, sementara lapisan lainnya tetap menyimpan aktivasi. Nilai `1` membuat checkpoint untuk setiap lapisan, yang merupakan perilaku all-or-nothing yang umum. Nilai yang lebih besar mengorbankan kecepatan demi menghemat memori, yang sepadan ketika memori yang dibebaskan oleh checkpoint penuh tidak terpakai.

offload (`bool`, *opsional*, default `False`) : Simpan aktivasi yang disimpan untuk recompute di memori host yang di-pin alih-alih di akselerator. Ini membebaskan `layers x sequence x hidden` byte memori perangkat, yang menjadi faktor dominan pada panjang sekuens yang panjang, dan menimbulkan biaya salinan dari perangkat ke host di forward serta salinan dari host ke perangkat di backward. Kedua salinan tersebut berjalan di stream komputasi, sehingga langkahnya menjadi lebih lambat.

activation_checkpointing_kwargs (dict, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke fungsi `torch.utils.checkpoint.checkpoint`.

Mengaktifkan activation checkpointing untuk model saat ini.

Kami melewatkan metode `__call__` dari modul, bukan `forward`, karena `__call__` menempelkan semua hook dari modul tersebut. https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

#### add_model_tags[[transformers.PreTrainedModel.add_model_tags]]

```python
add_model_tags(tags: list[str] | str)
```

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

**Parameter:**

tags (`Union[list[str], str]`) : Tag yang diinginkan untuk disuntikkan ke dalam model

Tambahkan tag kustom ke model yang di-*push* ke Hugging Face Hub. Tidak akan menimpa tag yang sudah ada di model.

Contoh:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

model.add_model_tags(["custom", "custom-bert"])

# Push the model to your namespace with the name "my-custom-bert".
model.push_to_hub("my-custom-bert")
```

#### can_generate[[transformers.PreTrainedModel.can_generate]]

```python
can_generate()
```

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

**Mengembalikan:** `bool`

Apakah model ini dapat menghasilkan rangkaian dengan `.generate()`.

Mengembalikan apakah model ini dapat menghasilkan rangkaian dengan `.generate()`, dari `GenerationMixin` atau yang memiliki antarmuka serupa.

Di balik layar, pada kelas di mana fungsi ini mengembalikan True, beberapa perubahan yang spesifik untuk generasi dipicu: misalnya, instans model akan memiliki atribut `generation_config` yang terisi.

#### cuda[[transformers.PreTrainedModel.cuda]]

```python
cuda(*args, **kwargs)
```

Nilai mock untuk jalur bertitik (misalnya `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

#### dequantize[[transformers.PreTrainedModel.dequantize]]

```python
dequantize(dtype = None)
```

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

Potensi untuk melakukan dequantisasi model jika model tersebut telah dikuantisasi dengan metode kuantisasi yang mendukung dequantisasi.

#### disable_input_require_grads[[transformers.PreTrainedModel.disable_input_require_grads]]

```python
disable_input_require_grads()
```

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

Menghapus `_require_grads_hook`.

#### enable_input_require_grads[[transformers.PreTrainedModel.enable_input_require_grads]]

```python
enable_input_require_grads()
```

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

Mengaktifkan gradien untuk input embeddings. Hal ini berguna untuk fine-tuning bobot adapter sambil menjaga bobot model tetap tetap.

#### from_pretrained[[transformers.PreTrainedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, *model_args, config: transformers.configuration_utils.PreTrainedConfig | str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', use_safetensors: bool | None = None, weights_only: bool = True, fusion_config: dict[str, bool | dict[str, typing.Any]] | None = None, disable_mmap: bool | None = None, **kwargs)
```

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

**Parameter:**

pretrained_model_name_or_path (`str` atau `os.PathLike`, *opsional*) : Dapat berupa salah satu dari:  - String, yaitu *model id* dari model pretrained yang dihosting di dalam model repo di huggingface.co. - Path ke *directory* yang berisi bobot model yang disimpan menggunakan [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.save_pretrained), misalnya `./my_model_directory/`. Directory yang disimpan dengan `save_pretrained(..., distributed_checkpoint=True)` akan terdeteksi dan dimuat dengan distributed checkpointing (DCP), sehingga mempertahankan mesh dan placements model saat ini. Hal ini membutuhkan `torch>=2.7` dan memuat secara ketat: setiap kunci model harus ada di dalam checkpoint. - `None` jika Anda menyediakan konfigurasi dan state dictionary (masing-masing dengan argumen kata kunci `config` dan `state_dict`).

model_args (urutan argumen posisional, *opsional*) : Semua argumen posisional yang tersisa akan diteruskan ke metode `__init__` model yang mendasarinya.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *opsional*) : Dapat berupa salah satu dari:  - sebuah instance dari kelas yang diturunkan dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig), - sebuah string atau path yang valid sebagai input untuk [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).  Konfigurasi untuk model yang akan digunakan sebagai pengganti konfigurasi yang dimuat secara otomatis. Konfigurasi dapat dimuat secara otomatis ketika:  - Model tersebut adalah model yang disediakan oleh pustaka (dimuat dengan string *model id* dari model pretrained). - Model tersebut disimpan menggunakan [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) dan dimuat ulang dengan menyediakan direktori penyimpanan. - Model tersebut dimuat dengan menyediakan direktori lokal sebagai `pretrained_model_name_or_path` dan file konfigurasi JSON bernama *config.json* ditemukan di dalam direktori tersebut.

state_dict (`dict[str, torch.Tensor]`, *opsional*) : Kamus keadaan yang akan digunakan sebagai pengganti kamus keadaan yang dimuat dari file bobot yang disimpan. Opsi ini dapat digunakan jika Anda ingin membuat model dari konfigurasi pralatih tetapi memuat bobot Anda sendiri. Namun, dalam kasus ini, Anda sebaiknya memeriksa apakah penggunaan [save_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) dan [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) bukan merupakan opsi yang lebih sederhana.

cache_dir (`Union[str, os.PathLike]`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh harus di-cache jika cache standar tidak digunakan.

ignore_mismatched_sizes (`bool`, *opsional*, default `False`) : Apakah akan melempar error jika beberapa bobot dari checkpoint tidak memiliki ukuran yang sama dengan bobot model (misalnya, jika Anda menginstansiasi model dengan 10 label dari checkpoint yang memiliki 3 label).

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

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

output_loading_info(`bool`, *opsional*, default `False`) : Apakah akan mengembalikan kamus yang berisi kunci yang hilang, kunci yang tidak terduga, dan pesan kesalahan.

local_files_only(`bool`, *opsional*, default `False`) : Apakah hanya melihat file lokal (yaitu, tidak mencoba mengunduh model).

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

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa identifikasi apa pun yang diizinkan oleh git.    Untuk menguji pull request yang Anda buat di Hub, Anda dapat meneruskan `revision="refs/pr/<pr_number>"`.

attn_implementation (`str`, *opsional*) : Implementasi attention yang akan digunakan dalam model (jika relevan). Dapat berupa salah satu dari - `"eager"` (implementasi manual dari attention) - `"sdpa"` (menggunakan [`F.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html)) - `"flash_attention_2"` (menggunakan [Dao-AILab/flash-attention](https://github.com/Dao-AILab/flash-attention)) - `"flash_attention_3"` (menggunakan [Dao-AILab/flash-attention/hopper](https://github.com/Dao-AILab/flash-attention/tree/main/hopper)) - `"flash_attention_4"` (menggunakan [Dao-AILab/flash-attention/flash_attn/cute](https://github.com/Dao-AILab/flash-attention/tree/main/flash_attn/cute)). Secara default, jika tersedia, SDPA akan digunakan. Default lainnya adalah implementasi manual `"eager"`.  Menerima referensi kernel HF dalam bentuk: /[@][:]  -  dan  adalah urutan karakter apa pun selain "/" dan ":". - "@" bersifat opsional (branch, tag, atau commit-ish), misalnya "@main", "@v1.2.0", "@abc123". - ":" bersifat opsional dan memilih fungsi di dalam repo kernel. - Kedua opsi dapat muncul bersama dan hanya dalam urutan ini: @revision terlebih dahulu, kemudian :kernel_name. - Kami sengaja mengizinkan prefiks "|" di awal (misalnya, "flash|...") karena kode akan menghapusnya sebelum dimuat; '|' tidak dikecualikan dalam kelas karakter di sini.  Contoh yang cocok: "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *opsional*) : Implementasi expert yang akan digunakan dalam model (jika relevan). Bisa berupa salah satu dari:  - `"eager"` (implementasi sekuensial dari perkalian matriks expert). - `"batched_mm"` (menggunakan [`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html)). - `"grouped_mm"` (menggunakan [`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html)).  Secara default, jika model mendukungnya, `"grouped_mm"` akan digunakan. Jika tidak, default-nya adalah implementasi `"eager"` manual.

**Parameter untuk inferensi model besar:**

dtype (`str` atau `torch.dtype`, *opsional*, default `"auto"`) : Menimpa `torch_dtype` default dan memuat model dengan `dtype` tertentu. Opsi yang tersedia adalah:  1. `torch.float16` atau `torch.bfloat16` atau `torch.float`: memuat model dengan `dtype` yang ditentukan, mengabaikan `config.dtype` model jika ada. Jika tidak ditentukan, model akan dimuat dalam `torch.float` (fp32).  2. `"auto"` - Entri `dtype` atau `torch_dtype` dalam file `config.json` model akan dicoba untuk digunakan. Jika entri ini tidak ditemukan, langkah selanjutnya adalah memeriksa `dtype` dari bobot pertama dalam checkpoint yang bertipe floating point dan menggunakannya sebagai `dtype`. Ini akan memuat model menggunakan `dtype` yang digunakan saat model disimpan di akhir pelatihan. Hal ini tidak dapat dijadikan indikator tentang bagaimana model tersebut dilatih, karena model mungkin dilatih dengan salah satu dtype presisi setengah, tetapi disimpan dalam fp32.  3. String yang merupakan `torch.dtype` yang valid. Misalnya, "float32" memuat model dalam `torch.float32`, "float16" memuat dalam `torch.float16`, dan seterusnya.    Untuk beberapa model, `dtype` yang digunakan saat pelatihan tidak diketahui - Anda dapat mencoba memeriksa paper model atau menghubungi para penulisnya dan meminta mereka untuk menambahkan informasi ini ke kartu model serta menyisipkan entri `dtype` atau `torch_dtype` dalam `config.json` di hub.

device_map (`str` atau `dict[str, Union[int, str, torch.device]]` atau `int` atau `torch.device`, *opsional*) : Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Tidak perlu dirinci hingga nama parameter/buffer; begitu nama modul tertentu dimasukkan, semua submodul di dalamnya akan dikirim ke perangkat yang sama. Jika hanya perangkat yang dilewatkan (*mis.*, `"cpu"`, `"cuda:1"`, `"mps"`, atau peringkat ordinal GPU seperti `1`) tempat model akan dialokasikan, peta perangkat akan memetakan seluruh model ke perangkat ini. Melewatkan `device_map = 0` berarti menempatkan seluruh model di GPU 0. Agar Accelerate menghitung `device_map` paling optimal secara otomatis, atur `device_map="auto"`. Untuk informasi lebih lanjut tentang setiap opsi, lihat [mendesain peta perangkat](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map).

max_memory (`Dict`, *opsional*) : Kamus pengidentifikasi perangkat ke memori maksimum jika menggunakan `device_map`. Jika tidak disetel, nilai defaultnya adalah memori maksimum yang tersedia untuk setiap GPU dan RAM CPU yang tersedia.

distributed_config ([DistributedConfig](/docs/transformers/v5.23.0/id/expert_parallelism#transformers.DistributedConfig), *opsional*) : Konfigurasi untuk pemuatan terdistribusi native dengan tensor parallelism atau FSDP2. Sampaikan `DistributedConfig(tp_size=N)` untuk menggunakan rencana tensor parallel yang telah didefinisikan sebelumnya pada model, `DistributedConfig(tp_plan=...)` untuk menentukan rencana tensor parallel, atau `DistributedConfig(fsdp_size=N)` untuk FSDP2. Memerlukan `torchrun` dan grup proses yang telah diinisialisasi ketika `tp_size > 1` atau `fsdp_size > 1`. Saling eksklusif dengan `device_map`.

device_mesh (`torch.distributed.DeviceMesh`, *opsional*) : Mesh perangkat torch. Jika tidak disediakan, akan menggunakan world size sebagai nilai default. Saat ini hanya digunakan untuk tensor parallel. Jika disediakan, mesh tersebut harus mengandung dimensi bernama `"tp"` jika dimensinya > 1; dimensi ini akan digunakan untuk tensor parallelism.

offload_folder (`str` atau `os.PathLike`, *opsional*) : Jika `device_map` berisi nilai `"disk"`, folder tempat bobot akan di-offload.

offload_buffers (`bool`, *opsional*) : Apakah akan meng-offload buffer dengan parameter model atau tidak.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *opsional*) : Kamus parameter konfigurasi atau objek QuantizationConfigMixin untuk kuantisasi (misalnya bitsandbytes, gptq).

subfolder (`str`, *opsional*, default `""`) : Jika file yang relevan berada di dalam subfolder dari repo model di huggingface.co, Anda dapat menentukan nama folder di sini.

variant (`str`, *opsional*) : Jika ditentukan, muat bobot dari nama file `variant`, *mis.* pytorch_model..bin.

use_safetensors (`bool`, *opsional*, default `None`) : Apakah akan menggunakan checkpoint `safetensors` atau tidak. Defaultnya adalah `None`. Jika tidak ditentukan dan `safetensors` tidak terinstal, nilainya akan disetel ke `False`.

weights_only (`bool`, *opsional*, default `True`) : Menunjukkan apakah unpickler harus dibatasi untuk hanya memuat tensor, tipe primitif, kamus, dan tipe apa pun yang ditambahkan melalui torch.serialization.add_safe_globals(). Jika diatur ke False, kita dapat memuat bobot subkelas tensor wrapper.

disable_mmap (`bool`, *opsional*) : Apakah akan menonaktifkan memory mapping saat memuat checkpoint safetensors. Ketika `None` (default), nilainya dideteksi secara otomatis menjadi `True` jika checkpoint berada pada sistem berkas FUSE `hf-mount` (digunakan oleh HF Spaces/Endpoints), di mana mmap + parallel page-faults dapat menyebabkan deadlock. Ketika `True`, berkas dibaca sepenuhnya ke dalam memori dan diurai dengan `safetensors.torch.load`. Ketika `False`, loader memory-mapped default selalu digunakan.

fusion_config (`dict[str, bool | dict[str, Any]]`, *opsional*) : Konfigurasi fusion opsional yang diterapkan sebelum instansiasi model. Setiap kunci mengaktifkan keluarga fusion, dan nilainya dapat berupa `True` untuk mengaktifkan fusion tersebut dengan opsi default, atau sebuah dictionary berisi opsi spesifik keluarga. Sebagai contoh, `{"patch_embeddings": True}` mengaktifkan fusion patch embedding. Ini sebaiknya hanya digunakan sebagai optimasi inferensi, karena dapat sedikit mengubah output. Jika diabaikan, `from_pretrained()` akan kembali ke `config.fusion_config` jika tersedia. Lihat panduan pemetaan fusion di `docs/source/en/fusion_mapping.md` untuk detail lebih lanjut.

key_mapping (`dict[str, str], *opsional*) : Pemetaan potensial untuk nama bobot jika menggunakan model di Hub yang kompatibel dengan arsitektur Transformers, tetapi tidak dikonversi secara sesuai.

kwargs (sisa kamus argumen kata kunci, *opsional*) : Dapat digunakan untuk memperbarui objek konfigurasi (setelah dimuat) dan menginisiasi model (misalnya, `output_attentions=True`). Perilakunya berbeda tergantung pada apakah `config` disediakan atau dimuat secara otomatis: - Jika konfigurasi disediakan dengan `config`, `**kwargs` akan langsung diteruskan ke metode `__init__` model yang mendasarinya (kami asumsikan semua pembaruan relevan pada konfigurasi sudah dilakukan) - Jika konfigurasi tidak disediakan, `kwargs` akan terlebih dahulu diteruskan ke fungsi inisialisasi kelas konfigurasi ([from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)). Setiap kunci dari `kwargs` yang sesuai dengan atribut konfigurasi akan digunakan untuk menimpa atribut tersebut dengan nilai `kwargs` yang diberikan. Kunci-kunci tersisa yang tidak sesuai dengan atribut konfigurasi apa pun akan diteruskan ke fungsi `__init__` model yang mendasarinya.

Instansiasi model pytorch pretrained dari konfigurasi model pre-trained.

Model secara default diatur dalam mode evaluasi menggunakan `model.eval()` (modul Dropout dinonaktifkan). Untuk melatih model, Anda harus terlebih dahulu mengembalikannya ke mode pelatihan dengan `model.train()`.

Peringatan *Weights from XXX not initialized from pretrained model* berarti bahwa bobot dari XXX tidak disertakan sebagai bagian dari model pretrained lainnya. Anda perlu melatih bobot tersebut dengan tugas fine-tuning downstream.

Peringatan *Weights from XXX not used in YYY* berarti bahwa layer XXX tidak digunakan oleh YYY, sehingga bobot tersebut dibuang.

Aktifkan ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) khusus untuk menggunakan metode ini di lingkungan yang terisolasi oleh firewall.

Contoh:

```python
>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
```

#### get_compiled_call[[transformers.PreTrainedModel.get_compiled_call]]

```python
get_compiled_call(compile_config: transformers.generation.configuration_utils.CompileConfig | None)
```

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

Kembalikan versi `torch.compile` dari `self.__call__`. Hal ini berguna untuk memilih secara dinamis antara `forward` yang tidak dikompilasi/dikompilasi selama inferensi, terutama untuk beralih antara prefill (di mana kami tidak ingin menggunakan versi terkompilasi untuk menghindari penghitungan ulang graf dengan bentuk baru) dan decoding iteratif (di mana kami menginginkan percepatan dari versi terkompilasi dengan bentuk statis).

#### get_decoder[[transformers.PreTrainedModel.get_decoder]]

```python
get_decoder()
```

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

Pencarian terbaik (best-effort) untuk modul *decoder*.

Urutan percobaan (menutupi ~85 % penggunaan saat ini):

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (banyak wrapper menyimpan decoder di sini)
3. `self.base_model.get_decoder()`    (wrapper bersarang)
4. fallback: raise untuk beberapa model eksotis yang memerlukan aturan khusus

#### get_encoder[[transformers.PreTrainedModel.get_encoder]]

```python
get_encoder(modality: str | None = None)
```

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

Pencarian terbaik (best-effort) untuk modul *encoder*. Jika diberikan argumen `modality`, fungsi ini mencari encoder yang spesifik untuk modalitas pada model multimodal (misalnya "image_encoder"). Secara default, fungsi ini mengembalikan encoder teks dari model jika ada, dan jika tidak, mengembalikan `self`.

Nilai `modality` yang mungkin adalah "image", "video", dan "audio".

#### get_expanded_tied_weights_keys[[transformers.PreTrainedModel.get_expanded_tied_weights_keys]]

```python
get_expanded_tied_weights_keys(all_submodels: bool = False)
```

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

Kembalikan kunci bobot terikat yang telah diperluas (jika berisi modul atau pola regex) hanya untuk model saat ini, atau secara rekursif untuk semua submodel jika `all_submodels=True` (yaitu, nilai konfigurasi untuk semua submodel akan diperiksa ulang).

Untuk hampir semua model, kami hanya perlu mengikat embedding, sehingga model memiliki properti internal `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}`. Dalam kasus ini, pemetaan sudah "diperluas", yaitu sudah berisi parameter lengkap, dan fungsi ini akan sekadar mengembalikan salinan dari properti tersebut. Untuk pola yang lebih kompleks, misalnya untuk `DFineForObjectDetection`, kami memiliki atribut berikut

```
_tied_weights_keys = {
    r"bbox_embed.(?![0])\d+": "bbox_embed.0",
    r"class_embed.(?![0])\d+": "class_embed.0",
    "model.decoder.class_embed": "class_embed",
    "model.decoder.bbox_embed": "bbox_embed",
}
```

Dalam kasus ini, fungsi tersebut mencari semua parameter dan buffer model, lalu mencocokkan semua parameter,

mengembalikan hal berikut:
```
{
    'bbox_embed.1.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.1.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'bbox_embed.1.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'bbox_embed.1.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    'bbox_embed.1.layers.2.bias': 'bbox_embed.0.layers.2.bias',
    'bbox_embed.1.layers.2.weight': 'bbox_embed.0.layers.2.weight',
    'bbox_embed.2.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.2.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    ...
    'class_embed.1.bias': 'class_embed.0.bias',
    'class_embed.1.weight': 'class_embed.0.weight',
    'class_embed.2.bias': 'class_embed.0.bias',
    'class_embed.2.weight': 'class_embed.0.weight',
    ...
    'model.decoder.class_embed.0.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.0.weight': 'class_embed.0.weight',
    'model.decoder.class_embed.1.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.1.weight': 'class_embed.0.weight',
    ...
    'model.decoder.bbox_embed.0.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'model.decoder.bbox_embed.0.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'model.decoder.bbox_embed.0.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'model.decoder.bbox_embed.0.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    ...
}
```

yaitu semua parameter yang cocok dengan pola regex dan modul di `_tied_weights_keys`

#### get_experts_implementation[[transformers.PreTrainedModel.get_experts_implementation]]

```python
get_experts_implementation()
```

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

Kembalikan implementasi pakar dari model ini dan submodelnya, sebagai `dict` dalam bentuk yang diterima oleh `set_experts_implementation` (`""` untuk model ini, dan satu entri per sub_config). Ini adalah pasangan dari `set_experts_implementation`, misalnya untuk mengambil snapshot implementasi saat ini dan memulihkannya kemudian.

#### get_memory_footprint[[transformers.PreTrainedModel.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

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

**Parameter:**

return_buffers (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan ukuran buffer tensors dalam perhitungan memory footprint. Buffer adalah tensors yang tidak memerlukan gradien dan tidak terdaftar sebagai parameter. Contoh: mean dan std pada lapisan batch norm. Silakan lihat: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Dapatkan jejak memori (memory footprint) dari sebuah model. Fungsi ini akan mengembalikan jejak memori model saat ini dalam byte. Berguna untuk melakukan benchmark jejak memori model saat ini dan merancang beberapa pengujian. Solusi terinspirasi dari diskusi PyTorch: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### get_parameter_or_buffer[[transformers.PreTrainedModel.get_parameter_or_buffer]]

```python
get_parameter_or_buffer(target: str)
```

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

Kembalikan parameter atau buffer yang diberikan oleh `target` jika ada, jika tidak, lempar error. Fungsi ini menggabungkan `get_parameter()` dan `get_buffer()` dalam satu fungsi yang praktis. Jika target adalah atribut `_extra_state`, fungsi ini akan mengembalikan extra state yang disediakan oleh modul. Perhatikan bahwa ini hanya berfungsi jika `target` adalah daun dari model.

#### gradient_checkpointing_disable[[transformers.PreTrainedModel.gradient_checkpointing_disable]]

```python
gradient_checkpointing_disable()
```

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

Alias yang tidak didukung lagi dari [activation_checkpointing_disable()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable), akan dihapus di v6.

#### gradient_checkpointing_enable[[transformers.PreTrainedModel.gradient_checkpointing_enable]]

```python
gradient_checkpointing_enable(gradient_checkpointing_kwargs = None, **kwargs)
```

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

Alias yang tidak didukung lagi dari [activation_checkpointing_enable()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable), akan dihapus di v6.

#### init_weights[[transformers.PreTrainedModel.init_weights]]

```python
init_weights()
```

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

Inisialisasi dan ikat bobot jika diperlukan. Jika menggunakan `PreTrainedModel` kustom, Anda perlu mengimplementasikan logika inisialisasi apa pun di `_init_weights`.

#### initialize_weights[[transformers.PreTrainedModel.initialize_weights]]

```python
initialize_weights()
```

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

Ini setara dengan memanggil `self.apply(self._initialize_weights)`, tetapi menangani model komposit dengan benar. Fungsi ini secara dinamis mendispatch fungsi `init_weights` yang tepat ke modul-modul saat kita bergerak maju di sepanjang graf modul melalui rekursi. Fungsi ini dapat menangani jumlah sub-model yang tidak terbatas. Tanpa fungsi ini, setiap model komposit harus melakukan rekursi kedua secara eksplisit ke semua sub-model di `_init_weights` terluar, yang sangat rawan kesalahan dan tidak efisien.

#### is_custom_code[[transformers.PreTrainedModel.is_custom_code]]

```python
is_custom_code()
```

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

Kembalikan apakah model saat ini adalah kode kustom, yaitu kode yang dimuat dari hub atau didefinisikan di modul/sesi khusus pengguna mana pun.

#### is_remote_code[[transformers.PreTrainedModel.is_remote_code]]

```python
is_remote_code()
```

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

Kembalikan apakah model saat ini adalah kode kustom, yaitu kode yang dimuat dari hub, atau kelas yang baru saja didaftarkan melalui `register_for_auto_class`.

#### mark_tied_weights_as_initialized[[transformers.PreTrainedModel.mark_tied_weights_as_initialized]]

```python
mark_tied_weights_as_initialized(loading_info)
```

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

Menambahkan flag `_is_hf_initialized` pada parameter yang akan diikat, untuk menghindari inisialisasi mereka di kemudian hari karena parameter tersebut akan diikat (ditimpa) anyway. Hal ini sangat penting karena sebagian besar embeddings diikat, dan mereka adalah parameter yang sangat besar (vocabularies sering kali 256k), sehingga menjalankan inisialisasi pada mereka sangat mahal.

#### named_non_persistent_buffers[[transformers.PreTrainedModel.named_non_persistent_buffers]]

```python
named_non_persistent_buffers(recurse: bool = True, remove_duplicate: bool = True)
```

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

Mirip dengan `named_buffers`, tetapi hanya menghasilkan buffer yang non-persistent. Fitur ini berguna karena tidak selalu mudah untuk mengetahui apakah sebuah buffer bersifat persistent atau tidak.

#### post_init[[transformers.PreTrainedModel.post_init]]

```python
post_init()
```

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

Metode yang dijalankan di akhir inisialisasi setiap model Transformer, untuk mengeksekusi kode yang membutuhkan modul model terinisialisasi dengan benar (seperti inisialisasi bobot). Metode ini juga digunakan untuk memperoleh semua properti statis yang benar (rencana paralelisasi, tied_weights_keys, _keep_in_fp32_modules, dll.) dengan tepat dalam kasus model komposit (yaitu, model tingkat atas harus mengetahui properti tersebut dari anak-anaknya).

#### register_for_auto_class[[transformers.PreTrainedModel.register_for_auto_class]]

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

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

**Parameter:**

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

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

#### resize_token_embeddings[[transformers.PreTrainedModel.resize_token_embeddings]]

```python
resize_token_embeddings(new_num_tokens: int | None = None, pad_to_multiple_of: int | None = None, mean_resizing: bool = True)
```

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

**Parameter:**

new_num_tokens (`int`, *opsional*) : Jumlah token baru dalam matriks embedding. Meningkatkan ukuran akan menambahkan vektor yang baru diinisialisasi di bagian akhir. Mengurangi ukuran akan menghapus vektor dari bagian akhir. Jika tidak diberikan atau `None`, hanya mengembalikan pointer ke modul `torch.nn.Embedding` token input dari model tanpa melakukan apa pun.

pad_to_multiple_of (`int`, *opsional*) : Jika diset, matriks embedding akan di-pad hingga menjadi kelipatan dari nilai yang diberikan. Jika `new_num_tokens` diset ke `None`, embedding hanya akan di-pad hingga menjadi kelipatan dari `pad_to_multiple_of`. Hal ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan compute capability `>= 7.5` (Volta), atau pada TPU yang diuntungkan dari panjang sekuens yang merupakan kelipatan 128. Untuk detail lebih lanjut tentang hal ini, atau bantuan dalam memilih nilai yang tepat untuk resizing, silakan merujuk ke panduan ini: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Apakah akan menginisialisasi embedding yang ditambahkan dari distribusi normal multivariat yang memiliki mean dan kovarians dari embedding lama, atau menginisialisasinya dengan distribusi normal yang memiliki mean nol dan std sama dengan `config.initializer_range`. Menetapkan `mean_resizing` ke `True` berguna saat meningkatkan ukuran embedding pada model bahasa kausal, di mana probabilitas token yang dihasilkan tidak akan terpengaruh oleh embedding yang ditambahkan karena menginisialisasi embedding baru dengan mean dari embedding lama akan mengurangi kl-divergence antara probabilitas token berikutnya sebelum dan sesudah penambahan embedding baru. Lihat artikel ini untuk informasi lebih lanjut: https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Mengembalikan:** `torch.nn.Embedding`

Pointer ke modul Embeddings token input dari model.

Mengubah ukuran matriks embedding token input model jika `new_num_tokens != config.vocab_size`.

Menangani pengikatan bobot embedding setelahnya jika kelas model memiliki metode `tie_weights()`.

#### save_pretrained[[transformers.PreTrainedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, state_dict: dict | None = None, push_to_hub: bool = False, max_shard_size: int | str = '50GB', variant: str | None = None, token: str | bool | None = None, save_peft_format: bool = True, save_original_format: bool = True, distributed_checkpoint: bool = False, **kwargs)
```

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

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori tempat menyimpan. Akan dibuat jika belum ada.

is_main_process (`bool`, *opsional*, default `True`) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna saat pelatihan terdistribusi seperti TPU dan perlu memanggil fungsi ini di semua proses. Dalam kasus ini, setel `is_main_process=True` hanya pada proses utama untuk menghindari kondisi balapan.

state_dict (nested dictionary of `torch.Tensor`) : state dictionary dari model yang akan disimpan. Secara default menggunakan `self.state_dict()`, tetapi dapat digunakan untuk hanya menyimpan sebagian model atau jika diperlukan tindakan pencegahan khusus saat memulihkan state dictionary model (misalnya saat menggunakan model parallelism).

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

max_shard_size (`int` atau `str`, *opsional*, defaultnya `"50GB"`) : Ukuran maksimum untuk checkpoint sebelum dipecah menjadi shard. Setiap shard checkpoint akan memiliki ukuran lebih kecil dari nilai ini. Jika dinyatakan sebagai string, harus berupa angka diikuti satuan (seperti `"5MB"`).    Jika bobot tunggal dari model lebih besar dari `max_shard_size`, bobot tersebut akan berada di shard checkpoint tersendiri yang ukurannya lebih besar dari `max_shard_size`.

variant (`str`, *opsional*) : Jika ditentukan, bobot disimpan dalam format model..safetensors.

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

save_peft_format (`bool`, *opsional*, default `True`) : Untuk kompatibilitas mundur dengan pustaka PEFT, jika bobot adapter terpasang pada model, semua kunci dari state dict adapter perlu diberi awalan `base_model.model`. Pengguna lanjutan dapat menonaktifkan perilaku ini dengan mengatur `save_peft_format` ke `False`.

save_original_format (`bool`, *opsional*, default `True`) : Untuk kompatibilitas mundur dengan versi sebelumnya dari `transformers`, Anda dapat menyimpan checkpoint dengan pemetaan terbaliknya. Pemetaan terbalik harus ada meskipun model dimuat dari checkpoint legacy None.

distributed_checkpoint (`bool`, *opsional*, default `False`) : Saat menyimpan model yang di-shard dengan FSDP atau TP, tulis safetensors dengan distributed checkpointing (DCP) alih-alih mengumpulkan (gather) bobot ke CPU terlebih dahulu. Setiap rank harus memanggil metode ini. Jika `False`, bobot dikumpulkan ke CPU pada rank 0 melalui `gather_full_state_dict` sebelum ditulis. Parameter ini hanya ditujukan untuk menyimpan dan melanjutkan pelatihan; setel ke `False` jika Anda menginginkan fitur lengkap `save_pretrained`. Dengan `push_to_hub=True`, rank 0 mengonsolidasikan checkpoint ke subdirektori `consolidated/` dan mengunggah direktori tersebut. Memerlukan `torch>=2.7`.

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

Simpan model dan file konfigurasinya ke sebuah direktori, sehingga dapat dimuat ulang menggunakan metode kelas [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained).

#### set_attn_implementation[[transformers.PreTrainedModel.set_attn_implementation]]

```python
set_attn_implementation(attn_implementation: str | dict, allow_all_kernels: bool = False)
```

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

**Parameter:**

attn_implementation (`str` atau `dict`) : Implementasi attention yang akan disetel untuk model ini. Nilainya dapat berupa `str`, yang dalam hal ini akan diteruskan ke semua submodel jika relevan, atau `dict` di mana kuncinya adalah nama sub_configs, yang dalam hal ini setiap submodel akan meneruskan nilai yang sesuai (ke dirinya sendiri dan semua submodel yang bersarang di dalamnya). Nilainya sendiri dapat berupa `dict` dalam format yang sama, untuk menargetkan sub_configs dari submodel tersebut (seperti saat menginisialisasi config dengan `attn_implementation` dict yang bersarang).

allow_all_kernels (`bool`, opsional) : Apakah akan memuat kernel dari repositori hub yang belum terverifikasi, jika `attn_implementation` adalah kernel kustom di luar repositori hub `kernels-community`.

Atur `attn_implementation` yang diminta untuk model ini.

#### set_decoder[[transformers.PreTrainedModel.set_decoder]]

```python
set_decoder(decoder)
```

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

Setter simetris. Meniru logika pencarian yang digunakan di `get_decoder`.

#### set_encoder[[transformers.PreTrainedModel.set_encoder]]

```python
set_encoder(encoder, modality: str | None = None)
```

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

Setter simetris. Mencerminkan logika pencarian yang digunakan di `get_encoder`.

#### set_experts_implementation[[transformers.PreTrainedModel.set_experts_implementation]]

```python
set_experts_implementation(experts_implementation: str | dict)
```

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

**Parameter:**

experts_implementation (`str` atau `dict`) : Implementasi expert yang akan diset untuk model ini. Nilainya dapat berupa `str`, yang dalam hal ini akan didispatch ke semua submodel jika relevan, atau `dict` di mana kuncinya adalah nama sub_configs, yang dalam hal ini setiap submodel akan mendispatch nilai yang sesuai.

Atur `experts_implementation` yang diminta untuk model ini.

#### set_use_kernels[[transformers.PreTrainedModel.set_use_kernels]]

```python
set_use_kernels(use_kernels, kernel_config: transformers.utils.kernel_config.KernelConfig | None = None, mode: Mode | None = None)
```

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

**Parameter:**

use_kernels (`bool`) : Apakah akan menggunakan pustaka `kernels` untuk meng-kernelisasi beberapa lapisan model.

kernel_config (`KernelConfig`, *opsional*) : Konfigurasi kernel yang akan digunakan untuk melakukan kernelisasi model. Jika `None`, pemetaan kernel default akan digunakan.

mode (`Mode`, *opsional*) : mode yang harus diterapkan selama `kernelize`. Opsional, secara default menggunakan mode pelatihan atau inferensi berdasarkan flag `training` internal.

Atur apakah akan menggunakan pustaka `kernels` untuk mengkernelisasi beberapa lapisan model.

#### tie_weights[[transformers.PreTrainedModel.tie_weights]]

```python
tie_weights(missing_keys: set[str] | None = None, recompute_mapping: bool = True)
```

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

Ikat bobot model. Jika `recompute_mapping=False` (default saat dipanggil secara internal), metode ini akan mengandalkan atribut `model.all_tied_weights_keys`, yang berisi pemetaan `{target: source}` untuk parameter yang terikat. Jika `recompute_mapping=True`, metode ini akan memeriksa ulang semua submodel internal dan konfigurasinya untuk menentukan parameter yang perlu diikat. Ini adalah default ketika `model.tie_weights()` dipanggil secara mandiri, di luar `__init__` dan `from_pretrained`, dalam hal nilai konfigurasi telah diubah di suatu tempat.

Perhatikan bahwa selama `from_pretrained`, penautan bersifat *simetris*: jika pemetaan menyatakan "tie target -> source" tetapi `source` tidak ada di checkpoint sementara `target` ada, kami *mengubah* posisi source dan target agar tetap dapat menautkan semuanya ke parameter yang benar-benar ada.

#### ke[[transformers.PreTrainedModel.to]]

```python
to(*args, **kwargs)
```

Nilai mock untuk jalur bertitik (misalnya `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

#### warn_if_padding_and_no_attention_mask[[transformers.PreTrainedModel.warn_if_padding_and_no_attention_mask]]

```python
warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
```

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

Menampilkan peringatan sekali jika input_ids tampaknya berisi padding dan tidak ada attention mask yang diberikan.

Model kustom juga harus menyertakan `_supports_assign_param_buffer`, yang menentukan apakah superfast init dapat diterapkan pada model tertentu. Tanda bahwa model Anda membutuhkan ini adalah jika `test_save_and_load_from_pretrained` gagal. Jika demikian, setel ini ke `False`.

## ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

#### transformers.modeling_utils.ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

```python
transformers.modeling_utils.ModuleUtilsMixin()
```

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

Beberapa utilitas untuk `torch.nn.Modules`, untuk digunakan sebagai mixin.

#### num_parameters[[transformers.modeling_utils.ModuleUtilsMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

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

**Parameter:**

only_trainable (`bool`, *opsional*, defaultnya `False`) : Apakah hanya mengembalikan jumlah parameter yang dapat dilatih

exclude_embeddings (`bool`, *opsional*, default `False`) : Apakah hanya mengembalikan jumlah parameter non-embeddings

**Mengembalikan:** `int`

Jumlah parameter.

Dapatkan jumlah parameter (secara opsional, yang dapat dilatih atau non-embeddings) dalam modul.

## Mendorong ke Hub[[transformers.utils.PushToHubMixin]]

#### transformers.utils.PushToHubMixin[[transformers.utils.PushToHubMixin]]

```python
transformers.utils.PushToHubMixin()
```

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

Mixin yang berisi fungsionalitas untuk mendorong model atau tokenizer ke hub.

#### push_to_hub[[transformers.utils.PushToHubMixin.push_to_hub]]

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

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

**Parameter:**

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

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

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

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

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

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

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

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

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

Unggah {object_files} ke 🤗 Model Hub.

Contoh:

```python
from transformers import {object_class}

{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")

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

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