LoRA a QLoRA — efektivní fine-tuning

Fine-tuning velkých jazykových modelů byl dlouho výsadou těch s obrovskými výpočetními zdroji. LoRA a QLoRA však přinášejí revoluci - umožňují efektivně přizpůsobit i nejmodernější modely s minimálními nároky na hardware a paměť.

Co je LoRA a proč ji potřebujeme¶

Low-Rank Adaptation (LoRA) představuje revoluční přístup k fine-tuningu velkých jazykových modelů. Zatímco tradiční fine-tuning vyžaduje aktualizaci všech parametrů modelu, LoRA upravuje pouze malou podmnožinu pomocí low-rank matic. To znamená dramatické snížení paměťových nároků a výpočetní složitosti.

Princip spočívá v rozkladu změn vah na dvě menší matice A a B, kde původní matice W se aktualizuje podle vzorce: W’ = W + BA. Rank těchto matic je typicky 1-64, což je řádově menší než původní dimenze.

Praktické výhody LoRA¶

Paměťová efektivita: Trénuje pouze 0,1-1% parametrů
Rychlejší trénink: Méně parametrů = rychlejší konvergence
Modulárnost: Adaptéry lze snadno vyměňovat pro různé úkoly
Zachování původního modelu: Base model zůstává nezmněn

Implementace LoRA s PEFT¶

Hugging Face PEFT (Parameter-Efficient Fine-Tuning) knihovna poskytuje jednoduchou implementaci LoRA. Zde je kompletní příklad fine-tuningu modelu pro klasifikaci textu:

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Načtení base modelu
model_name = "microsoft/DialoGPT-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, 
    num_labels=2,
    torch_dtype=torch.float16
)

# Konfigurace LoRA
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS,
    inference_mode=False,
    r=8,  # rank
    lora_alpha=32,  # scaling parameter
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"]  # které vrstvy adaptovat
)

# Aplikace LoRA na model
peft_model = get_peft_model(model, lora_config)

# Zobrazení počtu trénovatelných parametrů
peft_model.print_trainable_parameters()
# Výstup: trainable params: 294,912 || all params: 117,504,512 || trainable%: 0.25

Klíčové parametry LoRA¶

Rank (r): Určuje rozměr adaptačních matic. Nižší hodnoty (4-16) jsou paměťově efektivnější, vyšší (64-128) poskytují větší expresivitu. Alpha: Škálovací faktor, typicky 2-4× větší než rank. Target modules: Specifikuje, které vrstvy budou adaptovány - obvykle attention projekce.

QLoRA: Kvantizace + LoRA¶

QLoRA (Quantized LoRA) kombinuje LoRA s 4-bit kvantizací, což umožňuje fine-tuning i 65B parametrových modelů na běžných GPU. Využívá NormalFloat4 (NF4) kvantizaci optimalizovanou pro normálně distribuované váhy neuronových sítí.

from transformers import BitsAndBytesConfig
from peft import LoraConfig, prepare_model_for_kbit_training

# Konfigurace 4-bit kvantizace
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,  # nested kvantizace
)

# Načtení kvantizovaného modelu
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# Příprava pro k-bit trénink
model = prepare_model_for_kbit_training(model)

# QLoRA konfigurace
qlora_config = LoraConfig(
    r=64,
    lora_alpha=16,
    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, qlora_config)

Výhody QLoRA¶

QLoRA dosahuje 75% úspory paměti oproti standardnímu fine-tuningu při zachování 99% výkonnosti. Model Llama-2 7B lze fine-tunovat na 12GB GPU místo původních 28GB.

Trénink a optimalizace¶

Pro efektivní trénink s LoRA/QLoRA doporučujeme specifické nastavení optimalizátoru a scheduleru:

from transformers import Trainer, TrainingArguments
from torch.optim import AdamW

# Optimalizované trénovací argumenty pro LoRA
training_args = TrainingArguments(
    output_dir="./lora-model",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    warmup_steps=100,
    max_steps=1000,
    learning_rate=2e-4,  # vyšší LR pro LoRA
    fp16=True,  # nebo bf16 pro QLoRA
    logging_steps=50,
    save_strategy="steps",
    save_steps=500,
    remove_unused_columns=False,
    gradient_checkpointing=True,  # úspora paměti
)

# Vytvoření traineru
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer,
)

# Spuštění tréninku
trainer.train()

# Uložení pouze LoRA adaptéru (několik MB)
peft_model.save_pretrained("./my-lora-adapter")

Načítání a inference¶

Výhodou LoRA je možnost rychlého přepínání mezi různými adaptéry pro různé úkoly:

from peft import PeftModel

# Načtení base modelu
base_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")

# Načtení LoRA adaptéru
lora_model = PeftModel.from_pretrained(base_model, "./my-lora-adapter")

# Inference
inputs = tokenizer("Ahoj, jak se máš?", return_tensors="pt")
with torch.no_grad():
    outputs = lora_model.generate(**inputs, max_length=50)

# Přepnutí na jiný adaptér
lora_model.load_adapter("./another-task-adapter", adapter_name="task2")
lora_model.set_adapter("task2")

Merge adaptéru s base modelem¶

Pro produkční nasazení můžete sloučit LoRA adaptér přímo do původního modelu:

# Sloučení a uložení kompletního modelu
merged_model = lora_model.merge_and_unload()
merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

Best practices a tipý¶

Volba ranku: Začněte s r=8-16 pro většinu úkolů. Pro komplexní adaptace použijte r=32-64. Target modules: Pro transformer modely ciljte attention projekce (q_proj, v_proj). Pro specifické úkoly experimentujte s feed-forward vrstvami.

Learning rate: LoRA typicky vyžaduje vyšší learning rate (1e-4 až 2e-4) než full fine-tuning. Batch size: Menší batch size často funguje lépe díky regularizačnímu efektu LoRA.

Shrnutí¶

LoRA a QLoRA představují game-changer pro fine-tuning velkých modelů. LoRA umožňuje efektivní adaptaci s minimálními nároky na zdroje, zatímco QLoRA rozšiřuje tyto možnosti i na největší modely díky kvantizaci. Tyto techniky demokratizují přístup k pokročilému fine-tuningu a otevírají nové možnosti pro customizaci AI modelů i menším týmům s omezenými zdroji.

loraqlorapeft