LoRA файнтюнинг на GPU: полный гайд

Файнтюнинг (дообучение) больших языковых моделей позволяет адаптировать модель под свою задачу: от чат-бота на корпоративных данных до генерации кода в вашем стеке. Но полный файнтюнинг модели на 7B параметров требует ~112 ГБ VRAM — это 2× A100.

LoRA (Low-Rank Adaptation) решает эту проблему: вместо обновления всех весов модели обучаются только маленькие адаптерные матрицы. Результат — файнтюнинг 7B модели на одной RTX 3090, а с QLoRA — даже на RTX 4060 с 8 ГБ VRAM.

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

Проблема: полный файнтюнинг слишком дорог

При полном файнтюнинге с Adam-оптимизатором в FP32 нужно хранить в VRAM:

Плюс активации — ещё 10–50 ГБ в зависимости от batch size и длины контекста.

Решение: обучаем только адаптеры

LoRA замораживает все оригинальные веса модели и добавляет пару маленьких матриц (A и B) к каждому целевому слою:

W_new = W_frozen + α × (B × A)

Где:
- W_frozen — оригинальные веса (заморожены, не обновляются)
- A — матрица [hidden_dim × r] (инициализируется случайно)
- B — матрица [r × hidden_dim] (инициализируется нулями)
- r — ранг адаптера (обычно 8–64)
- α — scaling factor

Пример: для слоя 4096×4096 с r=16:
- Оригинал: 16.7M параметров
- LoRA: 4096×16 + 16×4096 = 131K параметров (в 128× меньше)

Обучаемых параметров обычно 0.1–2% от общего числа. Вместо 112 ГБ для 7B модели нужно ~16 ГБ с LoRA и ~6 ГБ с QLoRA.

LoRA vs QLoRA

QLoRA = LoRA + квантизация базовой модели в 4-bit NF4. Модель загружается в INT4, а LoRA-адаптеры обучаются в FP16/BF16. При этом вычисления идут в BFloat16 через деквантизацию «на лету».

Рекомендация: если VRAM хватает — используйте LoRA (быстрее и чуть лучше). Если VRAM ограничен — QLoRA даёт почти то же качество.

Требования к VRAM

QLoRA (рекомендуемые конфигурации)

Факторы, влияющие на VRAM

Практика: файнтюнинг с Hugging Face

Установка

pip install transformers peft trl bitsandbytes datasets accelerate

QLoRA файнтюнинг Qwen2.5-7B-Instruct

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset

# 1. Конфигурация квантизации (QLoRA)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,  # Важно: bfloat16, НЕ float16
    bnb_4bit_use_double_quant=True,  # Экономит ещё ~0.4 бит/параметр
)

# 2. Загрузка модели
model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)
model = prepare_model_for_kbit_training(model)

# 3. Конфигурация LoRA
lora_config = LoraConfig(
    r=32,                          # Ранг адаптера
    lora_alpha=64,                 # Scaling (обычно 2× r)
    target_modules=[               # Какие слои адаптировать
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Пример вывода: trainable params: 41,943,040 || all params: 7,657,300,480 || 0.55%

# 4. Загрузка датасета
dataset = load_dataset("your-dataset", split="train")

# 5. Параметры обучения
training_args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,    # Эффективный batch = 16
    gradient_checkpointing=True,      # Экономит VRAM
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.05,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,                        # BFloat16 обучение
    optim="paged_adamw_8bit",         # 8-bit Adam (экономит VRAM)
    max_grad_norm=0.3,
    report_to="none",
)

# 6. Запуск обучения
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=training_args,
    max_seq_length=2048,
)

trainer.train()

# 7. Сохранение адаптера
model.save_pretrained("./lora-adapter")
tokenizer.save_pretrained("./lora-adapter")

Важные детали

bnb_4bit_compute_dtype=torch.bfloat16 — используйте bfloat16, не float16! Float16 вызывает NaN-ы при обучении на Ampere+ GPU (RTX 3000+, A100).

bnb_4bit_use_double_quant=True — двойная квантизация. Квантизует сами квантизационные константы, экономя ~0.4 бит/параметр без потери качества.

paged_adamw_8bit — 8-bit Adam оптимизатор с пейджингом в CPU RAM при нехватке VRAM. Экономит 4–8 ГБ на больших моделях.

Выбор гиперпараметров

Ранг (r)

Общее правило: r=32 — хороший дефолт. Увеличивайте, если модель недообучается. Уменьшайте, если VRAM не хватает.

lora_alpha

Обычно lora_alpha = 2 × r. Это scaling factor: ΔW = (α/r) × B × A. При alpha=2r и r=32 scaling = 2.0.

target_modules

Рекомендация: включайте все attention + MLP слои (как в примере выше). Разница в VRAM минимальна, а качество заметно лучше.

Learning rate

• QLoRA: 1e-4 — 3e-4 (выше, чем при полном файнтюнинге)
• LoRA (FP16 base): 5e-5 — 2e-4
• Используйте cosine scheduler с warmup 3–5%

Подготовка датасета

Формат для instruction tuning

[
    {
        "instruction": "Объясни что такое LoRA простыми словами",
        "input": "",
        "output": "LoRA — это метод дообучения нейросетей..."
    },
    {
        "instruction": "Переведи на английский",
        "input": "Привет, как дела?",
        "output": "Hello, how are you?"
    }
]

Формат chat (для чат-моделей)

[
    {
        "messages": [
            {"role": "system", "content": "Ты помощник по Python."},
            {"role": "user", "content": "Как отсортировать список?"},
            {"role": "assistant", "content": "Используйте sorted() или list.sort()..."}
        ]
    }
]

Сколько данных нужно?

Лучше 500 качественных примеров, чем 50 000 шумных.

Использование обученного адаптера

Инференс

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

# Загружаем базовую модель
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")

# Накладываем LoRA-адаптер
model = PeftModel.from_pretrained(base_model, "./lora-adapter")

# Генерация
inputs = tokenizer("Ваш промпт", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Merge адаптера в базовую модель

Для продакшена можно слить адаптер с базой:

merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

После merge получается обычная модель, которую можно квантизовать в GGUF и запускать через llama.cpp.

Multi-GPU обучение

Для моделей, которые не помещаются на одну GPU:

# FSDP (рекомендуется для 2+ GPU)
accelerate launch --multi_gpu --num_processes 2 train.py

Или через DeepSpeed ZeRO Stage 2:

accelerate launch --config_file ds_config.yaml train.py

Частые ошибки

CUDA OOM при обучении

1. Уменьшите per_device_train_batch_size (до 1)
2. Увеличьте gradient_accumulation_steps (компенсация)
3. Включите gradient_checkpointing=True
4. Уменьшите max_seq_length
5. Уменьшите ранг r

NaN loss

1. Убедитесь: bnb_4bit_compute_dtype=torch.bfloat16 (не float16!)
2. Уменьшите learning rate
3. Добавьте max_grad_norm=0.3 (gradient clipping)
4. Проверьте датасет на пустые / битые примеры

Модель не учится (loss не падает)

1. Увеличьте learning rate (попробуйте 3e-4)
2. Увеличьте ранг r (16 → 64)
3. Добавьте MLP-слои в target_modules
4. Проверьте формат данных (должен совпадать с chat template модели)
5. Убедитесь, что достаточно данных (минимум 100 примеров)

Выбор GPU для файнтюнинга

Для серьёзного файнтюнинга больших моделей (32B+) аренда GPU-сервера с A100 или RTX 4090 — самый экономичный вариант.

Итог

LoRA/QLoRA демократизировали файнтюнинг — теперь дообучить 7B модель можно на GPU за $300, а 70B — на паре б/у RTX 3090.

Нужен мощный GPU для файнтюнинга? Арендуйте GPU-сервер в облаке Intelion — RTX 4090, A100, H100 с оплатой по минутам.