SLM vs LLM: come scegliere il modello giusto per la tua PMI europea

Piccolo o grande: la domanda giusta è che cosa entra e che cosa serve

Scegliere fra un modello piccolo (SLM) e uno grande (LLM) non è una scelta fra due categorie: è una scelta lungo una scala di parametri, dove ogni gradino costa memoria, tempo e licenza, e rende qualcosa in capacità. Per una PMI la soglia pratica non è un numero di miliardi di parametri, ma la macchina che puoi permetterti e la qualità minima che il tuo compito richiede. Il modo corretto di decidere è misurare sui tuoi documenti, e l'articolo ti mostra come farlo con un programma che gira sul tuo computer.

Un esempio quotidiano: un assistente che risponde alle domande sul regolamento interno (ferie, trasferte, note spese) lavora su testi brevi e su fatti, e un modello piccolo con il documento davanti può bastare; un assistente che deve riassumere un contratto di cento pagine e confrontarlo con un altro lavora su un contesto lungo e su ragionamenti a più passi, dove la differenza di capacità si sente di più. Nessuno dei due casi si decide a priori: si decide con una prova.

Che cosa cambia salendo di taglia

Prima di confrontare modelli conviene sapere quali grandezze si muovono quando il numero di parametri cresce. Le conseguenze sono prevedibili, a differenza della qualità, che dipende dal compito.

• Memoria dei pesi: cresce in proporzione ai parametri e ai bit per peso; raddoppiare i parametri raddoppia il file.
• Velocità di generazione: su CPU è limitata dalla banda di memoria, quindi scende all'incirca in proporzione inversa alla dimensione del file.
• Costo del server: salta a gradini, perché la RAM si compra a taglie fisse.
• Capacità sul tuo compito: generalmente aumenta, ma in misura che solo una prova sui tuoi dati può dirti.

Le prime tre voci si calcolano; l'ultima si misura. È l'asimmetria da tenere presente: le schede dei modelli e i benchmark pubblici descrivono compiti generali, mentre la tua domanda riguarda i tuoi documenti in italiano, con il tuo gergo. Per questo l'articolo non riporta classifiche: non le ho potute verificare su una fonte primaria che misuri il tuo caso, e un numero di MMLU non ti dice se il modello capisce il tuo regolamento.

Taglia, memoria e licenza di alcuni modelli aperti

Il programma seguente elenca otto modelli aperti con il numero esatto di parametri e la licenza dichiarata nella loro scheda su Hugging Face (consultata il 2026-11-13), e calcola quanta memoria occupano i soli pesi a 16 bit, a 8 bit e a circa 4,9 bit, il valore implicito nei file quantizzati della libreria Ollama come mostrato nell'articolo sul server. La formula è parametri per bit diviso otto.

"""Taglia e licenza di alcuni modelli aperti.

Parametri: campo safetensors.total dell'API di Hugging Face (2026-11-13).
Licenza: campo license della scheda del modello (stessa data).
La memoria dei pesi e' parametri x bit / 8; 4.9 bit e' il valore implicito
nei file Ollama calcolato nell'articolo precedente della serie.
"""
GIB = 1024 ** 3
MODELLI = [
    # nome, miliardi di parametri esatti, licenza dichiarata dalla scheda
    ("Qwen2.5-3B-Instruct", 3_085_938_688, "qwen-research (uso commerciale: chiedere licenza)"),
    ("Phi-3.5-mini-instruct", 3_821_079_552, "MIT"),
    ("Mistral-7B-Instruct-v0.3", 7_248_023_552, "Apache-2.0"),
    ("Qwen2.5-7B-Instruct", 7_615_616_512, "Apache-2.0"),
    ("Llama-3.1-8B-Instruct", 8_030_261_248, "llama3.1 (licenza Meta)"),
    ("gemma-2-9b-it", 9_241_705_984, "gemma (licenza Google)"),
    ("Mistral-Nemo-Instruct-2407", 12_247_782_400, "Apache-2.0"),
    ("Qwen2.5-14B-Instruct", 14_770_033_664, "Apache-2.0"),
]


def gib(parametri, bit):
    return parametri * bit / 8 / GIB


print(f"{'modello':28s} {'Mld':>6s} {'16 bit':>8s} {'8 bit':>7s} {'4.9 bit':>8s}  licenza")
for nome, par, lic in MODELLI:
    print(f"{nome:28s} {par / 1e9:6.2f} {gib(par, 16):7.1f}G {gib(par, 8):6.1f}G {gib(par, 4.9):7.1f}G  {lic}")

# Output:
# modello                         Mld   16 bit   8 bit  4.9 bit  licenza
# Qwen2.5-3B-Instruct            3.09     5.7G    2.9G     1.8G  qwen-research (uso commerciale: chiedere licenza)
# Phi-3.5-mini-instruct          3.82     7.1G    3.6G     2.2G  MIT
# Mistral-7B-Instruct-v0.3       7.25    13.5G    6.8G     4.1G  Apache-2.0
# Qwen2.5-7B-Instruct            7.62    14.2G    7.1G     4.3G  Apache-2.0
# Llama-3.1-8B-Instruct          8.03    15.0G    7.5G     4.6G  llama3.1 (licenza Meta)
# gemma-2-9b-it                  9.24    17.2G    8.6G     5.3G  gemma (licenza Google)
# Mistral-Nemo-Instruct-2407    12.25    22.8G   11.4G     7.0G  Apache-2.0
# Qwen2.5-14B-Instruct          14.77    27.5G   13.8G     8.4G  Apache-2.0

La colonna a 16 bit mostra perché un modello da 8 miliardi non entra in una macchina da 8 GB senza quantizzazione: servono circa 15 GiB di soli pesi. La quantizzazione a poco meno di 5 bit li porta a 4-5 GiB, a costo di una perdita di precisione che non è quantificata in questa tabella e che va misurata con il metodo della sezione seguente. I due modelli da 12 e 15 miliardi richiedono circa 7 e 8 GiB di pesi, quindi una macchina da 16 GB è il minimo realistico, senza contare la cache.

La colonna delle licenze è la più trascurata e la più rischiosa. I modelli con licenza Apache-2.0 o MIT consentono l'uso commerciale senza condizioni particolari. Quello di Qwen2.5 da 3 miliardi è rilasciato con una licenza di ricerca: il testo definisce «non commerciale» come uso per ricerca o valutazione, e dice che chi usa commercialmente i materiali deve chiedere una licenza ad Alibaba Cloud. Lo stesso nome di famiglia, Qwen2.5, ha quindi licenze diverse a seconda della taglia: la taglia da 7 e 14 miliardi risulta Apache-2.0, quella da 3 miliardi no.

La licenza di Llama 3.1 è una licenza propria di Meta, non una licenza open source standard. Dal testo ufficiale, consultato il 2026-11-13, emergono tre obblighi concreti: se i prodotti tuoi e delle tue affiliate superano 700 milioni di utenti attivi mensili devi chiedere una licenza a Meta; se distribuisci i materiali o un prodotto che li contiene devi allegare la licenza e mostrare «Built with Llama»; e l'uso deve rispettare la politica d'uso accettabile. Per una PMI il primo limite è lontano, gli altri due no. La licenza di Gemma è anch'essa propria di Google e qui non l'ho letta per intero: leggila prima di usarlo in un prodotto.

Quantizzazione: meno bit, meno memoria, qualità da verificare

Quantizzare significa rappresentare ogni peso con meno bit di quanti ne usi il modello originale. Il risultato è un file più piccolo e più veloce da leggere dalla memoria, con una perdita di precisione. Quanto pesi quella perdita sul tuo compito non lo sa nessuno in anticipo: ci sono compiti in cui una quantizzazione a 4-5 bit è indistinguibile e compiti, come i calcoli o l'estrazione di numeri, in cui gli errori affiorano prima.

La regola operativa è di confrontare lo stesso modello in due quantizzazioni sullo stesso insieme di domande, e scegliere la più piccola che non peggiora il risultato oltre la tua soglia. Se la tabella dice che passare da 8 a circa 5 bit fa risparmiare 3 GiB, quel risparmio vale solo se la qualità resta nei limiti: il metodo per saperlo è il prossimo.

Come confrontare due modelli sui tuoi documenti

Il metodo è semplice: prepara un insieme di domande reali con la risposta attesa espressa come parole che devono comparire, fai rispondere i due modelli, conta le risposte corrette. Il problema è statistico, non tecnico: con poche domande il punteggio è troppo incerto per distinguere due modelli. Il programma seguente lo mostra con otto domande di un regolamento aziendale immaginario e due «modelli» che sono funzioni con risposte scritte a mano (nessun modello vero viene chiamato): serve a vedere il calcolo, non a giudicare un prodotto.

"""Quante domande servono per confrontare due modelli sui TUOI documenti.

I due 'modelli' sono funzioni che restituiscono risposte scritte a mano: servono
a mostrare il metodo, non a misurare un modello vero. Nessun modello e' chiamato.
"""
from math import sqrt

Z95 = 1.959964   # quantile normale per l'intervallo al 95%
Z80 = 0.841621   # quantile normale per una potenza dell'80%

# Insieme di controllo: domanda -> parole che la risposta DEVE contenere.
DOMANDE = {
    "Quanti giorni di preavviso per le ferie?": ["10", "giorni"],
    "Chi approva una trasferta?": ["responsabile"],
    "Entro quando si presenta la nota spese?": ["30", "giorni"],
    "Dove si segnala un incidente informatico?": ["helpdesk"],
    "Quale e' il limite di spesa senza approvazione?": ["500"],
    "Chi custodisce le chiavi dell'archivio?": ["segreteria"],
    "Quando si rinnova la formazione sicurezza?": ["anno"],
    "Come si richiede un permesso?": ["portale"],
}

RISPOSTE_A = [  # modello 'A' (inventato): sbaglia la domanda sull'incidente
    "10 giorni", "il responsabile", "entro 30 giorni", "scrivere a un collega",
    "500 euro", "la segreteria", "ogni anno", "dal portale",
]
RISPOSTE_B = [  # modello 'B' (inventato): sbaglia la domanda sul permesso
    "10 giorni", "il responsabile", "entro 30 giorni", "all'helpdesk",
    "500 euro", "la segreteria", "ogni anno", "lo chiedi al capo",
]


def esiti(risposte):
    return [all(p in r for p in attese) for r, attese in zip(risposte, DOMANDE.values())]


def wilson(successi, n, z=Z95):
    """Intervallo di Wilson per una proporzione: regge anche con n piccolo."""
    p = successi / n
    centro = (p + z * z / (2 * n)) / (1 + z * z / n)
    meta = z * sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return centro - meta, centro + meta


for nome, r in [("A", RISPOSTE_A), ("B", RISPOSTE_B)]:
    s = sum(esiti(r))
    lo, hi = wilson(s, len(DOMANDE))
    print(f"modello {nome}: {s}/{len(DOMANDE)} corrette, intervallo 95% = [{lo:.2f}, {hi:.2f}]")


def n_per_gruppo(p1, p2):
    """Domande per ciascun modello per distinguere due proporzioni
    (test a due code, alfa 5%, potenza 80%, approssimazione normale)."""
    var = p1 * (1 - p1) + p2 * (1 - p2)
    return (Z95 + Z80) ** 2 * var / (p1 - p2) ** 2


print("\ndomande necessarie per ciascun modello")
for p1, p2 in [(0.70, 0.80), (0.70, 0.90), (0.50, 0.90)]:
    print(f"  {p1:.0%} contro {p2:.0%}: circa {n_per_gruppo(p1, p2):.0f}")

# Output:
# modello A: 7/8 corrette, intervallo 95% = [0.53, 0.98]
# modello B: 7/8 corrette, intervallo 95% = [0.53, 0.98]
#
# domande necessarie per ciascun modello
#   70% contro 80%: circa 290
#   70% contro 90%: circa 59
#   50% contro 90%: circa 17

I due modelli ottengono lo stesso 7 su 8, pur sbagliando domande diverse, e l'intervallo di confidenza di Wilson al 95% va da 0,53 a 0,98: con otto domande non sappiamo se la vera precisione sia il 53% o il 98%, e nemmeno se un modello sia meglio dell'altro. La seconda parte dell'uscita risponde alla domanda pratica: per distinguere il 70% dall'80% servono circa 290 domande per ciascun modello, per distinguere il 70% dal 90% circa 59, per distinguere il 50% dal 90% circa 17. Il calcolo usa l'approssimazione normale con soglia 5% e potenza 80%.

Ne seguono due conseguenze. Differenze piccole fra modelli simili sono quasi impossibili da dimostrare per una PMI, quindi conviene scegliere con altri criteri (licenza, memoria, velocità) e riservare la prova a differenze grandi. E l'insieme di controllo vale più del modello: costruirlo bene (domande vere, risposte verificate da chi conosce il regolamento) è il lavoro che resta utile anche quando il modello cambia. Un limite del metodo: cercare parole attese penalizza le risposte corrette ma formulate diversamente, e premia quelle che contengono le parole per caso; per compiti non fattuali serve una valutazione umana.

Quando passare a un modello più grande

I segnali per salire di taglia sono osservabili, non vaghi. Li elenco come cose da controllare sul tuo insieme di domande, non come regole universali: non ho una fonte che li quantifichi.

• Il punteggio sul tuo insieme di controllo resta sotto la soglia anche dopo aver migliorato il prompt e il recupero dei documenti.
• Gli errori sono di ragionamento (confronti, calcoli, condizioni annidate), non di informazione mancante.
• Il compito richiede un contesto più lungo di quello che il modello piccolo gestisce bene.
• La lingua o il gergo del tuo settore sono poco coperti e il modello inventa termini.

Il primo segnale è il più importante, perché separa un problema di modello da un problema di dati. Dare al modello il documento giusto (si chiama recupero, ed è il tema dell'articolo sul recupero con ricerca vettoriale) rimedia a ciò che il modello non sa, ma non a ciò che non sa fare. Se anche con il documento giusto davanti il modello sbaglia, il problema è la capacità e la risposta è un modello più grande, in proprio o in cloud: il confronto dei costi è nell'articolo sui costi, e i casi in cui il cloud è la scelta migliore sono in quando non conviene farlo in proprio.

Non legare il codice a un nome di modello

Qualunque sia la scelta di oggi, fra sei mesi uscirà un modello migliore. La difesa è banale e costa poco: il nome del modello sta in un file di configurazione, non nel codice; le chiamate passano da una sola funzione; il tuo insieme di controllo si riesegue con un comando. Così cambiare modello significa cambiare una riga e rieseguire la prova, non riscrivere l'applicazione. Per le famiglie di modelli attuali, con la loro architettura e le differenze di memoria della cache, vedi il confronto in quale modello scegliere.

Domande frequenti

Che cosa sai fare adesso

Sai stimare la memoria dei pesi di un modello dal numero di parametri e dai bit, sai leggere la licenza prima di scegliere e conosci le tre condizioni più rilevanti di quella di Llama 3.1. Sai anche perché otto domande non bastano per confrontare due modelli, e sai calcolare quante ne servono per la differenza che ti interessa. Le fonti qui sotto indicano dove ho preso ogni dato; i punteggi dei modelli non sono riportati perché non li ho verificati sul tuo compito.

Nella stessa serie trovi anche il riepilogo con la scheda di decisione.