# Kuantisasi model

## Integrasi `bitsandbytes`

Accelerate membawa kuantisasi `bitsandbytes` ke model Anda. Anda sekarang dapat memuat model pytorch apa pun dalam 8-bit atau 4-bit dengan beberapa baris kode.

Jika Anda ingin menggunakan model Transformers dengan `bitsandbytes`, Anda harus mengikuti [dokumentasi](https://huggingface.co/docs/transformers/main_classes/quantization) ini.

Untuk mempelajari lebih lanjut tentang cara kerja kuantisasi `bitsandbytes`, lihatlah artikel blog tentang [kuantisasi 8-bit](https://huggingface.co/blog/hf-bitsandbytes-integration) dan [kuantisasi 4-bit](https://huggingface.co/blog/4bit-transformers-bitsandbytes).

### Prasyarat
Anda perlu menginstal persyaratan berikut:

- Instal pustaka `bitsandbytes`
```bash
pip install bitsandbytes
```
Untuk perangkat non-cuda, Anda dapat merujuk pada panduan instalasi bitsandbytes [di sini](https://huggingface.co/docs/bitsandbytes/main/en/installation#multi-backend).

- Instal `accelerate` terbaru dari sumber
```bash
pip install git+https://github.com/huggingface/accelerate.git
```
- Instal `minGPT` dan `huggingface_hub` untuk menjalankan contoh
```bash
git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
pip install huggingface_hub
```

### Cara kerjanya

Pertama, kita perlu menginisialisasi model kita. Untuk menghemat memori, kita dapat menginisialisasi model kosong menggunakan context manager [init_empty_weights()](/docs/accelerate/main/id/package_reference/big_modeling#accelerate.init_empty_weights).

Mari kita ambil model GPT2 dari pustaka minGPT.
```py
from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    empty_model = GPT(model_config)
```

Lalu, kita perlu mendapatkan path ke bobot model Anda. Path tersebut dapat berupa file state_dict (misalnya "pytorch_model.bin") atau folder yang berisi checkpoint yang dipecah (sharded).

```py
from huggingface_hub import snapshot_download
weights_location = snapshot_download(repo_id="marcsun13/gpt2-xl-linear-sharded")
```

Terakhir, Anda perlu mengatur konfigurasi kuantisasi Anda dengan [BnbQuantizationConfig](/docs/accelerate/main/id/package_reference/utilities#accelerate.utils.BnbQuantizationConfig).

Berikut adalah contoh untuk kuantisasi 8-bit:
```py
from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_8bit=True, llm_int8_threshold = 6)
```

Berikut adalah contoh untuk kuantisasi 4-bit:
```py
from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4")
```

Untuk mengkuantisasi model kosong Anda dengan konfigurasi yang dipilih, Anda perlu menggunakan [load_and_quantize_model()](/docs/accelerate/main/id/package_reference/utilities#accelerate.utils.load_and_quantize_model).

```py
from accelerate.utils import load_and_quantize_model
quantized_model = load_and_quantize_model(empty_model, weights_location=weights_location, bnb_quantization_config=bnb_quantization_config)
```

### Menyimpan dan memuat model 8-bit

Anda dapat menyimpan model 8-bit Anda dengan accelerate menggunakan [save_model()](/docs/accelerate/main/id/package_reference/accelerator#accelerate.Accelerator.save_model).

```py
from accelerate import Accelerator
accelerate = Accelerator()
new_weights_location = "path/to/save_directory"
accelerate.save_model(quantized_model, new_weights_location)

quantized_model_from_saved = load_and_quantize_model(empty_model, weights_location=new_weights_location, bnb_quantization_config=bnb_quantization_config, device_map = "auto")
```

Perhatikan bahwa serialisasi model 4-bit saat ini belum didukung.

### Offload modul ke cpu dan disk 

Anda dapat memindahkan beberapa modul ke cpu/disk jika ruang di GPU tidak cukup untuk menyimpan seluruh model di GPU Anda. Hal ini menggunakan big model inference di baliknya. Periksa [dokumentasi](https://huggingface.co/docs/accelerate/usage_guides/big_modeling) ini untuk detail lebih lanjut.

Untuk kuantisasi 8-bit, modul yang dipilih akan dikonversi ke presisi 8-bit.

Untuk kuantisasi 4-bit, modul yang dipilih akan dipertahankan dalam `torch_dtype` yang diberikan pengguna di `BnbQuantizationConfig`. Kami akan menambahkan dukungan untuk mengonversi modul yang di-offload ini menjadi 4-bit ketika serialisasi 4-bit sudah memungkinkan.

 Anda hanya perlu meneruskan `device_map` kustom untuk meng-offload modul ke cpu/disk. Modul yang di-offload akan dikirim ke GPU saat diperlukan. Berikut adalah contohnya:

```py
device_map = {
    "transformer.wte": 0,
    "transformer.wpe": 0,
    "transformer.drop": 0,
    "transformer.h": "cpu",
    "transformer.ln_f": "disk",
    "lm_head": "disk",
}
```
### Lakukan penyesuaian halus pada model terkuantisasi

Tidak mungkin melakukan pelatihan murni 8bit atau 4bit pada model-model ini. Namun, Anda dapat melatih model-model ini dengan memanfaatkan metode fine-tuning yang efisien secara parameter (PEFT) dan, misalnya, melatih adapter di atasnya. Silakan lihat pustaka [peft](https://github.com/huggingface/peft) untuk detail lebih lanjut.

Saat ini, Anda tidak dapat menambahkan adapter di atas model kuantisasi apa pun. Namun, dengan dukungan resmi untuk adapter pada model Transformers, Anda dapat melakukan fine-tuning pada model kuantisasi. Jika Anda ingin melakukan fine-tuning pada model Transformers, ikuti [dokumentasi](https://huggingface.co/docs/transformers/main_classes/quantization) ini sebagai gantinya. Lihat [demo](https://colab.research.google.com/drive/1VoYNfYDKcKRQRor98Zbf2-9VQTtGJ24k?usp=sharing) ini tentang cara melakukan fine-tuning pada model Transformers 4-bit.

Perhatikan bahwa Anda tidak perlu meneruskan `device_map` saat memuat model untuk pelatihan. Model Anda akan dimuat secara otomatis di GPU Anda. Harap diperhatikan bahwa `device_map=auto` harus digunakan hanya untuk inferensi.

### Demo contoh - menjalankan GPT2 1.5b di Google Colab

Lihat [demo](https://colab.research.google.com/drive/1T1pOgewAWVpR9gKpaEWw4orOrzPFb3yM?usp=sharing) Google Colab untuk menjalankan model terkuantisasi pada model GPT2. Checkpoint model GPT2-1.5B berada dalam FP32 yang menggunakan 6GB memori. Setelah kuantisasi, model ini menggunakan 1.6GB dengan modul 8-bit dan 1.2GB dengan modul 4-bit.

