ArtikelLokal AI

KV-cache i Ollama: spara minne utan att byta modell

Med samma modell och kontext kan en annan cachetyp ge mer minnesmarginal. Jämför f16 med q8_0, kontrollera vad servern faktiskt körde och bedöm svaren mot ett facit.

Publicerad · Senast granskad

Ett öppet chassi i mörk metall med tre gröna minnesmoduler i rad, en svart enhet och en kylfläns, upplyst av grönt sken mot mörk bakgrund.
Cachetypen avgör hur mycket minne kontexten tar. Provet visar om vinsten håller med samma modell och samma kontext.

Modellen fungerar med en kort fråga, men marginalen krymper när du arbetar med längre underlag. Då är KV-cachens typ värd ett eget prov. Behåll modellen och kontexten, ändra en inställning och kontrollera både minne och svar. Börja med f16 som referens och välj ett annat läge först när din egen körning ger stöd för det.

Håll isär vikterna, cachen och totalminnet

Modellens viktkvantisering och KV-cachens typ är två olika inställningar. Ollamas API redovisar exempelvis modellens quantization_level i modelldetaljerna, medan cachetypen väljs separat för servern. Använd därför samma modell med samma digest i jämförelsen, annars kan ett modellbyte förklara resultatet. Se API-dokumentationen för laddade modeller. Avvägningen mellan Q4, Q5 och Q8 för vikterna finns i artikeln om kvantisering; här ligger vikterna fast.

I Ollamas FAQ anges tre cachetyper: f16 som standard, q8_0 med ungefär halva cacheminnet och q4_0 med ungefär en fjärdedel. Andelarna gäller cachen. Läs dem inte som halvering eller fjärdedelning av datorns totala minnesanvändning. FAQ:n knyter kvantiserad cache till Flash Attention och säger att kvalitetspåverkan beror på modell och uppgift.

Dokumenterade cachelägen, inte uppmätta resultat
TypUngefärlig cacheandel mot f16Förslag till provordning
f16ReferensUtgångsläge och kontrollkörning
q8_01/2Första alternativet att undersöka
q4_01/4Extra prov om du behöver mer marginal

Utgå från en avgränsad fråga: får du mer användbar minnesmarginal med godtagbara svar i just ditt arbetsflöde? Budgeten för hela körningen, med vikter, cache, runtime och operativsystem, räknar du fram i hårdvaruguiden för lokal AI. Vill du i stället hitta en rimlig kontextstorlek börjar du i artikeln om Ollamas kontextgräns. Här håller du kontexten fast.

Bestäm vad som ska vara lika

Skriv ett försökskort innan du startar: Ollamaversion, operativsystem, GPU och drivrutin, modellnamn och digest, viktkvantisering, num_ctx, parallellitet, prompt och genereringsinställningar. Ange även vilket verktyg du tänker läsa minnet med. Använd samma verktyg och enhet i samtliga omgångar.

Välj en kontext som du faktiskt använder. Provet nedan begär 4 096 token som ett uttryckligt provvärde, inte som en rekommendation för alla modeller. Om modellen eller backend ändrar begäran dokumenterar du det effektiva värdet och gör om jämförelsen på samma villkor. Parallellitet påverkar också minnesbehovet enligt FAQ:n. Provet begär därför en parallell förfrågan och kör förfrågningarna efter varandra.

Planera tre omgångar: f16-a, q8 och f16-b. Provskriptet skapar en resultatmapp per omgång. Den sista omgången upprepar referensen. Om de två referenserna skiljer sig kraftigt i minne eller svar ska du undersöka försöksmiljön innan du tillskriver skillnaden cachetypen.

Starta servern med rätt miljö

Avsluta först Ollama i aktivitetsfältet och kontrollera att ingen annan server svarar på samma port. Starta sedan en manuell server från det PowerShell-fönster där du anger variablerna. Byt bara cachetyp mellan omgångarna. Inställningen gäller globalt för serverns modeller, enligt FAQ:n.

# Windows PowerShell 5.1, serverfönstret. Kör från din provmapp.
$env:OLLAMA_FLASH_ATTENTION = '1'
$env:OLLAMA_KV_CACHE_TYPE = 'f16' # nästa omgång: 'q8_0'
$env:OLLAMA_NUM_PARALLEL = '1'
$env:OLLAMA_DEBUG = '1'
ollama serve 2>&1 | Tee-Object -FilePath '.\f16-a-server.log'

Ollama dokumenterar att automatisk Flash Attention beror på backend och enheter. Variabeln ovan begär läget; den visar inte att körningen använder det. OLLAMA_DEBUG ger mer detaljerad loggning. Efter varje omgång stoppar du servern med Ctrl+C och startar nästa med ett nytt loggfilnamn, exempelvis q8-server.log. Stäng provfönstret när du är klar, så att variablerna inte följer med när du startar din vanliga Ollama igen.

Kontrollera utfallet innan du jämför

Läs laddnings- och runnerdelen av loggen efter att modellen har laddats. Leta efter uppgifter om faktisk backend, Flash Attention, cachetyp, kontext, parallellitet och minnesallokering. Sökord som KV, cache och flash hjälper dig hitta avsnittet, men en träff på den begärda miljövariabeln räcker inte. Notera var varje uppgift kommer ifrån. Felsökningsguiden beskriver terminalutdata för manuellt startad server och Windowsappens loggfiler, och artikeln om Ollamas loggar hjälper dig tolka dem.

Hittar du ingen tydlig bekräftelse av tillämpad cachetyp skriver du ”ej verifierad”. Behåll råloggen och dra ingen slutsats om kvantiserad cache från den omgången. Behandla även ett startfel, en varning eller ett ändrat körläge som ett resultat att undersöka. Tvinga inte fram en lyckad jämförelse genom att byta fler inställningar mitt i försöket.

Provskriptet sparar svaret från /api/ps före och efter körningen. Det ger underlag för att kontrollera modelldigest och rapporterad kontext. Komplettera med ollama ps för CPU/GPU-placering. Varken placeringen eller ett sammanfattande storleksvärde ersätter en bekräftelse av cachetypen.

Kör samma uppgift och bedöm mot samma facit

Skriptet nedan gör en uppvärmningsförfrågan och sparar sedan tre svar samt rådata från API:t. Spara det som jamfor-cache.ps1 i provmappen med kodningen UTF-8 med BOM, så att Windows PowerShell 5.1 läser å, ä och ö rätt. Kör det i ett andra PowerShell-fönster medan servern är igång och ange modellen med -Model. Modellen måste redan finnas lokalt: skriptet hämtar ingen modell och väljer inte cachetyp åt servern.

powershell -ExecutionPolicy Bypass -File .\jamfor-cache.ps1 -Model 'DIN-MODELL' -RunName f16-a
#requires -Version 5.1
[CmdletBinding()]
param(
    [Parameter(Mandatory=$true)][string]$Model,
    [Parameter(Mandatory=$true)][ValidateSet('f16-a','q8','f16-b','q4')][string]$RunName,
    [string]$OutputRoot = $PSScriptRoot
)
$ErrorActionPreference = 'Stop'
# En redan startad lokal server väljer cachetypen. Skriptet ändrar den inte.
$runPath = Join-Path $OutputRoot $RunName
if (Test-Path -LiteralPath $runPath) {
    throw 'Resultatmappen finns redan. Välj en ny rot för att bevara tidigare rådata.'
}
New-Item -ItemType Directory -Path $runPath | Out-Null
$prompt = @'
Underlaget innehåller exakt tre påhittade orderrader:
A103 | 2026-10-02 | betald
B204 | 2026-10-03 | obetald
C305 | 2026-10-03 | betald
Ange order-id för ordern med datum 2026-10-03 och status obetald.
Svara med endast order-id, utan annan text.
'@
$payload = @{
    model = $Model
    prompt = $prompt
    stream = $false
    keep_alive = '10m'
    options = @{ num_ctx = 4096; temperature = 0; seed = 42; num_predict = 128 }
}
$json = $payload | ConvertTo-Json -Depth 8
$json | Set-Content -LiteralPath (Join-Path $runPath 'request.json') -Encoding UTF8
$utf8 = [System.Text.Encoding]::UTF8.GetBytes($json)
$warmup = Invoke-RestMethod -Uri 'http://127.0.0.1:11434/api/generate' -Method Post -ContentType 'application/json; charset=utf-8' -Body $utf8 -TimeoutSec 600
$warmup | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath (Join-Path $runPath 'warmup.json') -Encoding UTF8
Invoke-RestMethod -Uri 'http://127.0.0.1:11434/api/ps' | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath (Join-Path $runPath 'ps-before.json') -Encoding UTF8
$results = @()
for ($i = 1; $i -le 3; $i++) {
    $response = Invoke-RestMethod -Uri 'http://127.0.0.1:11434/api/generate' -Method Post -ContentType 'application/json; charset=utf-8' -Body $utf8 -TimeoutSec 600
    $response | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath (Join-Path $runPath ('response-{0}.json' -f $i)) -Encoding UTF8
    $tokensPerSecond = $null
    if ($response.eval_duration -gt 0) {
        $tokensPerSecond = $response.eval_count * 1000000000.0 / $response.eval_duration
    }
    $results += [pscustomobject]@{
        run = $RunName
        repetition = $i
        exact_match = ([string]$response.response).Trim() -ceq 'B204'
        done = $response.done
        done_reason = $response.done_reason
        prompt_eval_count = $response.prompt_eval_count
        eval_count = $response.eval_count
        eval_duration_ns = $response.eval_duration
        tokens_per_second = $tokensPerSecond
        effective_cache_type = 'ej verifierad'
        effective_flash_attention = 'ej verifierad'
        log_reference = $null
        ram_measurement = $null
        vram_measurement = $null
        separate_kv_memory = $null
        memory_tool_and_unit = $null
    }
}
$results | Export-Csv -LiteralPath (Join-Path $runPath 'results.csv') -NoTypeInformation -Encoding UTF8
Invoke-RestMethod -Uri 'http://127.0.0.1:11434/api/ps' | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath (Join-Path $runPath 'ps-after.json') -Encoding UTF8
Write-Output ('Rådata sparade i {0}. Granska logg, placering, fel och svar före slutsats.' -f $runPath)

Kontrollfrågan använder tre påhittade orderrader och ber modellen ange order-id för rätt kombination av datum och status. Facit är exakt B204. Läs det som en kontroll av försökskedjan. Vill du bedöma den kontext du arbetar med lägger du till ett fryst, längre underlag från din egen uppgift och använder samma underlag och frågor i varje läge.

Bestäm bedömningen före första svaret: godkänt betyder rätt id utan extra text, och det är vad skriptets kolumn exact_match kontrollerar. För din riktiga uppgift kan kriteriet vara att samtliga efterfrågade belopp och datum återges korrekt, utan tillagda uppgifter. Kräv samma prestation av f16 och q8_0. En kortare eller mer välformulerad text är inte automatiskt ett bättre svar när uppgiften är att extrahera fakta.

Genererings-API:t dokumenterar tokenräknare och tidsvärden i nanosekunder. Skriptet sparar dem tillsammans med svaret. Tolka hastighet först efter att du har granskat fel och svarskvalitet. Ett svar som avbryts eller missar facit ska inte vinna på en kort generationstid.

Skriv ett beslut med rätt räckvidd

För varje omgång fyller du i begärd och verifierad cachetyp, loggreferens, minnesverktyg, uppmätt RAM och VRAM med enhet, CPU/GPU-placering, tokenräknare och antal godkända svar av tre. Håll redovisat cacheminne separat från processminne och hela GPU:ns minnesanvändning. Om verktyget inte visar cachen separat lämnar du den kolumnen tom.

Välj q8_0 om ditt dokumenterade prov visar tillräcklig marginal och godtagbara svar. Behåll f16 om vinsten är oklar, kvaliteten inte håller eller det effektiva läget inte kan styrkas. Testa q4_0 när du har ett konkret behov och kan bedöma svaren lika noggrant, med samma skript och -RunName q4. Formulera slutsatsen med modell, kontext och miljö: ”det här fungerade för den här uppgiften”. Ett nytt underlag eller en annan backend motiverar en ny kontroll.

FAQ

Är KV-cache samma sak som modellens viktkvantisering?

Nej. Behåll samma modell och viktkvantisering när du jämför cachetyper, så att försöket undersöker cacheinställningen.

Halverar q8_0 hela minnesanvändningen?

Ollamas ungefärliga halvering gäller cacheminnet jämfört med f16. Den beskriver inte hela körningens RAM eller VRAM.

Visar miljövariabeln att cachetypen används?

Nej. Kontrollera den effektiva körningen i loggen och markera cachetypen som ej verifierad om underlaget inte räcker.

När ska jag behålla f16?

Behåll referensläget när vinsten är oklar, svaren inte klarar dina krav eller det effektiva cacheläget inte kan verifieras.


Källor och metod

Källorna kontrollerades 14 november 2026. Provskriptet är syntaxkontrollerat i Windows PowerShell 5.1 men inte kört mot en modell. Artikeln innehåller inga egna mätvärden för minne, hastighet eller svarskvalitet.