Limity a optimalizace Vision API
Na této stránce
Poznej limity, abys je dokázal obejít
Předchozích deset lekcí pokrývalo to, co Vision API zvládá dobře. Tato lekce se zaměřuje na oblasti, kde naráží na obtíže. Není to cvičení pokory: rozdíl mezi demo prototypem, který ohromí, a aplikací, která obstojí v produkci, spočívá přesně v tomhle. Zde se naučíš o technických omezeních, běžných pastech – v čele s vizuálními halucinacemi – a strategiích pro optimalizaci nákladů a latence.
Technická omezení
Už jsme se dříve dotkli omezení formátů, ale teď si je shrneme. Každý obrázek je omezen přibližně na 20 MB a stejně bude interně změněna jeho velikost, typicky na 768×768 nebo ekvivalent: obrázek ve 4K nezlepší výsledky. Akceptované formáty jsou JPEG, PNG, GIF (pouze první snímek) a WebP. Vision API nepodporuje přímo PDF – pro to musíš využít Document AI, jak jsme probírali v lekci 8.
Nejzásadnějším omezením zůstává spotřeba tokenů. Každý obrázek spotřebuje značné množství tokenů a tato funkce převádí tento odhad na dolary místo abstraktních jednotek:
# 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)
Porovnej tato dvě volání na konci skriptu: druhé stojí desítkykrát více než první. Vynásob si to svým denním objemem, než se rozhodneš. K tomu připočti limit kontextového okna, který nesmí být překročen součtem obrázků + promptu + odpovědi – tento strop dosáhnou multiple obrázky mnohem rychleji než dlouhý text.
Vizuální halucinace
Model může „vymyslet“ detaily, které na obrázku chybí. To je v produkci nejkritičtější problém, protože probíhá tiše: odpověď je dobře strukturovaná, věrohodná a špatná.
Opakují se čtyři vzorce. Vymyšlený text, kdy model přečte slovo, které na obrázku neexistuje. Přibližná čísla, kde hodnoty přečtené z grafu mohou mít odchylku 5–15 % od reality. Přidané detaily, kdy model doplní to, co nevidí jasně, věrohodnými informacemi – rozmazané číslo SIRET se stane perfektně naformátovaným, ale falešným SIRET. Nakonec záměna prvků, kdy jsou dva blízké objekty sloučeny do jednoho.
Existují tři protiopatření; kombinuj je podle míry kritičnosti. Zaprvé, přinuť model, aby kvalifikoval svou vlastní jistotu. Zadruhé, nech ho po přepsání textu obrázek znovu přečíst. Zatřetí, postav proti sobě dva modely se stejnou otázkou a ponech si pouze to, na čem se shodnou.
# 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
Dvojí čtení zdvojnásobí náklady: vyhraď si ho pro částky, identifikátory a vše, co spouští nevratnou akci.
Optimalizace nákladů
Nejnákladově efektivnější optimalizaci jsme probírali v lekci 5 a je nejjednodušší: před odesláním zmenši velikost obrázku. Fotografie o velikosti 6 MB zmenšená na 1024 pixelů nic neztrácí pro účely analýzy a odlehčí celý řetězec.
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}"
Dalším krokem je směrování podle složitosti: ne každý úkol si zaslouží ten nejdražší model. Stačí třířádková funkce k rozhodnutí, za předpokladu, že jsi své úkoly předem 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
Třetí pákou je ta nejčastěji zapomínaná: neplať dvakrát za stejnou analýzu. V produkci se stejný obrázek vrací častěji, než bys čekal – opětovné spuštění procesu, duplicitní odeslání nebo opakování po incidentu. Disková mezipaměť indexovaná podle hashi souboru a promptu eliminuje tato redundantní volání.
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
Klíč zahrnuje prompt i model, nejen obrázek: změna otázky u stejné fotky by skutečně měla spustit nové volání.
Optimalizace latence
U interaktivní aplikace ovlivňují vnímanou dobu odezvy čtyři nastavení. Změň velikost obrázků na straně klienta na maximum 1024 pixelů, což zkrátí dobu nahrávání. Vyber Small nebo Ministral, protože jejich generování je výrazně rychlejší. Předávej obrázky pomocí URL, pokud jsou již hostovány, abys避免 odesílání velkého těla požadavku v Base64. Nakonec povol streamování, které nesníží celkový čas, ale zobrazí odpověď, jakmile se vytváří:
# 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 místo chat.complete; zbytek zprávy je přesně stejný.
Kontrolní seznam pro produkci
Před nasazením aplikace Vision do produkce ověř každý z těchto bodů:
- Automatická změna velikosti obrázků (max 1024 px)
- Ověření formátu a velikosti před odesláním
- Zpracování chyb API (opakování, časový limit, záložní řešení)
- Ukládání výsledků do mezipaměti pro identické obrázky
- Inteligentní směrování (Small pro jednoduché, Large pro složité)
- Monitorování nákladů a latence
- Testování s nekvalitními obrázky (rozmazané, nízké rozlišení, otočené)
- Strategie proti halucinacím (úrovně jistoty, dvojí ověření)
Předposlední bod je ten, který se nejčastěji vynechává, a ten, který způsobuje největší škody: vytvoř sadu dat záměrně špatných obrázků a spusť ji před každým nasazením.
Klíčové poznatky
- Obrázky jsou interně měněny na menší velikost – není třeba odesílat velmi vysoké rozlišení
- Vizuální halucinace jsou hlavním rizikem – žádej o úrovně jistoty
- Změna velikosti na straně klienta je nejefektivnější optimalizací nákladů
- Směrování podle složitosti (Small vs. Large) snižuje náklady o 90 % u jednoduchých úkolů
- Disková mezipaměť zabraňuje redundantním voláním API pro stejné obrázky