# AdaLoRA

[AdaLoRA](https://hf.co/papers/2303.10512) (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](/docs/peft/v0.22.0/tr/package_reference/adalora#peft.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 yapmaktır; bu da çok sayıda aşağı akış görevi mevcut olduğunda uygulanamaz hale gelir. Bu nedenle, önceden eğitilmiş ağırlıkların artımlı güncellemelerini parametre verimli bir şekilde öğrenmek için birçok ince ayar yöntemi önerilmiştir, örneğin düşük rütbeli artımlar. Bu yöntemler genellikle artımlı 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ımlı 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.*

> [!WARNING]
> 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()](/docs/peft/v0.22.0/tr/package_reference/adalora#peft.AdaLoraModel.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) sınıfından türetme yapmanız gerekir. Örnek olarak bu [özel eğitim döngüsüne](https://github.com/huggingface/peft/blob/912ad41e96e03652cabf47522cd876076f7a0c4f/examples/conditional_generation/peft_adalora_seq2seq.py#L120) göz atabilirsiniz.

AdaLoRA, LoRA'dan kaynaklanan parametre bütçesini, bir göreve daha iyi uyarlanan önemli ağırlık matrislerine daha fazla parametre - başka bir deyişle, daha yüksek bir `r` derecesi - tahsis ederek ve önemsiz olanları budayarak yönetir. Derece, tekil değer ayrıştırması (SVD) benzeri bir yöntemle kontrol edilir. $\Delta W$, tekil değerleri içeren iki ortogonal matris ve bir çapraz matris ile parametrelenir. Bu parametreleme yöntemi, hesaplaması pahalı olan SVD'nin yinelemeli olarak uygulanmasını önler. Bu yönteme dayanarak, $\Delta W$'nin derecesi bir önem puanına göre ayarlanır. $\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.

> [!NOTE]
> **Katkulara açığız**: Bu bölümün açıklığa kavuşturulması gerekiyor.
>
> Önem ölçüsünün nasıl hesaplandığı belirsizdir. Açıklamalar da biraz tekrar içeriyor ve birleştirilerek iyileştirilebilir. Nasıl katkıda bulunulacağına dair bilgi için [buraya](../developer_guides/contributing#documentation-improvements) bakın.

## Karma performans değerlendirmesi genel bakış

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ADALORA" frameborder="0" width="850" height="1000"
>

## Kullanım

```py
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[[peft.AdaLoraConfig]]

#### peft.AdaLoraConfig[[peft.AdaLoraConfig]]

```python
peft.AdaLoraConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, r: int = 8, target_modules: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, lora_alpha: int = 8, lora_dropout: float = 0.0, fan_in_fan_out: bool = False, bias: Literal['none', 'all', 'lora_only'] = 'none', use_rslora: bool = False, modules_to_save: Optional[list[str]] = None, init_lora_weights: bool | Literal['gaussian', 'eva', 'olora', 'pissa', 'pissa_niter_[number of iters]', 'corda', 'astra', 'loftq', 'orthogonal', 'mica', 'nora'] = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, rank_pattern: dict | None = None, alpha_pattern: Optional[dict] = <factory>, megatron_config: Optional[dict] = None, megatron_core: Optional[str] = 'megatron.core', trainable_token_indices: Optional[Union[list[int], dict[str, list[int]]]] = None, loftq_config: Union[LoftQConfig, dict] = <factory>, eva_config: Optional[EvaConfig] = None, corda_config: Optional[CordaConfig] = None, astra_config: Optional[AstraConfig] = None, lora_ga_config: Optional[LoraGAConfig] = None, use_dora: bool = False, velora_config: Optional[Union[VeloraConfig, dict]] = None, alora_invocation_tokens: Optional[list[int]] = None, use_qalora: bool = False, qalora_group_size: int = 16, monteclora_config: Optional[MontecloraConfig] = None, layer_replication: Optional[list[tuple[int, int]]] = None, runtime_config: LoraRuntimeConfig = <factory>, lora_bias: bool = False, target_parameters: Optional[list[str]] = None, use_bdlora: Optional[BdLoraConfig] = None, arrow_config: Optional[ArrowConfig] = None, kasa_config: Optional[KasaConfig] = None, ensure_weight_tying: bool = False, target_r: int = 8, init_r: int = 12, tinit: int = 0, tfinal: int = 0, deltaT: int = 1, beta1: float = 0.85, beta2: float = 0.85, orth_reg_weight: float = 0.5, total_step: int | None = None)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adalora/config.py#L24)

**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 ayısı ı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`) : Duyarlılık yumuşatması için EMA'nın hiperparametresi.

beta2 (`float`) : Belirsizlik kuantifikasyonu için EMA'nın hiperparametresi.

orth_reg_weight (`float`) : Ortogonal düzenleme 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 ayrılan rank.

Bu, bir [AdaLoraModel](/docs/peft/v0.22.0/tr/package_reference/adalora#peft.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ı tam da burada gerçekleşir. Bu süreç, `total_step - tfinal` adımına ulaşılana kadar devam eder.

`total_step - tfinal` adımına ulaşıldığında başlayan son aşama, katman sıralarını artık değiştirmez; bunun yerine bir önceki aşamadan elde edilen indirgenmiş 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 indirgeme olmadan ön eğitim yapar, ardından bütçemizin adım adım azaldığı indirgeme aşamasında 80 (100-20) adım harcar ve son olarak indirgeme olmadan 20 adımı son ince ayama ayırırız.

## AdaLoraModel[[peft.AdaLoraModel]]

#### peft.AdaLoraModel[[peft.AdaLoraModel]]

```python
peft.AdaLoraModel(model, config, adapter_name, **kwargs)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adalora/model.py#L36)

**Parametreler:**

model ([transformers.PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) : Uyarlanacak model.

config ([AdaLoraConfig](/docs/peft/v0.22.0/tr/package_reference/adalora#peft.AdaLoraConfig)) : AdaLora modelinin yapılandırması.

adapter_name (`str`) : Adaptörün adı, varsayılan olarak `"default"`'tur.

low_cpu_mem_usage (`bool`, `optional`, varsayılan `False`) : Meta cihazında boş adaptör ağırlıkları oluşturur. Yükleme sürecini hızlandırmak için faydalıdır.

**Dönüş:** `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:
```py
>>> 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**:
- **model** ([transformers.PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) -- Uyarlanacak model.
- **peft_config** ([AdaLoraConfig](/docs/peft/v0.22.0/tr/package_reference/adalora#peft.AdaLoraConfig)): AdaLora modelinin yapılandırması.

#### add_weighted_adapter[[peft.AdaLoraModel.add_weighted_adapter]]

```python
add_weighted_adapter(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adalora/model.py#L370)

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

#### update_and_allocate[[peft.AdaLoraModel.update_and_allocate]]

```python
update_and_allocate(global_step)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adalora/model.py#L328)

**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:

```python
>>> loss = model(**input).loss
>>> loss.backward()
>>> optimizer.step()
>>> model.base_model.update_and_allocate(i_step)
>>> optimizer.zero_grad()
```

