Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Vision API piirangud ja optimeerimine

Õppetund 11 / 12 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Tunneta piiranguid, et neist mööda hiilida
  2. Tehnilised piirangud
  3. Visuaalsed hallutsinatsioonid
  4. Kulude optimeerimine
  5. Latentsuse optimeerimine
  6. Tootmise kontrollnimekiri
  7. Peamised punktid

Tunneta piiranguid, et neist mööda hiilida

Eelmised kümme õppetundi käsitlesid seda, mida Vision API hästi teeb. See tund räägib sellest, kus see raskustesse satub. See pole alandlikkuse harjutus: erinevus demo-prototüübi, mis paneb silmad särama, ja tootmises vastu pidava rakenduse vahel seisneb täpselt selles. Siin õpid tundma tehnilisi piiranguid, levinud lõkse – millest peamine on visuaalsed hallutsinatsioonid – ning strateegiaid kulude ja latentsuse optimeerimiseks.

Tehnilised piirangud

Oleme vormingupiirangutest varem juba rääkinud, kuid võtame need kokku. Iga pildi maksimaalne suurus on umbes 20 MB ja seda muudetakse niikuinii sisemiselt väiksemaks, tavaliselt mõõtmetele 768x768 või samaväärseks: 4K pilt ei paranda tulemusi. Toetatud vormingud on JPEG, PNG, GIF (ainult esimene kaader) ja WebP. Vision API ei toeta otseselt PDF-faile – selleks pead kasutama Document AI-d, nagu arutasime 8. õppetunnis.

Kõige struktuurseim piirang on tokenite tarbimine. Iga pilt tarbib olulise hulga tokeneid ja see funktsioon teisendab hinnangu dollariteks, mitte abstraktseteks ühikuteks:

# 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)

Võrdle skripti lõpus olevaid kahte väljakutset: teine maksab kümneid kordi rohkem kui esimene. Korruta see oma päevase mahuga enne otsuse tegemist. Sellele lisandub kontekstiakna limiit, mida piltide, vihje ja vastuse summa ei tohi ületada – lagi, mille mitu pilti saavutavad palju kiiremini kui pikk tekst.

Visuaalsed hallutsinatsioonid

Mudel võib „leiutada“ üksikasju, mida pildil tegelikult pole. See on tootmises kõige kriitilisem probleem, sest see on vaikne: vastus on hästi vormistatud, usutav ja vale.

Korduvad neli mustrit. Väljamõeldud tekst, kus mudel loeb sõna, mida pildil ei eksisteeri. Ligikaudsed arvud, kus diagrammilt loetud väärtused võivad tegelikkusest erineda 5–15%. Lisatud üksikasjad, kus mudel täidab seda, mida ta selgelt ei näe, usutava informatsiooniga – udune SIRET-number muutub ideaalses vormingus, kuid võltsitud SIRET-numbriks. Lõpuks elementide segiajamine, kus kaks lähestikku asuvat objekti liidetakse üheks.

On olemas kolm vastumeedet; kombineeri neid vastavalt kriitilisusele. Esiteks sunni mudelit hindama oma kindlust. Teiseks pane ta pilti pärast transkribeerimist uuesti lugema. Kolmandaks pane kaks mudelit sama küsimuse kallal tööle ja jäta alles ainult see, milles nad nõustuvad.

# 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

Topeltlugemine kahekordistab kulu: reserveeri see summade, identifikaatorite ja kõige jaoks, mis käivitab pöördumatuid tegevusi.

Kulude optimeerimine

Kõige kulutõhusam optimeerimine sai käsitletud 5. õppetunnis ja see on kõige lihtsam: vähenda pildi suurust enne saatmist. 6 MB foto, mis on vähendatud 1024 pikslini, ei kaota analüüsi seisukohalt midagi ja kergendab kogu ahelat.

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}"

Järgmisena tuleb suunamine keerukuse järgi: mitte iga ülesanne ei väärise kõige kallimat mudelit. Kolmerealine funktsioon on otsustamiseks piisav, eeldusel, et oled oma ülesanded eelnevalt klassifitseerinud.

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

Kolmas hoob on kõige sagedamini unustatu: ära maksa sama analüüsi eest kaks korda. Tootmises naaseb sama pilt sagedamini, kui arvad – protsessi uuesti käivitamine, topeltsaatmised või katse pärast intsidenti. Faili räsil ja vihjel põhinev ketasmälu vahemälu kõrvaldab need üleliigsed väljakutsed.

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

Võti sisaldab vihjet ja mudelit, mitte ainult pilti: sama foto puhul erineva küsimuse esitamine peakski käivitama uue väljakutse.

Latentsuse optimeerimine

Interaktiivse rakenduse puhul mõjutavad tajutavat vastamisaega neli seadet. Muuda pildid kliendi poolel maksimaalselt 1024 piksli suuruseks, mis lühendab üleslaadimisaega. Vali Small või Ministral, kuna nende genereerimine on oluliselt kiirem. Edasta pildid URL-i kaudu, kui need on juba majutatud, et vältida suure Base64-päringukeha saatmist. Lõpuks luba voogedastus (streaming), mis ei vähenda koguaega, kuid kuvab vastust selle koostumise käigus:

# 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)

See on chat.stream, mis asendab chat.complete-i; ülejäänud sõnum on täpselt sama.

Tootmise kontrollnimekiri

Enne Vision-rakenduse tootmisse viimist kontrolli iga järgmist punkti:

  • Automaatne pildi suuruse muutmine (max 1024 px)
  • Vormingu ja suuruse valideerimine enne saatmist
  • API vigade käsitlemine (uuesti proovimine, aegumine, varuplaan)
  • Tulemite vahemällu salvestamine identsete piltide jaoks
  • Intelligentsed suunamine (Small lihtsate, Large keerukate jaoks)
  • Kulude ja latentsuse jälgimine
  • Testimine halva kvaliteediga piltidega (udused, madala eraldusvõimega, pööratud)
  • Hallutsinatsioonivastane strateegia (kindlustasemed, topeltkontroll)

Teine viimane punkt on see, mida kõige sagedamini vahele jäetakse ja mis põhjustab kõige rohkem kahju: koosta tahtlikult halbade piltide andmestik ja käivita see enne iga kasutuselevõttu.

Peamised punktid

  • Pilte muudetakse sisemiselt väiksemaks – pole vaja saata väga kõrge eraldusvõimega pilte
  • Visuaalsed hallutsinatsioonid on peamine risk – küsi kindlustasemeid
  • Kliendi poolel suuruse muutmine on kõige kulutõhusam optimeerimine
  • Keerukuse järgi suunamine (Small vs Large) vähendab lihtsate ülesannete kulusid 90%
  • Ketasmälu vahemälu hoiab ära üleliigsed API väljakutsed samade piltide puhul