Fine-Tuning och Transfer Learning: Guide för Modellträning

Fine-tuning är processen att anpassa förtränade modeller för specifika uppgifter eller domäner. Med rätt fine-tuning-strategier kan prestandaförbättringar på upp till 40% uppnås i företags‑AI‑lösningar.

Grunderna i Transfer Learning

Transfer learning är överföringen av kunskap som lärts in i en uppgift till en annan.

Fördelar med Transfer Learning

Dataeffektivitet: Bra resultat med mindre data
Tidsbesparing: Mycket snabbare än träning från grunden
Kostnadsreduktion: Färre beräkningsresurser
Prestanda: Utnyttjar förtränad kunskap

Förträning 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

Full Fine-Tuning

Uppdaterar alla modellens parametrar.

Fördelar

Maximal anpassningsförmåga
Högsta möjliga prestanda

Nackdelar

Höga minneskrav
Risk för katastrofal glömska
Separat modellkopia för varje uppgift

Hårdvarukrav

Model Size	GPU Memory (FP32)	GPU Memory (FP16)
7B	28 GB	14 GB
13B	52 GB	26 GB
70B	280 GB	140 GB

Parameter-Efficient Fine-Tuning (PEFT)

Fine-tuning genom att endast uppdatera en liten del av parametrarna.

PEFT Fördelar

Minneseffektivitet: 90%+ reduktion
Hastighet: Snabbare träning
Modularitet: En basmodell, flera adaptrar
Katastrofal Glömska: Minimal risk

LoRA (Low-Rank Adaptation)

Den mest populära PEFT-metoden.

LoRA-teori

Uppdaterar viktmatrisen approximativt med låg-rank-matriser:

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)

Parameterbesparingar

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

LoRA-konfiguration

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)

LoRA-hyperparametrar

Rank (r):

Låg (4–8): Enkla uppgifter, lite data
Medel (16–32): Allmän användning
Hög (64–128): Komplex anpassning

Alpha:

Generellt alpha = 2 × r

Target Modules:

Attention-lager: q_proj, k_proj, v_proj, o_proj
MLP-lager: gate_proj, up_proj, down_proj

QLoRA (Quantized LoRA)

Kombination av LoRA + 4-bitars kvantisering.

QLoRA-funktioner

4-bit NormalFloat (NF4): Anpassat kvantiseringsformat
Double Quantization: Kvantisering av kvantiseringskonstanter
Paged Optimizers: Hantering av GPU‑minnesöverskridning

QLoRA Minnesjämförelse

Method	7B Model	70B Model
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

QLoRA-implementation

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## Andra PEFT-metoder
17
18### Prefix Tuning
19
20Lägger till lärbara prefix till inbäddningar:
21

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

1
2### Prompt Tuning
3
4Lära sig mjuka prompts:
5

[SOFT_PROMPT] + "Actual input text"

1
2### Adapter Layers
3
4Lägga till små nätverk mellan transformer-lager:
5

Attention → Adapter → LayerNorm → FFN → Adapter → LayerNorm

1
2### (IA)³ - Infused Adapter
3
4Multiplicera aktiveringar med lärda vektorer:
5

output = activation × learned_vector

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

Chat-format:

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

Datakvalitet

Bra datakaraktäristik:

Mångfald (diverse exempel)
Konsistens (konsekvent format)
Noggrannhet (korrekta etiketter)
Tillräcklig mängd (vanligtvis 1K–100K exempel)

Dataaugmentering

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)

Träningsstrategier

Hyperparameterurval

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)

Inlärningshastighet

Full finjustering: 1e-5 - 5e-5
LoRA: 1e-4 - 3e-4
QLoRA: 2e-4 - 5e-4

Regularisering

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

Utvärdering och validering

Metriker

Perplexity:

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

BLEU/ROUGE: Kvalitet på textgenerering

Uppgiftsspecifikt: Noggrannhet, F1, anpassade metrikar

Upptäcka överanpassning

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

Driftsättning

Modellhopslagning

Slå samman LoRA-adapter med basmodellen:

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

Multi-Adapter Serving

Flera adapters med en enda basmodell:

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

Företags-pipeline för finjustering

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

Vanliga problem och lösningar

1. Out of Memory

Lösning: QLoRA, gradient checkpointing, minska batch-storlek

2. Katastrofal glömska

Lösning: Lägre learning rate, replay buffer, elastic weight consolidation

3. Överanpassning

Lösning: Mer data, regularisering, early stopping

4. Dålig generalisering

Lösning: Ökad datamångfald, instruktionernas mångfald

Slutsats

Finjustering är det mest effektiva sättet att anpassa förtränade modeller till företags behov. Kraftfulla anpassningar kan göras även med begränsade resurser genom att använda PEFT-metoder som LoRA och QLoRA.

På Veni AI tillhandahåller vi konsult- och implementeringstjänster för finjusteringsprojekt för företag. Kontakta oss för era behov.