GPTQ

Proyek GPT-QModel (paket Python gptqmodel) mengimplementasikan algoritma GPTQ, yaitu 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.

pip install --upgrade accelerate optimum transformers

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

pip install gptqmodel --no-build-isolation

Buat kelas GPTQConfig dan atur jumlah bit untuk kuantisasi, dataset untuk kalibrasi bobot kuantisasi, serta tokenizer untuk menyiapkan dataset.

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.

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 ke 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.

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 lewati parameter max_memory untuk mengalokasikan jumlah memori yang akan digunakan pada perangkat Anda (GPU dan CPU).

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

Tergantung pada perangkat keras Anda, proses kuantisasi model dari awal dapat memakan waktu cukup lama. Kuantisasi model facebook/opt-350m pada GPU Google Colab tier gratis dapat memakan waktu sekitar 5 menit, tetapi kuantisasi model dengan 175 miliar parameter pada NVIDIA A100 dapat memakan waktu sekitar 4 jam. Sebelum Anda mengkuantisasi sebuah model, sebaiknya periksa di Hub apakah versi GPTQ-kuantisasi dari model tersebut sudah tersedia.

Setelah model dikuantisasi, Anda dapat menggunakan push_to_hub() untuk mendorong model dan tokenizer ke Hub agar mudah dibagikan dan diakses. Hal ini menyimpan GPTQConfig.

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

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.

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(), 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.

from transformers import AutoModelForCausalLM

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

Marlin

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.

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 PEFT untuk pengalaman langsung.