PEFT documentation

AdaLoRA

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

AdaLoRA

AdaLoRA (Adaptive LoRA), tüm modüller arasında parametreleri eşit dağıtan LoRA'nın aksine, ağırlık matrislerine ve katmanlara atanacak eğitilebilir parametre sayısını optimize etmek için kullanılan bir yöntemdir. Önemli ağırlık matrisleri ve katmanlara daha fazla parametre ayrılırken, önemsiz olanlara daha az parametre tahsis edilir. Matrislerin ortalama istenen rank değerini veya r değerini ve AdaLoRA'nın hangi modüllere uygulanacağını target_modules ile kontrol edebilirsiniz. Ayarlanması gereken diğer önemli parametreler lora_alpha (ölçekleme faktörü) ve modules_to_save (AdaLoRA katmanları dışında eğitilecek ve kaydedilecek modüllerdir). Tüm bu parametreler - ve daha fazlası - AdaLoraConfig içinde bulunur.

Makalenin özeti şudur:

Büyük önceden eğitilmiş dil modellerini aşağı akış görevlerinde ince ayar yapma, NLP'de önemli bir paradigma haline gelmiştir. Ancak, yaygın uygulama, önceden eğitilmiş modeldeki tüm parametreleri ince ayar yapmayı içerir ve bu, çok sayıda aşağı akış görevi mevcut olduğunda uygulanamaz hale gelir. Bu nedenle, önceden eğitilmiş ağırlıkların artımsal güncellemelerini parametre verimli bir şekilde öğrenmek için birçok ince ayar yöntemi önerilmiştir, örneğin düşük rütbeli artışlar. Bu yöntemler genellikle artımsal güncellemelerin bütçesini tüm önceden eğitilmiş ağırlık matrisleri arasında eşit olarak dağıtır ve farklı ağırlık parametrelerinin değişen önemini göz ardı eder. Sonuç olarak, ince ayar performansı optimum değildir. Bu boşluğu doldurmak için, AdaLoRA'yı öneriyoruz; bu yöntem, parametre bütçesini ağırlık matrisleri arasında önem puanlarına göre uyumlu bir şekilde tahsis eder. Özellikle, AdaLoRA artımsal güncellemeleri tekil değer ayrıştırması (SVD) biçiminde parametreler. Bu yeni yaklaşım, önemsiz güncellemelerin tekil değerlerini etkili bir şekilde budamamıza olanak tanır; bu da özünde parametre bütçelerini azaltmakla birlikte yoğun ve kesin SVD hesaplamalarından kaçınmaktır. AdaLoRA'nın etkinliğini doğrulamak için doğal dil işleme, soru-cevap ve doğal dil üretimi üzerinde birkaç önceden eğitilmiş modelle kapsamlı deneyler gerçekleştirdik. Sonuçlar, AdaLoRA'nın özellikle düşük bütçe ayarlarında taban çizgilerine göre belirgin bir iyileşme gösterdiğini kanıtlamaktadır. Kodumuz https://github.com/QingruZhang/AdaLoRA adresinde herkese açıktır.

AdaLoRA, parametre bütçesini ve maskesini güncellemek için her eğitim adımında çağrılması gereken bir update_and_allocate() yöntemine sahiptir; aksi takdirde uyarlama adımı gerçekleştirilmez. Bunun için bu yöntemi entegre etmek üzere özel bir eğitim döngüsü yazmanız veya Trainer sınıfından türetme yapmanız gerekir. Örnek olarak bu özel eğitim döngüsüne göz atabilirsiniz.

AdaLoRA, LoRA'dan gelen parametre bütçesini, önemli ağırlık matrislerine daha fazla parametre - başka bir deyişle daha yüksek bir rütbe r - tahsis ederek ve daha az önemli olanları budayarak yönetir. Rütbe, tekil değer ayrıştırması (SVD) benzeri bir yöntemle kontrol edilir. ΔW\Delta W iki dik matris ve tekil değerleri içeren bir çapraz matris ile parametrelenir. Bu parametreleme yöntemi, hesaplaması maliyetli olan SVD'nin yinelemeli olarak uygulanmasını önler. Bu yönteme dayanarak ΔW\Delta W nin rütbesi, bir önem puanına göre ayarlanır. ΔW\Delta W üçlülere bölünür ve her üçlü, model performansına katkısına göre puanlanır. Düşük önem puanına sahip üçlüler budanır ve yüksek önem puanına sahip üçlüler ince ayar için korunur.

AdaLoRA ile eğitim üç aşamadan oluşur: başlatma aşaması, bütçeleme aşaması ve son aşama. Başlatma aşamasında bütçeleme uygulanmadığından, rütlere dokunulmaz. Bütçeleme aşamasında yukarıda açıklanan süreç uygulanır ve rütler, daha önemli adaptörlere daha fazla rüt, daha az önemli katmanlara ise daha az rüt vermeyi hedefleyen bir bütçeye göre yeniden dağıtılır. Son aşamaya ulaşıldığında bütçeleme sona erer, rütler yeniden dağıtılır ancak performansı daha da iyileştirmek için yeniden dağıtılmış rütlerle bir süre daha eğitime devam edilebilir.

Katkulara açığız: Bu bölümün açıklığa kavuşturulması gerekiyor.

Önem ölçüsünün nasıl belirlendiği net değildir. Açıklamalar da biraz tekrar içeriyor ve birleştirilerek iyileştirilebilir. Nasıl katkıda bulunacağınızı burada görebilirsiniz.

Karma performans değerlendirmesi genel bakış

Kullanım

from peft import AdaLoraConfig, get_peft_model

config = AdaLoraConfig(
    r=8,
    init_r=12,
    tinit=200,
    tfinal=1000,
    deltaT=10,
    target_modules=["query", "value"],
    modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()

[... training code ...]

model.update_and_allocate(step_idx)

API

AdaLoraConfig

sınıf peft.AdaLoraConfig

< >

( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falser: int = 8target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonelora_alpha: int = 8lora_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: Literal['none', 'all', 'lora_only'] = 'none'use_rslora: bool = Falsemodules_to_save: Optional[list[str]] = Noneinit_lora_weights: bool | Literal['gaussian', 'eva', 'olora', 'pissa', 'pissa_niter_[number of iters]', 'corda', 'astra', 'loftq', 'orthogonal', 'mica', 'nora'] = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonerank_pattern: dict | None = Nonealpha_pattern: Optional[dict] = <factory>megatron_config: Optional[dict] = Nonemegatron_core: Optional[str] = 'megatron.core'trainable_token_indices: Optional[Union[list[int], dict[str, list[int]]]] = Noneloftq_config: Union[LoftQConfig, dict] = <factory>eva_config: Optional[EvaConfig] = Nonecorda_config: Optional[CordaConfig] = Noneastra_config: Optional[AstraConfig] = Nonelora_ga_config: Optional[LoraGAConfig] = Noneuse_dora: bool = Falsevelora_config: Optional[Union[VeloraConfig, dict]] = Nonealora_invocation_tokens: Optional[list[int]] = Noneuse_qalora: bool = Falseqalora_group_size: int = 16monteclora_config: Optional[MontecloraConfig] = Nonelayer_replication: Optional[list[tuple[int, int]]] = Noneruntime_config: LoraRuntimeConfig = <factory>lora_bias: bool = Falsetarget_parameters: Optional[list[str]] = Noneuse_bdlora: Optional[BdLoraConfig] = Nonearrow_config: Optional[ArrowConfig] = Nonekasa_config: Optional[KasaConfig] = Noneensure_weight_tying: bool = Falsetarget_r: int = 8init_r: int = 12tinit: int = 0tfinal: int = 0deltaT: int = 1beta1: float = 0.85beta2: float = 0.85orth_reg_weight: float = 0.5total_step: int | None = None )

Parametreler

  • target_r (int) — Artımlı matrisin hedef ortalama rütbesi.
  • init_r (int) — Her artımsal matris için başlangıç sırası.
  • tinit (int) — Başlangıç ince ayar ısınma adımları.
  • tfinal (int) — Son ince ayarın adım sayısı.
  • deltaT (int) — İki bütçe tahsisi arasındaki zaman aralığı.
  • beta1 (float) — Hassasiyet yumuşatma için EMA'nın hiperparametresi.
  • beta2 (float) — Belirsizlik kuantifikasyonu için EMA'nın hiperparametresi.
  • orth_reg_weight (float) — Ortogonal düzenlemenin katsayısı.
  • total_step (int) — Eğitimden önce belirtilmesi gereken toplam eğitim adımı sayısı.
  • rank_pattern (list) — RankAllocator tarafından her ağırlık matrisi için tahsis edilen rank.

Bu, bir AdaLoraModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır.

AdaLoRA, tinit, tfinal ve total_step tarafından tanımlanan üç aşamaya sahiptir.

Başlangıç aşaması, adaptörlerin ön eğitimi için bir adım olarak anlaşılabileceğinden, dereceleri azaltıldığında rastgele matrisler yerine azaltılabilecek bazı bilgilerin zaten kodlanmış olması sağlanır. Bu aşama, tinit sağlanarak tanımlanır.

İlk faz tamamlandıktan (tinit adım geçtikten) ve son faz başlamadan önce, AdaLoRA her adımda her katmanın sahip olabileceği rank bütçesini azaltır. Rank'ın azaltılması burada gerçekleşir. Bu süreç, total_step - tfinal adımına ulaşılana kadar devam eder.

Son aşama, total_step - tfinal adımına ulaşıldığında başlar ve katman sıralarını artık değiştirmez, ancak önceki aşamadan elde edilen azaltılmış sıralı katmanları ince ayarlar.

Pratik bir örnek: tinit 10, tfinal 20, total_step 100'dür. Bütçemiz sabit olduğu için (init aşaması) 10 adım boyunca rank indirimi yapmadan ön eğitim gerçekleştiririz, ardından bütçemizin adım adım azaldığı indirme aşamasında 80 (100-20) adım harcarız ve son olarak, indirme yapılmayan son ince ayama aşamasında 20 adım geçiririz.

AdaLoraModel

sınıf peft.AdaLoraModel

< >

( modelconfigadapter_name**kwargs ) → torch.nn.Module

Parametreler

  • model (transformers.PreTrainedModel) — Uyarlanacak model.
  • config (AdaLoraConfig) — AdaLora modelinin yapılandırması.
  • adapter_name (str) — Adaptörün adı, varsayılan olarak "default"'tır.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Meta cihazda boş adaptör ağırlıkları oluşturur. Yükleme sürecini hızlandırmak için faydalıdır.

Dönüş değeri

torch.nn.Module

AdaLora modeli.

Önceden eğitilmiş bir transformers modelinden AdaLoRA (Adaptive LoRA) modeli oluşturur. Makale: https://openreview.net/forum?id=lq62uWRJjiY

Örnek:

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import AdaLoraConfig, get_peft_model

>>> config = AdaLoraConfig(
...     peft_type="ADALORA",
...     task_type="SEQ_2_SEQ_LM",
...     init_r=12,
...     lora_alpha=32,
...     target_modules=["q", "v"],
...     lora_dropout=0.01,
...     total_step=1000,
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> adalora_model = get_peft_model(model, config)

Öznitelikler:

add_weighted_adapter

< >

( *args**kwargs )

Bu yöntem AdaLoRA için desteklenmez, bunun yerine LoRA kullanın.

update_and_allocate

< >

( global_step )

Parametreler

  • global_step (int) — Mevcut eğitim adımı, adalora bütçesini hesaplamak için kullanılır.

Bu yöntem, Adalora bütçesini ve maskesini günceller.

Bu, her eğitim adımında loss.backward() sonrasında ve zero_grad() öncesinde çağrılmalıdır.

tinit, tfinal ve deltaT metot içinde işlenir.

Örnek:

>>> loss = model(**input).loss
>>> loss.backward()
>>> optimizer.step()
>>> model.base_model.update_and_allocate(i_step)
>>> optimizer.zero_grad()
Update on GitHub