PEFT documentation

OSF (Ortogonal Alt Uzay İnce Ayarı)

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

OSF (Ortogonal Alt Uzay İnce Ayarı)

Ortogonal Alt Uzay İnce Ayarı (OSF), parametre güncellemelerini daha önce önemli olan yönlerin dikine kısıtlayan, sürekli öğrenme için tasarlanmış bir PEFT yöntemidir. Bu yaklaşım, ek parametrelere veya önceki gradyanların saklanmasına ihtiyaç duymadan tam ince ayar yapılmasını sağlarken felaketçi unutmayı önler.

Makalenin özeti şudur:

Büyük dil modellerinde (LLM) sürekli öğrenme, yeni görevlere uyum sağlarken daha önce öğrenilen görevlerdeki performansı önemli ölçüde düşüren katastrofik unutma sorununa yatkındır. Mevcut yöntemler genellikle, modelin ifade gücünü sınırlayan ve görev başına ek parametreler ekleyerek ölçeklenebilirlik sorunlarına yol açan düşük rütbeli, parametre verimli güncellemelere dayanır. Bu sınırlamaları ele almak için, adaptif tekil değer ayrıştırmadan (SVD) yararlanan yeni bir sürekli tam ince ayar yaklaşımı öneriyoruz. Yöntemimiz, görevlere özgü düşük rütbeli parametre alt uzaylarını dinamik olarak belirler ve güncellemeleri, önceki görevlerle ilişkili kritik yönlere dik olacak şekilde kısıtlar; böylece ek parametre yükü veya önceki görev gradyanlarının saklanması olmadan müdahaleyi etkili bir şekilde en aza indirir. Yaklaşımımızı, hem kodlayıcı-çözücü (T5-Large) hem de yalnızca çözücü (LLaMA-2 7B) modelleri kullanarak, sınıflandırma, üretim ve akıl yürütme gibi çeşitli görevleri kapsayan standart sürekli öğrenme kriterlerinde kapsamlı olarak değerlendiriyoruz. Deneysel olarak, yöntemimiz O-LoRA gibi son zamanlardaki baz çizgilerinden ortalama doğrulukta %7'ye varan bir artışla en iyi sonuçları elde etmekte ve unutmayı neredeyse ihmal edilebilir seviyelere indirgeyerek sürekli öğrenme süreci boyunca modelin genel dil yeteneklerini, talimat takibi doğruluğunu ve güvenliğini korumaktadır. Adaptif SVD çerçevemiz, model plastisitesi ile bilgi tutulumu arasında etkili bir denge sağlayarak, büyük dil modellerinde sürekli öğrenme senaryoları için pratik, teorik temelli ve hesaplamalı olarak ölçeklenebilir bir çözüm sunmaktadır.

OSF Nasıl Çalışır

OSF, SVD kullanarak her ağırlık matrisini yüksek-rank (donmuş) ve düşük-rank (eğitilebilir) bileşenlere ayırır:

W = U_high * S_high * V_high^T + U_low * S_low * V_low^T

Burada:

  • U_high, S_high, V_high: Önceki görevlerden önemli yönleri koru (donmuş)
  • U_low, S_low, V_low: Yeni görevlere uyum sağlamaya izin verir (eğitilebilir)

Eğitim sırasında, gradyanlar yüksek-rank alt uzaya dik olacak şekilde projekte edilir; bu sayede güncellemelerin daha önce öğrenilen bilgiyle çelişmesi önlenir.

Temel Kullanım

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import OSFConfig, get_peft_model

# Load base model
model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")

# Configure OSF
config = OSFConfig(
    target_modules=["q_proj", "v_proj"],  # Target attention layers
    effective_rank=8,                     # Default rank for decomposition
    rank_pattern={"q_proj": 16}           # Override rank for specific modules
)

# Apply OSF
model = get_peft_model(model, config)

# Train as usual
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)

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

inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
loss = model(**inputs, labels=inputs.input_ids).loss
loss.backward()
optimizer.step()
optimizer.zero_grad()

Yapılandırma Seçenekleri

Hedef Modüller

Hedef modülleri birkaç farklı şekilde belirleyebilirsiniz:

# Specific module names
config = OSFConfig(target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])

# All linear layers
config = OSFConfig(target_modules="all-linear")

# Model-specific defaults (automatically detected)
config = OSFConfig()  # Uses model-appropriate defaults

Etkili Sıralama Yapılandırması

Korunan/eğitilebilir alt uzayları kontrol edin:

# Global preserved rank (applies to all target modules)
config = OSFConfig(effective_rank=16)  # preserves top-16 singular directions; trains the rest

# Automatic preserved rank (50% of the smaller matrix dimension per target)
config = OSFConfig(effective_rank=None)

# Per-module preserved-rank overrides
config = OSFConfig(
    effective_rank=8,
    rank_pattern={
        "q_proj": 16,      # Higher rank for query projection
        "gate_proj": 4     # Lower rank for gate projection
    }
)

# Fractional preserved rank is supported (interpreted per-target as fraction * min_dim)
config = OSFConfig(effective_rank=0.8)  # preserve 80% of min_dim; train remaining 20%
config = OSFConfig(rank_pattern={"q_proj": 0.5})  # preserve 50% on q_proj, others use global/default

Not: OSF'in effective_rank değeri, eğitilebilir rütbe değil, korunan (donmuş) rübedir. Eğitilebilir rütbe min(weight.shape) - effective_rank değerine eşittir. Bu, eğitilebilir rübeden doğrudan bahseden LoRA'nın r parametresinden farklıdır.

Sürekli Öğrenme İçin Eğitim Tavsiyeleri

Sıralı Görev Öğrenimi

OSF, görevlerin sıralı olarak öğrenilmesi için özellikle tasarlanmıştır. Görevler arasında, korunan alt uzayın en güncel ağırlıkları yansıtması için SVD yeniden hesaplanır. Bunun basit bir yolu, güncellenmiş temel modeli OSF ile yeniden sarmalamaktır:

# Task 1: train on domain A with initial preserved subspace
r = 8  # initial effective rank to preserve
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_1_data)

# Task 2: recompute SVD on updated weights and increase preserved subspace
base_model = model.unload()  # unwrap base model without assuming internals
r += 4  # grow preserved subspace to include Task 1 knowledge
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_2_data)

# Task 3: recompute again and expand preserved subspace further
base_model = model.unload()
r += 4
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_3_data)

Görev Dizileri İçin Bütçe Dağıtımı

n görevlik bilinen bir dizide eğitim yapılırken, yeni görevleri öğrenirken önceki bilgiyi korumak için model kapasitesini kademeli olarak dağıtmak etkili bir stratejidir:

  • Görev 1: Tam kapasite kullanın (her şeyi eğitin)
  • Görev 2: Model kapasitesinin 1/n'ini dondurun, kalan (n-1)/n kapasiteyi eğitin
  • Görev 3: Model kapasitesinin 2/n'ini dondurun, kalan (n-2)/n kapasiteyi eğitin
  • Görev n: Model kapasitesinin (n-1)/n'ini dondurun, son görev için 1/n kapasiteyi kullanın

Bu yaklaşım, her görevin yeterli öğrenme kapasitesine sahip olmasını sağlarken önceki görevlerden daha fazla bilgiyi kademeli olarak korur.

# Example: 4-task sequence with progressive budget allocation
n_tasks = 4
max_preserved_rank = 512  # Upper bound for preserved rank per target (heuristic)

for task_id in range(n_tasks):
    # Freeze increases over time; trainable capacity shrinks
    preserved_fraction = (task_id + 1) / n_tasks
    preserved_rank = int(max_preserved_rank * preserved_fraction)

    config = OSFConfig(
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
        effective_rank=preserved_rank,
    )

    print(
        f"Task {task_id + 1}: Preserving rank {preserved_rank} "
        f"({preserved_fraction:.1%} of max_preserved_rank - {max_preserved_rank} frozen); trainable rank = min_dim - preserved_rank"
    )

    model = get_peft_model(base_model, config)
    train_task(model, task_data[task_id])

En İyi Uygulamalar

  1. Etkin Sıralama Seçimi: effective_rank=None ile başlayın (sıralama, hedef modül başına daha küçük ağırlık boyutunun %50'si olarak otomatik ayarlanır) ve görev karmaşıklığına göre ayarlayın
  2. Öğrenme Hızı: Standart ince ayara kıyasla daha küçük öğrenme hızları (1e-5 ile 1e-4) kullanın
  3. Görev Önem Derecesi: Kritik modüllere daha fazla kapasite ayırmak için rank_pattern kullanın
  4. Model Mimarisi: OSF, dikkat ve MLP ayrımının net olduğu transformer mimarileriyle en iyi şekilde çalışır
  5. Kapasite Planlaması: Bilinen görev dizileri için, plastisite ve kararlılığı dengelemek üzere kademeli bütçe tahsisi (1/n, 2/n, …, (n-1)/n dondurma) kullanın

Bellek Düşünceleri

OSF ağırlıkları yerinde değiştirir ve parametre eklemez, bu sayede bellek açısından verimlidir:

# Memory usage remains close to base model
print(f"Base model parameters: {base_model.num_parameters():,}")
print(f"OSF model parameters: {osf_model.num_parameters():,}")  # Similar count

Gelişmiş Kullanım

Özel Hedef Modülleri

Standart olmayan mimarilere sahip modeller için:

config = OSFConfig(
    target_modules=["dense", "intermediate.dense"],  # Custom layer names
    effective_rank=12,
    rank_pattern={"dense": 8, "intermediate.dense": 16}
)

Diğer Yöntemlerle Entegrasyon

OSF, diğer tekniklerle birleştirilebilir:

# Use with gradient checkpointing for memory efficiency
# note: use `model.gradient_checkpointing_enable()` for older Transformers versions
model.activation_checkpointing_enable()

# Apply weight decay selectively (regularizes low-rank factors to limit drift/overfitting in continual updates; keep small)
optimizer = torch.optim.AdamW([
    {"params": [p for n, p in model.named_parameters() if "U_low" in n], "weight_decay": 0.01},
    {"params": [p for n, p in model.named_parameters() if "S_low" in n], "weight_decay": 0.001},
    {"params": [p for n, p in model.named_parameters() if "V_low" in n], "weight_decay": 0.01},
], lr=1e-4)

Karma performans değerlendirmesi genel bakış

API

OSFConfig

sınıf peft.OSFConfig

< >

( 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 = Falseeffective_rank: Optional[Union[int, float]] = Nonetarget_modules: Optional[Union[list[str], str]] = Nonerank_pattern: Optional[dict[str, Union[int, float]]] = Noneinit_weights: Optional[bool] = Truemodules_to_save: Optional[list[str]] = Nonetarget_svd_config: Optional[dict[str, int]] = None )

Parametreler

  • effective_rank (int veya float, isteğe bağlı) — Korunan SVD rütbesi (“yüksek” alt uzay). En üst effective_rank tekil yönler dondurulur ve görevler arasında korunur; kalan boyutlar ise eğitilebilir düşük rütbeli alt uzayı oluşturur. None ise, hedef modül başına daha küçük ağırlık boyutunun %50'si varsayılan değer olarak kullanılır. Not: Bu, LoRA'nın r (eğitilebilir rütbe) değerinden farklıdır. OSF'de eğitilebilir rütbe min(weight.shape) - effective_rank'dir.
  • target_modules (Union[list[str], str], isteğe bağlı) — OSF'nin uygulanacağı modüllerin adları. Modül adlarının bir listesi veya “all-linear” olabilir.
  • rank_pattern (dict[str, int|float], isteğe bağlı) — Belirli modüller için effective_rank değerini geçersiz kılmak için regex desenlerinden oluşan bir sözlük. Değerler, mutlak tamsayılar veya (0, 1] aralığında, hedef başına daha küçük matris boyutunun bir kesri olarak yorumlanan kesirler olabilir.

Ortogonal Alt Uzay İnce Ayar (OSF) yapılandırması.

OSFModel

sınıf peft.OSFModel

< >

( modelconfigadapter_namelow_cpu_mem_usage: bool = Falsestate_dict: dict[str, torch.Tensor] | None = None )

Ortogonal Alt Uzay İnce Ayarını uygulayan minimal bir ayarlayıcı.

Yardımcı İşlevler

Ağırlık Ayrıştırması

peft.tuners.osf.utils.decompose_weight_matrix

< >

( weight: torch.Tensortop_k: int )

weight için bir SVD gerçekleştirin ve onu dondurulmuş ile eğitilebilir parçalara ayırın.

Gradient Projection

peft.tuners.osf.utils.project_gradient_to_orthogonal_space

< >

( svd_dict: dict[str, Any] )

U_low ve V_low gradyanlarını, yüksek rütbeli uzaya dik olacak şekilde projekte edin.

Update on GitHub