Aller au contenu principal

Comparer des Images avec la Vision API

L’analyse comparative visuelle

La comparaison d’images est un cas d’usage puissant qui exploite la capacité multi-images de l’API Vision. Que ce soit pour du contrôle qualité, du suivi d’évolution ou de la détection de différences, le modèle peut analyser deux ou plusieurs images et identifier les changements.

Dans cette leçon, vous apprendrez à structurer des prompts de comparaison et à exploiter les résultats.

Comparaison avant/après

Le cas le plus courant : vérifier ce qui a changé entre deux états.

from mistralai import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """Vous êtes un expert en analyse comparative d'images. Quand on vous présente deux images :
1. Décrivez brièvement chaque image
2. Listez les différences identifiées (avec emplacement)
3. Évaluez la significativité de chaque différence (mineure/majeure)
4. Donnez un score de similarité global (0-100%)"""
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Image AVANT (référence) :"},
                {"type": "image_url", "image_url": "https://exemple.com/avant.jpg"},
                {"type": "text", "text": "Image APRÈS (état actuel) :"},
                {"type": "image_url", "image_url": "https://exemple.com/apres.jpg"},
                {"type": "text", "text": "Identifiez toutes les différences entre ces deux images."}
            ]
        }
    ]
)

print(response.choices[0].message.content)

L’intercalation de texte (« Image AVANT », « Image APRÈS ») aide le modèle à identifier le rôle de chaque image.

Contrôle qualité produit

Comparer un produit à sa référence pour détecter les défauts :

import base64
import json

def encoder_image(chemin):
    with open(chemin, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/jpeg;base64,{b64}"

def controle_qualite(image_reference, image_echantillon):
    """Compare un échantillon à sa référence et détecte les défauts."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "Vous êtes un inspecteur qualité. Comparez l'échantillon à la référence et retournez un rapport JSON."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Référence (produit conforme) :"},
                    {"type": "image_url", "image_url": encoder_image(image_reference)},
                    {"type": "text", "text": "Échantillon à inspecter :"},
                    {"type": "image_url", "image_url": encoder_image(image_echantillon)},
                    {
                        "type": "text",
                        "text": """Comparez et retournez :
{
  "conforme": true/false,
  "score_conformite": 0-100,
  "defauts": [
    {"description": "...", "severite": "mineure/majeure/critique", "localisation": "..."}
  ],
  "recommandation": "accepter/revoir/rejeter"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

# Utilisation
resultat = controle_qualite("reference/produit-ok.jpg", "lot-42/echantillon-7.jpg")

if resultat["conforme"]:
    print(f"CONFORME - Score : {resultat['score_conformite']}%")
else:
    print(f"NON CONFORME - {len(resultat['defauts'])} défaut(s) détecté(s)")
    for defaut in resultat["defauts"]:
        print(f"  - [{defaut['severite']}] {defaut['description']}")

Suivi d’évolution dans le temps

Pour analyser une série chronologique d’images (chantier, croissance, dégradation) :

def analyser_evolution(images_chronologiques, contexte=""):
    """Analyse l'évolution visible sur une série d'images ordonnées."""
    content = [
        {
            "type": "text",
            "text": f"Voici {len(images_chronologiques)} images prises à des moments différents, dans l'ordre chronologique. {contexte}"
        }
    ]

    for i, (date, chemin) in enumerate(images_chronologiques):
        content.append({"type": "text", "text": f"Image {i+1} ({date}) :"})
        content.append({"type": "image_url", "image_url": encoder_image(chemin)})

    content.append({
        "type": "text",
        "text": "Décrivez l'évolution observée entre chaque étape. Identifiez les changements majeurs et la tendance générale."
    })

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": content}]
    )

    return response.choices[0].message.content

# Suivi d'un chantier
images = [
    ("2025-01", "chantier/jan-2025.jpg"),
    ("2025-06", "chantier/jun-2025.jpg"),
    ("2026-01", "chantier/jan-2026.jpg"),
]

evolution = analyser_evolution(images, contexte="Suivi d'un chantier de construction.")
print(evolution)

Comparer des interfaces utilisateur

Utile pour le développement web et le QA visuel :

def comparer_interfaces(screenshot_attendu, screenshot_reel):
    """Compare deux screenshots d'interface pour détecter les régressions visuelles."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "Vous êtes un testeur QA spécialisé en tests visuels d'interfaces web."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Design attendu (maquette) :"},
                    {"type": "image_url", "image_url": encoder_image(screenshot_attendu)},
                    {"type": "text", "text": "Rendu actuel (screenshot) :"},
                    {"type": "image_url", "image_url": encoder_image(screenshot_reel)},
                    {
                        "type": "text",
                        "text": """Comparez et retournez :
{
  "pixel_perfect": true/false,
  "differences": [
    {"element": "...", "attendu": "...", "reel": "...", "impact": "mineur/moyen/majeur"}
  ],
  "score_fidelite": 0-100,
  "verdict": "conforme/ajustements_mineurs/regression"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

Bonnes pratiques de comparaison

Pour obtenir les meilleurs résultats :

  • Nommez clairement les images : utilisez des labels (« Référence », « Échantillon », « Avant », « Après ») entre chaque image
  • Même angle et éclairage : la comparaison est plus fiable si les conditions de prise de vue sont similaires
  • Utilisez Large 3 : la comparaison requiert un raisonnement fin que les modèles plus petits ne maîtrisent pas toujours
  • Limitez à 2-3 images : au-delà, le modèle perd en précision comparative
  • Demandez un format structuré : JSON avec score, différences listées, et verdict

Points clés à retenir

  • La comparaison d’images exploite la capacité multi-images de l’API
  • Intercalez du texte explicatif entre les images pour clarifier leur rôle
  • Le mode JSON (response_format) est idéal pour les rapports de comparaison automatisés
  • Les cas d’usage principaux : contrôle qualité, suivi de chantier, QA visuel, avant/après
  • Utilisez toujours Mistral Large 3 pour les tâches de comparaison exigeantes
← Lecon precedenteExtraction de Données Structurées depuis des ImagesLecon suivante →Limites et Optimisation de la Vision API