Limity a optimalizácia Vision API
Na tejto strane
Poznaj limity, aby si ich dokázal obísť
Predchádzajúcich desať lekcií pokrylo to, čo Vision API zvláda dobre. Táto lekcia sa zameriava na oblasti, kde má problémy. Nie je to cvičenie pokory: rozdiel medzi demo prototypom, ktorý ohúri, a aplikáciou, ktorá obstojí v produkcii, spočíva presne v tomto. Tu sa naučíš o technických obmedzeniach, bežných pasciach – pričom vizuálne halucinácie sú tou najväčšou – a stratégiách na optimalizáciu nákladov a latencie.
Technické limity
Už sme sa dotkli obmedzení formátov, ale teraz si ich zhrňme. Každý obrázok je obmedzený na približne 20 MB a aj tak bude interne zmenšený, typicky na 768x768 alebo ekvivalent: obrázok v rozlíšení 4K nezlepší výsledky. Akceptované formáty sú JPEG, PNG, GIF (iba prvý snímok) a WebP. Vision API nepodporuje priamo PDF – na to musíš použiť Document AI, ako sme diskutovali v lekcii 8.
Najzásadnejším obmedzením zostáva spotreba tokenov. Každý obrázok spotrebuje významné množstvo tokenov a táto funkcia prepočítava tento odhad na doláre namiesto abstraktných jednotiek:
# 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)
Porovnaj tieto dva volania na konci skriptu: druhé stojí desaťkrát viac ako prvé. Vynásob si to svojím denným objemom skôr, než sa rozhodneš. K tomu sa pridáva limit kontextového okna, ktorý nesmie byť prekročený súčtom obrázkov + promptu + odpovede – tento strop dosiahneš pri viacerých obrázkoch oveľa rýchlejšie než pri dlhom texte.
Vizuálne halucinácie
Model môže „vymyslieť“ detaily, ktoré na obrázku nie sú prítomné. Toto je najkritickejší problém v produkcii, pretože je tichý: odpoveď je dobre štruktúrovaná, vierohodná a nesprávna.
Vyskytujú sa štyri opakujúce sa vzorce. Vymyslený text, kde model prečíta slovo, ktoré na obrázku neexistuje. Približné čísla, kde hodnoty prečítané z grafu sa môžu líšiť o 5 – 15 % od reality. Pridané detaily, kde model doplní to, čo nevidí jasne, vierohodnými informáciami – rozmazané číslo SIRET sa stane perfektne naformátovaným, ale falošným číslom SIRET. Nakoniec zámena prvkov, kde sa dva blízke objekty zlúčia do jedného.
Existujú tri protiopatrenia; kombinuj ich podľa miery kritickosti. Po prvé, prinúť model, aby kvalifikoval svoju vlastnú istotu. Po druhé, nechaj ho znovu prečítať obrázok po prepise. Po tretie, postav proti sebe dva modely s tou istou otázkou a ponechaj si len to, na čom sa zhodnú.
# 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
Dvojité čítanie zdvojnásobuje náklady: vyhradź si ho pre sumy, identifikátory a všetko, čo spúšťa nezvratnú akciu.
Optimalizácia nákladov
Nákladovo najefektívnejšiu optimalizáciu sme pokryli v lekcii 5 a je aj najjednoduchšia: zmenši veľkosť obrázka pred odoslaním. Fotografia s veľkosťou 6 MB zmenšená na 1024 pixelov nestráca nič z hľadiska analýzy a odľahčí celý reťazec.
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}"
Ďalej prichádza smerovanie podľa zložitosti: nie každá úloha si zaslúži najdrahší model. Na rozhodovanie stačí trojriadková funkcia, za predpokladu, že si svoje úlohy vopred klasifikoval.
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
Tretia páka je tá, na ktorú sa najčastejšie zabúda: neplať dvakrát za tú istú analýzu. V produkcii sa ten istý obrázok vracia častejšie, než by si čakal – opätovné spustenie procesu, duplicitné odoslania alebo opakovanie po incidente. Disková medzipamäť indexovaná podľa hashu súboru a promptu eliminuje tieto nadbytočné volania.
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
Kľúč zahŕňa prompt aj model, nielen obrázok: zmena otázky pri tej istej fotografii by mala skutočne spustiť nové volanie.
Optimalizácia latencie
Pre interaktívnu aplikáciu ovplyvňujú vnímaný čas odozvy štyri nastavenia. Zmeň veľkosť obrázkov na strane klienta na maximum 1024 pixelov, čo skráti čas nahrávania. Vyber si Small alebo Ministral, keďže ich generovanie je výrazne rýchlejšie. Odovzdávaj obrázky cez URL, ak sú už hostované, aby sa vyhlo odoslaniu veľkého tela požiadavky v Base64. Nakoniec povoľ streamovanie, ktoré neznižuje celkový čas, ale zobrazuje odpoveď postupne, ako sa vytvára:
# 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)
Je to chat.stream namiesto chat.complete; zvyšok správy je presne rovnaký.
Kontrolný zoznam pre produkciu
Pred nasadením aplikácie Vision do produkcie over každý z týchto bodov:
- Automatická zmena veľkosti obrázkov (max 1024 px)
- Validácia formátu a veľkosti pred odoslaním
- Ošetrenie chýb API (opakovanie, časový limit, záložné riešenie)
- Ukladanie výsledkov do medzipamäte pre identické obrázky
- Inteligentné smerovanie (Small pre jednoduché, Large pre zložité)
- Monitorovanie nákladov a latencie
- Testovanie s obrázkami zlej kvality (rozmazané, nízke rozlíšenie, otočené)
- Stratégia proti halucináciám (úrovne istoty, dvojitá verifikácia)
Predposledný bod je ten, ktorý sa najčastejšie vynecháva, a práve ten spôsobuje najväčšie škody: vytvor dataset úmyselne zlých obrázkov a spusti ho pred každým nasadením.
Kľúčové poznatky
- Obrázky sa interne zmenšujú – nie je potrebné odosielať veľmi vysoké rozlíšenie
- Vizuálne halucinácie sú hlavným rizikom – pýtaj si úrovne istoty
- Zmena veľkosti na strane klienta je najnákladovo efektívnejšia optimalizácia
- Smerovanie podľa zložitosti (Small vs. Large) znižuje náklady o 90 % pri jednoduchých úlohách
- Disková medzipamäť zabraňuje nadbytočným volaniam API pre tie isté obrázky