Bildanalys med Ollama: lokal visionsmodell läser bilden, ditt facit mäter svaret

Du vill att en modell ska beskriva en bild, svara på om ett visst föremål finns med eller sortera bilder efter innehåll, men bilderna ska inte lämna datorn. Ollama kan köra visionsmodeller lokalt. Enligt visionsdokumentationen tar sådana modeller emot bilder tillsammans med text och kan beskriva, klassificera och svara på frågor om det de ser. Hur ofta svaren stämmer står däremot ingenstans, och det är du som behöver ta reda på det för dina egna bilder.

Guiden visar tre sätt att skicka en bild: terminalen, REST-API:t och Python. Sedan bygger du ett facitprov som ger ett räknebart resultat. Redaktionen har inte Ollama installerat på arbetsdatorn, så kommandona är kontrollerade mot dokumentationen 31 oktober 2026 men inte körda här, och guiden redovisar inga egna mätresultat.

1. Välj en modell märkt vision

Alla modeller tar inte emot bilder. I Ollamas katalog filtrerar du fram dem med kategorin vision. Listan blandar modeller du hämtar och kör själv med poster som också är märkta cloud. Ska bilden stanna på datorn, välj en modell utan molnmärkning och gör kontrollerna i OCR-artikeln, som visar hur du stänger av molnfunktionerna och provar offline.

Guiden använder gemma4, eftersom Ollamas egen visionsdokumentation och CLI-referens gör det. Det är inte ett påstående om att den är bäst; katalogen anger inte vilken modell som träffar rätt oftast. Läs modellsidan för storlek innan du hämtar, och hämta modellen innan provet så att nedladdningen inte blandas ihop med första svaret:

ollama pull gemma4

2. Fråga om en bild i terminalen

Snabbstarten i visionsdokumentationen skriver bildens sökväg direkt i prompten:

ollama run gemma4 ./image.png what is in this image?

Lägg en egen bild i en mapp utan mellanslag i sökvägen, döp den till bild.png och ställ frågan på svenska från samma mapp:

ollama run gemma4 ./bild.png Vad finns på bilden? Svara kort.

CLI-referensen visar också ett skrivsätt där frågan och sökvägen står i samma citerade sträng, med sökvägen sist; hur sökvägar med mellanslag tolkas beskrivs inte, därav mappen ovan. Facit för steget: svaret beskriver något som faktiskt syns i bilden. Får du ett allmänt svar som inte nämner bilden alls, kontrollera att modellen är märkt vision och att sökvägen pekar på en befintlig fil.

3. Skicka bilden till REST-API:t som base64

Via API:t lägger du bilden i en images-array. Visionssidan säger att biblioteken tar filsökvägar, URL:er eller råa bytes, medan REST-API:t förväntar sig base64-kodad bilddata. I API-referensen är images ett valfritt fält i meddelandet till /api/chat, och bilderna ska ges som en array där varje bild är base64-kodad. Dokumentationens exempel är skrivet för ett bash-skal (Linux, macOS eller WSL). Dess första steg laddar ned en exempelbild till test.jpg; döp din egen bild till det namnet och kör steg 2 och 3:

# 2. Encode the image
IMG=$(base64 < test.jpg | tr -d '\n')

# 3. Send it to Ollama
curl -X POST http://localhost:11434/api/chat \
-H "Content-Type: application/json" \
-d '{
    "model": "gemma4",
    "messages": [{
    "role": "user",
    "content": "What is in this image?",
    "images": ["'"$IMG"'"]
    }],
    "stream": false
}'

I Windows PowerShell gör du samma sak med .NET-metoden Convert.ToBase64String. Varianten nedan är redaktionens översättning av exemplet, inte Ollamas:

$bild = [Convert]::ToBase64String([IO.File]::ReadAllBytes("$PWD\bild.png"))
$body = @{
  model    = "gemma4"
  messages = @(@{ role = "user"; content = "Vad finns på bilden? Svara kort."; images = @($bild) })
  stream   = $false
} | ConvertTo-Json -Depth 5
$svar = Invoke-RestMethod http://localhost:11434/api/chat -Method Post -ContentType "application/json; charset=utf-8" -Body ([Text.Encoding]::UTF8.GetBytes($body))
$svar.message.content

Två detaljer avgör om det fungerar. Skriv hela sökvägen med $PWD, eftersom en .NET-metod kan tolka en relativ sökväg mot en annan katalog än den PowerShell visar. Och sätt stream till false; enligt API-referensen kommer svaret då som ett enda objekt, med texten i message.content. Adressen localhost:11434 i alla exempel är din egen dator. Endpointen /api/generate tar också bilder, då som fältet images direkt i anropet.

Varken visionssidan eller API-referensen anger någon gräns för antal bilder, bildformat eller filstorlek; exemplen använder en PNG och en JPEG. Börja med en bild per fråga och pröva det du behöver i ditt eget facitprov.

4. Gör samma anrop från Python

Med Ollamas Python-bibliotek skickar du filsökvägen direkt, utan egen kodning. Exemplet följer visionsdokumentationen, med en fast sökväg i stället för dokumentationens input()-fråga:

from ollama import chat

path = 'bild.png'

response = chat(
  model='gemma4',
  messages=[
    {
      'role': 'user',
      'content': 'What is in this image? Be concise.',
      'images': [path],
    }
  ],
)

print(response.message.content)

Dokumentationens kommentarer visar att du också kan lägga base64-data eller råa bytes i images. Facit för steg 2 till 4 är detsamma: tre svar om samma bild som beskriver samma föremål. Svarar de olika, notera det.

5. Mät träffsäkerheten med ett facitprov

En beskrivning som låter rimlig säger lite om hur ofta modellen har rätt. Bygg därför ett prov där svaret går att räkna. Förslaget nedan är redaktionens metod:

• Välj tio egna bilder vars innehåll du känner väl, till exempel köket, skrivbordet och ett foto från en promenad.
• Skriv tre ja/nej-frågor per bild innan du kör modellen, och facit bredvid. Minst en fråga per bild ska gälla något som inte finns med, så att facit är nej.
• Spara frågorna som facit.csv med UTF-8-kodning i samma mapp som bilderna.

fil,fraga,facit
kok.jpg,Finns det en kaffekopp på bilden?,ja
kok.jpg,Finns det en katt på bilden?,nej
kok.jpg,Är fönstret öppet?,nej

Prompten och poängen ska mäta samma sak. Skriptet ställer därför varje fråga med svarsalternativen ja, nej och vet inte, ber om svaret som JSON enligt ett schema (API-referensen anger att format kan vara ett JSON-schema) och jämför svaret med facitkolumnen. Inställningen seed 101 och temperature 0 kommer från API-referensens exempel för reproducerbara svar och gör omkörningar jämförbara; identiska svar lovar källan inte.

$schema = @{ type = "object"; properties = @{ svar = @{ type = "string"; enum = @("ja", "nej", "vet inte") } }; required = @("svar") }
$resultat = foreach ($r in Import-Csv "$PWD\facit.csv" -Encoding UTF8) {
  $bild = [Convert]::ToBase64String([IO.File]::ReadAllBytes("$PWD\$($r.fil)"))
  $body = @{
    model    = "gemma4"
    messages = @(@{ role = "user"; content = "$($r.fraga) Svara bara ja, nej eller vet inte."; images = @($bild) })
    stream   = $false
    format   = $schema
    options  = @{ seed = 101; temperature = 0 }
  } | ConvertTo-Json -Depth 8
  $svar = Invoke-RestMethod http://localhost:11434/api/chat -Method Post -ContentType "application/json; charset=utf-8" -Body ([Text.Encoding]::UTF8.GetBytes($body))
  try { $modell = ($svar.message.content | ConvertFrom-Json).svar } catch { $modell = "ogiltigt" }
  [pscustomobject]@{ fil = $r.fil; fraga = $r.fraga; facit = $r.facit; modell = $modell; ratt = ($modell -eq $r.facit) }
}
$resultat | Format-Table fil, facit, modell, ratt
"{0} av {1} ratt" -f @($resultat | Where-Object ratt).Count, @($resultat).Count
$resultat | Export-Csv "$PWD\resultat.csv" -NoTypeInformation -Encoding UTF8

Schemat är en beställning, inte ett löfte: API-referensen säger inget om att modellen håller sig till svarsalternativen. Därför räknas allt annat än ja, nej eller vet inte som fel, och ett svar som inte går att tolka som JSON som ogiltigt.

6. Läs resultatet efter feltyp

Siffran längst ned är en början, men felen är olika allvarliga. Sortera resultat.csv i tre högar:

Med 30 frågor motsvarar ett enda fel drygt 3 procentenheter, så skillnader på ett par frågor mellan två modeller säger lite. Gör den fria beskrivningen från steg 2 till en andra kontroll: stryk under varje påstående i svaret och markera det som stämmer, fel eller går inte att avgöra mot ditt facit. Kör om hela provet när du byter modell eller tagg och skriv upp modellnamn, tagg och Ollama-version bredvid resultatet; siffran gäller bara den kombination du faktiskt har kört och de bilder du valt.

Så vet du att du är klar

• Samma bild har gett ett svar i terminalen, via /api/chat och från Python.
• resultat.csv finns och visar hur många frågor modellen besvarade rätt, med antalet påhittade ja redovisat för sig.
• Du vet vilka frågor modellen inte klarar på dina bilder och har antecknat modell, tagg och version.

Källor och metod

• Ollama, Vision: vad visionsmodeller gör, terminalkommandot, images-arrayen, base64 i REST-API:t, cURL- och Python-exemplen.
• Ollama, API-referensen (docs/api.md): fältet images i /api/chat och /api/generate, stream, format som JSON-schema och exemplet med seed och temperature.
• Ollama, visionsmodeller i katalogen: filtret och märkningen cloud.
• Ollama, CLI-referensen: ollama pull gemma4 och skrivsättet med sökvägen i prompten.
• Microsoft Learn, Convert.ToBase64String: base64-kodningen i PowerShell-varianten.

Källorna kontrollerades 31 oktober 2026. Ollama var inte installerat på redaktionens dator, så inga kommandon har körts mot en modell. PowerShell-skripten är syntaxkontrollerade men inte provkörda, och guiden anger inga träffsäkerheter, modellstorlekar eller minneskrav. Facitprovet är ditt eget.