04 - Fine-Tuning di LLM: LoRA, QLoRA e PEFT per Personalizzare i Modelli

# Configurazione LoRA con Hugging Face PEFT
from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer

# Carica il modello base
model_name = "meta-llama/Llama-3.1-8B"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Configura LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                    # Rango della decomposizione (più alto = più capacità)
    lora_alpha=32,           # Fattore di scala (tipicamente 2x r)
    lora_dropout=0.05,       # Dropout per regolarizzazione
    target_modules=[         # Layer a cui applicare LoRA
        "q_proj", "k_proj",  # Query e Key nell'attention
        "v_proj", "o_proj",  # Value e Output projection
    ],
    bias="none"              # Non addestrare i bias
)

# Applica LoRA al modello
peft_model = get_peft_model(model, lora_config)

# Verifica parametri trainabili
peft_model.print_trainable_parameters()
# Output: trainable params: 6,553,600 || all params: 8,030,261,248
# Percentage: 0.082% dei parametri totali!
      

# QLoRA: fine-tuning con quantizzazione 4-bit
from transformers import BitsAndBytesConfig
import torch

# Configurazione quantizzazione 4-bit
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                    # Quantizza a 4 bit
    bnb_4bit_quant_type="nf4",            # NormalFloat4 (migliore per LLM)
    bnb_4bit_compute_dtype=torch.bfloat16, # Compute in bfloat16
    bnb_4bit_use_double_quant=True        # Doppia quantizzazione per risparmiare RAM
)

# Carica modello quantizzato
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantization_config=bnb_config,
    device_map="auto"
)

# Applica LoRA sopra il modello quantizzato
peft_model = get_peft_model(model, lora_config)

# Ora il modello 8B richiede solo ~6GB di VRAM!
print(f"Memoria GPU: ~{torch.cuda.memory_allocated() / 1e9:.1f} GB")
      

# Preparazione dataset per fine-tuning
import json

# Formato instruction-following standard
training_examples = [
    {
        "instruction": "Analizza il sentiment di questa recensione del ristorante",
        "input": "La pasta era fredda e il servizio lentissimo. Mai più.",
        "output": "NEGATIVO. La recensione esprime insoddisfazione per due aspetti: qualità del cibo (pasta fredda) e servizio (lentissimo). L'espressione 'Mai più' indica un'esperienza fortemente negativa."
    },
    {
        "instruction": "Analizza il sentiment di questa recensione del ristorante",
        "input": "Ambiente carino, cibo nella media. Prezzi un po' alti per la zona.",
        "output": "NEUTRO/MISTO. La recensione presenta aspetti positivi (ambiente carino), neutri (cibo nella media) e negativi (prezzi alti). Il giudizio complessivo e bilanciato con leggera tendenza negativa."
    }
]

# Formattazione per il training
def format_for_training(example: dict) -> str:
    """Formatta un esempio nel template chat standard."""
    prompt = f"""### Instruction:
{example['instruction']}

### Input:
{example['input']}

### Response:
{example['output']}"""
    return prompt

# Salva dataset
with open("training_data.jsonl", "w") as f:
    for ex in training_examples:
        f.write(json.dumps({"text": format_for_training(ex)}) + "\n")

print(f"Dataset creato con {len(training_examples)} esempi")
      

# Training con Hugging Face Trainer
from transformers import TrainingArguments, Trainer
from datasets import load_dataset

# Carica dataset
dataset = load_dataset("json", data_files="training_data.jsonl", split="train")
dataset = dataset.train_test_split(test_size=0.1)

# Tokenizza
def tokenize(example):
    return tokenizer(
        example["text"],
        truncation=True,
        max_length=512,
        padding="max_length"
    )

tokenized = dataset.map(tokenize, batched=True)

# Configura training
training_args = TrainingArguments(
    output_dir="./fine-tuned-model",
    num_train_epochs=3,              # Numero di epoch (2-5 per LoRA)
    per_device_train_batch_size=4,   # Batch size per GPU
    gradient_accumulation_steps=4,   # Simula batch size più grande
    learning_rate=2e-4,              # Learning rate (1e-4 - 3e-4 per LoRA)
    warmup_steps=100,                # Warmup graduale
    logging_steps=10,                # Log ogni 10 step
    save_strategy="epoch",           # Salva a ogni epoch
    evaluation_strategy="epoch",     # Valuta a ogni epoch
    fp16=True,                       # Mixed precision per velocità
)

# Avvia training
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=tokenized["train"],
    eval_dataset=tokenized["test"],
)

trainer.train()

# Salva il modello LoRA (solo gli adapter, pochi MB)
peft_model.save_pretrained("./lora-adapters")
print("Training completato! Adapter salvati.")
      

# Merge degli adapter LoRA con il modello base
from peft import PeftModel

# Carica modello base + adapter
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    torch_dtype=torch.float16,
    device_map="auto"
)
merged_model = PeftModel.from_pretrained(base_model, "./lora-adapters")

# Fondi adapter con modello base
merged_model = merged_model.merge_and_unload()

# Salva modello completo
merged_model.save_pretrained("./final-model")
tokenizer.save_pretrained("./final-model")
print("Modello finale salvato (base + LoRA fusi)")

# Test del modello fine-tuned
inputs = tokenizer("### Instruction:\nAnalizza il sentiment...", return_tensors="pt")
outputs = merged_model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))