I miei progetti Agntbox AI utilizzano ora PEFT per l’armonia multi-modelli.

Ciao a tutti, qui è Nina, di ritorno per esplorare il mondo in continua evoluzione degli strumenti di IA per agntbox.com. Oggi voglio parlare di qualcosa che ha suscitato molto interesse nei miei progetti recenti: far sì che i modelli di IA si armonizzino, soprattutto quando non provengono tutti dalla stessa azienda. Più precisamente, ho lottato con — e alla fine sono rimasta molto impressionata da — i recenti progressi delle tecniche di PEFT (Parameter-Efficient Fine-Tuning), e di come rendano davvero pratica l’adattamento di modelli open source senza spendere una fortuna né perdere la pazienza.

Il mio punto di vista questa volta non è solo una panoramica generale del PEFT; ci concentreremo su come questo diventi il quadro per rendere il fine-tuning accessibile a sviluppatori indipendenti e team più piccoli. Dimenticate la necessità di una fattoria di server per adattare un grande modello di linguaggio (LLM). Stiamo parlando di prendere un potente mostro pre-addestrato e spingerlo delicatamente a svolgere compiti specifici con una frazione della potenza di calcolo che vi aspettereste. È come insegnare nuovi trucchi a un vecchio cane, ma il cane è un genio e avete bisogno di insegnargli solo alcuni segnali chiave.

L’elefante nella stanza: Perché il fine-tuning era un incubo

Siamo realistici. Qualche anno fa, se volevate affinare un modello come BERT o GPT-2 (le versioni open source, non il segreto di fabbrica di OpenAI), avevate bisogno di attrezzature costose. Parliamo di più GPU di alta gamma, ore di tempo di addestramento e una bolletta elettrica salata. Come blogger e sviluppatrice che spesso lavora su progetti di proof of concept o costruisce strumenti per clienti più piccoli, questo tipo di impegno era generalmente difficile da considerare. Spesso mi ritrovavo a cercare di adattare un modello pre-addestrato alla mia volontà con incentivi elaborati o combinando diversi piccoli modelli, solo per evitare il consumo di risorse di un vero fine-tuning.

Ricordo un progetto, alla fine del 2024, in cui stavo cercando di creare uno strumento di riassunto personalizzato per documenti legali molto specifici di un cliente. I riassuntori standard erano corretti, ma mancavano delle sfumature e delle frasi chiave cruciali per il contesto legale. La mia prima idea fu: “Ottimo, affinerò un modello T5.” Dopo circa un’ora di configurazione dell’ambiente e accorgendomi del volume di parametri che avrei cercato di aggiornare, il mio entusiasmo si è rapidamente evaporato. La mia unica RTX 3090, sebbene potente per i giochi, si stava già sforzando solo a pensarci. Alla fine mi sono rivolta a un approccio complesso di ingegneria dei prompt che ha funzionato, ma era fragile e difficile da mantenere.

Questa esperienza, e molte altre simili, ha messo in evidenza un enorme divario. Avevamo questi incredibili modelli fondamentali, ma farli diventare davvero nostri, adattarli ai nostri dati e compiti unici, sembrava un lusso riservato a laboratori di ricerca ben finanziati o grandi aziende tecnologiche. È qui che entra in gioco il PEFT e cambia le regole del gioco.

Cos’è esattamente il PEFT e perché dovrebbe interessarvi?

Il PEFT, o Parameter-Efficient Fine-Tuning, non è una tecnica unica ma un insieme di metodi progettati per adattare grandi modelli pre-addestrati a nuovi compiti o set di dati con molti meno parametri addestrabili rispetto al fine-tuning completo. Invece di aggiornare ogni peso in un modello che potrebbe avere miliardi di parametri, le metodologie PEFT aggiornano solo un piccolo sottoinsieme o introducono nuovi parametri più piccoli che vengono poi addestrati.

Pensatela in questo modo: avete uno chef stellato (il LLM pre-addestrato) che sa praticamente cucinare tutto. Volete che si specializzi nella cottura di un tipo di pane molto particolare. Un fine-tuning completo sarebbe come chiedere allo chef di apprendere di nuovo tutte le tecniche di cucina, tutte le ricette, dall’inizio, solo per perfezionare quel pane. Il PEFT, al contrario, è come dare allo chef un nuovo piccolo libro di ricette specificamente per quel pane, o un accessorio speciale per il suo forno. Mantiene tutto il suo know-how esistente, ma ora ha un modo mirato per eccellere nella vostra richiesta specifica.

Il principale vantaggio qui è un enorme risparmio di risorse informatiche – sia in termini di memoria GPU che di tempo di addestramento. Questo significa che potrete affinare modelli molto più grandi su GPU di tipo consumer, o anche su CPU se siete abbastanza pazienti. Questo democratizza l’accesso all’adattamento di modelli di IA all’avanguardia, ed è una grande opportunità per persone come noi.

LoRA: La mia attuale metodica PEFT preferita

Tra le varie tecniche di PEFT, l’Adaptation a Rang Basso (LoRA) è diventata la mia preferita personale e quella che ho utilizzato più frequentemente. È elegante nella sua semplicità e sorprendentemente efficace. LoRA funziona iniettando matrici di decomposizione a rango addestrabili nelle layer di trasformatore del modello pre-addestrato. Durante il fine-tuning, solo queste matrici iniettate vengono aggiornate, mentre i pesi del modello pre-addestrato originale rimangono fissi.

Questo significa che non state addestrando miliardi di parametri; potreste addestrarne solo qualche milione, o addirittura solo alcune centinaia di migliaia. I file “adapter” LoRA risultanti sono minuscoli, spesso solo pochi megabyte, rispetto ai gigabyte del modello originale. Potete quindi caricare questo adattatore sul modello base per ottenere la vostra versione specializzata. È incredibilmente efficiente anche per lo stoccaggio e il deploy.

Un esempio concreto: Fine-Tuning di Llama 2 per le risposte del supporto clienti

Passiamo alle cose concrete. Immaginate uno scenario in cui state costruendo un assistente IA per il supporto clienti. Volete che generi risposte che non solo rispondano alle domande, ma rispettino anche il tono specifico del vostro marchio, utilizzino un gergo particolare e seguano determinate politiche interne. Utilizzare un LLM generalista potrebbe portarvi all’80%, ma quel 20% rimanente è cruciale per un’esperienza educata e conforme al marchio.

Recentemente ho lavorato a un progetto simile per un piccolo cliente di e-commerce specializzato in gioielli artigianali. La loro voce di marchio è molto calorosa, personale e leggermente fantasiosa. Un modello standard di Llama 2 7B, sebbene potente, aveva spesso un tono troppo generico o formale. Il fine-tuning completo era fuori questione con il mio hardware. Ecco che entra in scena LoRA.

Impostazione dell’ambiente (semplificata)

Prima di tutto, installereste solitamente le librerie necessarie. Le librerie Hugging Face transformers e peft sono le vostre migliori amiche qui.

pip install transformers peft accelerate bitsandbytes

• transformers: Per accedere al modello base Llama 2.
• peft: Per l’implementazione di LoRA.
• accelerate: Aiuta con l’addestramento distribuito e l’ottimizzazione della memoria.
• bitsandbytes: Per la quantificazione a 4 bit, permettendovi di caricare anche modelli più grandi con meno VRAM.

Caricamento del modello di base e del tokenizer

Caricheremo una versione quantificata di Llama 2 7B per risparmiare memoria. La quantificazione riduce la precisione dei pesi del modello, permettendogli di stare in meno VRAM, spesso con un impatto minimo sulle prestazioni.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_id = "meta-llama/Llama-2-7b-hf" # O qualsiasi altra variante di Llama 2 a cui avete accesso

# Configurazione per la quantificazione a 4 bit
bnb_config = BitsAndBytesConfig(
 load_in_4bit=True,
 bnb_4bit_quant_type="nf4",
 bnb_4bit_compute_dtype=torch.bfloat16,
 bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config,
 device_map="auto",
 torch_dtype=torch.bfloat16,
)
model.config.use_cache = False # Importante per l'addestramento

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token # Llama 2 non ha un token di riempimento di default

Preparazione del modello per LoRA

Successivamente, utilizziamo la libreria peft per preparare il modello. Indichiamo quali layer vogliamo applicare LoRA (tipicamente i layer di attenzione, i valori correnti sono q_proj e v_proj), il rango (r) e il valore alpha (lora_alpha).

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# Preparare il modello per l'addestramento k-bit (importante per i modelli quantificati)
model = prepare_model_for_kbit_training(model)

# Configurazione LoRA
lora_config = LoraConfig(
 r=8, # Rang delle matrici di aggiornamento. Un rango più basso significa meno parametri addestrabili.
 lora_alpha=16, # Fattore di scalatura per i pesi di LoRA.
 target_modules=["q_proj", "v_proj"], # Applicare LoRA a questi strati di attenzione.
 lora_dropout=0.05, # Probabilità di dropout per gli strati LoRA.
 bias="none", # Di solito non ottimizziamo i pesi di bias con LoRA.
 task_type="CAUSAL_LM", # Specificare il tipo di compito.
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Quando ho eseguito questo sulla mia macchina, l’uscita di print_trainable_parameters() è stata rivelatrice. Invece di miliardi, vedevo qualcosa come “params addestrabili: 4.194.304 || tutti i params: 7.000.000.000 || percentuale addestrabile: 0.0599”. È meno dello 0.1% del totale dei parametri! È ciò che lo rende fattibile.

Dati di addestramento e configurazione dell’allenatore

Per i dati di addestramento, ho utilizzato un piccolo insieme di dati (circa 500 esempi) di sondaggi ai clienti accompagnati da risposte ideali, conformi al marchio, che il mio cliente aveva accuratamente selezionato nel tempo. Ogni esempio era formattato come una coppia istruzione-risposta.

# Dataset fittizio per illustrazione
from datasets import Dataset

data = [
 {"text": "### Cliente: Il mio collier è rotto, cosa devo fare?\n### Assistente: Oh no! Mi dispiace davvero sapere che il tuo collier è rotto. Ti prego di inviare una foto a [email protected] e organizzeremo subito una riparazione o una sostituzione. Vogliamo che adori i tuoi gioielli!",},
 {"text": "### Cliente: Fate spedizioni internazionali?\n### Assistente: Sì, lo facciamo! Spediamo i nostri tesori fatti a mano in tutto il mondo. Puoi trovare ulteriori dettagli sulla nostra pagina di spedizione, o non esitare a chiedere se hai un paese specifico in mente.",},
 # ... più esempi
]

dataset = Dataset.from_list(data)

def tokenize_function(examples):
 return tokenizer(examples["text"], truncation=True, max_length=512)

tokenized_dataset = dataset.map(tokenize_function, batched=True)

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
 output_dir="./results",
 num_train_epochs=3,
 per_device_train_batch_size=2, # Da regolare in base alla tua VRAM
 gradient_accumulation_steps=4, # Simulare una dimensione di lotto più grande
 optim="paged_adamw_8bit", # Ottimizzatore economico in memoria
 save_steps=100,
 logging_steps=10,
 learning_rate=2e-4,
 fp16=True,
 tf32=True,
 max_grad_norm=0.3,
 warmup_ratio=0.03,
 lr_scheduler_type="constant",
 report_to="none", # O "wandb" per i log
)

trainer = Trainer(
 model=model,
 train_dataset=tokenized_dataset,
 args=training_args,
 data_collator=None, # Il collatore di dati predefinito funziona bene qui
)

trainer.train()

Con questa configurazione, l’allenamento per 3 epoche sulla mia 3090 ha richiesto circa un’ora e mezza. L’utilizzo della memoria era gestibile, rimanendo ben al di sotto dei 24 GB di VRAM. È stata una svolta radicale rispetto ai miei precedenti tentativi di ottimizzazione completa.

Registrazione e caricamento dell’adattatore

Dopo l’addestramento, registri solo i pesi dell’adattatore LoRA, non l’intero modello.

model.save_pretrained("./llama2_customer_support_lora_adapter")
tokenizer.save_pretrained("./llama2_customer_support_lora_adapter")

Per utilizzarlo, carichi prima il modello di base (quantificato o meno) e poi carichi l’adattatore sopra:

from peft import PeftModel, PeftConfig

# Carica prima il modello di base
base_model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config, # O senza quantificazione se hai la VRAM
 device_map="auto",
 torch_dtype=torch.bfloat16,
)

# Carica l'adattatore PEFT
peft_model_id = "./llama2_customer_support_lora_adapter"
model = PeftModel.from_pretrained(base_model, peft_model_id)
model = model.eval() # Passare in modalità di valutazione

# Ora puoi utilizzare il modello per l'inferenza
inputs = tokenizer("### Cliente: Quanto tempo ci vuole in genere per la spedizione?\n### Assistente:", return_tensors="pt").to("cuda")
with torch.no_grad():
 outputs = model.generate(**inputs, max_new_tokens=100)
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))

I risultati sono stati davvero impressionanti. Il modello ha cominciato a generare risposte che corrispondevano perfettamente al tono fantasioso e utile del cliente. Ha utilizzato i loro nomi di prodotti specifici in modo naturale e ha compreso meglio le loro politiche interne. Questo progetto, che sarebbe stato proibitivo o complesso un anno o due fa, è diventato davvero fattibile con PEFT.

Oltre LoRA: Altre tecniche e considerazioni PEFT

Sebbene LoRA sia fantastica, non è l’unico attore nello spazio PEFT. Altre tecniche includono:

• Prefix Tuning: Aggiunge un piccolo prefisso addestrabile all’input di ogni strato di trasformatore.
• P-tuning / Prompt Tuning: Ottimizza un “soft prompt” continuo che viene aggiunto all’input, piuttosto che token discreti.
• Adapter Tuning: Inserisce piccoli moduli “adattatori” addestrabili tra gli strati del modello pre-addestrato.

Ognuna ha i propri compromessi in termini di prestazioni, utilizzo della memoria e complessità di implementazione. Tuttavia, LoRA trova attualmente un buon equilibrio per molte attività di ottimizzazione comune.

Quando considerare PEFT

• Hai una memoria GPU limitata (ad esempio, GPU di consumo come RTX 3080/3090/4090).
• Vuoi adattare un grande modello di fondazione a un dominio o a un compito specifico senza spendere una fortuna.
• Devi iterare rapidamente su diversi set di dati di ottimizzazione o approcci.
• Vuoi distribuire i tuoi modelli ottimizzati in modo efficiente (gli adattatori LoRA sono minuscoli!).

Limitazioni attuali e prossimi passi

Sebbene PEFT sia un enorme passo avanti, non è una soluzione miracolosa. La qualità della tua ottimizzazione dipende sempre fortemente dalla qualità e dalla quantità dei tuoi dati di addestramento. Per compiti estremamente complessi o nuovi, un piccolo adattatore potrebbe non essere sufficiente, e potresti dover prendere in considerazione un’ottimizzazione su larga scala o addirittura addestrare un modello da zero se le risorse lo consentono.

Un’altra cosa che ho notato è che, sebbene PEFT renda l’ottimizzazione accessibile, ottenere gli iperparametri giusti (come il r e lora_alpha di LoRA, o il tasso di apprendimento) richiede ancora alcune sperimentazioni. Non è sempre un processo “da impostare e dimenticare”.

Guardando al futuro, mi aspetto di vedere emergere metodi PEFT ancora più sofisticati, combinando potenzialmente diverse tecniche per maggiore efficienza e prestazioni. Potremmo anche vedere più strumenti automatizzati che aiutano a selezionare la migliore tecnica e i migliori iperparametri PEFT per un compito e un set di dati specifici. La possibilità di “fondere” gli adattatori LoRA nei pesi del modello di base sta diventando sempre più comune, il che è ottimo per il deployment quando desideri un file di modello consolidato.

Pratiche da ricordare

Se sei stato riluttante a ottimizzare grandi modelli di linguaggio a causa delle limitazioni delle risorse, ecco cosa dovresti fare:

1. Esplora Hugging Face PEFT: esplora la documentazione della libreria Hugging Face PEFT. È incredibilmente ben documentata e fornisce esempi per diversi modelli e tecniche.
2. Comincia con LoRA: Per la maggior parte delle attività basate su testo, LoRA è un ottimo punto di partenza. È solido e ampiamente supportato.
3. Quantifica il tuo modello di base: Ricorda sempre di caricare il tuo modello di base in precisione a 4 bit o 8 bit usando bitsandbytes. Questo riduce notevolmente i requisiti di VRAM, rendendo accessibili modelli più grandi.
4. Prepara dati di qualità: Anche con PEFT, la qualità dei tuoi dati di addestramento è fondamentale. Un piccolo set di dati di alta qualità sarà quasi sempre migliore di un grande set di dati rumorosi.
5. Sperimenta con gli iperparametri: Non avere paura di modificare il r (rank) e il lora_alpha di LoRA, così come il tasso di apprendimento e il numero di epoche. Piccole modifiche possono portare a miglioramenti notevoli.
6. Considera di unire gli adattatori per il deployment: Se stai implementando il tuo modello addestrato, verifica se il tuo adattatore PEFT può essere unito nei pesi del modello di base per creare un file modello unico e distribuitivo. Questo semplifica l’inferenza.

PEFT ha realmente cambiato il mio approccio alla creazione di applicazioni alimentate dall’IA. Ha trasformato il fine-tuning da una possibilità teorica per appassionati a uno strumento pratico e quotidiano. Se sei uno sviluppatore indipendente, una startup, o anche solo qualcuno con un progetto appassionante, PEFT è il framework che ti permetterà di personalizzare e possedere realmente i tuoi modelli di IA senza bisogno di un supercomputer. Provalo – potresti rimanere sorpreso da ciò che puoi realizzare!

🕒 Published: April 4, 2026