Salt la conținutul principal
Română— Alege o limbă
Meniu

Limite și optimizare pentru Vision API

Lecția 11 din 12 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Cunoașteți limitele pentru a le depăși
  2. Limite tehnice
  3. Halucinații vizuale
  4. Optimizarea costurilor
  5. Optimizarea latenței
  6. Lista de verificare pentru producție
  7. Puncte cheie

Cunoașteți limitele pentru a le depăși

Cele zece lecții anterioare au acoperit punctele forte ale Vision API. Această lecție se concentrează pe zonele unde acesta întâmpină dificultăți. Nu este vorba despre umilință: diferența dintre un prototip demonstrativ impresionant și o aplicație robustă în producție rezidă exact aici. Veți învăța despre constrângerile tehnice, capcanele frecvente—în special halucinațiile vizuale—și strategiile de optimizare a costurilor și a latenței.

Limite tehnice

Am abordat anterior constrângerile de format, dar să le reunim. Fiecare imagine este limitată la aproximativ 20 MB și va fi redimensionată intern, de obicei la 768x768 sau echivalent: o imagine 4K nu va îmbunătăți rezultatele. Formatele acceptate sunt JPEG, PNG, GIF (doar primul cadru) și WebP. Vision API nu suportă direct PDF—trebuie să apelați Document AI pentru aceasta, așa cum s-a discutat în Lecția 8.

Cea mai structurală constrângere rămâne consumul de tokeni. Fiecare imagine consumă un număr semnificativ de tokeni, iar această funcție traduce acea estimare în dolari, nu în unități abstracte:

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

Comparați cele două apeluri de la sfârșitul scriptului: al doilea costă de zeci de ori mai mult decât primul. Înmulțiți acest cost cu volumul dumneavoastră zilnic înainte de a lua o decizie. Pe lângă aceasta, există limita ferestrei de context, pe care totalul imaginilor + prompt + răspuns nu trebuie să o depășească—un plafon pe care multiple imagini îl ating mult mai rapid decât un text lung.

Halucinații vizuale

Modelul poate „inventa“ detalii absente din imagine. Aceasta este cea mai critică problemă în producție deoarece este silențioasă: răspunsul este bine format, plauzibil, dar greșit.

Patru tipare recurente apar. Text inventat, unde modelul citește un cuvânt care nu există în imagine. Numere aproximative, unde valorile citite dintr-un grafic pot devia cu 5–15% de la realitate. Detalii adăugate, unde modelul completează ceea ce nu vede clar cu informații plauzibile—un număr SIRET neclar devine un SIRET perfect formatat, dar fals. În final, confuzia de elemente, unde două obiecte apropiate sunt contopite într-unul singur.

Există trei contramăsuri; combinați-le în funcție de criticitate. În primul rând, forțați modelul să își califice propria certitudine. În al doilea rând, cereți-i să recitească imaginea după transcriere. În al treilea rând, puneți două modele să răspundă la aceeași întrebare și păstrați doar ceea ce agreează ambele.

# 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

Dubla citire dublează costul: rezervați-o pentru sume, identificatori și orice declanșează o acțiune ireversibilă.

Optimizarea costurilor

Cea mai eficientă optimizare a costurilor a fost acoperită în Lecția 5 și este cea mai simplă: reduceți dimensiunea imaginii înainte de a o trimite. O fotografie de 6 MB redimensionată la 1024 pixeli nu pierde nimic în scopuri de analiză și ușurează întregul lanț.

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

Urmează rutarea în funcție de complexitate: nu fiecare sarcină merită cel mai scump model. O funcție de trei linii este suficientă pentru a decide, cu condiția să fi clasificat sarcinile în prealabil.

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 treia pârghie este cea mai adesea uitată: nu plătiți de două ori pentru aceeași analiză. În producție, aceeași imagine revine mai des decât credeți—rerularea unui proces, trimiteri duplicate sau reîncercări după un incident. Un cache pe disc indexat pe hash-ul fișierului și prompt elimină aceste apeluri redundante.

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

Cheia include promptul și modelul, nu doar imaginea: schimbarea întrebării pentru aceeași fotografie ar trebui într-adevăr să declanșeze un nou apel.

Optimizarea latenței

Pentru o aplicație interactivă, patru setări afectează timpul de răspuns perceput. Redimensionați imaginile latoarea clientului la un maxim de 1024 pixeli, ceea ce scurtează timpul de încărcare. Alegeți Small sau Ministral, deoarece generarea lor este semnificativ mai rapidă. Transmiteți imaginile prin URL când sunt deja găzduite pentru a evita trimiterea unui corp de cerere Base64 voluminos. În final, activați streaming-ul, care nu reduce timpul total, dar afișează răspunsul pe măsură ce este construit:

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

Este chat.stream înlocuind chat.complete; restul mesajului este exact același.

Lista de verificare pentru producție

Înainte de a lansa o aplicație Vision în producție, verificați fiecare dintre aceste puncte:

  • Redimensionare automată a imaginilor (max 1024px)
  • Validarea formatului și a dimensiunii înainte de trimitere
  • Gestionarea erorilor API (reîncercare, timeout, fallback)
  • Cache-uirea rezultatelor pentru imagini identice
  • Rutare inteligentă (Small pentru simplu, Large pentru complex)
  • Monitorizarea costurilor și a latenței
  • Testarea cu imagini de calitate slabă (neclare, rezoluție mică, rotite)
  • Strategie anti-halucinație (niveluri de încredere, dublă verificare)

Penultimul punct este cel mai adesea omis și cel care cauzează cele mai mari daune: construiți un set de date cu imagini deliberat defecte și rulați-l înainte de fiecare lansare.

Puncte cheie

  • Imaginile sunt redimensionate intern—nu este nevoie să trimiteți rezoluții foarte mari
  • Halucinațiile vizuale sunt riscul principal—cereți niveluri de încredere
  • Redimensionarea latoarea clientului este cea mai eficientă optimizare a costurilor
  • Rutarea în funcție de complexitate (Small vs. Large) reduce costurile cu 90% pentru sarcinile simple
  • Cache-uirea pe disc evită apelurile API redundante pentru aceleași imagini