Cosa significa un basso carico GPU quando si esegue un LLM con llama.cpp?

Spesso ciò significa che molti layer restano sulla CPU, causando un calo netto della velocità di generazione dei token. È possibile provare ad aumentare l’offload dei layer sulla GPU tramite il parametro ngl, scegliere una quantizzazione più piccola o accorciare il contesto, in modo da far entrare una quota maggiore del modello sulla GPU.

In che modo una finestra di contesto più lunga influisce sui token al secondo con 16 GB di VRAM?

Un contesto più lungo aumenta la cache KV e l’uso della VRAM, riducendo i token al secondo o forzando l’offload parziale. Contesti più brevi, modelli più piccoli o quantizzazioni più aggressive aiutano a mantenere alte le prestazioni su una singola scheda da 16 GB.

Quale compromesso di quantizzazione è determinante per l’uso di modelli di grandi dimensioni su 16 GB?

Le quantizzazioni a basso numero di bit utilizzano meno VRAM e possono aumentare i token al secondo, ma potrebbero compromettere la qualità. Le quantizzazioni di tipo IQ3 e IQ4 sono compromessi comuni per llama.cpp su una singola GPU da 16 GB quando sono necessari contesti lunghi o checkpoint più grandi.

I modelli mixture-of-experts possono essere veloci su una singola GPU da 16 GB?

I modelli MoE possono raggiungere un’elevata velocità in token al secondo poiché in ogni passaggio in avanti viene eseguita solo una parte della rete, ma è comunque necessario disporre di una VRAM sufficiente per gli esperti attivi, i pesi e la KV cache alla lunghezza di contesto scelta.

Cosa si può provare se il contesto da 64K è molto più lento rispetto a quello da 32K sulla stessa GPU?

Regola il numero di livelli caricati sulla GPU con ngl, accetta un contesto più breve se adeguato al tuo compito o passa a una quantizzazione più leggera affinché più livelli restino sul dispositivo e la pressione sulla cache KV si attenui.

Benchmark di LLM con 16 GB di VRAM su llama.cpp (velocità e contesto)

Velocità dei token di llama.cpp con 16 GB di VRAM (tabelle).

Indice

Qui sto confrontando la velocità di diversi LLM eseguiti su GPU con 16 GB di VRAM, e scelgo il migliore per l’auto-ospitazione.

Ho eseguito questi LLM con llama.cpp utilizzando finestre di contesto da 19K, 32K e 64K token.

GPU stilizzata con blocchi VRAM e grafici in stile benchmark

In questo articolo registro i miei tentativi di spremere quanta più prestazione possibile in termini di velocità.

Tabella di confronto velocità LLM (token al secondo e VRAM)

Modello	Dimensione	19K VRAM	19K GPU/CPU	19K T/s	32K VRAM	32K Carico	32K T/s	64K VRAM	64K Carico	64K: T/s
Qwen3.6-35B-A3B-UD-IQ3_XXS	13.2	13.8GB	96%/100%	147.5	14.0GB	96%/101%	149.1	14.7GB	96%/101%	145.8
Qwen3.6-35B-A3B-UD-IQ4_XS	17.7	14.3GB	62%/266%	95.0	14.9GB	58%/279%	92.3	14.9GB	57%/293%	86.4
Qwen3.5-35B-A3B-UD-IQ3_S	13.6	14.3GB	93%/100%	136.4	14.6GB	93%/100%	138.5	14.9GB	88%/115%	136.8
Qwen3.5-27B-IQ3_XXS-bartowsky	11.3	12.8	98/100	44.9	13.5	98/100	44.9	14.5	45/415	23.6
Qwen3.5-27B-UD-IQ3_XXS	11.5	12.9	98/100	45.3	13.7	98/100	45.1	14.7	45/410	22.7
Qwen3.5-27B-IQ4_XS.gguf	15.0	14.6	49/406	20.5	14.7	37/465	17.4	14.7	23/533	13.3
Qwen3.5-122B-A10B-UD-IQ3_XXS	44.7	14.7	30/470	22.3	14.7	30/480	21.8	14.7	28/490	21.5
Qwen3.5-122B-A10B-UD-IQ3_S	46.5	14.7	25/516	19.4	14.7	24/516	19.5	14.7	24/516	19.6
Mistral-Small-4-119B UD-IQ3_XXS	42.8	14.8	28/585	30.4	14.7	27/574	28.5	14.9	20/590	31.5
Qwen3-Coder-Next-UD-IQ4_XS	38.4	14.6	32/460	41.1	14.7	29/440	41.3	14.8	32/460	38.3
Nemotron Super 120b IQ3_XXS	56.2	15.0	26/517	17.5	14.6	26/531	17.4	14.6	26/535	17.6
gemma-4-26B-A4B-it-UD-IQ4_XS	13.4	14.7	95/100	121.7	14.9	95/115	114.9	14.9	75/190	96.1
gemma-4-31B-it-UD-IQ3_XXS	11.8	14.8	68/287	29.2	14.8	41/480	18.4	14.8	18/634	8.1
GLM-4.7-Flash-IQ4_XS	16.3	15.0	66/240	91.8	14.9	62/262	86.1	14.9	53/313	72.5
GLM-4.7-Flash-REAP-23B IQ4_XS	12.6	13.7	92/100	122.0	14.4	95/102	123.2	14.9	71/196	97.1

19K, 32K e 64K sono le dimensioni del contesto.

Il carico (load) riportato sopra è il Carico GPU (GPU Load). Se vedi un numero basso in questa colonna, significa che il modello è eseguito principalmente sulla CPU e non può raggiungere una velocità dignitosa su questa hardware. Questo schema corrisponde a ciò che le persone osservano quando troppa poca parte del modello entra in GPU o quando il contesto sposta il lavoro sull’host.

Su llama.cpp, le prestazioni LLM, OpenCode e altri confronti

Se desideri percorsi di installazione, esempi di llama-cli e llama-server, e le flag importanti per la VRAM e i token al secondo (dimensione del contesto, batching, -ngl), inizia con Guida rapida a llama.cpp con CLI e Server.

Per una visione più ampia delle prestazioni (throughput rispetto alla latenza, limiti di VRAM, richieste parallele e come i benchmark si integrano tra hardware e runtime diversi), consulta Prestazioni LLM nel 2026: Benchmark, Colli di Bottiglia e Ottimizzazione.

La qualità della risposta è analizzata in altri articoli, ad esempio:

Migliori LLM per OpenCode - Testati Localmente. Puoi leggere di più su Opencode in Guida rapida a OpenCode: Installa, Configura e Usa l’Agente AI di Coding da Terminale
Confronto della qualità della Traduzione di Pagina Hugo - LLM su Ollama

Ho eseguito un test simile per LLM su Ollama: Migliori LLM per Ollama su GPU 16GB VRAM.

Se esegui Qwen 3.6 27B o 35B tramite llama.cpp e vuoi spingere ulteriormente la velocità di generazione, consulta Qwen 3.6 MTP vs Decodifica Standard su GPU 16GB — la decodifica speculativa MTP aggiunge fino al 67 % di throughput di generazione per il modello dense da 27B, con tabelle che mostrano il costo VRAM e il compromesso sulla finestra di contesto a ogni livello di --spec-draft-n-max.

Perché la lunghezza del contesto cambia i token al secondo

Man mano che si passa da 19K a 32K o 64K token, la KV cache cresce e la pressione sulla VRAM aumenta. Alcune righe mostrano un grande calo dei token al secondo a 64K, mentre altre restano stabili, il che è il segnale per riconsiderare quantizzazioni, limiti di contesto o offloading dei layer, piuttosto che dare per scontato che il modello sia “lento” in generale. Per il calcolo economico dietro questi numeri — la formula esatta per i byte KV per token, le tabelle del tipo di cache a 32K/64K/128K e come calcolare il proprio margine — consulta KV Cache su GPU 16 GB: Rendere il Contesto Lungo Effettivamente Adattabile.

I modelli e le quantizzazioni che ho scelto per i test sono per eseguire da solo e vedere se offrono un buon guadagno in termini di rapporto costo/beneficio su questa attrezzatura o no. Quindi niente quantizzazioni q8 con contesto da 200k qui :) …

GPU/CPU è un carico, misurato da nvitop.

llama.cpp, quando configura automaticamente lo scaricamento dei layer sulla GPU, cerca di mantenere liberi 1GB. Specifichiamo manualmente questo parametro tramite il parametro da riga di comando -ngl, ma qui non lo sto ottimizzando, mi serve solo capire che se c’è un calo significativo delle prestazioni aumentando la dimensione della finestra di contesto da 32k a 64k - possiamo provare ad aumentare la velocità su 64k ottimizzando il numero di layer non scaricati.

Hardware di test e configurazione llama.cpp

Ho testato la velocità dei LLM su un PC con questa configurazione:

CPU i-14700
RAM 64GB 6000Hz (2x32GB)
GPU RTX-4080
Ubuntu con driver NVidia
llama.cpp/llama-cli, nessun numero di layer non scaricato specificato
VRAM inizialmente utilizzata, prima di avviare llama-cli: 300MB

Esecuzioni extra a contesto 128K (Qwen3.5 27B e 122B)

Modello	128K Carico	128K: T/s
Qwen3.5-27B-UD-IQ3_XXS	16/625	9.6
Qwen3.5-122B-A10B-UD-IQ3_XXS	27/496	19.2

Esecuzioni Ottimizzate

Per alcuni modelli e quantizzazioni interessanti, ho provato a trovare parametri specifici da riga di comando per llama-cpp per sfruttare meglio la VRAM. Ecco ciò che sono riuscito a ottenere:

Modello	Contesto	Layer su GPU	Carico CPU/CPU	Velocità
Qwen3.5-27B-IQ4_XS.gguf	18k	65	98%/100%	38.0
Qwen3.5-27B-IQ4_XS.gguf	64k	53	33%/488%	15.7

Conclusione per build con 16 GB VRAM

Il mio attuale preferito Qwen3.5-27B-UD-IQ3_XXS sembra andare bene nel suo punto ideale a contesto 50k (sto ottenendo circa 36t/s)
Qwen3.5-122B-A10B-UD-IQ3_XXS sta superando in termini di prestazioni il Qwen3.5 27B sui contesti sopra i 64K.
Posso spingere Qwen3.5-35B-A3B-UD-IQ3_S a gestire contesto 100k token, e sta in vram, quindi nessun calo di prestazioni
Non userò gemma-4-31B su 16GB VRAM, ma gemma-4-26B potrebbe essere medio-bene…, devo testare.
Devo testare quanto bene funzionano Nemotron cascade 2 e GLM-4.7 Flash REAP 23B. saranno meglio del Qwen3.5-35B q3? Lo dubito ma comunque, potrei testare per confermare il sospetto.