Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Limity a optimalizace Vision API

Lekce 11 z 12 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Poznej limity, abys je dokázal obejít
  2. Technická omezení
  3. Vizuální halucinace
  4. Optimalizace nákladů
  5. Optimalizace latence
  6. Kontrolní seznam pro produkci
  7. Klíčové poznatky

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