Omejitve in optimizacija Vision API
Na tej strani
Spoznaj omejitve, da jih lahko obideš
Prejšnjih deset lekcij je pokrilo tisto, kar Vision API počne dobro. Ta lekcija pokriva področja, kjer ima težave. To ni vaja v skromnosti: razlika med demonstracijskim prototipom, ki navduši, in aplikacijo, ki zdrži v produkcijskem okolju, tiči prav v tem. Tu se boš naučil o tehničnih omejitvah, pogostih pasteh – med katerimi so vizualne halucinacije najpomembnejše – in strategijah za optimizacijo stroškov in zakasnitve.
Tehnične omejitve
Že smo se dotaknili omejitev formatov, vendar jih zdaj zberimo skupaj. Vsaka slika je omejena na približno 20 MB in bo tako ali tako interno spremenjena, običajno na 768x768 ali enakovredno: slika 4K ne bo izboljšala rezultatov. Sprejeti formati so JPEG, PNG, GIF (samo prvi okvir) in WebP. Vision API neposredno ne podpira PDF-jev – za to moraš poklicati Document AI, kot smo razpravljali v 8. lekciji.
Najbolj strukturna omejitev ostaja poraba žetonov. Vsaka slika porabi veliko število žetonov, ta funkcija pa to oceno pretvori v dolarje namesto v abstraktne enote:
# 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)
Primerjaj oba klica na koncu skripte: drugi stane več desetkratnik prvega. To pomnoži s svojim dnevnim obsegom, preden sprejmeš odločitev. Poleg tega obstaja še omejitev okna konteksta, ki je ne smejo preseči vsota slik + poziv + odgovor – to mejo več slik doseže veliko hitreje kot dolg tekst.
Vizualne halucinacije
Model lahko „izumi” podrobnosti, ki jih na sliki ni. To je v produkcijskem okolju najbolj kritična težava, ker je tiha: odgovor je dobro oblikovan, verjeten in napačen.
Ponavljajo se štirje vzorci. Izmišljeno besedilo, kjer model prebere besedo, ki na sliki ne obstaja. Približne številke, kjer se vrednosti, prebrane z grafa, lahko razlikujejo za 5–15 % od realnosti. Dodane podrobnosti, kjer model dopolni tisto, česar ne vidi jasno, z verjetnimi informacijami – zamegljena številka SIRET postane popolnoma oblikovana, a lažna številka SIRET. Nazadnje, zamenjava elementov, kjer se dva bližnja predmeta združita v enega.
Obstajajo trije protiukrepi; kombiniraj jih glede na kritičnost. Prvič, prisili model, da ovrednoti lastno gotovost. Drugič, naj ponovno prebere sliko po prepisu. Tretjič, postavi dva modela proti istemu vprašanju in obdrži le tisto, s čimer se strinjata oba.
# 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
Dvojno branje podvoji stroške: rezerviraj ga za zneske, identifikatorje in vse, kar sproži nepovratno dejanje.
Optimizacija stroškov
Najučinkovitejšo optimizacijo stroškov smo obravnavali v 5. lekciji in je najpreprostejša: zmanjšaj velikost slike pred pošiljanjem. Fotografija velikosti 6 MB, pomanjšana na 1024 pikslov, za namene analize ne izgubi ničesar in olajša celoten proces.
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}"
Sledi usmerjanje glede na kompleksnost: ni vsaka naloga vredna najdražjega modela. Dovolj je trivrstična funkcija za odločitev, pod pogojem, da si naloge vnaprej razvrstil.
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
Tretji vzvod je najbolj pozabljen: ne plačaj dvakrat za isto analizo. V produkcijskem okolju se ista slika vrača pogosteje, kot misliš – ponovno izvajanje procesa, podvojena pošiljanja ali poskusi po incidentu. Diskovni predpomnilnik, indeksiran z zgoščenko datoteke in pozivom, odpravi te odvečne klice.
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č vključuje poziv in model, ne le slike: sprememba vprašanja na isti fotografiji mora dejansko sprožiti nov klic.
Optimizacija zakasnitve
Pri interaktivni aplikaciji štiri nastavitve vplivajo na zaznani čas odziva. Slike pomanjšaj na strani odjemalca na največ 1024 pikslov, kar skrajša čas nalaganja. Izberi Small ali Ministral, saj je njihovo generiranje bistveno hitrejše. Slike posreduj prek URL-ja, ko so že gostovane, da se izogneš pošiljanju velikega telesa zahteve Base64. Nazadnje, omogoči pretakanje (streaming), kar ne zmanjša skupnega časa, vendar prikaže odgovor, medtem ko 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 namesto chat.complete; ostalo sporočilo je popolnoma enako.
Kontrolni seznam za produkcijo
Preden aplikacijo Vision uvedeš v produkcijo, preveri vsako od teh točk:
- Samodejno spreminjanje velikosti slik (največ 1024 px)
- Preverjanje formata in velikosti pred pošiljanjem
- Obravnava napak API-ja (ponovni poskus, časovna omejitev, nadomestilo)
- Predpomnjenje rezultatov za identične slike
- Inteligentno usmerjanje (Small za preproste, Large za kompleksne)
- Spremljanje stroškov in zakasnitve
- Testiranje s slikami slabe kakovosti (zamegljene, nizka ločljivost, zasukane)
- Strategija proti halucinacijam (ravni gotovosti, dvojno preverjanje)
Predzadnja točka je tista, ki jo najpogosteje preskočijo, in tista, ki povzroči največ škode: sestavi nabor podatkov namerno slabih slik in ga zaženi pred vsako uvedbo.
Ključne ugotovitve
- Slike so interno spremenjene – ni treba pošiljati zelo visoke ločljivosti
- Vizualne halucinacije so glavno tveganje – zahtevaj ravni gotovosti
- Spreminjanje velikosti na strani odjemalca je najučinkovitejša optimizacija stroškov
- Usmerjanje glede na kompleksnost (Small proti Large) zmanjša stroške za 90 % pri preprostih nalogah
- Diskovni predpomnilnik se izogne odvečnim klicem API-ja za iste slike