Limity i optymalizacja Vision API
Na tej stronie
Poznaj limity, aby móc je obejść
Poprzednie dziesięć lekcji omówiło mocne strony Vision API. Ta skupia się na obszarach, w których model ma trudności. Nie chodzi tu o ćwiczenie pokory: różnica między imponującym prototypem demonstracyjnym a aplikacją sprawdzającą się w środowisku produkcyjnym sprowadza się dokładnie do tego. Tutaj dowiesz się o ograniczeniach technicznych, typowych pułapkach – z halucynacjami wizualnymi na czele – oraz strategiach optymalizacji kosztów i opóźnień.
Ograniczenia techniczne
Wspominaliśmy już wcześniej o ograniczeniach formatów, ale warto zebrać je w całość. Każdy obraz jest limitowany do około 20 MB i tak czy inaczej zostanie wewnętrznie zmieniony rozmiar, zazwyczaj do 768x768 lub odpowiednika: obraz 4K nie poprawi wyników. Akceptowane formaty to JPEG, PNG, GIF (tylko pierwsza klatka) oraz WebP. Vision API nie obsługuje bezpośrednio plików PDF – do tego celu musisz użyć Document AI, o czym mówiliśmy w Lekcji 8.
Najbardziej strukturalnym ograniczeniem pozostaje zużycie tokenów. Każdy obraz konsumuje znaczną liczbę tokenów, a poniższa funkcja przelicza ten szacunek na dolary, a nie abstrakcyjne jednostki:
# 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)
Porównaj dwa wywołania na końcu skryptu: drugie kosztuje kilkadziesiąt razy więcej niż pierwsze. Pomnóż to przez swoją dzienną objętość przed podjęciem decyzji. Do tego dochodzi limit okna kontekstowego, którego nie może przekroczyć suma obrazów + promptu + odpowiedzi – sufit, do którego wiele obrazów dociera znacznie szybciej niż długi tekst.
Halucynacje wizualne
Model może „wymyślać“ szczegóły nieobecne na obrazie. To najważniejszy problem w środowisku produkcyjnym, ponieważ działa po cichu: odpowiedź jest poprawnie sformułowana, wiarygodna i błędna.
Powtarzają się cztery wzorce. Zmyślony tekst, gdzie model odczytuje słowo, którego nie ma na obrazie. Przybliżone liczby, gdzie wartości odczytane z wykresu mogą odbiegać o 5–15% od rzeczywistości. Dodane szczegóły, gdzie model uzupełnia to, czego nie widzi wyraźnie, prawdopodobnymi informacjami – rozmyty numer SIRET staje się idealnie sformatowanym, ale fałszywym numerem SIRET. Wreszcie, pomylenie elementów, gdzie dwa pobliskie obiekty są łączone w jeden.
Istnieją trzy środki zaradcze; łącz je w zależności od krytyczności zadania. Po pierwsze, zmuś model do określenia własnego poziomu pewności. Po drugie, każ mu ponownie przeczytać obraz po transkrypcji. Po trzecie, skonfrontuj dwa modele z tym samym pytaniem i zachowaj tylko to, co potwierdzają 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
Podwójne odczytanie podwaja koszt: zarezerwuj je dla kwot, identyfikatorów i wszystkiego, co uruchamia nieodwracalne działania.
Optymalizacja kosztów
Najbardziej opłacalną optymalizację omówiliśmy w Lekcji 5 i jest ona najprostsza: zmniejsz rozmiar obrazu przed wysłaniem. Zdjęcie 6 MB przeskalowane do 1024 pikseli nic nie traci pod kątem analizy, a odciąża cały łańcuch przetwarzania.
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}"
Kolejnym krokiem jest routowanie według złożoności: nie każde zadanie zasługuje na najdroższy model. Wystarczy trzylinijkowa funkcja, aby podjąć decyzję, pod warunkiem, że wcześniej sklasyfikowałeś swoje zadania.
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
Trzecim dźwignią, o której najczęściej się zapomina, jest: nie płać dwa razy za tę samą analizę. W środowisku produkcyjnym ten sam obraz pojawia się częściej, niż myślisz – ponowne uruchomienie procesu, duplikaty wysyłek lub ponowienie próby po incydencie. Dyskowe cache indeksowane hashem pliku i promptem eliminuje te zbędne wywołania.
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
Klucz zawiera prompt i model, a nie tylko obraz: zmiana pytania do tego samego zdjęcia powinna faktycznie uruchomić nowe wywołanie.
Optymalizacja opóźnień
W przypadku aplikacji interaktywnych cztery ustawienia wpływają na postrzegany czas odpowiedzi. Zmień rozmiar obrazów po stronie klienta do maksymalnie 1024 pikseli, co skraca czas przesyłania. Wybierz Small lub Ministral, ponieważ ich generowanie jest znacznie szybsze. Przesyłaj obrazy przez URL, gdy są już hostowane, aby uniknąć wysyłania dużego ciała żądania Base64. Na koniec włącz strumieniowanie, które nie skraca całkowitego czasu, ale wyświetla odpowiedź w miarę jej tworzenia:
# 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 chat.stream zastępujące chat.complete; reszta wiadomości pozostaje dokładnie taka sama.
Lista kontrolna przed wdrożeniem
Przed wdrożeniem aplikacji Vision do środowiska produkcyjnego sprawdź każdy z poniższych punktów:
- Automatyczna zmiana rozmiaru obrazu (maks. 1024 px)
- Walidacja formatu i rozmiaru przed wysłaniem
- Obsługa błędów API (ponawianie, limit czasu, mechanizm awaryjny)
- Buforowanie wyników dla identycznych obrazów
- Inteligentne routowanie (Small dla prostych, Large dla złożonych)
- Monitorowanie kosztów i opóźnień
- Testowanie na obrazach niskiej jakości (rozmyte, niska rozdzielczość, obrócone)
- Strategia antyhalucynacyjna (poziomy pewności, podwójna weryfikacja)
Przedostatni punkt jest najczęściej pomijany, a jednocześnie powoduje największe szkody: stwórz zbiór danych celowo złych obrazów i uruchamiaj go przed każdym wdrożeniem.
Kluczowe wnioski
- Obrazy są wewnętrznie zmieniane – nie ma potrzeby wysyłania bardzo wysokiej rozdzielczości
- Halucynacje wizualne to główne ryzyko – żądaj poziomów pewności
- Zmiana rozmiaru po stronie klienta to najbardziej opłacalna optymalizacja
- Routowanie według złożoności (Small vs Large) redukuje koszty o 90% w prostych zadaniach
- Dyskowe cache unika zbędnych wywołań API dla tych samych obrazów