A Vision API korlátai és optimalizálása
Ezen az oldalon
Ismerd a korlátokat, hogy megkerülhesd őket
Az előző tíz lecke azt mutatta be, miben erős a Vision API. Ez a lecke arra fókuszál, hol akadnak nehézségei. Ez nem az alázat gyakorlása: a különbség egy lenyűgöző demo prototípus és egy éles környezetben is megálló alkalmazás között pontosan ebben rejlik. Itt megtanulod a technikai korlátokat, a gyakori buktatókat – amelyek közül a legfontosabb a vizuális hallucináció –, valamint a költség- és késleltetés-optimalizálási stratégiákat.
Technikai korlátok
Már érintettük a formátum-korlátozásokat, de most foglaljuk őket össze. Minden kép mérete maximum körülbelül 20 MB lehet, és a rendszer amúgy is átméretezi őket belsőleg, jellemzően 768x768 képpontra vagy ezzel egyenértékűre: egy 4K-s kép nem javít az eredményeken. Az elfogadott formátumok: JPEG, PNG, GIF (csak az első kocka) és WebP. A Vision API nem támogatja közvetlenül a PDF-et – ehhez a Document AI-t kell hívnod, ahogy arról a 8. leckében szó volt.
A legstrukturálisabb korlát továbbra is a tokenfogyasztás. Minden kép jelentős számú tokent emészt fel, és ez a függvény ezt a becslést dollárra váltja át absztrakt egységek helyett:
# 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)
Hasonlítsd össze a szkript végén lévő két hívást: a második többszöröseibe kerül az elsőnek. Szorozd ezt meg a napi volumeneddel, mielőtt döntést hoznál. Ehhez járul még a kontextusablak korlátja, amelyet a képek + prompt + válasz összességének nem szabad túllépnie – ez egy olyan plafon, amelyet több kép sokkal gyorsabban elér, mint egy hosszú szöveg.
Vizuális hallucinációk
A modell képes olyan részleteket „kitalálni“, amelyek nincsenek jelen a képen. Ez a legkritikusabb probléma éles környezetben, mert néma: a válasz jól felépített, hihető, és mégis hibás.
Négy minta ismétlődik. Kitalált szöveg, ahol a modell olyan szót olvas ki, ami nincs is a képen. Hozzávetőleges számok, ahol a diagramból kiolvasott értékek 5–15%-kal térhetnek el a valóságtól. Hozzáadott részletek, ahol a modell kiegészíti azt, amit nem lát tisztán, hihető információkkal – egy elmosódott SIRET-számból tökéletesen formázott, de hamis SIRET lesz. Végül az elemek összekeverése, ahol két közeli tárgyat egybeolvaszt a modell.
Három ellentevés létezik; kombináld őket a kritikalitás alapján. Először, kényszerítsd ki, hogy a modell minősítse saját bizonyosságát. Másodszor, olvasd vissza vele a képet a transzkripció után. Harmadszor, állíts szembe két modellt ugyanazzal a kérdéssel, és csak azt tartsd meg, amiben megegyeznek.
# 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
A dupla olvasás megduplázza a költséget: csak összegekre, azonosítókra és minden olyan esetre tartogasd, ami visszafordíthatatlan műveletet indít el.
Költségek optimalizálása
A legköltséghatékonyabb optimalizálást az 5. leckében tárgyaltuk, és ez a legegyszerűbb is: csökkentsd a képméretet elküldés előtt. Egy 6 MB-os fotó 1024 képpontra való átméretezése semmit sem veszít el elemzési szempontból, és megkönnyíti az egész láncolatot.
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}"
Ezt követi a komplexitás szerinti útvonalválasztás: nem minden feladat érdemli meg a legdrágább modellt. Egy háromsoros függvény is elég a döntéshez, feltéve, hogy előre osztályoztad a feladataidat.
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
A harmadik emelő a leggyakrabban elfeledett: ne fizess kétszer ugyanazért az elemzésért. Éles környezetben ugyanaz a kép sokkal gyakrabban tér vissza, mint gondolnád – egy folyamat újrafuttatása, ismételt küldések vagy egy incidens utáni újrapróbálkozás miatt. Egy fájlkivonaton (hash) és prompton alapuló lemezes gyorsítótár kiküszöböli ezeket a felesleges hívásokat.
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
A kulcs tartalmazza a promptot és a modellt is, nem csak a képet: ugyanazon a fotón a kérdés megváltoztatása valóban új hívást kell, hogy indítson.
Késleltetés optimalizálása
Egy interaktív alkalmazásnál négy beállítás befolyásolja az észlelt válaszidőt. Méretezd át a képeket kliens oldalon maximum 1024 képpontra, ami lerövidíti a feltöltési időt. Válaszd a Small vagy Ministral modelleket, mivel ezek generálása jelentősen gyorsabb. Küldd a képeket URL-en keresztül, ha azok már hosztolva vannak, hogy elkerüld egy nagy Base64-es kéréstörzs elküldését. Végül engedélyezd a streamelést, ami nem csökkenti a teljes időt, de megjeleníti a választ, ahogy az felépül:
# 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)
Itt a chat.stream helyettesíti a chat.complete-et; az üzenet többi része pontosan ugyanaz marad.
Ellenőrző lista élesítéshez
Mielőtt egy Vision alkalmazást éles környezetbe telepítenél, ellenőrizd az alábbi pontokat:
- Automatikus képátméretezés (max. 1024 px)
- Formátum- és méretellenőrzés küldés előtt
- API-hibakezelés (újrapróbálkozás, időtúllépés, tartalék megoldás)
- Eredmények gyorsítótárazása azonos képeknél
- Intelligens útvonalválasztás (Small az egyszerű, Large a komplex feladatokhoz)
- Költség- és késleltetésfigyelés
- Tesztelés rossz minőségű képekkel (elmosódott, alacsony felbontású, elforgatott)
- Hallucinációellenes stratégia (bizonyossági szintek, dupla ellenőrzés)
A második utolsó pont az, amit a leggyakrabban kihagynak, és ami a legtöbb kárt okozza: készíts egy szándékosan rossz képekből álló adathalmazt, és futtasd le minden telepítés előtt.
Főbb megállapítások
- A képeket a rendszer belsőleg átméretezi – nincs szükség nagyon nagy felbontás küldésére
- A vizuális hallucinációk az elsődleges kockázatot jelentik – kérj bizonyossági szinteket
- A kliens oldali átméretezés a legköltséghatékonyabb optimalizálás
- A komplexitás szerinti útvonalválasztás (Small vs. Large) 90%-kal csökkenti a költségeket az egyszerű feladatoknál
- A lemezes gyorsítótár elkerüli a felesleges API-hívásokat ugyanazon képeknél