Fare il fine-tuning di un modello linguistico — cioe' specializzarlo sui tuoi dati e sul tuo stile — un tempo richiedeva GPU costose e settimane di lavoro. Oggi, grazie a QLoRA e alla libreria Unsloth, puoi addestrare un modello open su misura gratis, dentro un notebook di Google Colab con la GPU gratuita T4, in circa mezz'ora. Questa guida ti porta dall'inizio alla fine: dataset, codice, addestramento, prova e esportazione in Ollama per usarlo in locale.

A chi serve questa guida e cosa otterrai

E' pensata per chi ha gia' un minimo di familiarita' con Python e vuole un modello che risponda in un certo modo o conosca informazioni specifiche (lo stile della tua azienda, un formato di risposta, un dominio di nicchia). Al termine avrai un adattatore LoRA addestrato e un modello pronto da usare. Non diventerai un esperto di deep learning, ma capirai cosa fa ogni passaggio.

Prerequisiti reali: un account Google (per Colab), un account Hugging Face gratuito (per scaricare alcuni modelli serve accettare la licenza e generare un token), e un piccolo dataset di esempi. Nessun hardware locale: gira tutto sulla GPU gratuita di Colab.

Cos'e' LoRA e perche' QLoRA rende tutto gratis

Addestrare da zero tutti i miliardi di parametri di un modello e' proibitivo. LoRA (Low-Rank Adaptation) aggira il problema: congela il modello originale e addestra solo un piccolo insieme di matrici aggiuntive, gli "adattatori". Sono pochi megabyte invece di gigabyte, e il risultato e' quasi equivalente a un addestramento completo per molti compiti.

QLoRA aggiunge la quantizzazione a 4 bit: carica il modello base in una forma compressa, riducendo drasticamente la memoria GPU richiesta. La combinazione permette di addestrare modelli da diversi miliardi di parametri sui 15-16 GB di una T4 gratuita. Unsloth e' la libreria che rende il tutto veloce ed efficiente: grazie a kernel scritti a mano ottiene un addestramento 2-5 volte piu' rapido e fino al 50-80% di memoria in meno rispetto agli approcci standard, ed e' tra i pochi strumenti che funzionano bene anche su T4.

Quale modello scegliere per la T4 gratuita

Per partire su Colab gratuito conviene un modello piccolo. Due scelte solide:

  • Gemma (versioni piccole di Google): ottime per girare su T4 gratuita con QLoRA, supportano anche il fine-tuning multimodale nelle varianti adatte. Unsloth fornisce notebook gia' pronti.
  • Llama 3.1 8B: per i principianti e' un'ottima base, perche' ha la community piu' ampia, tantissimi tutorial e un buon rapporto qualita'/risorse.

Regola pratica: piu' il modello e' grande, piu' i risultati sono buoni ma piu' memoria serve. Su T4 gratuita resta sui modelli da pochi miliardi di parametri; per i piu' grandi serve Colab Pro con GPU A100.

Con QLoRA e Unsloth bastano una GPU T4 gratuita e circa mezz'ora per addestrare un modello.

Passo 1: preparare Colab e installare Unsloth

Crea un nuovo notebook su Google Colab, poi vai su Runtime → Cambia tipo di runtime e seleziona la GPU T4. Nella prima cella installa Unsloth:

!pip install -q -U unsloth
# verifica che la GPU sia attiva
import torch
print(torch.cuda.get_device_name(0))

Dovresti vedere stampato Tesla T4. Se compare un errore "no CUDA device", non hai selezionato la GPU: torna alle impostazioni del runtime.

Passo 2: caricare il modello in 4 bit

Unsloth carica modello e tokenizer gia' pronti per QLoRA con poche righe:

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gemma-2-2b-it-bnb-4bit",
    max_seq_length = 2048,
    dtype = None,          # rileva da solo il tipo migliore
    load_in_4bit = True,   # QLoRA: carica in 4 bit
)

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,                # "rango" LoRA: 8-32 vanno bene
    lora_alpha = 16,
    lora_dropout = 0,
    target_modules = ["q_proj","k_proj","v_proj","o_proj",
                      "gate_proj","up_proj","down_proj"],
    use_gradient_checkpointing = "unsloth",
)

Il parametro r e' il "rango" dell'adattatore: piu' alto significa piu' capacita' di apprendimento ma piu' memoria. Per iniziare, 16 e' un buon valore.

Passo 3: preparare il dataset

Il dataset e' la parte che decide la qualita' del risultato. Per un assistente in stile chat, il formato piu' semplice e' una lista di esempi con istruzione e risposta. Puoi caricarne uno da Hugging Face o crearne uno tuo in formato JSON. Esempio minimale fatto in casa:

from datasets import Dataset

esempi = [
    {"instruction": "Saluta un cliente in modo formale.",
     "output": "Buongiorno e benvenuto. Come posso esserle utile oggi?"},
    {"instruction": "Spiega cos'e' un preventivo in una frase.",
     "output": "Un preventivo e' una stima scritta dei costi di un servizio prima dell'acquisto."},
    # ... aggiungi decine o centinaia di esempi
]

def formatta(e):
    testo = f"<start_of_turn>user\n{e['instruction']}<end_of_turn>\n" \
            f"<start_of_turn>model\n{e['output']}<end_of_turn>"
    return {"text": testo}

dataset = Dataset.from_list(esempi).map(formatta)

Regola d'oro: la qualita' batte la quantita'. Cento esempi curati e coerenti valgono piu' di mille esempi disordinati. Per risultati seri punta ad almeno qualche centinaio di esempi ben scritti.

Passo 4: addestrare il modello

Si usa il trainer della libreria TRL, configurato da Unsloth:

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = 2048,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,          # per una prova; aumenta per dataset reali
        learning_rate = 2e-4,
        fp16 = True,
        logging_steps = 1,
        optim = "adamw_8bit",
        output_dir = "outputs",
    ),
)

trainer.train()

Su T4, con un piccolo dataset e poche decine di step, l'addestramento si completa in pochi minuti. Vedrai la "loss" scendere: e' il segnale che il modello sta imparando dai tuoi esempi.

Passo 5: provare il modello addestrato

FastLanguageModel.for_inference(model)
prompt = "<start_of_turn>user\nSaluta un cliente in modo formale.<end_of_turn>\n<start_of_turn>model\n"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
out = model.generate(**inputs, max_new_tokens=64)
print(tokenizer.decode(out[0], skip_special_tokens=True))

Il risultato atteso e' una risposta nello stile dei tuoi esempi: formale, asciutta, coerente con il tono che hai insegnato. Se le risposte sono fuori tema, di solito servono piu' esempi o piu' step di addestramento.

Passo 6: esportare e usarlo in locale con Ollama

Per usare il modello fuori da Colab, Unsloth permette di esportarlo in formato GGUF, compatibile con Ollama e llama.cpp:

model.save_pretrained_gguf("modello_gguf", tokenizer, quantization_method="q4_k_m")

Scarichi la cartella, crei un file Modelfile che punta al GGUF e lo registri con ollama create mio-modello -f Modelfile. A quel punto giri il tuo modello personalizzato in locale con ollama run mio-modello. Abbiamo dedicato una guida completa a Ollama per chi vuole approfondire questo passaggio.

Errori comuni e come risolverli

  • "CUDA out of memory": riduci max_seq_length (per esempio a 1024), abbassa per_device_train_batch_size a 1 o scegli un modello piu' piccolo.
  • "You are not authorized to access this model": alcuni modelli richiedono di accettare la licenza su Hugging Face e di fornire un token; usa from huggingface_hub import login; login("IL_TUO_TOKEN").
  • Il modello "dimentica" tutto e risponde male: e' il rischio dell'overfitting con troppi step su pochi dati. Riduci gli step o aumenta e diversifica gli esempi.
  • Sessione Colab che si disconnette: la GPU gratuita ha limiti di tempo; salva spesso gli adattatori con model.save_pretrained("lora_salvato").

Varianti, alternative e quando NON fare fine-tuning

Se ti serve solo dare al modello informazioni aggiornate o documenti specifici, spesso il fine-tuning non e' la strada giusta: meglio un sistema RAG, che recupera i tuoi documenti al momento della domanda senza riaddestrare nulla (ne abbiamo parlato in una guida dedicata). Il fine-tuning conviene quando vuoi cambiare stile, formato o comportamento del modello in modo stabile. Per progetti piu' grandi puoi salire di modello con Colab Pro e GPU A100, oppure usare l'interfaccia no-code di Unsloth Studio. La regola finale: parti piccolo, verifica che il flusso funzioni end-to-end, e solo dopo investi su dataset piu' ricchi e modelli piu' grandi. La documentazione ufficiale di Unsloth resta il riferimento per i notebook aggiornati.