Почему ваша LoRA не учится: иллюзия потерь и как её сломать

Парадокс: loss падает, но модель не меняется

Вы запускаете тонкую настройку LoRA. График потерь красиво ползёт вниз. Эпохи проходят, метрики улучшаются. Вы радостно сохраняете адаптеры, загружаете модель... И обнаруживаете, что она ведёт себя абсолютно так же, как и до обучения. Loss обманул вас.

Почему? Потому что современные библиотеки автоматизации (я смотрю на тебя, PEFT) скрывают технический долг под слоями абстракции. Вы думаете, что настраиваете модель. На самом деле вы наблюдаете артефакты оптимизатора, которые не имеют ничего общего с реальным обучением.

Что на самом деле происходит в вашей LoRA

Вот типичный сценарий, который я вижу в 80% случаев:

1. Вы загружаете модель с 4-bit квантованием через bitsandbytes
2. Добавляете LoRA адаптеры с rank=8 или 16
3. Используете AdamW с learning_rate=2e-4
4. Обучаете 3 эпохи на датасете из 1000 примеров
5. Loss падает с 3.2 до 1.8. Кажется, успех!

А теперь откройте веса LoRA и посмотрите на их L2 норму. Скорее всего, вы увидите что-то вроде:

# Типичные замороженные веса LoRA
lora_A_norm = 0.0003  # Должно быть ~0.1-0.5
lora_B_norm = 0.0002  # Должно быть ~0.1-0.5

Веса настолько малы, что их вклад в прямом проходе пренебрежимо мал. Модель игнорирует ваши адаптеры. Loss падает потому, что...

Технический аудит: 5 точек отказа

1 Проверка выравнивания квантованных весов

Самая частая проблема в 2026 году - несовместимость квантованных весов и LoRA инициализации. Когда вы загружаете модель с 4-bit квантованием, её веса уже деформированы. Стандартная инициализация LoRA (из N(0, 0.01)) становится бессмысленной.

# КАК НЕ НАДО делать (стандартный подход)
from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)
# Проблема: инициализация не учитывает квантование!

Решение - адаптивная инициализация, которая учитывает масштаб квантованных весов:

# Правильная инициализация для 4-bit моделей
import torch
import torch.nn as nn

def adaptive_lora_init(module, lora_r=8):
    """Инициализация LoRA с учётом масштаба квантованных весов"""
    # Получаем масштаб исходных весов
    if hasattr(module, 'weight'):
        weight_norm = module.weight.norm().item()
        # Адаптивный масштаб инициализации
        init_scale = weight_norm / (lora_r ** 0.5)
        
        # Инициализируем LoRA_A с малыми значениями
        lora_A = nn.Parameter(torch.randn(module.weight.size(0), lora_r) * init_scale * 0.01)
        # LoRA_B инициализируем нулями
        lora_B = nn.Parameter(torch.zeros(lora_r, module.weight.size(1)))
        
        return lora_A, lora_B
    return None, None

2 Диагностика градиентного потока

Градиенты в Q-LoRA часто затухают или взрываются. Особенно в глубоких моделях типа Mistral-8x22B или Yi-34B. Вам нужен мониторинг в реальном времени:

class GradientMonitor:
    def __init__(self, model):
        self.model = model
        self.grad_norms = []
        
    def hook(self):
        """Хук для отслеживания градиентов LoRA"""
        for name, param in self.model.named_parameters():
            if 'lora' in name and param.requires_grad:
                param.register_hook(
                    lambda grad, name=name: self._store_grad_norm(grad, name)
                )
    
    def _store_grad_norm(self, grad, name):
        grad_norm = grad.norm().item()
        self.grad_norms.append((name, grad_norm))
        
        # Критические значения для 4-bit LoRA
        if grad_norm < 1e-7:
            print(f"ВНИМАНИЕ: Затухающие градиенты в {name}: {grad_norm}")
        elif grad_norm > 1.0:
            print(f"ВНИМАНИЕ: Взрыв градиентов в {name}: {grad_norm}")

Запускайте этот монитор первые 100 шагов обучения. Если видите затухающие градиенты (norm < 1e-6) - ваша LoRA уже мертва.

3 Верификация обновления весов

Loss падает? Отлично. Но обновляются ли веса? Проверяйте разницу в весах между шагами:

def check_weight_updates(model, prev_weights):
    """Сравнивает текущие веса с предыдущими"""
    updates = {}
    for name, param in model.named_parameters():
        if 'lora' in name and param.requires_grad:
            if name in prev_weights:
                diff = (param.data - prev_weights[name]).norm().item()
                updates[name] = diff
                
                # Здоровое обновление для LoRA
                expected_min = 1e-5  # Минимальное значимое изменение
                if diff < expected_min:
                    print(f"СТАГНАЦИЯ: {name} не обновляется, diff={diff}")
            
            # Сохраняем текущие веса для следующей проверки
            prev_weights[name] = param.data.clone()
    
    return updates, prev_weights

4 Настройка learning rate для квантованных моделей

Стандартный learning_rate=2e-4 убивает LoRA в 4-bit моделях. Почему? Потому что квантованные веса имеют другую динамику масштаба.

Используйте learning rate scheduler с warmup. Но не стандартный линейный! Для LoRA нужен агрессивный warmup:

from torch.optim.lr_scheduler import LambdaLR

def lora_lr_scheduler(optimizer, warmup_steps=100, total_steps=1000):
    """Кастомный scheduler для LoRA"""
    def lr_lambda(current_step):
        if current_step < warmup_steps:
            # Агрессивный warmup для прорыва через стагнацию
            return float(current_step) / float(max(1, warmup_steps)) * 2.0
        # После warmup плавное снижение
        progress = float(current_step - warmup_steps) / float(max(1, total_steps - warmup_steps))
        return max(0.1, 0.5 * (1.0 + math.cos(math.pi * progress)))
    
    return LambdaLR(optimizer, lr_lambda)

5 Проверка совместимости target_modules

В 2026 году архитектуры моделей стали ещё более разнообразными. То, что работало для Llama-2, убивает Qwen3.5. Всегда проверяйте фактические имена модулей:

# Получаем реальные имена модулей модели
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3.5-7B-Instruct")

lora_modules = []
for name, module in model.named_modules():
    # Ищем линейные слои
    if isinstance(module, nn.Linear):
        # Для Qwen3.5 работают другие модули
        if "q_proj" in name or "k_proj" in name or "v_proj" in name or "o_proj" in name:
            lora_modules.append(name)
        # Или для FFN слоев
        elif "gate_proj" in name or "up_proj" in name or "down_proj" in name:
            lora_modules.append(name)

print(f"Доступные модули для LoRA: {lora_modules[:10]}...")

Практическое решение: скрипт аудита LoRA

Соберём всё вместе в один диагностический скрипт. Запускайте его перед началом настоящего обучения:

import torch
import numpy as np
from tqdm import tqdm

def lora_health_check(model, dataloader, device="cuda"):
    """Полная диагностика здоровья LoRA"""
    
    print("=== АУДИТ LoRA НАЧАТ ===")
    
    # 1. Проверка инициализации
    print("\n1. Проверка инициализации весов:")
    lora_params = []
    for name, param in model.named_parameters():
        if 'lora' in name:
            norm = param.norm().item()
            lora_params.append((name, norm))
            
            if 'lora_A' in name:
                if norm < 0.001:
                    print(f"  ✗ {name}: СЛИШКОМ МАЛЕНЬКИЙ ({norm})")
                else:
                    print(f"  ✓ {name}: нормально ({norm})")
    
    # 2. Тестовый проход с градиентами
    print("\n2. Тестовый проход (10 батчей):")
    model.train()
    optimizer = torch.optim.AdamW(
        filter(lambda p: p.requires_grad, model.parameters()),
        lr=1e-3
    )
    
    grad_monitor = {name: [] for name, _ in lora_params}
    
    for i, batch in enumerate(tqdm(dataloader, total=min(10, len(dataloader)))):
        if i >= 10:
            break
            
        # Forward pass
        outputs = model(**batch)
        loss = outputs.loss
        
        # Backward
        optimizer.zero_grad()
        loss.backward()
        
        # Сбор статистики градиентов
        for name, param in model.named_parameters():
            if 'lora' in name and param.grad is not None:
                grad_norm = param.grad.norm().item()
                grad_monitor[name].append(grad_norm)
        
        # Тестовый шаг оптимизации
        optimizer.step()
    
    # 3. Анализ градиентов
    print("\n3. Анализ градиентов:")
    for name, gradients in grad_monitor.items():
        if gradients:
            avg_grad = np.mean(gradients)
            std_grad = np.std(gradients)
            
            if avg_grad < 1e-6:
                print(f"  ✗ {name}: ГРАДИЕНТЫ ЗАТУХАЮТ (avg={avg_grad:.2e})")
            elif avg_grad > 1.0:
                print(f"  ⚠ {name}: ВОЗМОЖЕН ВЗРЫВ (avg={avg_grad:.2f})")
            else:
                print(f"  ✓ {name}: нормально (avg={avg_grad:.2e}, std={std_grad:.2e})")
    
    # 4. Проверка обновления весов
    print("\n4. Проверка обновления весов:")
    weight_updates = []
    for (name, initial_norm) in lora_params:
        for n, p in model.named_parameters():
            if n == name:
                current_norm = p.norm().item()
                update_ratio = abs(current_norm - initial_norm) / max(initial_norm, 1e-8)
                weight_updates.append((name, update_ratio))
                
                if update_ratio < 0.01:  # Менее 1% изменения
                    print(f"  ✗ {name}: ВЕСА НЕ ОБНОВЛЯЮТСЯ ({update_ratio*100:.2f}%)")
                else:
                    print(f"  ✓ {name}: веса обновляются ({update_ratio*100:.2f}%)")
    
    print("\n=== АУДИТ ЗАВЕРШЕН ===")
    
    # Сводная оценка
    issues = sum(1 for _, ratio in weight_updates if ratio < 0.01)
    total = len(weight_updates)
    
    if issues / total > 0.5:
        print(f"\n🚨 КРИТИЧЕСКОЕ СОСТОЯНИЕ: {issues}/{total} модулей не обучаются")
        print("   Рекомендация: проверьте инициализацию и learning rate")
    elif issues > 0:
        print(f"\n⚠ ПРЕДУПРЕЖДЕНИЕ: {issues}/{total} модулей имеют проблемы")
        print("   Рекомендация: настройте target_modules")
    else:
        print("\n✅ LoRA готова к обучению!")
    
    return {
        "gradient_stats": grad_monitor,
        "weight_updates": weight_updates
    }

Почему это всё ещё проблема в 2026 году?

Библиотеки вроде PEFT и Hugging Face Transformers стали слишком удобными. Они скрывают сложность, пока вы не столкнётесь с реальной проблемой. Автоматическая настройка LoRA работает... пока не работает.

Особенно критично это стало с появлением гибридных методов QAT+LoRA, где проблемы масштабирования усугубляются. Или когда вы пытаетесь обучать LoRA поверх GGUF - там свои грабли.

Что делать, если аудит показал проблемы

По результатам диагностики у вас будет чёткая картина. Действуйте по схеме:

• Затухающие градиенты → Увеличьте learning rate в 5-10 раз. Используйте агрессивный warmup.
• Взрыв градиентов → Добавьте gradient clipping с max_norm=1.0. Уменьшите learning rate.
• Веса не обновляются → Проверьте target_modules. Возможно, вы цепляете не те слои.
• Инициализация слишком мала → Используйте adaptive_lora_init из примеров выше.

И главное - никогда не доверяйте только loss. Всегда проверяйте:

1. Нормы весов LoRA до и после обучения
2. Качество генерации на контрольных примерах
3. Сравнение perplexity на validation set

Скрытая ошибка, которую все пропускают

Есть одна тонкость, которая стала особенно актуальной в 2026. Когда вы используете mixed precision training (AMP) с 4-bit квантованными моделями, градиенты для LoRA могут попадать в «мёртвую зону» численной точности.

Решение - принудительно использовать FP32 для градиентов LoRA:

# Принудительная точность для LoRA градиентов
from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

with autocast(dtype=torch.bfloat16):
    outputs = model(**batch)
    loss = outputs.loss

# Важно: масштабируем loss, но градиенты LoRA остаются в FP32
scaler.scale(loss).backward()

# И явно указываем, какие параметры должны быть в FP32
for name, param in model.named_parameters():
    if 'lora' in name:
        param.data = param.data.float()  # Веса в FP32
        if param.grad is not None:
            param.grad = param.grad.float()  # Градиенты в FP32

scaler.step(optimizer)
scaler.update()

Эта техника критична для больших моделей (70B+), где численная стабильность становится проблемой.

Когда всё равно не работает

Бывает. Особенно с экзотическими архитектурами или когда вы пытаетесь сделать что-то действительно сложное - например, настроить LoRA для VibeVoice с его diffusion-head.

В этом случае откажитесь от автоматизации. Соберите тренировочный цикл вручную:

# Минимальный рабочий цикл для проблемных случаев
def manual_lora_training(model, dataloader, steps=1000):
    """Ручное обучение с полным контролем"""
    
    # Только LoRA параметры
    lora_params = [p for n, p in model.named_parameters() if 'lora' in name]
    optimizer = torch.optim.Adam(lora_params, lr=1e-3)
    
    losses = []
    weight_norms = []
    
    for step, batch in enumerate(dataloader):
        if step >= steps:
            break
        
        # 1. Forward в полной точности
        with torch.no_grad():
            # Заморозить базовую модель
            for p in model.parameters():
                p.requires_grad = False
            # Разморозить только LoRA
            for p in lora_params:
                p.requires_grad = True
        
        # 2. Forward pass
        outputs = model(**batch)
        loss = outputs.loss
        
        # 3. Backward
        optimizer.zero_grad()
        loss.backward()
        
        # 4. Мониторинг перед шагом
        grad_norms = [p.grad.norm().item() for p in lora_params if p.grad is not None]
        
        # 5. Шаг оптимизации
        optimizer.step()
        
        # 6. Мониторинг после шага
        current_norms = [p.norm().item() for p in lora_params]
        weight_norms.append(current_norms)
        
        if step % 100 == 0:
            print(f"Step {step}: loss={loss.item():.4f}, "
                  f"grad_norm={np.mean(grad_norms):.2e}, "
                  f"weight_norm={np.mean(current_norms):.4f}")
            
            # Если веса не растут - увеличиваем LR
            if step > 10 and np.mean(current_norms) < 0.01:
                print("Веса слишком малы, увеличиваем LR")
                for g in optimizer.param_groups:
                    g['lr'] *= 2.0
    
    return losses, weight_norms

Этот подход грубый, неэффективный... но работает, когда всё остальное проваливается.

Итог: ваша чек-лист перед обучением LoRA

Перед тем как запускать недельное обучение на дорогом инстансе с A100, пройдитесь по этому списку:

1. Запустите lora_health_check на 10 батчах
2. Проверьте, что градиенты LoRA имеют норму >1e-6
3. Убедитесь, что веса LoRA увеличиваются после шага оптимизации
4. Настройте learning rate под ваше квантование (см. таблицу выше)
5. Проверьте target_modules - они актуальны для вашей модели?
6. Для 4-bit моделей используйте adaptive инициализацию
7. Добавьте мониторинг норм весов в TensorBoard/WandB

Loss - лгун. Веса - правдивы. Смотрите на веса.

P.S. Если вы столкнулись с петлями повторений в LoRA, знайте - это часто следствие той же проблемы стагнации весов. Модель не научилась новому, поэтому повторяет старое.