Grænser og optimering af Vision API
På denne side
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