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

Questo significa spesso che molti layer restano sulla CPU, causando un forte calo della velocità di token. Puoi provare ad aumentare l’offloading dei layer sulla GPU tramite ngl, scegliere una quantizzazione più piccola o ridurre il contesto in modo che una parte maggiore del modello risieda sulla GPU.

Come influisce una finestra di contesto più ampia sul numero di token al secondo su 16 GB di VRAM?

Un contesto più lungo aumenta la cache KV e l’utilizzo della VRAM, il che può ridurre i token al secondo o costringere a un offload parziale. Un contesto più breve, modelli più piccoli o quantizzazioni più aggressive aiutano a mantenere alte le prestazioni su una singola scheda da 16 GB.

Quali compromessi di quantizzazione sono rilevanti per l’adattamento di modelli di grandi dimensioni in 16 GB?

I quants a bit più bassi utilizzano meno VRAM e possono aumentare i token al secondo, ma potrebbero compromettere la qualità. I quants di stile IQ3 e IQ4 sono compromessi comuni per llama.cpp su una singola GPU da 16 GB quando è necessario un contesto lungo 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à di elaborazione in token al secondo poiché solo una parte della rete viene eseguita in ogni passaggio in avanti, ma è comunque necessaria sufficiente VRAM per gli esperti attivi, i pesi e la cache KV alla lunghezza del contesto scelta.

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

Regola il numero di layer caricati sulla GPU tramite ngl, accetta un contesto più breve se adatto al tuo compito, oppure passa a una quantizzazione più leggera affinché più layer restino sul dispositivo e si riduca la pressione sulla cache KV.

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

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

Indice

Qui confronto la velocità di diversi LLM (modelli linguistici di grandi dimensioni) in esecuzione su una GPU con 16 GB di VRAM, scegliendo il migliore per l’auto-hospitamento (self-hosting).

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

GPU stilizzata con blocchi VRAM e grafici in stile benchmark

In questo post registro i miei tentativi di spremere il massimo delle prestazioni in termini di velocità possibile.

Tabella di confronto della velocità dei 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) sopra indicato è il Carico della GPU. Se vedi un numero basso in questa colonna, significa che il modello sta girando prevalentemente sulla CPU e non riesce a raggiungere una velocità decente su questo hardware. Questo pattern corrisponde a ciò che si osserva quando una parte troppo piccola del modello entra nella GPU o quando il contesto sposta il carico di lavoro sull’host (CPU).

Informazioni su llama.cpp, prestazioni LLM, OpenCode e altri confronti

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

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

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

Migliori LLM per OpenCode - Testati Localmente. Puoi leggere di più su Opencode in OpenCode Quickstart: Installa, Configura e Usa l’Agente di Coding AI da Terminale
Confronto della qualità della traduzione delle pagine Hugo - LLM su Ollama

Ho eseguito test simili per i LLM su Ollama: Migliori LLM per Ollama su GPU con 16GB di 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 denso 27B, con tabelle che mostrano il costo della VRAM e il compromesso della finestra di contesto a ogni livello --spec-draft-n-max.

Perché la lunghezza del contesto cambia i token al secondo

Passando da 19K a 32K o 64K token, la cache KV cresce e la pressione sulla VRAM aumenta. Alcune righe mostrano un grande calo nei token al secondo a 64K, mentre altre rimangono stabili; questo è il segnale per rivalutare le quantizzazioni, i limiti del contesto o l’offloading dei layer, invece di assumere che il modello sia “lento” in generale.

I modelli e le quantizzazioni che ho scelto di testare sono stati selezionati per essere eseguiti personalmente e vedere se offrono un buon guadagno in termini di rapporto costo/beneficio su questa attrezzatura o meno. Quindi qui non troverai quantizzazioni q8 con contesto 200k :) …

GPU/CPU è il carico, misurato da nvitop.

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

Hardware di test e configurazione di 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 layer rilasciato specificato
VRAM utilizzata inizialmente, 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 (Finetuned Runs)

Per alcuni modelli e quantizzazioni interessanti ho provato a trovare parametri speciali della riga di comando di llama-cpp per sfruttare meglio la VRAM. Ecco cosa sono riuscito a ottenere:

Modello	Contesto	Layer sulla 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

Conclusioni per configurazioni con 16 GB di VRAM

Il mio attuale preferito Qwen3.5-27B-UD-IQ3_XXS si presenta bene nel suo punto ottimale di 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 superiori a 64K.
Posso spingere Qwen3.5-35B-A3B-UD-IQ3_S a gestire un contesto di 100k token, e entra nella vram, quindi nessun calo di prestazioni
Non userò gemma-4-31B su 16GB di VRAM, ma gemma-4-26B potrebbe andare mediamente bene…, devo testare.
Devo testare quanto bene funzionano Nemotron cascade 2 e GLM-4.7 Flash REAP 23B. Saranno migliori di Qwen3.5-35B q3? Ne dubito, ma comunque, potrei testare per confermare il sospetto.