Accelerate documentation

Kuantisasi model

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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

Untuk mempelajari lebih lanjut tentang cara kerja kuantisasi bitsandbytes, lihatlah artikel blog tentang kuantisasi 8-bit dan kuantisasi 4-bit.

Prasyarat

Anda perlu menginstal persyaratan berikut:

  • Instal pustaka bitsandbytes
pip install bitsandbytes

Untuk perangkat non-cuda, Anda dapat merujuk pada panduan instalasi bitsandbytes di sini.

  • Instal accelerate terbaru dari sumber
pip install git+https://github.com/huggingface/accelerate.git
  • Instal minGPT dan huggingface_hub untuk menjalankan contoh
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().

Mari kita ambil model GPT2 dari pustaka minGPT.

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

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.

Berikut adalah contoh untuk kuantisasi 8-bit:

from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_8bit=True, llm_int8_threshold = 6)

Berikut adalah contoh untuk kuantisasi 4-bit:

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

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

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. Ini menggunakan inferensi model besar di baliknya. Periksa dokumentasi 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:

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 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 ini sebagai gantinya. Lihat demo 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 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.

Update on GitHub