
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.
| Typ | Ungefärlig cacheandel mot f16 | Förslag till provordning |
|---|---|---|
| f16 | Referens | Utgångsläge och kontrollkörning |
| q8_0 | 1/2 | Första alternativet att undersöka |
| q4_0 | 1/4 | Extra 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
- Ollama: FAQ om cachetyper, Flash Attention, parallellitet och miljövariabler i Windows.
- Ollama: Troubleshooting om loggar och felsökningsläge.
- Ollama: Generate a response om förfrågans fält, tokenräknare och tidsenheter.
- Ollama: List running models om digest, kontext och viktkvantisering för laddade modeller.
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.