# Memuat model

Transformers menyediakan banyak model pretrained yang siap digunakan dengan satu baris kode. Hal ini memerlukan kelas model dan metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained).

Panggil [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengunduh dan memuat bobot serta konfigurasi model yang disimpan di [Hub](https://hf.co/models) Hugging Face.

> [!TIP]
> Metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) memuat bobot yang disimpan dalam format file [safetensors](https://hf.co/docs/safetensors/index) jika tersedia. Secara tradisional, bobot model PyTorch diserialisasi dengan utilitas [pickle](https://docs.python.org/3/library/pickle.html) yang diketahui tidak aman. File Safetensor lebih aman dan lebih cepat untuk dimuat.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", device_map="auto")
```

Panduan ini menjelaskan bagaimana model dimuat, berbagai cara untuk memuat model, cara mengatasi masalah memori untuk model yang sangat besar, dan cara memuat model kustom.

## Model dan konfigurasi

Semua model memiliki file `configuration.py` dengan atribut spesifik seperti jumlah lapisan tersembunyi, ukuran kosakata, fungsi aktivasi, dan lainnya. Anda juga akan menemukan file `modeling.py` yang mendefinisikan lapisan dan operasi matematika yang terjadi di dalam setiap lapisan. File `modeling.py` mengambil atribut model di `configuration.py` dan membangun model sesuai dengan atribut tersebut. Pada titik ini, Anda memiliki model dengan bobot acak yang perlu dilatih untuk menghasilkan output yang bermakna.

> [!TIP]
> *Arsitektur* merujuk pada kerangka model, sedangkan *checkpoint* merujuk pada bobot model untuk arsitektur tertentu. Sebagai contoh, [BERT](./model_doc/bert) adalah sebuah arsitektur, sementara [google-bert/bert-base-uncased](https://huggingface.co/google-bert/bert-base-uncased) adalah sebuah checkpoint. Anda akan melihat istilah *model* digunakan secara bergantian dengan arsitektur dan checkpoint.

Terdapat dua jenis model umum yang dapat dimuat:

1. Model dasar, seperti [AutoModel](/docs/transformers/main/id/model_doc/auto#transformers.AutoModel) atau [LlamaModel](/docs/transformers/main/id/model_doc/llama2#transformers.LlamaModel), yang menghasilkan hidden states.
2. Model dengan *head* tertentu yang terpasang, seperti [AutoModelForCausalLM](/docs/transformers/main/id/model_doc/auto#transformers.AutoModelForCausalLM) atau [LlamaForCausalLM](/docs/transformers/main/id/model_doc/llama2#transformers.LlamaForCausalLM), untuk menjalankan tugas-tugas tertentu.

## Kelas model

Untuk mendapatkan model pretrained, Anda perlu memuat bobot ke dalam model. Hal ini dilakukan dengan memanggil [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) yang menerima bobot dari Hugging Face Hub atau direktori lokal.

Terdapat dua kelas model, yaitu kelas [AutoModel](./model_doc/auto) dan kelas yang spesifik untuk model tertentu.

Kelas [AutoModel](./model_doc/auto) adalah cara yang praktis untuk memuat arsitektur tanpa perlu mengetahui nama kelas model yang tepat, karena tersedia banyak model. Kelas ini secara otomatis memilih kelas model yang benar berdasarkan file konfigurasi. Anda hanya perlu mengetahui tugas dan checkpoint yang ingin digunakan.

Ganti model atau tugas dengan mudah, selama arsitekturnya didukung untuk tugas tertentu.

Sebagai contoh, model yang sama dapat digunakan untuk tugas-tugas yang berbeda.

```py
from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification, AutoModelForQuestionAnswering

# use the same API for 3 different tasks
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForQuestionAnswering.from_pretrained("meta-llama/Llama-2-7b-hf")
```

Dalam kasus lain, Anda mungkin ingin dengan cepat mencoba beberapa model yang berbeda untuk suatu tugas.

```py
from transformers import AutoModelForCausalLM

# use the same API to load 3 different models
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
model = AutoModelForCausalLM.from_pretrained("google/gemma-7b")
```

Kelas [AutoModel](./model_doc/auto) dibangun di atas kelas yang spesifik untuk model. Semua kelas model yang mendukung tugas tertentu dipetakan ke kelas tugas `AutoModelFor` yang sesuai.

Jika Anda sudah mengetahui kelas model yang ingin digunakan, Anda dapat langsung menggunakan kelas spesifik model tersebut.

```py
from transformers import LlamaModel, LlamaForCausalLM

model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
```

## Model besar

Model pretrained yang besar membutuhkan banyak memori untuk dimuat. Proses pemuatan melibatkan:

1. membuat model dengan bobot acak
2. memuat bobot terlatih sebelumnya
3. menempatkan bobot terlatih pada model

Anda membutuhkan cukup memori untuk menyimpan dua salinan bobot model (acak dan pretrained), yang mungkin tidak memungkinkan tergantung pada perangkat keras Anda. Dalam lingkungan pelatihan terdistribusi, hal ini bahkan lebih menantang karena setiap proses memuat model pretrained.

Transformers mengurangi beberapa tantangan terkait memori ini dengan inisialisasi cepat, checkpoint terbagi, fitur [Big Model Inference](https://hf.co/docs/accelerate/usage_guides/big_modeling) dari Accelerate, dan dukungan untuk tipe data bit yang lebih rendah.

### Checkpoint terpecah

[save_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) secara otomatis memecah checkpoint yang ukurannya lebih dari 50GB. Hal ini menjaga jumlah shard tetap rendah untuk model besar dan menyederhanakan pengelolaan file.

Parameter dimuat secara paralel dan memori puncak hanya bergantung pada ukuran model. Gunakan `max_shard_size` di [save_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) untuk mengatur ukuran checkpoint maksimum sebelum sharding.

> [!NOTE]
> Pemakaian memori untuk model yang memerlukan konversi bobot dinamis bergantung pada ukuran model dan ukuran parameter terbesar dalam satu konversi. Hal ini biasanya berlaku untuk model mixture-of-experts (MoE), di mana pemakaian memori adalah ukuran model ditambah jumlah ahli pada satu lapisan. Lihat panduan [dynamic weight loader](./weightconverter#fast-and-efficient-model-loading) untuk mempelajari lebih lanjut tentang cara model dimuat.

[save_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) juga membuat file indeks yang memetakan nama parameter ke file shard-nya. Indeks tersebut berisi dua kunci, yaitu `metadata` dan `weight_map`.

```py
import json
import os
import tempfile

with tempfile.TemporaryDirectory() as tmp_dir:
    model.save_pretrained(tmp_dir, max_shard_size="50GB")
    with open(os.path.join(tmp_dir, "model.safetensors.index.json"), "r") as f:
        index = json.load(f)

print(index.keys())
```

`metadata` menyimpan ukuran total model.

```py
index["metadata"]
{'total_size': 28966928384}
```

`weight_map` memetakan setiap parameter ke file shard-nya.

```py
index["weight_map"]
{'lm_head.weight': 'model-00006-of-00006.safetensors',
 'model.embed_tokens.weight': 'model-00001-of-00006.safetensors',
 'model.layers.0.input_layernorm.weight': 'model-00001-of-00006.safetensors',
 'model.layers.0.mlp.down_proj.weight': 'model-00001-of-00006.safetensors',
 ...
}
```

### Inferensi Model Besar

> [!TIP]
> Pastikan Anda telah menginstal Accelerate v0.9.0 dan PyTorch v1.9.0 atau yang lebih baru untuk menggunakan fitur ini!

[from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) ditingkatkan dengan fitur [Big Model Inference](https://hf.co/docs/accelerate/usage_guides/big_modeling) dari Accelerate.

Big Model Inference membuat *kerangka model* pada perangkat [meta](https://pytorch.org/docs/main/meta.html) PyTorch. Perangkat meta tidak menyimpan data nyata apa pun, hanya metadata.

Bobot yang diinisialisasi secara acak hanya dibuat saat bobot pretrained dimuat, untuk menghindari pemeliharaan dua salinan model di memori secara bersamaan. Penggunaan memori maksimum hanyalah ukuran model.

> [!TIP]
> Pelajari lebih lanjut tentang penempatan perangkat di [Merancang peta perangkat](https://hf.co/docs/accelerate/v0.33.0/en/concept_guides/big_model_inference#designing-a-device-map).

Fitur kedua dari Big Model Inference berkaitan dengan cara bobot dimuat dan didistribusikan dalam kerangka model. Bobot model didistribusikan ke semua perangkat yang tersedia, dimulai dari perangkat tercepat (biasanya GPU) dan kemudian memindahkan sisa bobot ke perangkat yang lebih lambat (CPU dan hard drive).

Kombinasi kedua fitur tersebut mengurangi penggunaan memori dan waktu pemuatan untuk model pretrained berukuran besar.

Setel [device_map](https://github.com/huggingface/transformers/blob/026a173a64372e9602a16523b8fae9de4b0ff428/src/transformers/modeling_utils.py#L3061) ke `"auto"` untuk mengaktifkan Big Model Inference.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("google/gemma-7b", device_map="auto")
```

Anda juga dapat secara manual menetapkan lapisan ke perangkat dalam `device_map`. Peta ini harus memetakan semua parameter model ke perangkat, tetapi Anda tidak perlu merinci ke mana semua submodul dari suatu lapisan ditempatkan jika seluruh lapisan berada di perangkat yang sama.

Akses atribut `hf_device_map` untuk melihat bagaimana model didistribusikan di antara perangkat.

```py
device_map = {"model.layers.1": 0, "model.layers.14": 1, "model.layers.31": "cpu", "lm_head": "disk"}
model.hf_device_map
```

### Offloading ke disk

Ketika model terlalu besar untuk total kapasitas GPU dan RAM CPU, Big Model Inference memindahkan sisa bobot ke disk. Atur `offload_folder` ke sebuah direktori setiap kali ada bobot yang dipetakan ke `"disk"`, karena di situlah Transformers menyimpan bobot yang dipindahkan.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    offload_folder="./offload",
)
```

Gunakan `max_memory` untuk membatasi jumlah data yang dipegang oleh setiap perangkat. Transformers mengisi perangkat berdasarkan urutan kecepatan dan mengirim apa pun yang tidak muat ke disk. Contoh di bawah ini membatasi GPU ke 10GB dan CPU ke 30GB, sehingga sisa bobot akan disimpan di `offload_folder`.

```py
model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    max_memory={0: "10GB", "cpu": "30GB"},
    offload_folder="./offload",
)
```

Setel `max_memory={}` untuk menentukan bahwa tidak ada memori gpu atau cpu yang tersedia dan untuk memaksa offloading seluruh model ke disk.

```py
model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-7b",
    device_map="auto",
    max_memory={},
    offload_folder="./offload",
)
```

> [!NOTE]
> Disk offloading menukar memori dengan kecepatan. Membaca bobot dari disk pada setiap forward pass lebih lambat daripada membaca dari memori CPU atau GPU. Disk offloading penuh memerlukan `accelerate>1.14.0`

### Tipe data model

Argumen `dtype` mengontrol [dtype](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype) PyTorch yang digunakan untuk menginstansiasi bobot model. Secara default, Transformers memuat bobot dengan nilai `dtype` atau `torch_dtype` lama dari `config.json`. Jika `config.json` tidak menyertakan salah satu nilai tersebut, Transformers menggunakan dtype dari bobot floating-point pertama dalam checkpoint.

Override nilai default dengan meneruskan dtype tertentu.

```py
import torch
from transformers import AutoModelForCausalLM

# specific dtype
model = AutoModelForCausalLM.from_pretrained("google/gemma-3-1b-it", dtype=torch.float16)
```

[AutoConfig](/docs/transformers/main/id/model_doc/auto#transformers.AutoConfig) juga menerima `dtype` untuk model yang dibuat dari awal.

```py
import torch
from transformers import AutoConfig, AutoModel

my_config = AutoConfig.from_pretrained("google/gemma-2b", dtype=torch.float16)
model = AutoModel.from_config(my_config)
```

## Model kustom

Model kustom dibangun di atas kelas konfigurasi dan pemodelan Transformers, mendukung API `AutoClass`, dan dimuat dengan [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained). Perbedaannya adalah kode pemodelannya *tidak* berasal dari Transformers.

Ambil kehati-hatian ekstra saat memuat model kustom. Meskipun Hub mencakup [pemindaian malware](https://hf.co/docs/hub/security-malware#malware-scanning) untuk setiap repositori, Anda tetap harus berhati-hati untuk menghindari eksekusi kode berbahaya secara tidak sengaja.

Setel `trust_remote_code=True` di [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat model kustom.

```py
from transformers import AutoModelForImageClassification

model = AutoModelForImageClassification.from_pretrained("sgugger/custom-resnet50d", trust_remote_code=True)
```

Sebagai lapisan keamanan tambahan, muat model kustom dari revisi tertentu untuk menghindari pemuatan kode model yang mungkin telah berubah. Hash commit dapat disalin dari [riwayat commit](https://hf.co/sgugger/custom-resnet50d/commits/main) model.

```py
commit_hash = "ed94a7c6247d8aedce4647f00f20de6875b5b292"
model = AutoModelForImageClassification.from_pretrained(
    "sgugger/custom-resnet50d", trust_remote_code=True, revision=commit_hash
)
```

Lihat panduan [Customize models](./custom_models) untuk informasi lebih lanjut.