Addestrare un modello di intelligenza artificiale sui propri dati sembra roba da grandi laboratori con migliaia di GPU. In realta', grazie a una tecnica chiamata LoRA, oggi puoi personalizzare un modello linguistico aperto anche con una sola scheda grafica gratuita, quella che Google mette a disposizione su Colab. In questa guida vedremo come farlo passo passo con Unsloth, una libreria che rende il processo veloce e leggero, fino a esportare il modello e usarlo in locale con Ollama.

A chi serve questa guida e cosa otterrai

Questa guida e' pensata per chi ha gia' un minimo di dimestichezza con Python e vuole fare il salto dal semplice uso di ChatGPT alla creazione di un modello su misura: uno sviluppatore che vuole un assistente specializzato sul gergo della propria azienda, un ricercatore che deve adattare un modello a un dominio specifico, un appassionato curioso. Alla fine avrai un modello aperto (per esempio un Llama o un Qwen di piccole dimensioni) addestrato a rispondere nel formato e nello stile che gli hai insegnato, salvato in un formato pronto per l'uso locale.

Non serve hardware costoso: bastano un account Google e un browser. Tutto gira sulla GPU gratuita di Colab.

Prima chiariamo: cos'e' LoRA e perche' cambia tutto

Un modello linguistico ha miliardi di parametri. Riaddestrarli tutti ("full fine-tuning") richiede memoria enorme e costi proibitivi. LoRA (Low-Rank Adaptation) usa un trucco: congela il modello originale e aggiunge dei piccoli "adattatori", matrici molto piu' leggere, che vengono addestrati al posto dell'intero modello. Il risultato e' che si modifica meno dell'1% dei parametri, con un consumo di memoria ridotto di decine di volte. La variante QLoRA aggiunge la quantizzazione a 4 bit del modello di base, abbassando ancora i requisiti: e' questo che permette di lavorare sulla GPU gratuita di Colab.

Con LoRA si addestra meno dell'1% dei parametri: basta una GPU gratuita per iniziare.

Prerequisiti e preparazione dell'ambiente

Ti servono: un account Google, un account Hugging Face (gratuito) con un token di accesso, e — se vuoi partire da un modello con licenza ad accesso controllato come alcuni Llama — l'accettazione delle relative condizioni sul sito di Hugging Face.

  1. Vai su colab.research.google.com e crea un nuovo notebook.
  2. Dal menu Runtime > Cambia tipo di runtime seleziona come acceleratore hardware una GPU T4 (disponibile nel piano gratuito).
  3. Installa Unsloth eseguendo questa cella:
!pip install unsloth

Passo 1: caricare il modello di base

Unsloth semplifica il caricamento del modello gia' quantizzato a 4 bit. Scegli un modello piccolo per stare nei limiti della T4 (per esempio un modello da 3-8 miliardi di parametri):

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/llama-3.1-8b-instruct-bnb-4bit",
    max_seq_length = 2048,
    load_in_4bit = True,
)

Poi si applicano gli adattatori LoRA al modello, indicando quali moduli addestrare e il "rango" (la dimensione degli adattatori, un compromesso tra qualita' e leggerezza):

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    lora_alpha = 16,
    target_modules = ["q_proj","k_proj","v_proj","o_proj",
                      "gate_proj","up_proj","down_proj"],
    use_gradient_checkpointing = "unsloth",
)

Passo 2: preparare il dataset

Il fine-tuning e' bravo quanto i dati che gli dai. Ti serve un insieme di esempi nel formato "istruzione - risposta". Puoi partire da un dataset pubblico di Hugging Face o crearne uno tuo in formato JSON, con almeno qualche centinaio di esempi di qualita' (meglio pochi ma puliti che tanti ma disordinati). Un esempio di struttura:

from datasets import load_dataset

# Un dataset tuo, caricato da un file JSON con campi "instruction" e "output"
dataset = load_dataset("json", data_files="mio_dataset.json", split="train")

def formatta(esempio):
    testo = f"### Istruzione:\n{esempio['instruction']}\n\n### Risposta:\n{esempio['output']}"
    return {"text": testo}

dataset = dataset.map(formatta)

Passo 3: avviare l'addestramento

Si usa il trainer della libreria TRL. I parametri chiave sono il numero di passi (o epoche), il learning rate e la dimensione del batch. Per un primo esperimento bastano poche centinaia di passi:

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,
        max_steps = 300,
        learning_rate = 2e-4,
        fp16 = True,
        logging_steps = 10,
        output_dir = "output",
        optim = "adamw_8bit",
    ),
)

trainer.train()

Durante l'esecuzione vedrai scendere il valore della "loss": e' il segnale che il modello sta imparando. Su una T4, 300 passi con un modello da 8 miliardi richiedono in genere pochi minuti.

Passo 4: provare il modello e salvarlo

Subito dopo l'addestramento puoi testarlo con un prompt:

FastLanguageModel.for_inference(model)
inputs = tokenizer(
    "### Istruzione:\nPresentati come assistente dell'azienda.\n\n### Risposta:\n",
    return_tensors = "pt").to("cuda")
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=128)[0]))

Per usarlo fuori da Colab, esporta il modello in formato GGUF (quello compatibile con Ollama e llama.cpp):

model.save_pretrained_gguf("mio-modello", tokenizer, quantization_method="q4_k_m")

Scarica la cartella risultante, poi in locale crea un file Modelfile che punta al file .gguf e importalo in Ollama:

ollama create mio-modello -f Modelfile
ollama run mio-modello

Errori comuni e come risolverli

  • "CUDA out of memory": riduci per_device_train_batch_size a 1, abbassa max_seq_length (per esempio a 1024) o scegli un modello piu' piccolo.
  • Il modello ripete o non segue le istruzioni: spesso il dataset e' troppo piccolo o poco vario. Aggiungi esempi e assicurati che il formato del prompt in addestramento sia identico a quello che userai in inferenza.
  • "401 / gated repo" durante il download: non hai accettato la licenza del modello o manca il login. Esegui from huggingface_hub import login; login("IL_TUO_TOKEN") e accetta le condizioni sul sito.
  • La sessione Colab si disconnette: il piano gratuito ha limiti di tempo. Salva spesso su Google Drive e tieni gli addestramenti brevi, oppure valuta Colab Pro per sessioni piu' lunghe.

Quando NON fare fine-tuning (e le alternative)

Il fine-tuning e' potente ma non e' la risposta a tutto. Se il tuo obiettivo e' far rispondere il modello su documenti aziendali aggiornati, spesso conviene di piu' un sistema RAG (che recupera i testi rilevanti e li passa al modello) piuttosto che riaddestrare. Il fine-tuning brilla invece quando vuoi cambiare stile, tono o formato delle risposte, insegnare un compito ripetitivo molto specifico o comprimere istruzioni lunghe in un comportamento stabile. La regola pratica: prova prima con un buon prompt e con il RAG; passa al fine-tuning quando questi non bastano. E ricorda di valutare sempre il modello su esempi che non ha visto in addestramento, per accorgerti se ha "imparato a memoria" invece di generalizzare.