Ograničenja i optimizacija Vision API-ja
Na ovoj stranici
Upoznaj ograničenja da bi ih zaobišao
Prethodnih deset lekcija pokrilo je ono u čemu Vision API excelira. Ova lekcija bavi se onim gdje posrće. To nije vježba poniznosti: razlika između demo prototipa koji oduševljava i aplikacije koja izdrži u produkciji svodi se točno na ovo. Ovdje ćeš naučiti o tehničkim ograničenjima, čestim zamkama—pri čemu su vizualne halucinacije najvažnije—te strategijama za optimizaciju troškova i kašnjenja (latencije).
Tehnička ograničenja
Već smo dotaknuli ograničenja formata, ali sada ćemo ih objediniti. Svaka slika ograničena je na otprilike 20 MB i ionako će biti interno promijenjena veličina, obično na 768x768 ili ekvivalentno: slika u 4K rezoluciji neće poboljšati rezultate. Prihvaćeni formati su JPEG, PNG, GIF (samo prvi kadar) i WebP. Vision API ne podržava izravno PDF—za to moraš koristiti Document AI, kako je raspravljeno u Lekciji 8.
Najstrukturnije ograničenje ostaje potrošnja tokena. Svaka slika troši značajan broj tokena, a ova funkcija pretvara tu procjenu u dolare umjesto u apstraktne jedinice:
# 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)
Usporedi dva poziva na kraju skripte: drugi košta desetke puta više od prvog. Pomnoži to sa svojim dnevnim volumenom prije donošenja odluke. Uz to, tu je i ograničenje kontekstnog prozora (context window), koje ukupan zbroj slika + prompta + odgovora ne smije prijeći—strop kojeg više slika doseže mnogo brže nego dugačak tekst.
Vizualne halucinacije
Model može „izmisliti“ detalje kojih nema na slici. To je najkritičniji problem u produkciji jer je tih: odgovor je dobro strukturiran, uvjerljiv i pogrešan.
Četiri se obrasca ponavljaju. Izmišljeni tekst, gdje model pročita riječ koja ne postoji na slici. Približni brojevi, gdje vrijednosti pročitane s grafikona mogu odstupati 5–15% od stvarnosti. Dodani detalji, gdje model popunjava ono što ne vidi jasno vjerojatnim informacijama—zamućeni SIRET broj postaje savršeno formatiran, ali lažan SIRET. Konačno, zabuna elemenata, gdje se dva obližnja objekta spajaju u jedan.
Postoje tri protumjere; kombiniraj ih ovisno o kritičnosti. Prvo, prisili model da kvalificira vlastitu sigurnost. Drugo, neka ponovno pročita sliku nakon transkripcije. Treće, suprotstavi dva modela istom pitanju i zadrži samo ono oko čega se slažu.
# 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
Dvostruko čitanje udvostručuje trošak: rezerviraj ga za iznose, identifikatore i sve što pokreće nepovratnu radnju.
Optimizacija troškova
Najisplativija optimizacija obrađena je u Lekciji 5, a najjednostavnija je: smanji veličinu slike prije slanja. Fotografija od 6 MB smanjena na 1024 piksela ne gubi ništa za potrebe analize i olakšava cijeli lanac.
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}"
Slijedi usmjeravanje prema složenosti: ne zaslužuje svaki zadatak najskuplji model. Dovoljna je funkcija od tri retka za odluku, pod uvjetom da si unaprijed klasificirao svoje zadatke.
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
Treća poluga je ona koju se najčešće zaboravlja: ne plaćaj dvaput za istu analizu. U produkciji se ista slika vraća češće nego što misliš—ponovno pokretanje procesa, duplicirana slanja ili ponovni pokušaj nakon incidenta. Diskovni predmemorija (cache) indeksirana hashom datoteke i promptom eliminira ove suvišne pozive.
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
Ključ uključuje prompt i model, a ne samo sliku: promjena pitanja na istoj fotografiji doista bi trebala pokrenuti novi poziv.
Optimizacija latencije
Za interaktivnu aplikaciju, četiri postavke utječu na percipirano vrijeme odgovora. Promijeni veličinu slika na strani klijenta na najviše 1024 piksela, što skraćuje vrijeme prijenosa. Odaberi Small ili Ministral, jer je njihova generacija znatno brža. Proslijedi slike putem URL-a kada su već hostane kako bi izbjegao slanje velikog Base64 tijela zahtjeva. Konačno, omogući streaming (strujanje), što ne smanjuje ukupno vrijeme, ali prikazuje odgovor dok se gradi:
# 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)
To je chat.stream koji zamjenjuje chat.complete; ostatak poruke je točno isti.
Kontrolni popis za produkciju
Prije raspoređivanja Vision aplikacije u produkciju, provjeri svaku od ovih točaka:
- Automatska promjena veličine slike (maks. 1024 px)
- Validacija formata i veličine prije slanja
- Rukovanje greškama API-ja (ponovni pokušaj, istek vremena, rezervna opcija)
- Predmemoriranje rezultata za identične slike
- Inteligentno usmjeravanje (Small za jednostavne, Large za složene zadatke)
- Praćenje troškova i latencije
- Testiranje sa slikama loše kvalitete (zamućene, niske rezolucije, rotirane)
- Strategija protiv halucinacija (razine sigurnosti, dvostruka verifikacija)
Pretposljednja točka je ona koju se najčešće preskače, a koja uzrokuje najveću štetu: izgradi skup podataka namjerno loših slika i pokreni ga prije svakog raspoređivanja.
Ključne točke
- Slike se interno mijenjaju veličinu—nema potrebe slati vrlo visoku rezoluciju
- Vizualne halucinacije su primarni rizik—zatraži razine sigurnosti
- Promjena veličine na strani klijenta najisplativija je optimizacija
- Usmjeravanje prema složenosti (Small naspram Large) smanjuje troškove za 90% kod jednostavnih zadataka
- Diskovna predmemorija izbjegava suvišne API pozive na istim slikama