Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Grænser og optimering af Vision API

Lektion 11 af 12 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Kend grænserne for at omgå dem
  2. Tekniske begrænsninger
  3. Visuelle hallucinationer
  4. Optimering af omkostninger
  5. Optimering af ventetid
  6. Produktions-tjekliste
  7. Vigtige pointer

Kend grænserne for at omgå dem

De foregående ti lektioner har dækket, hvad Vision API gør godt. Denne lektion fokuserer på, hvor det har svært ved at levere. Det handler ikke om ydmyghed: forskellen mellem en demo-prototype, der imponerer, og en applikation, der holder i produktion, afhænger netop af dette. Her lærer du om tekniske begrænsninger, faldgruber – især visuelle hallucinationer – og strategier til at optimere omkostninger og ventetid.

Tekniske begrænsninger

Vi har tidligere nævnt formatbegrænsninger, men lad os samle trådene. Hvert billede er begrænset til ca. 20 MB og vil under alle omstændigheder blive ændret internt, typisk til 768x768 eller tilsvarende: et 4K-billede vil ikke forbedre resultaterne. Accepterede formater er JPEG, PNG, GIF (kun første billede) og WebP. Vision API understøtter ikke PDF direkte – du skal bruge Document AI til det, som diskuteret i lektion 8.

Den mest strukturelle begrænsning er stadig token-forbrug. Hvert billede bruger et betydeligt antal tokens, og denne funktion omsætter estimatet til dollars i stedet for abstrakte enheder:

# Estimate the cost of a vision call
def estimate_cost(num_images=1, text_tokens=100, response_tokens=500,
                 tokens_per_image=1000, input_price=0.10, output_price=0.30):
    """Estimates the cost in dollars for a vision call (Small 3.2)."""
    input_tokens = (num_images * tokens_per_image) + text_tokens
    output_tokens = response_tokens

    input_cost = (input_tokens / 1_000_000) * input_price
    output_cost = (output_tokens / 1_000_000) * output_price
    total_cost = input_cost + output_cost

    print(f"Input tokens: {input_tokens} (${input_cost:.4f})")
    print(f"Output tokens: {output_tokens} (${output_cost:.4f})")
    print(f"Total cost: ${total_cost:.4f}")
    return total_cost

# 1 image with Small 3.2
estimate_cost(num_images=1)

# 5 images with Large 3
estimate_cost(num_images=5, input_price=2.00, output_price=6.00)

Sammenlign de to kald i slutningen af scriptet: det andet koster dusinvis af gange mere end det første. Gang det med dit daglige volumen, før du træffer en beslutning. Derudover er der grænsen for kontekstvinduet, som summen af billeder + prompt + svar ikke må overskride – et loft, som flere billeder når meget hurtigere end en lang tekst.

Visuelle hallucinationer

Modellen kan „opfinde” detaljer, der ikke findes på billedet. Dette er det mest kritiske problem i produktion, fordi det er lydløst: svaret er velstruktureret, troværdigt og forkert.

Fire mønstre går igen. Opfundet tekst, hvor modellen læser et ord, der ikke eksisterer på billedet. Omtrentlige tal, hvor værdier læst fra et diagram kan afvige 5–15 % fra virkeligheden. Tilføjede detaljer, hvor modellen udfylder det, den ikke ser tydeligt, med troværdige oplysninger – et sløret SIRET-nummer bliver til et perfekt formateret, men falsk SIRET. Endelig forveksling af elementer, hvor to nærliggende objekter smeltes sammen til ét.

Der findes tre modforholdsregler; kombinér dem baseret på kritikalitet. Først skal du tvinge modellen til at kvalificere sin egen sikkerhed. Dernæst skal du få den til at genlæse billedet efter transskription. Tredje mulighed er at sætte to modeller op mod hinanden på samme spørgsmål og kun beholde det, de er enige om.

# 1. Ask for a confidence level
prompt_confiance = """Analyze this image. For each piece of extracted information, indicate your confidence level:
- [CERTAIN]: clearly visible
- [PROBABLE]: partially visible or inferred
- [INCERTAIN]: barely legible, estimated

If an element is illegible, mark it [ILLISIBLE] rather than guessing."""

# 2. Ask for cross-verification
prompt_verification = """Read the text in this document. After transcribing, reread the image and verify every number and proper noun. Correct any detected errors."""

# 3. Double reading with two models
def double_verification(image_uri, question):
    """Sends the same image to two models and compares results."""
    resultats = {}
    for modele in ["mistral-small-latest", "mistral-large-latest"]:
        response = client.chat.complete(
            model=modele,
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": question},
                    {"type": "image_url", "image_url": image_uri}
                ]
            }]
        )
        resultats[modele] = response.choices[0].message.content

    return resultats

Dobbeltlæsning fordobler omkostningerne: reserver det til beløb, identifikatorer og alt, der udløser en irreversibel handling.

Optimering af omkostninger

Den mest omkostningseffektive optimering blev dækket i lektion 5, og den er den enkleste: reducer billedstørrelsen før afsendelse. Et 6 MB-foto, der ændres til 1024 pixels, mister intet i forhold til analyseformål og letter hele kæden.

from PIL import Image
from io import BytesIO
import base64

def optimiser_image(chemin, taille_max=1024, qualite=80):
    """Resizes and compresses an image for the Vision API."""
    img = Image.open(chemin)
    taille_originale = img.size

    # Resize
    if max(img.size) > taille_max:
        img.thumbnail((taille_max, taille_max))

    # Compress as JPEG
    buffer = BytesIO()
    img.convert("RGB").save(buffer, format="JPEG", quality=qualite)
    taille_fichier = buffer.tell()

    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")

    print(f"Original: {taille_originale} | Optimized: {img.size} | Size: {taille_fichier/1024:.0f} KB")
    return f"data:image/jpeg;base64,{b64}"

Dernæst kommer routing baseret på kompleksitet: ikke hver opgave fortjener den dyreste model. En funktion på tre linjer er nok til at beslutte det, forudsat at du har klassificeret dine opgaver på forhånd.

def choose_model(task):
    """Selects the optimal model based on the task."""
    simple_tasks = ["classification", "ocr_simple", "description", "triage"]
    complex_tasks = ["extraction_json", "comparaison", "analyse_graphique", "raisonnement"]

    if task in simple_tasks:
        return "mistral-small-latest"  # ~$0.10/M tokens
    else:
        return "mistral-large-latest"  # ~$2.00/M tokens

Den tredje løftestang er den, der oftest glemmes: betal ikke to gange for samme analyse. I produktion vender det samme billede oftere tilbage, end du tror – genkørsel af en proces, dobbelte sendinger eller genforsøg efter en hændelse. En disk-cache indekseret på fil-hash og prompt eliminerer disse redundante kald.

import hashlib
import json
from pathlib import Path

CACHE_DIR = Path("cache_vision/")
CACHE_DIR.mkdir(exist_ok=True)

def analyser_avec_cache(image_path, prompt, modele="mistral-small-latest"):
    """Analyzes an image with disk caching."""
    # Generate a cache key
    with open(image_path, "rb") as f:
        image_hash = hashlib.md5(f.read()).hexdigest()
    cache_key = hashlib.md5(f"{image_hash}{prompt}{modele}".encode()).hexdigest()
    cache_file = CACHE_DIR / f"{cache_key}.json"

    # Check cache
    if cache_file.exists():
        return json.loads(cache_file.read_text())

    # API call
    response = client.chat.complete(
        model=modele,
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": prompt},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )

    resultat = response.choices[0].message.content

    # Save to cache
    cache_file.write_text(json.dumps(resultat, ensure_ascii=False))
    return resultat

Nøglen inkluderer promptet og modellen, ikke kun billedet: at ændre spørgsmålet på samme foto bør faktisk udløse et nyt kald.

Optimering af ventetid

For en interaktiv applikation påvirker fire indstillinger den oplevede svartid. Ændr størrelsen på billeder på klientsiden til maksimalt 1024 pixels, hvilket forkorter upload-tiden. Vælg Small eller Ministral, da deres generering er betydeligt hurtigere. Send billeder via URL, når de allerede er hostet, for at undgå at sende en stor Base64-request-body. Endelig skal du aktivere streaming, hvilket ikke reducerer den samlede tid, men viser svaret, mens det bygges op:

# Streaming for a progressive response
stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image."},
            {"type": "image_url", "image_url": image_url}
        ]
    }]
)

for chunk in stream:
    if chunk.data.choices[0].delta.content:
        print(chunk.data.choices[0].delta.content, end="", flush=True)

Det er chat.stream, der erstatter chat.complete; resten af beskeden er præcis den samme.

Produktions-tjekliste

Før du udruller en Vision-applikation til produktion, skal du verificere hvert af disse punkter:

  • Automatisk ændring af billedstørrelse (maks. 1024 px)
  • Validering af format og størrelse før afsendelse
  • Håndtering af API-fejl (genforsøg, timeout, fallback)
  • Caching af resultater for identiske billeder
  • Intelligent routing (Small til simple, Large til komplekse)
  • Overvågning af omkostninger og ventetid
  • Test med billeder i dårlig kvalitet (slørede, lav opløsning, roterede)
  • Strategi mod hallucinationer (sikkerhedsniveauer, dobbeltverifikation)

Det næstsidste punkt er det, der oftest springes over, og det, der forårsager mest skade: opbyg et datasæt med bevidst dårlige billeder og kør det før hver udrulning.

Vigtige pointer

  • Billeder ændres internt – ingen grund til at sende meget høj opløsning
  • Visuelle hallucinationer er den primære risiko – bed om sikkerhedsniveauer
  • Størrelsesændring på klientsiden er den mest omkostningseffektive optimering
  • Routing baseret på kompleksitet (Small vs. Large) skærer omkostningerne med 90 % på simple opgaver
  • Disk-caching undgår redundante API-kald på de samme billeder