Fine-Tuning e Transfer Learning: Guida all’Addestramento dei Modelli

Il fine-tuning è il processo di personalizzazione di modelli pre-addestrati per compiti o domini specifici. Con le giuste strategie di fine-tuning, è possibile ottenere incrementi di performance fino al 40% nelle soluzioni di AI aziendale.

Fondamenti di Transfer Learning

Il transfer learning consiste nel trasferire la conoscenza appresa in un compito verso un altro compito.

Vantaggi del Transfer Learning

1. Efficienza dei dati: Buoni risultati con meno dati
2. Risparmio di tempo: Molto più veloce rispetto all’addestramento da zero
3. Riduzione dei costi: Minori risorse di calcolo
4. Performance: Sfrutta la conoscenza pre-addestrata

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

Full Fine-Tuning

Aggiornamento di tutti i parametri del modello.

Vantaggi

• Massima capacità di adattamento
• Massimo potenziale di performance

Svantaggi

• Elevato requisito di memoria
• Rischio di catastrophic forgetting
• Copia separata del modello per ogni task

Requisiti Hardware

Parameter-Efficient Fine-Tuning (PEFT)

Fine-tuning aggiornando solo una piccola parte dei parametri.

Vantaggi del PEFT

• Efficienza della memoria: Riduzione superiore al 90%
• Velocità: Addestramento più rapido
• Modularità: Un singolo modello base, più adapter
• Catastrophic Forgetting: Rischio ridotto al minimo

LoRA (Low-Rank Adaptation)

Il metodo PEFT più diffuso.

Teoria di LoRA

Aggiornamento approssimato della matrice dei pesi tramite matrici a basso rango:

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)

Risparmio sui Parametri

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

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

Iperparametri LoRA

Rank (r):

• Basso (4-8): Task semplici, pochi dati
• Medio (16-32): Uso generale
• Alto (64-128): Adattamento complesso

Alpha:

• Generalmente alpha = 2 × r

Target Modules:

• Livelli di attenzione: q_proj, k_proj, v_proj, o_proj
• Livelli MLP: gate_proj, up_proj, down_proj

QLoRA (Quantized LoRA)

Combinazione di LoRA + quantizzazione a 4 bit.

Caratteristiche di QLoRA

1. 4-bit NormalFloat (NF4): Formato di quantizzazione personalizzato
2. Double Quantization: Quantizzazione delle costanti di quantizzazione
3. Paged Optimizers: Gestione dell’overflow della memoria GPU

Confronto della Memoria in QLoRA

Implementazione 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## Altri Metodi PEFT
17
18### Prefix Tuning
19
20Aggiunge prefissi apprendibili agli embedding di input:
21

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

1
2### Prompt Tuning
3
4Apprendimento di soft prompt:
5

[SOFT_PROMPT] + "Actual input text"

1
2### Adapter Layers
3
4Aggiunta di piccole reti tra i livelli del transformer:
5

Attention → Adapter → LayerNorm → FFN → Adapter → LayerNorm

1
2### (IA)³ - Infused Adapter
3
4Moltiplicazione delle attivazioni con vettori appresi:
5

output = activation × learned_vector

1
2## Preparazione dei Dati
3
4### Formati dei Dati
5
6**Instruction Format:**
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}

Qualità dei Dati

Caratteristiche di buoni dati:

• Diversità (esempi diversificati)
• Coerenza (formato coerente)
• Accuratezza (etichette accurate)
• Quantità sufficiente (di solito 1K-100K esempi)

Data Augmentation

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 di Training

Scelta degli Iperparametri

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)

Learning Rate

• Full fine-tuning: 1e-5 - 5e-5
• LoRA: 1e-4 - 3e-4
• QLoRA: 2e-4 - 5e-4

Regolarizzazione

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

Evaluation e Validazione

Metriche

Perplexity:

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

BLEU/ROUGE: qualità della generazione testuale

Task-specific: Accuracy, F1, metriche personalizzate

Rilevamento dell’Overfitting

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

Deployment

Model Merging

Merge dell’adapter LoRA nel modello base:

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

Multi-Adapter Serving

Più adapter con un singolo modello base:

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

Enterprise Fine-Tuning Pipeline

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

Problemi Comuni e Soluzioni

1. Out of Memory

Soluzione: QLoRA, gradient checkpointing, riduzione della batch size

2. Catastrophic Forgetting

Soluzione: Learning rate più basso, replay buffer, elastic weight consolidation

3. Overfitting

Soluzione: Più dati, regolarizzazione, early stopping

4. Scarsa Generalizzazione

Soluzione: Maggiore diversità dei dati, diversità delle instruction

Conclusione

Il fine-tuning è il modo più efficace per adattare i modelli pre-addestrati alle esigenze aziendali. Potenti personalizzazioni possono essere realizzate anche con risorse limitate utilizzando metodi PEFT come LoRA e QLoRA.

In Veni AI forniamo servizi di consulenza e implementazione per progetti di fine-tuning aziendale. Contattaci per le tue esigenze.