Guide sull’IA · 11 min di lettura

Cos'è la quantizzazione nell'IA? Come i modelli a 4 e 8 bit riducono la memoria

La quantizzazione salva i pesi dei modelli IA a 4 o 8 bit per ridurre la memoria. Scopri i compromessi sulla precisione e il ruolo di GGUF.

Un reticolo cristallino luminoso e rado a sinistra si compatta in un gruppo più fitto di blocchi densi a destra, su sfondo scuro senza testo né loghi

La quantizzazione nell’IA è una tecnica di compressione che memorizza i pesi di un modello, e talvolta le sue attivazioni, con meno bit, riducendo la memoria necessaria. Passando da pesi a 16 bit alla quantizzazione a 8 o 4 bit, un modello da 8B scende da circa 16GB a circa 8GB o 4–5GB per i soli pesi, sacrificando parte della precisione in cambio di un ingombro inferiore.

Quando esamino le schede dei modelli per il deployment locale, ricorrono sempre le stesse etichette: 8 bit, 4 bit, GPTQ, AWQ e GGUF. Ciascuna indica un modo diverso di rappresentare i numeri in una rete neurale affinché il modello possa funzionare su una singola GPU, un portatile o un’istanza server più piccola.

Come riduce la memoria la quantizzazione dei modelli?

La quantizzazione riduce la memoria diminuendo il numero di bit assegnati a ogni parametro nelle matrici dei pesi di un modello. A novembre 2026, la panoramica sulla quantizzazione di Hugging Face osserva che i modelli sono generalmente caricati in bf16, che richiede 2 byte per parametro. Secondo la regola empirica di Hugging Face relativa ai soli pesi, un modello da 8B parametri richiede circa 16GB per i pesi in bf16, circa 8GB a 8 bit e circa 4–5GB a 4 bit.

Questo esempio da 8B è una regola empirica per i soli pesi, non un budget VRAM completo per l’inferenza. La memoria effettiva necessaria al servizio comprende anche le attivazioni, l’overhead del runtime e la cache chiave-valore che conserva la cronologia dell’attenzione attraverso il prompt e l’output. Se prevedi di servire contesti lunghi, la nostra guida su cos’è una cache KV spiega perché la memoria cresce con la lunghezza della sequenza.

Come semplice calcolo dello spazio di archiviazione, ogni riduzione della larghezza in bit diminuisce i byte grezzi necessari per parametro:

Formato di precisione Spazio per parametro (calcolo) Ingombro relativo dei pesi rispetto a BF16
FP32 4 byte 2x
FP16 / BF16 2 byte 1x
FP8 / INT8 1 byte 0.5x
FP4 / INT4 / 4 bit in stile NVFP4 0.5 byte 0.25x (più overhead del formato)

Questi valori in byte descrivono il calcolo dello spazio grezzo, non un benchmark del tempo effettivo o della qualità dell’output. A parità di condizioni, passare da BF16 a 8 bit dimezza la memoria dei pesi, mentre passare da BF16 a 4 bit la riduce a circa un quarto. L’intervallo di 4–5GB per un modello da 8B tiene conto dei metadati di quantizzazione e dell’overhead del formato. Come afferma Hugging Face, meno bit costano un po’ di precisione e ogni metodo di quantizzazione comporta un compromesso diverso tra memoria, velocità e precisione.

Due modi di caricare i modelli quantizzati nella pratica

I checkpoint quantizzati entrano in una pipeline di inferenza o fine-tuning attraverso due procedure di caricamento distinte, a seconda che la compressione avvenga al volo o in anticipo.

  1. Quantizzare un checkpoint a precisione completa durante il caricamento. In Hugging Face Transformers, si passa un oggetto di configurazione della quantizzazione a from_pretrained insieme a un checkpoint standard. Per esempio, la documentazione ufficiale mostra come caricare meta-llama/Llama-3.1-8B-Instruct a 4 bit passando BitsAndBytesConfig(load_in_4bit=True, ...). La maggior parte dei metodi applicati al caricamento non usa dati di calibrazione; GPTQ è l’eccezione perché si calibra su un dataset mentre il modello viene caricato.
  2. Caricare un checkpoint già quantizzato. Quando un checkpoint è già stato compresso e salvato, lo si carica senza passare una nuova configurazione di quantizzazione. Transformers legge i dettagli della quantizzazione dal file config.json del repository o da un file GGUF indicato per nome. Metodi come AWQ, AutoRound, AQLM, compressed-tensors e GGUF supportano in Transformers solo questa procedura: si parte da un checkpoint quantizzato in precedenza con la libreria propria del metodo. È così che vengono distribuite molte versioni dei modelli a pesi aperti nel 2026.

Metodi di quantizzazione comuni: bitsandbytes, GPTQ, AWQ e GGUF

I metodi comuni di quantizzazione dei modelli differiscono per il momento in cui avviene la compressione, le larghezze in bit e l’hardware supportati, e per il fatto che siano destinati a pipeline Transformers o a runtime locali autonomi.

Metodo / formato Procedura in Transformers Larghezze in bit / tipo numerico Hardware nella documentazione HF Nota operativa principale
bitsandbytes Quantizzare al caricamento o caricare un modello salvato 4 bit e 8 bit CUDA, XPU, HPU, CPU Nessuna calibrazione; supporta il fine-tuning
GPTQ Prequantizzato o calibrato al caricamento 4 bit (da int4 a fp16 al volo) CUDA, XPU, CPU Richiede un dataset di calibrazione; usare GPT-QModel
AWQ Solo prequantizzato 4 bit CUDA, XPU, CPU Conserva i pesi importanti tramite le attivazioni
GGUF Solo prequantizzato (gguf_file) Da 1 a 8 bit CUDA, MPS, XPU, CPU File unico; standard in llama.cpp e Ollama
NVFP4 / FP8 a granularità fine Quantizzare al caricamento (specifico per hardware) Virgola mobile a 4 / 8 bit GPU NVIDIA (NVFP4 su Blackwell) Rappresentazione in virgola mobile

bitsandbytes

La guida alla scelta del metodo di Hugging Face consiglia bitsandbytes quando si vuole far rientrare un modello in meno memoria con la minima configurazione. Quantizza a 4 o 8 bit durante il caricamento senza un dataset di calibrazione, funziona su CUDA, XPU, HPU e CPU e supporta sia il salvataggio sia il fine-tuning. Secondo la documentazione di bitsandbytes, la modalità a 8 bit usa LLM.int8() e dimezza la memoria usata dai pesi. La modalità a 4 bit permette QLoRA, che comprime i pesi a 4 bit mantenendo addestrabile il modello mediante l’inserimento di un piccolo insieme di pesi addestrabili di adattamento a basso rango (LoRA).

GPTQ

GPTQ è un metodo di quantizzazione post-addestramento che comprime indipendentemente ogni riga di una matrice dei pesi per minimizzare l’errore di ricostruzione. Secondo la documentazione GPTQ di Hugging Face, i pesi sono quantizzati a int4 e ripristinati a fp16 al volo durante l’inferenza. Ciò può ridurre di 4 volte l’uso di memoria perché i pesi int4 sono dequantizzati in un kernel fuso anziché nella memoria globale della GPU; larghezze in bit minori richiedono anche meno tempo per la comunicazione. La quantizzazione GPTQ richiede un dataset di calibrazione e un tokenizer, come in GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer) nella documentazione. Transformers non supporta più AutoGPTQ e indirizza invece gli utenti a GPT-QModel.

AWQ

AWQ, abbreviazione di Activation-aware Weight Quantization, si concentra sulla protezione del piccolo sottoinsieme di pesi più importante per la qualità dell’output. Come spiega la documentazione AWQ di Hugging Face, AWQ conserva una piccola frazione dei pesi importanti per le prestazioni dell’LLM per comprimere un modello a 4 bit con un degrado minimo delle prestazioni. In Transformers, AWQ è disponibile solo prequantizzato e carica checkpoint creati con llm-awq o autoawq.

GGUF

GGUF è un formato a file singolo che riunisce pesi, configurazione e tokenizer di un modello in un unico file invece di usare un config.json separato. Per questo Transformers richiede un argomento gguf_file esplicito. Negli strumenti locali come llama.cpp e Ollama, GGUF è il formato dei file con etichette come Q4_K_M e supporta pesi prequantizzati da 1 a 8 bit su CUDA, MPS, XPU e CPU.

Una limitazione importante riguarda specificamente Transformers: Hugging Face osserva che la maggior parte dei modelli GGUF viene dequantizzata a precisione completa durante il caricamento in Transformers, usando tanta memoria quanto un modello non quantizzato, salvo una limitata eccezione che usa MPS e kernel su alcuni modelli Qwen3.5. Questo comportamento appartiene al caricatore GGUF di Transformers; i runtime locali come llama.cpp e Ollama sono progettati per eseguire direttamente i pesi GGUF quantizzati.

Formati in virgola mobile a pochi bit: FP8, NVFP4 e MXFP8

La quantizzazione a pochi bit si estende anche ai formati in virgola mobile, diversi dai formati interi come INT8 e INT4. La guida alla scelta di Hugging Face elenca FP8 a granularità fine, MXFP4 e NVFP4, che quantizza nel formato in virgola mobile a 4 bit di NVIDIA sulle GPU Blackwell durante il caricamento. Esistono anche decine di altri schemi, tra cui torchao, HQQ e compressed-tensors, tutti catalogati nella guida alla scelta di Transformers.

Qual è la differenza tra quantizzazione dei soli pesi e quantizzazione completa?

La quantizzazione dei soli pesi comprime le matrici dei parametri memorizzate, lasciando attivazioni e cache KV a una precisione superiore, a meno che questi componenti non siano quantizzati separatamente. Molte pipeline diffuse di inferenza GGUF a 4 bit e di inferenza sui soli pesi memorizzano pesi a larghezza ridotta e dequantizzano o calcolano le moltiplicazioni tra matrici in un formato più ampio.

Durante la generazione di testi lunghi, attivazioni e cache KV continuano a consumare RAM della GPU o del sistema insieme ai pesi. Hugging Face documenta la quantizzazione della cache KV come fase di ottimizzazione separata per sequenze lunghe. Anche l’architettura determina la memoria totale: persino nei progetti sparsi descritti nella nostra spiegazione di Mixture of Experts, tutti gli esperti instradati e condivisi devono risiedere in memoria, anche se solo una frazione viene eseguita per token.

In cosa differisce la quantizzazione post-addestramento dall’addestramento nativo a pochi bit?

La quantizzazione post-addestramento parte da un checkpoint finito ad alta precisione e lo comprime successivamente, mentre l’addestramento nativo a pochi bit addestra e distribuisce il modello direttamente in formati numerici a pochi bit. GPTQ, AWQ, la maggior parte delle conversioni GGUF e bitsandbytes al caricamento rientrano nella categoria post-addestramento, accettando un certo errore di conversione dopo la conclusione di preaddestramento e allineamento.

L’addestramento nativo a pochi bit elimina questa conversione successiva. Un esempio attuale è Inkling 2 Mini, pubblicato da Thinking Machines Lab il 20 novembre 2026. Secondo l’annuncio ufficiale di Inkling 2 Mini e la scheda del modello, il modello da 26.4B parametri occupa circa 20GB di memoria ed è stato addestrato con NVFP4 a 4 bit nei livelli esperti per tutti i passaggi in avanti, dal preaddestramento all’apprendimento per rinforzo, oltre a MXFP8 a 8 bit nei passaggi in avanti degli ultimi quattro livelli.

Thinking Machines Lab afferma che i pesi di Inkling 2 Mini sono distribuiti con la stessa precisione numerica usata per addestrarli — 20 livelli in NVFP4 e 4 in MXFP8 — e quindi non c’è perdita di conversione dovuta alla quantizzazione. Ciò significa che non si perde precisione convertendo un checkpoint BF16 finito a 4 bit dopo l’addestramento; non è un confronto con un gemello BF16 separato. Le indicazioni hardware del team raccomandano Apple silicon con almeno 32GB di memoria, GPU con almeno 32GB di VRAM oppure un singolo NVIDIA DGX Spark.

Quale approccio alla quantizzazione è adatto al tuo lavoro?

La scelta del metodo dipende dal runtime, dall’hardware e dalla necessità di effettuare fine-tuning oppure solo inferenza. Poiché ogni metodo offre compromessi diversi tra memoria, velocità e precisione a seconda dell’attività, nessuna larghezza in bit è adatta a tutti i carichi di lavoro.

  • Scegli bitsandbytes se vuoi caricare un checkpoint esistente a precisione completa in 4 o 8 bit con una configurazione minima, oppure fare fine-tuning con QLoRA.
  • Scegli GPTQ o AWQ se vuoi un checkpoint a 4 bit già calibrato o sensibile alle attivazioni, creato per l’inferenza.
  • Scegli GGUF se vuoi un checkpoint portatile a file singolo per runtime locali come llama.cpp o Ollama.
  • Scegli checkpoint nativi a pochi bit quando uno sviluppatore distribuisce pesi addestrati direttamente in NVFP4, FP8 o MXFP8.

Controlla sempre la licenza del modello prima di convertire o ridistribuire pesi quantizzati e lascia memoria disponibile per la cache KV e l’overhead del runtime. Se il tuo obiettivo è ridurre i costi dell’inferenza cloud anziché far rientrare i pesi nell’hardware locale, consulta le strategie di prompt e instradamento nella nostra guida su come ridurre i costi delle API IA.

FAQ

La quantizzazione a 4 bit riduce sempre la qualità in modo evidente?

Nessuna singola regola prevede l’effetto preciso della quantizzazione a 4 bit sulla qualità per ogni modello e attività. Secondo la documentazione di Hugging Face, meno bit costano un po’ di precisione e ogni metodo comporta un compromesso diverso tra memoria, velocità e precisione. Metodi come AWQ e GPTQ cercano di limitare l’errore tenendo conto delle attivazioni o tramite calibrazione, mentre larghezza in bit, architettura del modello e carico di lavoro influenzano il risultato.

Perché un modello 8B a 4 bit richiede più di 4–5GB di VRAM totale?

La cifra di 4–5GB per un modello 8B a 4 bit è una regola empirica di Hugging Face per i soli pesi, non un budget completo per il servizio. L’esecuzione richiede memoria anche per attivazioni, overhead del runtime e cache KV, che cresce con la lunghezza del prompt e della generazione. Quantizzare i pesi riduce l’ingombro statico del modello, ma i contesti lunghi richiedono comunque una pianificazione separata della memoria.

Qual è la differenza tra GGUF e GPTQ o AWQ?

GGUF è un formato a file singolo che riunisce pesi, configurazione e tokenizer per runtime locali come llama.cpp e Ollama, e supporta checkpoint prequantizzati da 1 a 8 bit. GPTQ e AWQ sono metodi di quantizzazione a 4 bit generalmente memorizzati in checkpoint organizzati in directory con un file config.json: GPTQ calibra ogni riga della matrice dei pesi e AWQ conserva i pesi critici in base alle attivazioni.

Caricare un file GGUF in Transformers fa risparmiare memoria?

La maggior parte dei file GGUF non fa risparmiare memoria quando viene caricata tramite Hugging Face Transformers. Secondo la panoramica sulla quantizzazione di Hugging Face, la maggior parte dei modelli GGUF viene dequantizzata a precisione completa durante il caricamento in Transformers e occupa tanta memoria quanto un modello non quantizzato, salvo una limitata eccezione con kernel MPS su alcuni modelli Qwen3.5. Le app locali come llama.cpp e Ollama evitano questo comportamento di Transformers.

Cos’è NVFP4 rispetto alla quantizzazione INT4?

NVFP4 è il formato in virgola mobile a 4 bit di NVIDIA supportato sull’hardware Blackwell, mentre INT4 rappresenta i pesi come numeri interi a 4 bit. Entrambi i formati memorizzano ogni parametro in 0.5 byte, riducendo lo spazio grezzo dei pesi in modo simile alla quantizzazione intera a 4 bit. I formati in virgola mobile come NVFP4 e MXFP8 a 8 bit possono anche essere usati direttamente durante addestramento e deployment, come nel caso di Inkling 2 Mini di Thinking Machines Lab.

Fonti

Scritto da

Chunyu Cai

Chunyu Cai è l’amministratore delegato di Lotook, LLC e un imprenditore che scrive di modelli di IA, agenti e di come cambiano il lavoro quotidiano. Chunyu Cai ha conseguito un master presso Imperial College London.