PEFT documentation

OSF (Orthogonal Subspace Fine-tuning)

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

OSF (Orthogonal Subspace Fine-tuning)

Метод дообучения в ортогональном подпространстве (OSF) — это метод PEFT, разработанный для непрерывного обучения, который ограничивает обновления параметров так, чтобы они были ортогональны ранее важным направлениям. Такой подход позволяет выполнять полное дообучение, предотвращая катастрофическое забывание, без необходимости добавлять дополнительные параметры или хранить предыдущие градиенты.

Аннотация из статьи:

Непрерывное обучение в больших языковых моделях (LLM) подвержено катастрофическому забыванию, при котором адаптация к новым задачам значительно ухудшает результаты на ранее изученных. Существующие методы обычно опираются на обновления с низкой рангом и эффективностью по параметрам, что ограничивает выразительность модели и вводит дополнительные параметры для каждой задачи, что приводит к проблемам масштабируемости. Для преодоления этих ограничений мы предлагаем новый подход к непрерывному полному дообучению, использующий адаптивное разложение по сингулярным значениям (SVD). Наш метод динамически определяет подпространства параметров с низкой рангом, специфичные для задачи, и ограничивает обновления так, чтобы они были ортогональны критическим направлениям, связанным с предыдущими задачами, тем самым эффективно минимизируя взаимное влияние без дополнительных затрат по параметрам или хранения градиентов предыдущих задач. Мы подробно оцениваем наш подход на стандартных бенчмарках непрерывного обучения, используя как модели с архитектурой «кодек-декодер» (T5-Large), так и модели только с декодером (LLaMA-2 7B), охватывая разнообразные задачи, включая классификацию, генерацию и рассуждения. Эмпирически наш метод достигает результатов уровня state-of-the-art, повышая среднюю точность до 7% по сравнению с недавними базовыми методами, такими как O-LoRA, и, что примечательно, сохраняет общие языковые возможности модели, точность следования инструкциям и безопасность на протяжении всего процесса непрерывного обучения, снижая забывание до практически пренебрежимо малых уровней. Наш адаптивный SVD-фреймворк эффективно балансирует пластичность модели и удержание знаний, предлагая практичное, теоретически обоснованное и вычислительно масштабируемое решение для сценариев непрерывного обучения в больших языковых моделях.

Как работает OSF

OSF разлагает каждую матрицу весов на компоненту высокого ранга (замороженную) и компоненту низкого ранга (обучаемую) с помощью SVD:

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

Где:

  • U_high, S_high, V_high: Сохранение важных направлений из предыдущих задач (заморожено)
  • U_low, S_low, V_low: позволяют адаптироваться к новым задачам (обучаемые)

В процессе обучения градиенты проецируются так, чтобы быть ортогональными подпространству высокого ранга, что гарантирует, обновления не будут влиять на ранее полученные знания.

Базовое использование

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

Варианты конфигурации

Целевые модули

Вы можете указать целевые модули несколькими способами:

# 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

Конфигурация эффективного ранга

Управление сохраняемыми/обучаемыми подпространствами:

# 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

Примечание: effective_rank в OSF — это сохраняемый (замороженный) ранг, а не обучаемый ранг. Обучаемый ранг равен min(weight.shape) - effective_rank. Это отличается от r в LoRA, который напрямую задает обучаемый ранг.

Советы по обучению для непрерывного обучения

Последовательное обучение задач

OSF специально разработан для последовательного обучения задачам. Между задачами пересчитывайте SVD, чтобы сохраняемое подпространство отражало последние веса. Один из простых способов — снова обернуть обновлённую базовую модель с помощью OSF:

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

Распределение бюджета для последовательностей задач

При обучении на известной последовательности из n задач одной из эффективных стратегий является постепенное распределение ёмкости модели для баланса между обучением новым задачам и сохранением ранее полученных знаний:

  • Задача 1: использование полной ёмкости (обучение всех параметров)
  • Задача 2: Заморозьте 1/n ёмкости модели, обучите оставшиеся (n-1)/n
  • Задача 3: Заморозьте 2/n ёмкости модели, обучите оставшиеся (n-2)/n
  • Задача n: заморозить (n-1)/n ёмкости модели, использовать 1/n ёмкости для последней задачи

Такой подход обеспечивает каждой задаче достаточную ёмкость для обучения, постепенно сохраняя всё больше знаний из предыдущих задач.

# 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])

Лучшие практики

  1. Выбор эффективного ранга: начните с effective_rank=None (автоматически устанавливает ранг в 50% от меньшего измерения весов для каждого целевого модуля) и корректируйте в зависимости от сложности задачи
  2. Скорость обучения: используйте меньшие значения скорости обучения (от 1e-5 до 1e-4) по сравнению со стандартной дообучением
  3. Важность задачи: используйте rank_pattern, чтобы выделить больше ресурсов для критически важных модулей
  4. Архитектура модели: OSF лучше всего работает с трансформерными архитектурами, имеющими чёткое разделение на механизмы внимания и MLP
  5. Планирование ёмкости: для известных последовательностей задач используйте прогрессивное распределение бюджета (заморозка 1/n, 2/n, …, (n-1)/n), чтобы сбалансировать пластичность и стабильность

Особенности использования памяти

OSF изменяет веса на месте и не добавляет параметров, что делает его экономичным по памяти:

# 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

Расширенное использование

Пользовательские целевые модули

Для моделей с нестандартными архитектурами:

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

Интеграция с другими методами

OSF можно комбинировать с другими техниками:

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

Обзор бенчмарков

API

OSFConfig

класс 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 )

Параметры

  • effective_rank (int или float, необязательный) — Сохраняемый ранг SVD («высокое» подпространство). Верхние effective_rank сингулярных направления замораживаются и сохраняются между задачами; оставшиеся измерения образуют обучаемое подпространство низкого ранга. Если None, по умолчанию используется 50% от меньшего измерения весов для каждого целевого модуля. Примечание: это отличается от r в LoRA (обучаемый ранг). В OSF обучаемый ранг равен min(weight.shape) - effective_rank.
  • target_modules (Union[list[str], str], необязательный) — Имена модулей, к которым следует применить OSF. Может быть списком имён модулей или “all-linear”.
  • rank_pattern (dict[str, int|float], optional) — Словарь регулярных выражений для переопределения effective_rank для конкретных модулей. Значения могут быть абсолютными целыми числами или дробями в интервале (0, 1], которые интерпретируются как доля от меньшего измерения матрицы для каждой цели.

Конфигурация для дообучения в ортогональном подпространстве (OSF).

OSFModel

класс peft.OSFModel

< >

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

Минимальный тюнер, реализующий Orthogonal Subspace Fine-tuning.

Вспомогательные функции

Декомпозиция весов

peft.tuners.osf.utils.decompose_weight_matrix

< >

( weight: torch.Tensortop_k: int )

Выполните SVD для weight и разделите его на замороженную и обучаемую части.

Проекция градиента

peft.tuners.osf.utils.project_gradient_to_orthogonal_space

< >

( svd_dict: dict[str, Any] )

Проекция градиентов U_low и V_low в пространство, ортогональное пространству высокого ранга.

Update on GitHub