Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Limieten en optimalisatie van de Vision API

Les 11 van 12 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Ken de limieten om ze te omzeilen
  2. Technische limieten
  3. Visuele hallucinaties
  4. Kosten optimaliseren
  5. Latentie optimaliseren
  6. Productiechecklist
  7. Belangrijkste punten

Ken de limieten om ze te omzeilen

De vorige tien lessen behandelden waarin de Vision API uitblinkt. Deze les focust op waar de API moeite mee heeft. Dit is geen oefening in nederigheid: het verschil tussen een demo-prototype dat indruk maakt en een applicatie die standhoudt in productie, hangt precies hiervan af. Hier leert u over technische beperkingen, veelvoorkomende valkuilen—waarbij visuele hallucinaties de belangrijkste zijn—en strategieën om kosten en latentie te optimaliseren.

Technische limieten

We hebben eerder al formatbeperkingen aangestipt, maar laten we ze samenvoegen. Elke afbeelding is beperkt tot ongeveer 20 MB en wordt intern toch verkleind, doorgaans naar 768x768 of equivalent: een 4K-afbeelding verbetert de resultaten niet. Geaccepteerde formaten zijn JPEG, PNG, GIF (alleen het eerste frame) en WebP. De Vision API ondersteunt PDF niet direct; daarvoor moet u Document AI aanroepen, zoals besproken in Les 8.

De meest structurele beperking blijft het tokenverbruik. Elke afbeelding verbruikt een aanzienlijk aantal tokens, en deze functie vertaalt die schatting naar dollars in plaats van abstracte eenheden:

# 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)

Vergelijk de twee aanroepen aan het einde van het script: de tweede kost tientallen keren meer dan de eerste. Vermenigvuldig dit met uw dagelijkse volume voordat u een beslissing neemt. Daar komt nog de limiet van het contextvenster bij, die het totaal van afbeeldingen + prompt + antwoord niet mag overschrijden; een plafond dat bij meerdere afbeeldingen veel sneller wordt bereikt dan bij een lange tekst.

Visuele hallucinaties

Het model kan details “verzinnen” die niet in de afbeelding staan. Dit is het meest kritieke probleem in productie omdat het stilzwijgend gebeurt: het antwoord is goed gevormd, aannemelijk en fout.

Vier patronen keren terug. Verzonnen tekst, waarbij het model een woord leest dat niet in de afbeelding staat. Benaderende getallen, waarbij waarden uit een grafiek 5–15% kunnen afwijken van de werkelijkheid. Toegevoegde details, waarbij het model invult wat het niet duidelijk ziet met aannemelijke informatie—een wazig SIRET-nummer wordt een perfect geformatteerd maar nep SIRET-nummer. Tot slot elementverwarring, waarbij twee nabije objecten tot één worden samengevoegd.

Er bestaan drie tegenmaatregelen; combineer deze op basis van kritikaliteit. Forceer het model eerst om zijn eigen zekerheid te kwalificeren. Laat het vervolgens de afbeelding opnieuw lezen na het transcriberen. Zet tot slot twee modellen tegenover dezelfde vraag en houd alleen vast wat ze overeenkomen.

# 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

Dubbel lezen verdubbelt de kosten: reserveer dit voor bedragen, identificatiecodes en alles wat een onomkeerbare actie activeert.

Kosten optimaliseren

De meest kosteneffectieve optimalisatie werd behandeld in Les 5, en het is de simpelste: verklein de afbeelding voordat u deze verzendt. Een foto van 6 MB die wordt verkleind naar 1024 pixels verliest niets voor analysedoeleinden en licht de hele keten op.

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}"

Daarna komt routing op basis van complexiteit: niet elke taak verdient het duurste model. Een functie van drie regels volstaat om dit te beslissen, mits u uw taken vooraf hebt geclassificeerd.

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

De derde hefboom wordt het vaakst vergeten: betaal niet tweemaal voor dezelfde analyse. In productie keert dezelfde afbeelding vaker terug dan u denkt—het opnieuw uitvoeren van een proces, dubbele verzendingen of opnieuw proberen na een incident. Een schijfcache geïndexeerd op de bestandshash en prompt elimineert deze redundante aanroepen.

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

De sleutel bevat de prompt en het model, niet alleen de afbeelding: het wijzigen van de vraag bij dezelfde foto moet inderdaad een nieuwe aanroep activeren.

Latentie optimaliseren

Voor een interactieve applicatie beïnvloeden vier instellingen de waargenomen responstijd. Verklein afbeeldingen aan de clientzijde tot maximaal 1024 pixels, wat de uploadtijd verkort. Kies Small of Ministral, aangezien hun generatie aanzienlijk sneller is. Geef afbeeldingen door via URL wanneer ze al gehost zijn om het verzenden van een grote Base64-request-body te vermijden. Schakel tot slot streaming in; dit vermindert de totale tijd niet, maar toont het antwoord terwijl het wordt opgebouwd:

# 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)

Het is chat.stream dat chat.complete vervangt; de rest van het bericht is exact hetzelfde.

Productiechecklist

Controleer elk van deze punten voordat u een Vision-applicatie naar productie deployt:

  • Automatisch verkleinen van afbeeldingen (max. 1024 px)
  • Validatie van formaat en grootte voordat verzending plaatsvindt
  • Afhandeling van API-fouten (opnieuw proberen, time-out, fallback)
  • Resultaten cachen voor identieke afbeeldingen
  • Intelligente routing (Small voor eenvoudig, Large voor complex)
  • Monitoring van kosten en latentie
  • Testen met afbeeldingen van slechte kwaliteit (wazig, lage resolutie, gedraaid)
  • Anti-hallucinatie strategie (zekerheidsniveaus, dubbele verificatie)

Het op een na laatste punt is degene die het vaakst wordt overgeslagen, en degene die de meeste schade veroorzaakt: bouw een dataset met bewust slechte afbeeldingen en voer deze uit vóór elke deployment.

Belangrijkste punten

  • Afbeeldingen worden intern verkleind—het is niet nodig om een zeer hoge resolutie te verzenden
  • Visuele hallucinaties zijn het primaire risico—vraag om zekerheidsniveaus
  • Verkleinen aan de clientzijde is de meest kosteneffectieve optimalisatie
  • Routing op basis van complexiteit (Small vs. Large) verlaagt de kosten met 90% bij eenvoudige taken
  • Schijfcaching voorkomt redundante API-aanroepen bij dezelfde afbeeldingen