Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A Vision API korlátai és optimalizálása

11. lecke 12 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Ismerd a korlátokat, hogy megkerülhesd őket
  2. Technikai korlátok
  3. Vizuális hallucinációk
  4. Költségek optimalizálása
  5. Késleltetés optimalizálása
  6. Ellenőrző lista élesítéshez
  7. Főbb megállapítások

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