GGUF kwantisatie: Q4_K_M vs Q6_K vs Q8_0 gemeten

👁 114 keer gelezen

Wat is GGUF kwantisatie en welk formaat moet je kiezen? Q4_K_M vormt het praktische minimum, terwijl Q5_K_M en Q6_K vrijwel niet te onderscheiden zijn van het origineel en Q8_0 vooral nuttig is wanneer VRAM geen rol speelt. In mijn overzicht over lokale AI modellen leg ik de basisprincipes uit, maar hieronder zet ik alle harde metingen op een rij.

Wat te kiezen: het overzicht in het kort

• Q4_K_M: De kleinste variant waarbij tekstkwaliteit niet merkbaar instort. Een 11B-model in Q4_K_M is 6,72 GB groot en voorspelt in 94,1% van de gevallen exact hetzelfde token als Q8_0.
• Q5_K_M en Q6_K: De beste balans als je grafische geheugen het toelaat. Het verschil in perplexity ten opzichte van Q8_0 valt binnen de meetfout.
• Q8_0: Vrijwel identiek aan het origineel (96,7% tokengelijkheid met F16 bij het 1.5B-model), maar bijna dubbel zo zwaar als Q4_K_M en een stuk langzamer in generatie.
• Q3_K_M en lager: Alleen geschikt als noodoplossing bij grote modellen. Een klein 1.5B-model in Q2_K stort volledig in (0 van de 12 taken succesvol).
• Een groter model in Q4 presteert beter dan een kleiner model in Q8. Bielik 11B in Q3_K_M (5,40 GB) loste 11 van de 12 taken op, terwijl Bielik 4.5B in Q8_0 (5,06 GB) bleef steken op 5 van de 12.

Wat is GGUF?

GGUF is een binair bestandsformaat ontwikkeld door ggml-org (de makers van llama.cpp) en is in gebruik sinds augustus 2023. Één bestand bevat zowel de modelgewichten als de benodigde metadata: modelarchitectuur, tokenizer, chatsjabloon en de maximale contextlengte. Daardoor laad je hetzelfde bestand in llama.cpp, in programma’s zoals beschreven in mijn vergelijking tussen Ollama vs LM Studio, of via interfaces zoals Open WebUI.

De officiële specificatie hanteert een vaste naamstructuur: Naam-Grootte-Finewash-Versie-Codering.gguf. Bij een bestand als Bielik-11B-v3.0-Instruct.Q4_K_M.gguf geeft het laatste deel aan welke kwantisatie is toegepast.

Wat betekent GGUF kwantisatie: Q4_K_M, Q6_K, Q8_0, F16 en IQ

Kwantisatie betekent dat de gewichten van het model worden opgeslagen met minder bits per gewicht. Het ongecomprimeerde origineel bewaart elk gewicht in 16 bits (F16 of BF16). Q8_0 brengt dit terug naar ongeveer 8,5 bits, en Q4_K_M gebruikt minder dan 5 bits. Hierdoor wordt het bestand compacter, past het in minder VRAM en genereert het sneller omdat het geheugenkanaal van de videokaart minder data hoeft te verplaatsen.

De exacte bits per gewicht zijn afkomstig uit de officiële documentatie van llama-quantize (gemeten op Llama 3.1 8B). De letter K staat voor k-quants: gewichten worden verdeeld in superblokken van 256, waarbij ook de schaalfactoren worden gecomprimeerd. De toevoegingen _S, _M, _L slaan op gemengde precisie: bij Q4_K_M krijgen de meest gevoelige tensors een hogere resolutie (Q6_K). IQ duidt op nieuwere niet-lineaire methoden. Een imatrix (belangrijkheidsmatrix) berekent via een tekstfragment welke gewichten cruciaal zijn om afrondingsfouten te minimaliseren.

Mijn metingen op de RTX 4090

Op 17 oktober 2026 heb ik alle formaten gemeten op mijn eigen pc met een RTX 4090 24 GB, Intel i9-14900KF, 64 GB RAM en Windows 11. Ik gebruikte llama.cpp met CUDA, waarbij het volledige model op de videokaart werd geladen.

• Bestanden: Officiële F16 en Q8_0 van Bielik 1.5B v3.0 en Q8_0 van 4.5B en 11B via speakleash op Hugging Face (met geverifieerde sha256-hashes). Overige varianten genereerde ik via llama-quantize (1.5B vanuit F16, 4.5B en 11B vanuit Q8_0 vanwege mijn downloadlimiet van 5 GB). Voor 11B testte ik ook de officiële Q4_K_M via Ollama.
• Perplexity en tokengelijkheid: Gemeten met llama-perplexity bij een contextlengte van 2048 op een literaire prozatekst van Zofia Nałkowska (circa 7900 woorden, publiek domein). Gelijkheid toont het percentage tokens waarbij het meest waarschijnlijke token overeenkomt met de basisversie (F16 bij 1.5B, Q8_0 bij 4.5B en 11B).
• Snelheid: Gemeten via llama-bench, generatie van 128 tokens, gemiddelde van 3 herhalingen.
• VRAM: Toename in nvidia-smi tijdens het draaien van llama-server met context 4096.
• Taken: Een praktijktest van 12 korte opdrachten met één exact antwoord (grammatica, correctie, rekenen, JSON, getallen voluit schrijven), temperatuur 0.

Bielik 1.5B: de volledige ladder van F16 tot Q2_K

Een model van 1.5B parameters is feitelijk te compact voor veeleisende logica, ongeacht de kwantisatie: zelfs in F16 gaf het foute antwoorden op historische feiten. In Q3_K_M werden auteursnamen verwisseld, en Q2_K herhaalde bij een jaartalvraag simpelweg continu hetzelfde getal.

Bielik 11B: van Q8_0 naar Q3_K_M

De officiële Q4_K_M en mijn eigen conversie vanuit Q8_0 leverden vrijwel identieke prestaties op (108,0 vs 109,1 tok/s, beiden 10/12 op de takenlijst).

Belangrijkste inzichten uit de data

• Tot en met Q5_K_M vallen de verschillen in perplexity binnen de meetfout (circa ±0,10 bij 11B). Pas bij Q4_K_M bij kleine modellen of Q3_K_M bij grotere modellen daalt de overeenstemming merkbaar.
• Hoe groter het model, hoe beter het bestand is tegen kwantisatie. Q4_K_M behield bij 11B een tokengelijkheid van 94,1%, vergeleken met 83,6% bij 1.5B en 82,7% bij 4.5B.
• Een imatrix levert gratis kwaliteitswinst: Q4_K_M met een belangmatrix steeg bij 1.5B van 83,6% naar 88,1% tokengelijkheid bij exact dezelfde bestandsgrootte.
• Korte praktijktaken tonen weinig verschil bij 11B: scores van 9 tot 11 uit 12 weerspiegelen toevalsmarges in afzonderlijke formuleringen. Perplexity en overeenstemming van tokens geven een betrouwbaarder technisch beeld.
• Perplexity op een bekende tekst (zoals Prus’ klassieker) kwam uit op 1,20, wat bewijst dat het model die tekst uit het hoofd kende. Vandaar dat ik een andere tekst gebruikte. Vergelijk getallen niet tussen 1.5B en 11B: door afwijkende tokenizers telt hetzelfde fragment respectievelijk 14.767 en 23.760 tokens.

Welke kwantisatie kies je per videokaart?

De getoonde VRAM-cijfers betreffen alleen het model in llama-server. Houd rekening met Windows en software op de achtergrond, die doorgaans 1 tot 2 GB VRAM opeisen.

• 8 GB VRAM: Bielik 11B in Q3_K_M (6,3 GB bij 4096 context) of Bielik 4.5B in Q8_0 (5,3 GB). Een 11B in Q4_K_M vergt 7,5 GB en zit daarmee gevaarlijk strak op de limiet.
• 12 GB VRAM: Bielik 11B in Q4_K_M of Q5_K_M (7,5 tot 8,6 GB), waardoor er voldoende geheugen overblijft voor langere contexten.
• 16 GB VRAM: Bielik 11B in Q6_K (9,7 GB) of Q4_K_M met volledige 32.768 context (13,0 GB).
• 24 GB VRAM: Bielik 11B in Q8_0 draait zelfs op 32.768 context moeiteloos (17,7 GB). Als alternatief kun je een aanzienlijk zwaarder model draaien in Q4_K_M, zoals getest in mijn analyse van Gemma 4 31B lokaal. Bekijk ook het overzicht van lokale AI vs API kosten om te zien of eigen hardware loont.

Zelf kwantisaties vergelijken: stappenplan

1. Download llama.cpp van de officiële GitHub-pagina van ggml-org (kies voor NVIDIA de release met CUDA) en pak dit uit in bijvoorbeeld D:\llama-cuda.
2. Download 2 of 3 kwantisaties van hetzelfde model naar één map via de Hugging Face CLI: hf download speakleash/Bielik-11B-v3.0-Instruct-GGUF Bielik-11B-v3.0-Instruct.Q4_K_M.gguf --local-dir D:\modele.
3. Controleer de integriteit via Get-FileHash D:\modele\*.gguf en vergelijk de sha256-hash met de repository.
4. Plaats een UTF-8 tekstbestand met enkele duizenden woorden klaar dat het model niet uit zijn trainingsdata kent.
5. Voer het onderstaande PowerShell-script uit om snelheid en perplexity automatisch naar een tabel en CSV weg te schrijven.

PowerShell benchmarkscript: porownaj-kwantyzacje.ps1

Getest op 17 oktober met twee Bielik 1.5B-bestanden. Op de processor alleen (-Warstwy 0) gaf Q4_K_M een perplexity van 54,31 tegenover 54,27 op de GPU.

# porownaj-kwantyzacje.ps1 - porównanie kwantyzacji GGUF w llama.cpp (
# Dla każdego pliku .gguf w folderze: rozmiar, szybkość (llama-bench: prompt 512 i generowanie 128 tokenów, 3 powtórzenia)
# i opcjonalnie perplexity na Twoim pliku tekstowym (llama-perplexity, kontekst 2048). Wynik: tabela + plik CSV.
#
# Użycie (PowerShell):
#   powershell -ExecutionPolicy Bypass -File .\porownaj-kwantyzacje.ps1 -Modele D:\modele -Llama D:\llama-cuda -Tekst D:\tekst.txt
# -Modele  folder z plikami .gguf (różne kwantyzacje tego samego modelu)
# -Llama   folder z llama-bench.exe i llama-perplexity.exe (paczka llama.cpp z GitHuba ggml-org, wersja CUDA dla kart NVIDIA)
# -Tekst   (opcjonalnie) plik .txt w UTF-8, najlepiej 5-20 tysięcy słów po polsku; bez niego tylko szybkość
# -Warstwy (opcjonalnie) ile warstw na GPU, domyślnie 99 = wszystkie
param(
    [Parameter(Mandatory = $true)][string]$Modele,
    [Parameter(Mandatory = $true)][string]$Llama,
    [string]$Tekst = "",
    [int]$Warstwy = 99
)
$ErrorActionPreference = "Continue"   # llama.cpp pisze logi na stderr - "Stop" w PowerShell 5.1 przerwałby skrypt
$bench = Join-Path $Llama "llama-bench.exe"
$ppl = Join-Path $Llama "llama-perplexity.exe"
if (-not (Test-Path $bench)) { throw "Nie ma $bench - podaj folder z rozpakowanym llama.cpp w -Llama" }
$pliki = Get-ChildItem -Path $Modele -Filter *.gguf | Sort-Object Length -Descending
if ($pliki.Count -eq 0) { throw "W folderze $Modele nie ma plików .gguf" }
if ($Tekst -and -not (Test-Path $Tekst)) { throw "Nie ma pliku tekstowego $Tekst" }

$wyniki = @()
foreach ($p in $pliki) {
    Write-Host "== $($p.Name)" -ForegroundColor Cyan
    $w = [ordered]@{ Plik = $p.Name; GB = [math]::Round($p.Length / 1e9, 2); Prompt_tok_s = ""; Generowanie_tok_s = ""; Perplexity = "" }

    # 1. Szybkość: llama-bench zwraca JSON (jedna pozycja dla pp512, druga dla tg128)
    $json = & $bench -m $p.FullName -p 512 -n 128 -r 3 -ngl $Warstwy -o json 2>$null | Out-String
    $start = $json.IndexOf("[")
    if ($start -ge 0) {
        foreach ($e in ($json.Substring($start) | ConvertFrom-Json)) {
            if ($e.n_prompt -gt 0) { $w.Prompt_tok_s = [math]::Round($e.avg_ts, 1) } else { $w.Generowanie_tok_s = [math]::Round($e.avg_ts, 1) }
        }
    } else { Write-Host "llama-bench nie zwrócił wyniku (za mało VRAM? spróbuj -Warstwy 20)" -ForegroundColor Yellow }

    # 2. Perplexity (im niżej, tym lepiej; porównuj tylko pliki tego samego modelu na tym samym tekście)
    if ($Tekst) {
        $log = & $ppl -m $p.FullName -f $Tekst -c 2048 -ngl $Warstwy 2>&1 | Out-String
        $m = [regex]::Match($log, "Final estimate: PPL = ([\d.]+)")
        if ($m.Success) { $w.Perplexity = [double]::Parse($m.Groups[1].Value, [Globalization.CultureInfo]::InvariantCulture) }
        else { Write-Host "llama-perplexity: brak wyniku (tekst za krótki? potrzeba min. ok. 4100 tokenów)" -ForegroundColor Yellow }
    }
    $wyniki += [pscustomobject]$w
    Writ

Wie Ollama gebruikt, hoeft niets handmatig te converteren: het commando ollama run SpeakLeash/bielik-11b-v3.0-instruct:Q4_K_M downloadt exact dezelfde gewichten als de Hugging Face repository (gecontroleerd via de sha256-hash van de modellaag).

Veelgestelde vragen

Bronnen

• ggml-org: GGUF-formaatspecificatie
• llama.cpp: llama-quantize documentatie
• llama.cpp PR 1684: beschrijving k-quants
• Hugging Face: speakleash/Bielik-11B-v3.0-Instruct-GGUF
• Hugging Face: speakleash/Bielik-4.5B-v3.0-Instruct-GGUF
• Hugging Face: speakleash/Bielik-1.5B-v3.0-Instruct-GGUF
• Ollama: SpeakLeash/bielik-11b-v3.0-instruct modelkaart
• llama.cpp releases overzicht
• Metingen van 17 oktober 2026: RTX 4090, llama.cpp CUDA build 11194, 17 GGUF-varianten

Gecontroleerd op 17 oktober 2026.

// lees verderClaude Opus 5.5 effort levels: low, medium of high - verschil gemetenBenchmarksGoogle AI Ultra: wat krijg je en wanneer is het de moeite waard?HandleidingenOffice voor €160 of gratis? Dit lever je inHandleidingen

Kinetyra