Fine-Tuning i Transfer Learning: Przewodnik po Trenowaniu Modeli

Fine-tuning to proces dostosowywania wstępnie wytrenowanych modeli do konkretnych zadań lub domen. Przy odpowiednich strategiach fine-tuningu można osiągnąć wzrost wydajności sięgający nawet 40% w rozwiązaniach AI klasy enterprise.

Podstawy Transfer Learning

Transfer learning polega na przenoszeniu wiedzy zdobytej podczas treningu na jednym zadaniu do innego zadania.

Zalety Transfer Learning

Wydajność danych: Dobre rezultaty przy mniejszej liczbie danych
Oszczędność czasu: Znacznie szybsze niż trenowanie od zera
Redukcja kosztów: Mniejsze zużycie zasobów obliczeniowych
Wydajność: Wykorzystanie wiedzy z modeli wstępnie wytrenowanych

Pre-training vs Fine-tuning

1Pre-training:
2- Large, general dataset (TBs)
3- Learning general language/task understanding
4- Training takes months
5- Cost in millions of dollars
6
7Fine-tuning:
8- Small, domain-specific dataset (MB-GB)
9- Specific task adaptation
10- Training takes hours-days
11- Cost in thousands of dollars

Pełny Fine-Tuning

Aktualizacja wszystkich parametrów modelu.

Zalety

Maksymalna zdolność adaptacji
Najwyższy potencjał wydajności

Wady

Wysokie zapotrzebowanie na pamięć
Ryzyko katastrofalnego zapominania
Osobna kopia modelu dla każdego zadania

Wymagania sprzętowe

Rozmiar modelu	Pamięć GPU (FP32)	Pamięć GPU (FP16)
7B	28 GB	14 GB
13B	52 GB	26 GB
70B	280 GB	140 GB

Parameter-Efficient Fine-Tuning (PEFT)

Fine-tuning poprzez aktualizację jedynie niewielkiej części parametrów.

Zalety PEFT

Oszczędność pamięci: Redukcja o ponad 90%
Szybkość: Szybsze trenowanie
Modularność: Jeden model bazowy, wiele adapterów
Katastrofalne zapominanie: Zminimalizowane ryzyko

LoRA (Low-Rank Adaptation)

Najpopularniejsza metoda PEFT.

Teoria LoRA

Aktualizacja macierzy wag przybliżona macierzami niskiego rzędu:

1W' = W + ΔW = W + BA
2
3Where:
4- W: Original weight matrix (d × k)
5- B: Low-rank matrix (d × r)
6- A: Low-rank matrix (r × k)
7- r: Rank (typical: 8-64)

Oszczędność parametrów

1Original: d × k parameters
2LoRA: r × (d + k) parameters
3
4Example (d=4096, k=4096, r=16):
5Original: 16.7M parameters
6LoRA: 131K parameters
7Savings: ~127x

Konfiguracja LoRA

1from peft import LoraConfig, get_peft_model
2
3config = LoraConfig(
4    r=16,                      # Rank
5    lora_alpha=32,             # Scaling factor
6    target_modules=[           # Which layers to apply
7        "q_proj",
8        "k_proj", 
9        "v_proj",
10        "o_proj"
11    ],
12    lora_dropout=0.05,
13    bias="none",
14    task_type="CAUSAL_LM"
15)
16
17model = get_peft_model(base_model, config)

Hiperparametry LoRA

Rank (r):

Niski (4-8): Proste zadania, mało danych
Średni (16-32): Zastosowania ogólne
Wysoki (64-128): Złożona adaptacja

Alpha:

Zazwyczaj alpha = 2 × r

Target Modules:

Warstwy attention: q_proj, k_proj, v_proj, o_proj
Warstwy MLP: gate_proj, up_proj, down_proj

QLoRA (Quantized LoRA)

Połączenie LoRA + 4-bitowej kwantyzacji.

Cechy QLoRA

4-bit NormalFloat (NF4): Niestandardowy format kwantyzacji
Podwójna kwantyzacja: Kwantyzacja stałych kwantyzacyjnych
Paged Optimizers: Zarządzanie przepełnieniem pamięci GPU

Porównanie pamięci QLoRA

Metoda	Model 7B	Model 70B
Full FT (FP32)	28 GB	280 GB
Full FT (FP16)	14 GB	140 GB
LoRA (FP16)	12 GB	120 GB
QLoRA (4-bit)	6 GB	48 GB

Implementacja QLoRA

1from transformers import BitsAndBytesConfig
2import torch
3
4bnb_config = BitsAndBytesConfig(
5    load_in_4bit=True,
6    bnb_4bit_use_double_quant=True,
7    bnb_4bit_quant_type="nf4",
8    bnb_4bit_compute_dtype=torch.bfloat16
9)
10
11model = AutoModelForCausalLM.from_pretrained(
12    "meta-llama/Llama-2-7b-hf",
13    quantization_config=bnb_config,
14    device_map="auto"
15)
16## Inne metody PEFT
17
18### Prefix Tuning
19
20Dodaje uczone prefiksy do osadzeń wejściowych:
21

Input: [PREFIX_1, PREFIX_2, ..., PREFIX_N, token_1, token_2, ...]

1
2### Prompt Tuning
3
4Uczenie miękkich promptów:
5

[SOFT_PROMPT] + "Actual input text"

1
2### Warstwy Adapterów
3
4Dodawanie małych sieci między warstwami transformera:
5

Attention → Adapter → LayerNorm → FFN → Adapter → LayerNorm

1
2### (IA)³ - Infused Adapter
3
4Mnożenie aktywacji przez wyuczone wektory:
5

output = activation × learned_vector

1
2## Przygotowanie danych
3
4### Format danych
5
6**Format instrukcji:**
7```json
8{
9  "instruction": "Summarize this text",
10  "input": "Long text...",
11  "output": "Summary..."
12}

Format czatu:

1{
2  "messages": [
3    {"role": "system", "content": "You are a helpful assistant"},
4    {"role": "user", "content": "Question..."},
5    {"role": "assistant", "content": "Answer..."}
6  ]
7}

Jakość danych

Cechy dobrych danych:

Różnorodność (różne przykłady)
Spójność (spójny format)
Dokładność (precyzyjne etykiety)
Wystarczająca ilość (zwykle 1K–100K przykładów)

Augmentacja danych

1# Paraphrasing
2augmented_data = paraphrase(original_data)
3
4# Back-translation
5translated = translate(text, "tr")
6back_translated = translate(translated, "en")
7
8# Synonym replacement
9augmented = replace_synonyms(text)

Strategie treningowe

Dobór hiperparametrów

1training_args = TrainingArguments(
2    learning_rate=2e-4,        # Typical for LoRA
3    num_train_epochs=3,
4    per_device_train_batch_size=4,
5    gradient_accumulation_steps=4,
6    warmup_ratio=0.03,
7    lr_scheduler_type="cosine",
8    fp16=True,
9    logging_steps=10,
10    save_strategy="epoch",
11    evaluation_strategy="epoch"
12)

Współczynnik uczenia

Pełne dostrajanie: 1e-5 - 5e-5
LoRA: 1e-4 - 3e-4
QLoRA: 2e-4 - 5e-4

Regularyzacja

1# Weight decay
2weight_decay=0.01
3
4# Dropout
5lora_dropout=0.05
6
7# Gradient clipping
8max_grad_norm=1.0

Ewaluacja i walidacja

Metryki

Perplexity:

PPL = exp(average cross-entropy loss)
Lower = better

BLEU/ROUGE: Jakość generowanego tekstu

Zadaniowe: Accuracy, F1, metryki niestandardowe

Wykrywanie przeuczenia

1Train loss ↓ + Validation loss ↑ = Overfitting
2
3Solutions:
4- Early stopping
5- More dropout
6- Data augmentation
7- Fewer epochs

Wdrożenie

Łączenie modeli

Scalanie adaptera LoRA z modelem bazowym:

merged_model = model.merge_and_unload()
merged_model.save_pretrained("merged_model")

Serwowanie wielu adapterów

Wiele adapterów z jednym modelem bazowym:

1from peft import PeftModel
2
3base_model = AutoModelForCausalLM.from_pretrained("base")
4model_a = PeftModel.from_pretrained(base_model, "adapter_a")
5model_b = PeftModel.from_pretrained(base_model, "adapter_b")

Pipeline dostrajania dla przedsiębiorstw

1┌─────────────┐     ┌─────────────┐     ┌─────────────┐
2│ Data        │────▶│ Training    │────▶│ Evaluation  │
3│ Preparation │     │ (LoRA/QLoRA)│     │ & Testing   │
4└─────────────┘     └─────────────┘     └──────┬──────┘
5                                                │
6                    ┌─────────────┐     ┌──────▼──────┐
7                    │ Production  │◀────│ Model       │
8                    │ Deployment  │     │ Registry    │
9                    └─────────────┘     └─────────────┘

Typowe problemy i rozwiązania

1. Brak pamięci

Rozwiązanie: QLoRA, gradient checkpointing, zmniejszenie batch size

2. Katastrofalne zapominanie

Rozwiązanie: Niższy learning rate, replay buffer, elastic weight consolidation

3. Przeuczenie

Rozwiązanie: Więcej danych, regularyzacja, early stopping

4. Słaba generalizacja

Rozwiązanie: Zwiększenie różnorodności danych, różnorodność instrukcji

Wnioski

Dostrajanie (fine-tuning) jest najskuteczniejszym sposobem dostosowania wstępnie wytrenowanych modeli do potrzeb przedsiębiorstwa. Za pomocą metod PEFT, takich jak LoRA i QLoRA, można wprowadzić zaawansowane dostosowania nawet przy ograniczonych zasobach.

W Veni AI oferujemy usługi doradcze i wdrożeniowe dla projektów dostrajania modeli w środowisku korporacyjnym. Skontaktuj się z nami w razie potrzeby.