Bitsandbytes

bitsandbytes kütüphanesi, donanım hızlandırıcı işlevlerinin etrafında hafif bir Python sarmalayıcısı aracılığıyla LLM'ler için kuantizasyon araçları sağlar. Bellek ayak izini azaltarak sınırlı hesaplama kaynaklarıyla büyük modeller üzerinde çalışmayı mümkün kılar.

bitsandbytes'in temelinde şunlar yer alır:

• Kantize Doğrusal Katmanlar: Standart PyTorch doğrusal katmanlarını bellek verimli kantize alternatiflerle değiştiren Linear8bitLt ve Linear4bit katmanları
• Optimize Edilmiş Optimizer'lar: optim modülü aracılığıyla yaygın optimizer'ların 8-bit sürümleri, büyük modellerin azaltılmış bellek gereksinimleriyle eğitimine olanak tanır
• Matris Çarpımı: Kuantize edilmiş formattan faydalanan optimize edilmiş matris çarpma işlemleri

bitsandbytes iki ana kuantizasyon özelliği sunar:

1. LLM.int8() - Performans kaybı olmadan çıkarımı (inference) daha erişilebilir kılan 8 bitlik bir kuantizasyon yöntemidir. Naif kuantizasyonun aksine LLM.int8(), kritik hesaplamalarda daha yüksek hassasiyeti dinamik olarak koruyarak modelin hassas bölümlerindeki bilgi kaybını önler.

2. QLoRA - Modeli eğilebilirlik özelliğini koruyarak daha da sıkıştıran, küçük bir eğitilebilir düşük rütbeli uyarlama (LoRA) ağırlığı seti ekleyen 4-bit kuantizasyon tekniği.

Not: Kullanıcı dostu bir kuantizasyon deneyimi için bitsandbytes topluluk alanını kullanabilirsiniz.

bitsandbytes'i yüklemek için aşağıdaki komutu çalıştırın.

pip install --upgrade transformers accelerate bitsandbytes

Kaynaktan derlemek için bitsandbytes kurulum kılavuzundaki talimatları izleyin.

Donanım Uyumluluğu

bitsandbytes, CUDA sürümleri 11.8 - 13.0 için NVIDIA GPU'lar, Intel XPU, Intel Gaudi (HPU) ve CPU üzerinde desteklenmektedir. Ek platformları destekleme konusunda devam eden bir çalışma bulunmaktadır. Geri bildirimde bulunmak veya test etmek isterseniz, daha fazla bilgi için bitsandbytes deposuna göz atın.

NVIDIA GPU'lar (CUDA)

Bu arka uç, Linux x86-64, Linux aarch64 ve Windows platformlarında desteklenmektedir.

Intel GPU'lar (XPU)

Bu arka uç, Linux x86-64 ve Windows x86-64 platformlarında desteklenmektedir.

Intel Gaudi (HPU)

Bu arka uç, Gaudi2 ve Gaudi3 için Linux x86-64 üzerinde desteklenmektedir.

CPU

Bu backend, Linux x86-64, Linux aarch64 ve Windows x86-64 platformlarında desteklenmektedir.

Quantization Örnekleri

BitsAndBytesConfig nesnesini from_pretrained() fonksiyonuna geçirerek bir modeli kuantize edin. Bu yöntem, Accelerate destekleyen ve torch.nn.Linear katmanları içeren herhangi bir modalitedeki herhangi bir model için geçerlidir.

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

8 ve 4 bit eğitim yalnızca extra parametrelerin eğitimi için desteklenir.

Bellek kullanımınızı get_memory_footprint ile kontrol edin.

print(model.get_memory_footprint())

quantization_config olmadan from_pretrained() ile quantize edilmiş modelleri yükleyin.

from transformers import AutoModelForCausalLM, AutoTokenizer

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

LLM.int8

Bu bölüm, 8-bit kuantizasyonun bazı özel özelliklerini, örneğin offloading, outlier eşikleri, modül dönüşümünün atlanması ve finetuning gibi konuları ele alır.

Offloading

8-bit modeller, çok büyük modellerin belleğe sığabilmesi için ağırlıkları CPU ile GPU arasında aktarabilir. CPU'ya yönlendirilen ağırlıklar float32 olarak saklanır ve 8-bit'e dönüştürülmez. Örneğin, bigscience/bloom-1b7 için BitsAndBytesConfig üzerinden offload özelliğini etkinleştirebilirsiniz.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(llm_int8_enable_fp32_cpu_offload=True)

lm_head hariç her şeyi GPU'ya sığdıracak şekilde özel bir cihaz haritası tasarlayın; lm_head CPU'ya yönlendirilir.

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

Şimdi modelinizi özel device_map ve quantization_config ile yükleyin.

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

Aykırı değer eşiği

“Outlier” (aykırı değer), belirli bir eşiğin üzerindeki gizli durum değeridir ve bu değerler fp16 ile hesaplanır. Değerler genellikle normal dağılıma sahiptir ([-3.5, 3.5]), ancak büyük modellerde bu dağılım çok farklı olabilir ([-60, 6] veya [6, 60]). 8-bit kuantizasyon ~5 civarındaki değerler için iyi çalışır, ancak bu değerin ötesinde önemli bir performans cezası söz konusudur. İyi bir varsayılan eşik değeri 6'dır, ancak daha az kararlı modeller (küçük modeller veya ince ayar) için daha düşük bir eşik gerekebilir.

Modeliniz için en iyi eşiği bulmak için BitsAndBytesConfig içindeki llm_int8_threshold parametresiyle deneyler yapın. Örneğin, eşiği 0.0 olarak ayarlamak, bazı doğruluk kayıpları pahasına çıkarımı önemli ölçüde hızlandırır.

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

Modül dönüşümünü atla

Jukebox gibi bazı modellerde, her modülü 8-bit'e küçültmeniz gerekmez; bu işlem aslında kararsızlığa yol açabilir. Jukebox'ta, BitsAndBytesConfig içindeki llm_int8_skip_modules parametresi kullanılarak atlanması gereken birkaç lm_head modülü vardır.

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

İnce Ayar

PEFT kütüphanesi, flan-t5-large ve facebook/opt-6.7b gibi büyük modellerin 8-bit kuantizasyon ile ince ayarını destekler. Eğitim için device_map parametresini iletmenize gerek yoktur çünkü model otomatik olarak bir GPU'ya yüklenir. Yine de device_map parametresi ile cihaz haritasını özelleştirebilirsiniz (device_map="auto" yalnızca çıkarım için kullanılmalıdır).

QLoRA

Bu bölüm, 4-bit kuantizasyonun bazı özel özelliklerini, örneğin hesaplama veri türünün değiştirilmesi, Normal Float 4 (NF4) veri türü ve iç içe kuantizasyon gibi konuları ele alır.

Hesaplama veri türü

Hesaplama hızını artırmak için BitsAndBytesConfig içinde veri türünü varsayılan değer olan float32'den bf16'ya değiştirin.

import torch
from transformers import BitsAndBytesConfig

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

Normal Float 4 (NF4)

NF4, QLoRA makalesinden gelen ve normal dağılımdan başlatılan ağırlıklar için uyarlanmış 4 bitlik bir veri türüdür. 4 bitlik temel modelleri eğitmek için NF4 kullanmalısınız.

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)

Çıkarım için bnb_4bit_quant_type performans üzerinde büyük bir etkiye sahip değildir. Ancak, model ağırlıklarıyla tutarlı kalmak için bnb_4bit_compute_dtype ve dtype değerlerini kullanmanız gerekir.

İç içe nicelleştirme

İç içe nicelleştirme, ek performans maliyeti olmadan ek bellek tasarrufu sağlayabilir. Bu özellik, zaten nicelleştirilmiş ağırlıklara ikinci bir nicelleştirme uygulayarak ek olarak 0,4 bit/parametre tasarruf sağlar. Örneğin, iç içe nicelleştirme ile Llama-13b modelini 1024 dizi uzunluğu, 1 parti boyutu ve 4 adımlık gradyan biriktirme etkinleştirilerek 16GB NVIDIA T4 GPU üzerinde ince ayarlayabilirsiniz.

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)

bitsandbytes modellerini dekuantize etme

Kantize edildikten sonra, bir modeli dequantize() ile orijinal hassasiyete geri getirebilirsiniz ancak bu, bazı kalite kayıplarına yol açabilir. Kantize edilmemiş modelin sığması için yeterli GPU belleğiniz olduğundan emin olun.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig, AutoTokenizer

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

Kaynaklar

8-bit kuantizasyonun ayrıntıları hakkında daha fazla bilgi için Hugging Face Transformers, Accelerate ve bitsandbytes kullanarak ölçekli transformer'lar için 8-bit matris çarpımına nazik bir giriş başlıklı makaleye göz atın.

Bu defterde 4-bit kuantizasyonu deneyin ve Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA makalesinde detaylarını öğrenin.