PEFT documentation

Kantizasyon

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Kantizasyon

Quantization, verileri daha az bit ile temsil ederek özellikle büyük dil modelleri (LLM) söz konusu olduğunda bellek kullanımını azaltmak ve çıkarımı hızlandırmak için faydalı bir tekniktir. Bir modeli kuantize etmenin birkaç yolu vardır:

  • AWQ algoritmasıyla hangi model ağırlıklarının kuantize edileceğini optimize etme
  • ağırlık matrisinin her satırını GPTQ algoritmasıyla bağımsız olarak kuantize etme
  • bitsandbytes kütüphanesiyle 8-bit ve 4-bit hassasiyete kuantizasyon
  • AQLM algoritmasıyla 2-bit hassasiyete kadar düşük değerlerde kuantizasyon

Ancak bir model kuantize edildikten sonra, ağırlıkların ve aktivasyonların daha düşük hassasiyeti nedeniyle eğitim kararsız olabileceğinden, genellikle aşağı akış görevleri için daha fazla eğitilmez. Ancak PEFT yöntemleri yalnızca ek eğitilebilir parametreler eklediği için, kuantize edilmiş bir modeli üzerine bir PEFT adaptörü ile eğitmenizi sağlar! Kuantizasyonu PEFT ile birleştirmek, en büyük modelleri bile tek bir GPU üzerinde eğitmek için iyi bir strateji olabilir. Örneğin, QLoRA, bir modeli 4-bite kuantize edip ardından LoRA ile eğiten bir yöntemdir. Bu yöntem, 65B parametreli bir modeli tek bir 48GB GPU üzerinde ince ayar yapmanıza olanak tanır!

Bu kılavuzda, bir modelin 4-bite nasıl kuantize edileceğini ve LoRA ile nasıl eğitileceğini göreceksiniz.

Bir modeli kuantize et

bitsandbytes, Transformers entegrasyonuna sahip bir kuantizasyon kütüphanesidir. Bu entegrasyon sayesinde bir modeli 8 veya 4-bit olarak kuantize edebilir ve BitsAndBytesConfig sınıfını yapılandırarak birçok başka seçeneği etkinleştirebilirsiniz. Örneğin, şunları yapabilirsiniz:

  • Modeli yüklerken 4-bite kuantize etmek için load_in_4bit=True değerini ayarlayın
  • Normal dağılımdan başlatılan ağırlıklar için özel bir 4-bit veri türü kullanmak için bnb_4bit_quant_type="nf4" değerini ayarlayın
  • Zaten kuantize edilmiş ağırlıkları kuantize etmek için iç içe geçmiş bir kuantizasyon şeması kullanmak için bnb_4bit_use_double_quant=True değerini ayarlayın
  • Daha hızlı hesaplama için bfloat16 kullanmak üzere bnb_4bit_compute_dtype=torch.bfloat16 olarak ayarlayın
import torch
from transformers import BitsAndBytesConfig

config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)

config değerini from_pretrained yöntemine iletin.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)

Ardından, kuantize edilmiş modeli eğitim için ön işlemek üzere prepare_model_for_kbit_training() fonksiyonunu çağırmalısınız.

from peft import prepare_model_for_kbit_training

model = prepare_model_for_kbit_training(model)

Şimdi, kuantize edilmiş model hazır olduğuna göre, bir yapılandırma oluşturalım.

LoraConfig

Aşağıdaki parametrelerle (veya kendi seçtiklerinizle) bir LoraConfig oluşturun:

from peft import LoraConfig

config = LoraConfig(
    r=16,
    lora_alpha=8,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

Ardından kuantize edilmiş model ve yapılandırmadan bir PeftModel oluşturmak için get_peft_model() fonksiyonunu kullanın.

from peft import get_peft_model

model = get_peft_model(model, config)

Hangi eğitim yöntemini tercih ederseniz edin, eğitim için her şey hazır!

LoftQ başlatma

LoftQ, kuantizasyon hatasını en aza indirecek şekilde LoRA ağırlıklarını başlatır ve kuantize modellerin eğitiminde performansı artırabilir. Başlamak için bu talimatları izleyin.

LoftQ yalnızca target_parameters ile hedeflenenler dahil olmak üzere doğrusal katmanlara uygulanır. Gömme ve konvolüsyonel katmanlar desteklenmez ve bunun yerine varsayılan LoRA başlatması kullanılır. nn.MultiheadAttention katmanları desteklenmez ve bir hata oluşturur.

Genel olarak, LoftQ'nun en iyi şekilde çalışması için, hedeflenmeyen katmanlara LoftQ uygulanamadığından, mümkün olduğunca çok katmanı LoRA ile hedeflemeniz önerilir. Bu, LoraConfig(..., target_modules="all-linear") parametresinin geçirilmesinin büyük olasılıkla en iyi sonuçları vereceği anlamına gelir. Ayrıca, 4bit kuantizasyon kullanırken kuantizasyon yapılandırmanızda kuantizasyon tipi olarak nf4 kullanmalısınız, yani BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4").

Genel olarak, LoftQ'nun en iyi şekilde çalışması için, hedeflenmeyen katmanlara LoftQ uygulanamadığından, mümkün olduğunca çok katmanı LoRA ile hedeflemeniz önerilir. Bu, LoraConfig(..., target_modules="all-linear") parametresinin geçirilmesinin büyük olasılıkla en iyi sonuçları vereceği anlamına gelir. Ayrıca, 4bit kuantizasyon kullanırken kuantizasyon yapılandırmanızda kuantizasyon tipi olarak nf4 kullanmalısınız, yani BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4").

LoftQ'nun uygulanması için şu anda iki amaçlanan yöntem bulunmaktadır:

  1. kuantize edilmemiş temel modeli yükleyin, hedeflediğiniz kuantizasyon seviyesiyle (ör. nf4 için bits=4) LoftQ uygulayın ve sonuçlanan adaptörü kaydedin. Ardından temel modeli örneğin BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4") kullanarak kuantize edin ve LoftQ ile başlatılmış adaptörü bunun üzerine yükleyin
  2. kuantize edilmiş temel modeli yükleyin, LoRA ile bir PEFT modeli başlatın (loftq yok) ve kuantize edilmemiş temel modelin referans ağırlıklarını ağırlık dosyasından akış olarak alarak LoftQ başlatma işlemini uygulamak için replace_lora_weights_loftq kullanın (bir sonraki bölümde daha ayrıntılı açıklanır)

Uygulama sırasında LoftQ uygulaması için replace_lora_weights_loftq kullanımı

LoftQ başlatma yöntemini uygulamak için daha kolay ama daha sınırlı bir yol, replace_lora_weights_loftq kolaylık fonksiyonunu kullanmaktır. Bu fonksiyon girdi olarak kuantize edilmiş PEFT modelini alır ve LoRA ağırlıklarını, LoftQ ile başlatılmış karşılıklarıyla yerinde değiştirir.

from peft import replace_lora_weights_loftq
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
base_model = AutoModelForCausalLM.from_pretrained(..., quantization_config=bnb_config)
# note: don't pass init_lora_weights="loftq" or loftq_config!
lora_config = LoraConfig(task_type="CAUSAL_LM")
peft_model = get_peft_model(base_model, lora_config)
replace_lora_weights_loftq(peft_model)

replace_lora_weights_loftq, hangi katmanların değiştirileceği veya değiştirilmeyeceği üzerinde daha fazla kontrol sağlamak için callback argümanı geçmenize de olanak tanır; bu, ampirik olarak sonuçları oldukça iyileştirebilir. Bunun daha ayrıntılı bir örneğini görmek için bu defterine göz atın.

replace_lora_weights_loftq, LoftQ'nun yalnızca bir yineleme adımını uygular. Bu, LoRA ağırlıklarının ve kuantize edilmiş temel model ağırlıklarının yinelemeli olarak güncellenmesi yerine yalnızca LoRA ağırlıklarının güncellendiği anlamına gelir. Bu durum daha düşük performansla sonuçlanabilir ancak değiştirilmiş kuantize ağırlıkların ek bir kopyasını tutmak zorunda kalmak yerine, temel modelden türetilen orijinal kuantize ağırlıkları kullanabilme avantajına sahiptir. Bu ödünleşimin değerli olup olmadığı kullanım senaryosuna bağlıdır.

Şu anda replace_lora_weights_loftq şu ek kısıtlamalara sahiptir:

  • Model dosyaları bir safetensors dosyası olarak saklanmalıdır.
  • Yalnızca bitsandbytes 4bit kuantizasyonu desteklenir.

PiSSA başlatma

PiSSA, kuantize ağırlıklara uygulanamaz. Genellikle kuantize edilmemiş temel modele uygulanır, ardından elde edilen artık kaydedilir ve kuantizasyonla yüklenir; bu işlem, kuantize edilmemiş tüm modelin belleğe sığmasını gerektirir.

Alternatif olarak, replace_lora_weights_pissa kuantize edilmiş bir PEFT modelini alır ve kuantize edilmemiş modelin ağırlıklarını ağırlık dosyasından katman katman olarak akışa alır. Her katmanın LoRA ağırlıkları PiSSA ile başlatılır ve taban ağırlığı yeniden kuantize edilmiş artık (residual) ile değiştirilir.

from peft import replace_lora_weights_pissa
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
base_model = AutoModelForCausalLM.from_pretrained(..., quantization_config=bnb_config)
# note: don't pass init_lora_weights="pissa" here!
lora_config = LoraConfig(task_type="CAUSAL_LM")
peft_model = get_peft_model(base_model, lora_config)
replace_lora_weights_pissa(peft_model, init_lora_weights="pissa_niter_4")

Hem "pissa" hem de "pissa_niter_[number of iters]" desteklenir.

Taban ağırlıklarının değiştirildiği için, modeli geri yüklemek için yalnızca adaptörün kaydedilmesi yeterli değildir. Diğer PiSSA başlatmaları gibi, taban modeli de kaydedin veya eğitilen adaptörü save_pretrained() işlevinin path_initial_model_for_weight_conversion argümanını kullanarak dönüştürün.

Şu anda replace_lora_weights_pissa şu ek kısıtlamalara sahiptir:

  • Model dosyaları bir safetensors dosyası olarak saklanmalıdır.
  • Yalnızca bitsandbytes 4bit kuantizasyonu desteklenir.
  • DoRA gibi LoRA varyantları desteklenmez.

QLoRA tarzı eğitim

QLoRA, transformer mimarisindeki tüm doğrusal katmanlara eğitilebilir ağırlıklar ekler. Bu doğrusal katmanların öznitelik adları mimariler arasında farklılık gösterebildiğinden, LoRA'yı tüm doğrusal katmanlara eklemek için target_modules değerini "all-linear" olarak ayarlayın:

config = LoraConfig(target_modules="all-linear", ...)

GPTQ nicelleştirme

GPTQ tabanlı [2, 3, 4, 8] bit kuantizasyonu hakkında daha fazla bilgiyi GPT-QModel ve Transformers GPTQ belgelerinde bulabilirsiniz. PEFT, GPT-QModel aracılığıyla GPTQ eğitim sonrası işlemlerini destekler.

# GPT-QModel install
pip install "gptqmodel>=7.0.0"
from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

model_id = "facebook/opt-125m"
tokenizer = AutoTokenizer.from_pretrained(model_id)

gptq_config = GPTQConfig(bits=4, group_size=128, dataset="wikitext2", tokenizer=tokenizer)

quantized_model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", quantization_config=gptq_config)

# save quantized model
quantized_model.save_pretrained("./opt-125m-gptq")
tokenizer.save_pretrained("./opt-125m-gptq")

Kantize edildikten sonra, GPTQ modellerini PEFT API'leri ile eğitimin ardından eğitebilirsiniz.

AQLM kuantizasyonu

Dil Modellerinin Aditif Kuantizasyonu (AQLM), Büyük Dil Modelleri sıkıştırma yöntemidir. Birden fazla ağırlığı birlikte kuantize eder ve bunlar arasındaki karşılıklı bağımlılıklardan yararlanır. AQLM, 8-16 ağırlıktan oluşan grupları birden fazla vektör kodunun toplamı olarak temsil eder. Bu sayede modelleri, doğruluk kaybı oldukça düşük olacak şekilde 2-bit'e kadar sıkıştırılabilir.

AQLM kuantizasyon süreci hesaplama açısından maliyetli olduğundan, önceden kuantize edilmiş modellerin kullanılması önerilir. Kullanılabilir modellerin kısmi bir listesi, resmi aqlm deposunda bulunabilir.

Modeller LoRA adaptör ayarlamasını destekler. Kuantize edilmiş modeli ayarlamak için aqlm çıkarım kütüphanesini yüklemeniz gerekir: pip install aqlm>=1.0.2. İnce ayarlanmış LoRA adaptörleri ayrı olarak kaydedilmelidir, çünkü bunların AQLM kuantize ağırlıklarıyla birleştirilmesi mümkün değildir.

quantized_model = AutoModelForCausalLM.from_pretrained(
    "BlackSamorez/Mixtral-8x7b-AQLM-2Bit-1x16-hf-test-dispatch",
    dtype="auto", device_map="auto", low_cpu_mem_usage=True,
)

peft_config = LoraConfig(...)

quantized_model = get_peft_model(quantized_model, peft_config)

AQLM+LoRA ince ayarının genel bir bakış için Google Colab örneğine başvurabilirsiniz.

EETQ kuantizasyonu

EETQ ile kuantize edilmiş modeller üzerinde de LoRA ince ayarı yapabilirsiniz. EETQ paketi, LLM.int8() algoritmasından daha hızlı olduğu iddia edilen 8-bit kuantizasyonu gerçekleştirmek için basit ve verimli bir yol sunar. Öncelikle, EETQ ile uyumlu bir transformers sürümüne sahip olduğunuzdan emin olun (ör. en son pypi sürümünü veya kaynak kodunu kurarak).

import torch
from transformers import EetqConfig

config = EetqConfig("int8")

config değerini from_pretrained yöntemine iletin.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)

ve bir LoraConfig oluşturup get_peft_model fonksiyonuna iletin:

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=16,
    lora_alpha=8,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, config)

HQQ kuantizasyonu

Büyük Makine Öğrenimi Modellerinin Yarım-Karesel Kuantizasyonu (HQQ) kullanılarak kuantize edilen modeller, LoRA adaptör ayarlamasını destekler. Kuantize modeli ayarlamak için hqq kütüphanesini şu komutla yüklemeniz gerekir: pip install hqq.

from hqq.engine.hf import HQQModelForCausalLM

device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"

quantized_model = HQQModelForCausalLM.from_quantized(save_dir_or_hfhub, device=device)
peft_config = LoraConfig(...)
quantized_model = get_peft_model(quantized_model, peft_config)

Veya HQQ ile uyumlu bir transformers sürümünü kullanın (ör. en son pypi sürümünü veya kaynak kodundan kurarak).

from transformers import HqqConfig, AutoModelForCausalLM

quant_config = HqqConfig(nbits=4, group_size=64)
quantized_model = AutoModelForCausalLM.from_pretrained(save_dir_or_hfhub, device_map=device_map, quantization_config=quant_config)
peft_config = LoraConfig(...)
quantized_model = get_peft_model(quantized_model, peft_config)

torchao (PyTorch Mimari Optimizasyonu)

PEFT, int8 kuantizasyonu için torchao (“ao”) ile kuantize edilmiş modelleri destekler.

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, TorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig

model_id = ...
quantization_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())
base_model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config)
peft_config = LoraConfig(...)
model = get_peft_model(base_model, peft_config)

Dikkat edilmesi gerekenler:

  • En güncel torchao (>= v0.4.0) ve transformers (> 4.42) sürümlerini kullanın.
  • Şu anda yalnızca doğrusal katmanlar desteklenmektedir.
  • quant_type = "int4_weight_only" şu anda desteklenmiyor.
  • NF4 henüz transformers'ta uygulanmadığından desteklenmemektedir.
  • DoRA şu anda yalnızca quant_type = "int8_weight_only" ile çalışır.
  • LoRA ile kullanıldığında torchao için açık destek mevcuttur. Ancak torchao bir katmanı kuantize ettiğinde, sınıfı değişmez; yalnızca altta yatan tensörün tipi değişir. Bu nedenle, açıkça desteklenmese de LoRA dışındaki PEFT yöntemleri genellikle torchao ile de çalışır. Bununla birlikte, birleştirme (merging) yalnızca LoRA ve quant_type = "int8_weight_only" ile doğru şekilde çalışır. Farklı bir PEFT yöntemi veya dtype kullanırsanız, birleştirme büyük olasılıkla bir hataya yol açar ve hata oluşmasa bile sonuçlar yine de yanlış olacaktır.

INC nicelleştirme

Intel Neural Compressor (INC), Intel Gaudi hızlandırıcıları (HPU cihazları olarak da bilinir) dahil olmak üzere çeşitli cihazlar için model kuantizasyonunu destekler. INC kullanılarak kuantize edilmiş modeller üzerinde LoRA ince ayarı yapabilirsiniz. PyTorch modelleriyle INC kullanmak için kütüphaneyi şu komutla yükleyin: pip install neural-compressor[pt]. HPU cihazları için bir modeli FP8 hassasiyetine kuantize etmek, aşağıdaki tek adımlı kuantizasyon iş akışıyla yapılabilir:

import torch
from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare
quant_configs = {
    ...
}
config = FP8Config(**quant_configs)

Yapılandırmayı prepare yöntemine iletin, kalibrasyon istatistiklerini toplamak için çıkarım çalıştırın ve modeli FP8 hassasiyetine dönüştürmek için finalize_calibration ve convert yöntemlerini çağırın:

model = prepare(model, config)
# Run inference to collect calibration statistics
...
# Finalize calibration and convert the model to FP8 precision
finalize_calibration(model)
model = convert(model)
# Load PEFT LoRA adapter as usual
...

HPU cihazları için INC-kuantize edilmiş FLUX metinden görüntüye modeline PEFT LoRA adaptörünün nasıl yükleneceğini gösteren bir örnek burada sunulmaktadır.

Dikkat edilmesi gerekenler:

  • INC-kuantize edilmiş modeller için merge() ve unmerge() yöntemleri şu anda desteklenmemektedir.
  • Şu anda PEFT adaptörleri yüklenirken yalnızca Linear INC-kuantize katmanları desteklenmektedir.

Desteklenen Diğer PEFT Yöntemleri

LoRA'nın yanı sıra, aşağıdaki PEFT yöntemleri de kuantizasyonu destekler:

  • VeRA (bitsandbytes kuantizasyonunu destekler)
  • AdaLoRA (bitsandbytes ve GPTQ nicelleştirmesini destekler)
  • (IA)³ (bitsandbytes kuantizasyonunu destekler)

Transformer Engine (TE) LoRA

PEFT, NVIDIA Transformer Engine katmanlarının (te.pytorch.Linear, te.pytorch.LayerNormLinear ve te.pytorch.LayerNormMLP) üzerine LoRA adaptörlerini destekler. TE katmanları, transformer eğitimini hızlandırmak için FP8 ve füzyonlu çekirdekler kullanır; LoRA adaptörlerini bağlamak, TE hızlandırmalı modelleri parametre verimli bir şekilde ince ayar yapmanızı sağlar.

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    task_type="TOKEN_CLS",
)
model = get_peft_model(te_model, config)

Transformer Engine yüklendiğinde, PEFT eşleşen katmanları otomatik olarak TeLinear adaptörüne yönlendirir — ek yapılandırma gerekmez.

Dikkat Edilmesi Gerekenler

  • merge() ve unmerge() TE katmanları için henüz desteklenmiyor.
  • DoRA, TE katmanlarıyla desteklenmez.

Tam bir ESM2 token-sınıflandırma örneği examples/lora_finetuning_transformer_engine/ altında mevcuttur.

Kantize ağırlıklara adaptörlerin birleştirilmesi

Destekleyen herhangi bir kuantizasyon yöntemi için merge_adapter(), temel ağırlığı dekuantize eder, adaptör ağırlıklarını ekler ve sonucu yeniden kuantize eder. unmerge_adapter() aynı işlemi tersine yapar; bu nedenle orijinal kuantize ağırlıkları geri yüklemez ve tekrarlanan birleştirme/geri alma döngüleri yuvarlama hatası biriktirebilir. Orijinal ağırlıkları geri almak için temel modeli yeniden yükleyin. Birleştirme yapmadan temel model ile adaptör arasında geçiş yapmak için disable_adapter() bağlam yöneticisini kullanın.

Sonraki adımlar

Kuantizasyon hakkında daha fazla bilgi edinmek istiyorsanız, aşağıdakiler size yardımcı olabilir:

Update on GitHub