# GPTQ

Proyek [GPT-QModel](https://github.com/ModelCloud/GPTQModel) (paket Python `gptqmodel`) mengimplementasikan algoritma GPTQ, sebuah teknik kuantisasi pasca-pelatihan di mana setiap baris matriks bobot dikuantisasi secara independen untuk menemukan versi bobot yang meminimalkan error. Bobot ini dikuantisasi ke int4, tetapi dipulihkan ke fp16 secara langsung selama inferensi. Hal ini dapat menghemat penggunaan memori hingga 4x karena bobot int4 didekuantisasi dalam kernel yang terfusi, bukan di memori global GPU. Inferensi juga lebih cepat karena bitwidth yang lebih rendah membutuhkan waktu komunikasi yang lebih singkat.

AutoGPTQ tidak lagi didukung di Transformers. Instal GPT-QModel sebagai gantinya.

Install Accelerate, Transformers, dan Optimum terlebih dahulu.

```bash
pip install --upgrade accelerate optimum transformers
```

Lalu jalankan perintah di bawah ini untuk menginstal GPT-QModel.

```bash
pip install gptqmodel --no-build-isolation
```

Buat kelas [GPTQConfig](/docs/transformers/main/id/main_classes/quantization#transformers.GPTQConfig) dan atur jumlah bit untuk kuantisasi, dataset untuk kalibrasi bobot kuantisasi, serta tokenizer untuk menyiapkan dataset.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
gptq_config = GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer)
```

Anda dapat meneruskan dataset Anda sendiri sebagai daftar string, tetapi sangat disarankan untuk menggunakan dataset yang sama dari paper GPTQ.

```py
dataset = ["gptqmodel is an easy-to-use model quantization library with user-friendly apis, based on the GPTQ algorithm."]
gptq_config = GPTQConfig(bits=4, dataset=dataset, tokenizer=tokenizer)
```

Muat model yang akan dikuantisasi dan lewati [GPTQConfig](/docs/transformers/main/id/main_classes/quantization#transformers.GPTQConfig) ke [from_pretrained()](/docs/transformers/main/id/model_doc/auto#transformers.AutoModel.from_pretrained). Atur `device_map="auto"` untuk secara otomatis memindahkan model ke CPU guna membantu model muat di memori, serta mengizinkan modul model dipindahkan antara CPU dan GPU untuk kuantisasi.

```py
quantized_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", device_map="auto", quantization_config=gptq_config)
```

Jika Anda kehabisan memori karena dataset terlalu besar (disk offloading tidak didukung), coba teruskan parameter `max_memory` untuk mengalokasikan jumlah memori yang akan digunakan pada perangkat Anda (GPU dan CPU).

```py
quantized_model = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-125m",
    device_map="auto",
    max_memory={0: "30GiB", 1: "46GiB", "cpu": "30GiB"},
    quantization_config=gptq_config
)
```

> [!WARNING]
> Tergantung pada perangkat keras Anda, mengkuantisasi model dari awal dapat memakan waktu. Mengkuantisasi model [facebook/opt-350m](https://huggingface.co/facebook/opt-350m) pada GPU Google Colab tier gratis dapat memakan waktu sekitar 5 menit, tetapi mengkuantisasi model dengan 175B parameter pada NVIDIA A100 dapat memakan waktu sekitar 4 jam. Sebelum Anda mengkuantisasi model, adalah ide yang baik untuk memeriksa Hub apakah versi model yang sudah dikuantisasi GPTQ sudah ada.

Setelah model dikuantisasi, Anda dapat menggunakan [push_to_hub()](/docs/transformers/main/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) untuk mendorong model dan tokenizer ke Hub agar mudah dibagikan dan diakses. Hal ini menyimpan [GPTQConfig](/docs/transformers/main/id/main_classes/quantization#transformers.GPTQConfig).

```py
quantized_model.push_to_hub("opt-125m-gptq")
tokenizer.push_to_hub("opt-125m-gptq")
```

[save_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.save_pretrained) menyimpan model terkuantisasi secara lokal. Jika model dikuantisasi dengan parameter `device_map`, pastikan untuk memindahkan seluruh model ke GPU atau CPU sebelum menyimpannya. Contoh di bawah ini menyimpan model di CPU.

```py
quantized_model.save_pretrained("opt-125m-gptq")
tokenizer.save_pretrained("opt-125m-gptq")

# if quantized with device_map set
quantized_model.to("cpu")
quantized_model.save_pretrained("opt-125m-gptq")
```

Muat ulang model terkuantisasi dengan [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained), dan atur `device_map="auto"` untuk mendistribusikan model secara otomatis ke semua GPU yang tersedia, sehingga model dimuat lebih cepat tanpa menggunakan memori lebih dari yang dibutuhkan.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto")
```

## Marlin

[Marlin](https://github.com/IST-DASLab/marlin) adalah kernel CUDA GPTQ khusus 4-bit yang sangat dioptimalkan untuk arsitektur GPU NVIDIA A100 (Ampere). Proses pemuatan, dekuantisasi, dan eksekusi bobot pasca-dekuantisasi sangat diparalelkan, sehingga memberikan peningkatan inferensi yang signifikan dibandingkan kernel CUDA GPTQ asli. Marlin hanya tersedia untuk inferensi terkuantisasi dan tidak mendukung kuantisasi model.

Inferensi Marlin dapat diaktifkan dengan parameter `backend` di [GPTQConfig](/docs/transformers/main/id/main_classes/quantization#transformers.GPTQConfig).

```py

from transformers import AutoModelForCausalLM, GPTQConfig

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto", quantization_config=GPTQConfig(bits=4, backend="marlin"))
```

## GPT-QModel

GPT-QModel adalah backend yang secara aktif dipelihara untuk GPTQ di Transformers. Awalnya di-fork dari AutoGPTQ, namun sejak itu telah berkembang dengan peningkatan signifikan seperti kuantisasi yang lebih cepat, penggunaan memori yang lebih rendah, dan nilai default yang lebih akurat.

GPT-QModel menyediakan kuantisasi asimetris yang berpotensi menurunkan error kuantisasi dibandingkan kuantisasi simetris. Model ini tidak kompatibel mundur dengan checkpoint AutoGPTQ lama, dan tidak semua kernel (Marlin) mendukung kuantisasi asimetris.

GPT-QModel juga memiliki dukungan yang lebih luas untuk model LLM terbaru, model multimodal (Qwen2-VL dan Ovis1.6-VL), platform (Linux, macOS, Windows 11), dan perangkat keras (AMD ROCm, Apple Silicon, CPU Intel/AMD, serta GPU Intel Datacenter Max/Arc, dll.).

Kernel Marlin juga diperbarui untuk GPU A100, dan kernel lainnya diperbarui untuk mencakup auto-padding bagi model legacy serta model dengan fitur in/out yang tidak seragam.

## Sumber daya

Jalankan kuantisasi GPTQ dengan [notebook](https://colab.research.google.com/drive/1_TIrmuKOFhuRRiTWN94iLKUFu6ZX4ceb?usp=sharing) PEFT untuk pengalaman langsung.