Bitsandbytes

Perpustakaan bitsandbytes menyediakan alat kuantisasi untuk LLM melalui pembungkus Python ringan di sekitar fungsi akselerator perangkat keras. Perpustakaan ini memungkinkan penggunaan model besar dengan sumber daya komputasi yang terbatas dengan mengurangi jejak memori mereka.

Pada intinya, bitsandbytes menyediakan:

• Lapisan Linear Terkuantisasi: lapisan Linear8bitLt dan Linear4bit yang menggantikan lapisan linear PyTorch standar dengan alternatif terkuantisasi yang hemat memori
• Optimized Optimizers: 8-bit versions of common optimizers through its optim module, enabling training of large models with reduced memory requirements
• Pengalian Matriks: Operasi pengalian matriks yang dioptimalkan dengan memanfaatkan format kuantisasi

bitsandbytes menawarkan dua fitur kuantisasi utama:

1. LLM.int8() - Metode kuantisasi 8-bit yang membuat inferensi lebih mudah diakses tanpa degradasi kinerja yang signifikan. Berbeda dengan kuantisasi naif, LLM.int8() secara dinamis mempertahankan presisi yang lebih tinggi untuk komputasi kritis, sehingga mencegah hilangnya informasi pada bagian-bagian sensitif model.

2. QLoRA - Teknik kuantisasi 4-bit yang mengompresi model lebih lanjut sambil tetap mempertahankan kemampuan pelatihan dengan menyisipkan seperangkat kecil bobot adaptasi peringkat rendah (LoRA) yang dapat dilatih.

Catatan: Untuk pengalaman kuantisasi yang lebih ramah pengguna, Anda dapat menggunakan ruang komunitas bitsandbytes.

Jalankan perintah di bawah ini untuk menginstal bitsandbytes.

pip install --upgrade transformers accelerate bitsandbytes

Untuk mengompilasi dari sumber, ikuti instruksi di panduan instalasi bitsandbytes.

Kompatibilitas Perangkat Keras

bitsandbytes didukung pada GPU NVIDIA untuk versi CUDA 11.8 - 13.0, Intel XPU, Intel Gaudi (HPU), dan CPU. Saat ini sedang dilakukan upaya untuk mendukung platform tambahan. Jika Anda tertarik untuk memberikan umpan balik atau melakukan pengujian, silakan lihat repositori bitsandbytes untuk informasi lebih lanjut.

GPU NVIDIA (CUDA)

Backend ini didukung pada platform Linux x86-64, Linux aarch64, dan Windows.

GPU Intel (XPU)

Backend ini didukung pada platform Linux x86-64 dan Windows x86-64.

Intel Gaudi (HPU)

Backend ini didukung pada Linux x86-64 untuk Gaudi2 dan Gaudi3.

CPU

Backend ini didukung pada platform Linux x86-64, Linux aarch64, dan Windows x86-64.

Contoh Kuantisasi

Kuantisasi model dengan meneruskan BitsAndBytesConfig ke from_pretrained(). Ini berlaku untuk model apa pun dalam modalitas apa pun, selama mendukung Accelerate dan berisi lapisan torch.nn.Linear.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model_8bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7", 
    device_map="auto",
    quantization_config=quantization_config
)

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model_8bit = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-350m", 
    device_map="auto",
    quantization_config=quantization_config, 
    dtype="auto"
)
model_8bit.model.decoder.layers[-1].final_layer_norm.weight.dtype

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-560m", 
    device_map="auto",
    quantization_config=quantization_config
)

model.push_to_hub("bloom-560m-8bit")

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model_4bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7",
    device_map="auto",
    quantization_config=quantization_config
)

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model_4bit = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-350m",
    device_map="auto",
    quantization_config=quantization_config, 
    dtype="auto"
)
model_4bit.model.decoder.layers[-1].final_layer_norm.weight.dtype

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-560m", 
    device_map="auto",
    quantization_config=quantization_config
)

model.push_to_hub("bloom-560m-4bit")

Pelatihan 8-bit dan 4-bit hanya didukung untuk melatih parameter ekstra.

Periksa jejak memori Anda dengan get_memory_footprint.

print(model.get_memory_footprint())

Muat model terkuantisasi dengan from_pretrained() tanpa quantization_config.

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("{your_username}/bloom-560m-8bit", device_map="auto")

LLM.int8

Bagian ini membahas beberapa fitur spesifik dari kuantisasi 8-bit, seperti offloading, ambang batas outlier, pengabaian konversi modul, dan finetuning.

Offloading

Model 8-bit dapat memindahkan bobot (weights) antara CPU dan GPU agar model yang sangat besar muat di memori. Bobot yang dikirim ke CPU disimpan dalam float32 dan tidak dikonversi ke 8-bit. Sebagai contoh, aktifkan offloading untuk bigscience/bloom-1b7 melalui BitsAndBytesConfig.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(llm_int8_enable_fp32_cpu_offload=True)

Desain peta perangkat kustom agar semua muat di GPU Anda, kecuali lm_head, yang dikirim ke CPU.

device_map = {
    "transformer.word_embeddings": 0,
    "transformer.word_embeddings_layernorm": 0,
    "lm_head": "cpu",
    "transformer.h": 0,
    "transformer.ln_f": 0,
}

Sekarang muat model Anda dengan device_map dan quantization_config kustom.

model_8bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7",
    dtype="auto",
    device_map=device_map,
    quantization_config=quantization_config,
)

Ambang batas outlier

“Outlier” adalah nilai hidden state yang melebihi ambang batas tertentu, dan nilai-nilai ini dihitung dalam fp16. Meskipun nilai-nilai tersebut biasanya berdistribusi normal ([-3.5, 3.5]), distribusinya bisa sangat berbeda untuk model besar ([-60, 6] atau [6, 60]). Kuantisasi 8-bit bekerja dengan baik untuk nilai ~5, tetapi melampaui itu, terdapat penurunan kinerja yang signifikan. Nilai ambang batas default yang baik adalah 6, tetapi ambang batas yang lebih rendah mungkin diperlukan untuk model yang lebih tidak stabil (model kecil atau finetuning).

Untuk menemukan ambang batas terbaik untuk model Anda, lakukan eksperimen dengan parameter llm_int8_threshold di BitsAndBytesConfig. Sebagai contoh, mengatur ambang batas ke 0.0 secara signifikan mempercepat inferensi dengan potensi kerugian beberapa akurasi.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

model_id = "bigscience/bloom-1b7"

quantization_config = BitsAndBytesConfig(
    llm_int8_threshold=0.0,
    llm_int8_enable_fp32_cpu_offload=True
)

model_8bit = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype="auto",
    device_map=device_map,
    quantization_config=quantization_config,
)

Lewati konversi modul

Untuk beberapa model, seperti Jukebox, Anda tidak perlu mengkuantisasi setiap modul ke 8-bit karena hal itu justru dapat menyebabkan ketidakstabilan. Pada Jukebox, terdapat beberapa modul lm_head yang harus dilewati menggunakan parameter llm_int8_skip_modules di BitsAndBytesConfig.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

model_id = "bigscience/bloom-1b7"

quantization_config = BitsAndBytesConfig(
    llm_int8_skip_modules=["lm_head"],
)

model_8bit = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype="auto",
    device_map="auto",
    quantization_config=quantization_config,
)

Penyesuaian Ulang

Perpustakaan PEFT mendukung fine-tuning model besar seperti flan-t5-large dan facebook/opt-6.7b dengan kuantisasi 8-bit. Anda tidak perlu meneruskan parameter device_map untuk pelatihan karena model dimuat secara otomatis ke GPU. Namun, Anda tetap dapat menyesuaikan device map dengan parameter device_map (device_map="auto" sebaiknya hanya digunakan untuk inferensi).

QLoRA

Bagian ini membahas beberapa fitur spesifik dari kuantisasi 4-bit, seperti mengubah tipe data komputasi, tipe data Normal Float 4 (NF4), dan kuantisasi bersarang.

Jenis data komputasi

Ubah tipe data dari float32 (nilai default) menjadi bf16 di BitsAndBytesConfig untuk mempercepat komputasi.

import torch
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)

Float 4 Normal (NF4)

NF4 adalah tipe data 4-bit dari paper QLoRA, yang diadaptasi untuk bobot yang diinisialisasi dari distribusi normal. Anda sebaiknya menggunakan NF4 untuk melatih model dasar 4-bit.

from transformers import BitsAndBytesConfig

nf4_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
)

model_nf4 = AutoModelForCausalLM.from_pretrained(model_id, dtype="auto", quantization_config=nf4_config)

Untuk inferensi, bnb_4bit_quant_type tidak memiliki dampak besar pada kinerja. Namun, agar tetap konsisten dengan bobot model, Anda sebaiknya menggunakan nilai bnb_4bit_compute_dtype dan dtype.

Kuantisasi bersarang

Kuantisasi bersarang dapat menghemat memori tambahan tanpa biaya performa tambahan. Fitur ini melakukan kuantisasi kedua pada bobot yang sudah terkuantisasi untuk menghemat 0,4 bit/parameter tambahan. Sebagai contoh, dengan kuantisasi bersarang, Anda dapat melakukan finetuning model Llama-13b pada GPU NVIDIA T4 16GB dengan panjang sekuens 1024, ukuran batch 1, dan mengaktifkan akumulasi gradien dengan 4 langkah.

from transformers import BitsAndBytesConfig

double_quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
)

model_double_quant = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf", dtype="auto", quantization_config=double_quant_config)

Mendequantisasi model bitsandbytes

Setelah dikuantisasi, Anda dapat dequantize() model ke presisi aslinya, tetapi hal ini dapat menyebabkan penurunan kualitas. Pastikan Anda memiliki memori GPU yang cukup untuk menampung model yang telah didekuantisasi.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", BitsAndBytesConfig(load_in_4bit=True))
model.dequantize()

Sumber daya

Pelajari lebih lanjut tentang detail kuantisasi 8-bit di Pengenalan Santai untuk Perkalian Matriks 8-bit untuk transformer berskala besar menggunakan Hugging Face Transformers, Accelerate, dan bitsandbytes.

Coba kuantisasi 4-bit di notebook ini dan pelajari detailnya lebih lanjut di Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA.