Vision API : limites et optimisation
På denna sida
Connaître les limites pour mieux les contourner
Les dix leçons précédentes ont détaillé les forces de la Vision API. Celle-ci se concentre sur ses faiblesses. Il ne s’agit pas d’un exercice d’humilité : la différence entre un prototype de démonstration bluffant et une application robuste en production repose exactement là-dessus. Tu vas ici découvrir les contraintes techniques, les pièges courants — les hallucinations visuelles en tête — et les stratégies pour optimiser les coûts et la latence.
Limites techniques
Nous avons déjà évoqué les contraintes de format, mais regroupons-les. Chaque image est limitée à environ 20 Mo et sera de toute façon redimensionnée en interne, généralement à 768x768 ou équivalent : une image 4K n’améliorera pas les résultats. Les formats acceptés sont JPEG, PNG, GIF (première image uniquement) et WebP. La Vision API ne prend pas en charge les PDF directement ; il faut faire appel à Document AI pour cela, comme vu à la leçon 8.
La contrainte la plus structurelle reste la consommation de tokens. Chaque image consomme un nombre significatif de tokens, et cette fonction traduit cette estimation en dollars plutôt qu’en unités abstraites :
# 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)
Compare les deux appels à la fin du script : le second coûte des dizaines de fois plus cher que le premier. Multiplie ce montant par ton volume quotidien avant de prendre une décision. À cela s’ajoute la limite de la fenêtre de contexte, que le total images + prompt + réponse ne doit pas dépasser — un plafond que plusieurs images atteignent bien plus vite qu’un long texte.
Hallucinations visuelles
Le modèle peut « inventer » des détails absents de l’image. C’est le problème le plus critique en production car il est silencieux : la réponse est bien formée, plausible, et fausse.
Quatre schémas récurrents existent. Le texte inventé, où le modèle lit un mot qui n’existe pas dans l’image. Les nombres approximatifs, où les valeurs lues sur un graphique peuvent s’écarter de 5 à 15 % de la réalité. Les détails ajoutés, où le modèle comble ce qu’il ne voit pas clairement par des informations plausibles — un numéro SIRET flou devient un SIRET parfaitement formaté mais faux. Enfin, la confusion d’éléments, où deux objets proches sont fusionnés en un seul.
Trois contre-mesures existent ; combine-les selon la criticité. Premièrement, force le modèle à qualifier sa propre certitude. Deuxièmement, demande-lui de relire l’image après transcription. Troisièmement, oppose deux modèles à la même question et ne conserve que ce sur quoi ils s’accordent.
# 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
La double lecture double le coût : réserve-la aux montants, aux identifiants et à tout ce qui déclenche une action irréversible.
Optimiser les coûts
L’optimisation la plus rentable a été abordée à la leçon 5, et c’est la plus simple : réduire la taille de l’image avant envoi. Une photo de 6 Mo redimensionnée à 1024 pixels ne perd rien pour l’analyse et allège toute la chaîne.
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}"
Vient ensuite le routage par complexité : toutes les tâches ne méritent pas le modèle le plus cher. Une fonction de trois lignes suffit pour décider, à condition d’avoir classifié tes tâches en amont.
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
Le troisième levier est le plus souvent oublié : ne paie pas deux fois pour la même analyse. En production, la même image revient plus souvent que tu ne le penses — relance de processus, doublons d’envoi ou nouvelle tentative après un incident. Un cache disque indexé sur le hachage du fichier et le prompt élimine ces appels redondants.
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
La clé inclut le prompt et le modèle, pas seulement l’image : changer la question sur la même photo doit effectivement déclencher un nouvel appel.
Optimiser la latence
Pour une application interactive, quatre paramètres affectent le temps de réponse perçu. Redimensionne les images côté client à 1024 pixels maximum, ce qui réduit le temps d’upload. Choisis Small ou Ministral, car leur génération est nettement plus rapide. Passe les images par URL lorsqu’elles sont déjà hébergées pour éviter d’envoyer un corps de requête Base64 volumineux. Enfin, active le streaming, qui ne réduit pas le temps total mais affiche la réponse au fur et à mesure de sa construction :
# 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)
C’est chat.stream qui remplace chat.complete ; le reste du message est strictement identique.
Checklist de production
Avant de déployer une application Vision en production, vérifie chacun de ces points :
- Redimensionnement automatique des images (max 1024 px)
- Validation du format et de la taille avant envoi
- Gestion des erreurs API (nouvelle tentative, délai d’attente, repli)
- Mise en cache des résultats pour les images identiques
- Routage intelligent (Small pour le simple, Large pour le complexe)
- Surveillance des coûts et de la latence
- Tests avec des images de mauvaise qualité (floues, basse résolution, tournées)
- Stratégie anti-hallucination (niveaux de confiance, double vérification)
L’avant-dernier point est le plus souvent ignoré, et celui qui cause le plus de dégâts : construis un jeu de données d’images volontairement mauvaises et exécute-le avant chaque déploiement.
Viktiga punkter
- Les images sont redimensionnées en interne — inutile d’envoyer une très haute résolution
- Les hallucinations visuelles sont le risque principal — demande des niveaux de confiance
- Le redimensionnement côté client est l’optimisation la plus rentable
- Le routage par complexité (Small vs Large) réduit les coûts de 90 % sur les tâches simples
- La mise en cache disque évite les appels API redondants sur les mêmes images