Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Limites et optimisation de l'API Vision

Nodarbība 11 no 12 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Connaître les limites pour les contourner
  2. Limites techniques
  3. Hallucinations visuelles
  4. Optimiser les coûts
  5. Optimiser la latence
  6. Liste de contrôle pour la production
  7. Galvenās atziņas

Connaître les limites pour les contourner

Les dix leçons précédentes ont couvert les points forts de l’API Vision. Celle-ci aborde ses faiblesses. Il ne s’agit pas d’un exercice d’humilité : la différence entre un prototype de démonstration impressionnant et une application robuste en production repose exactement là-dessus. Ici, tu apprendras 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. L’API Vision ne prend pas en charge directement les PDF – tu dois faire appel à Document AI pour cela, comme vu à la leçon 8.

La contrainte la plus structurelle reste la consommation de jetons. Chaque image consomme un nombre significatif de jetons, 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 cela par ton volume quotidien avant de prendre une décision. En plus de cela, il y a la limite de la fenêtre de contexte, que le total images + invite + réponse ne doit pas dépasser – un plafond que plusieurs images atteignent beaucoup 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é couverte à la leçon 5, et c’est la plus simple : réduire la taille de l’image avant l’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 d’un processus, envois en double ou nouvelle tentative après un incident. Un cache disque indexé sur le hachage du fichier et l’invite é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 l’invite 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 à un maximum de 1024 pixels, ce qui réduit le temps de téléchargement. 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 exactement le même.

Liste de contrôle pour la 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 délibérément mauvaises et exécute-le avant chaque déploiement.

Galvenās atziņas

  • 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