Comparaison multi-images
Analyser plusieurs images en une requête
L’un des atouts majeurs de la vision Grok est la capacité d’envoyer un nombre illimité d’images dans une seule requête. Cela ouvre des possibilités uniques pour la comparaison, le suivi temporel et l’analyse croisée que les API limitées à une seule image ne peuvent pas offrir.
Structure d’une requête multi-images
Le format est simple : vous ajoutez autant d’objets input_image que nécessaire dans le tableau input, en les intercalant avec du texte pour guider l’analyse :
response = client.responses.create(
model="grok-4",
input=[
{"type": "input_text", "text": "Image A :"},
{"type": "input_image", "image_url": url_image_a},
{"type": "input_text", "text": "Image B :"},
{"type": "input_image", "image_url": url_image_b},
{"type": "input_text", "text": "Compare ces deux images en détail."}
]
)Labelliser chaque image avec un texte (“Image A”, “Image B”) aide le modèle à structurer sa réponse et à référencer clairement chaque image.
Cas d’usage : comparaison avant/après
Parfait pour le suivi de projets, la rénovation, le design ou le contrôle qualité :
def comparer_avant_apres(url_avant, url_apres):
prompt = """Compare ces deux images (avant et après) et identifie :
1. Les changements principaux
2. Les éléments qui n'ont pas changé
3. Les améliorations visibles
4. Les éventuels problèmes introduits
Présente ta réponse sous forme de liste structurée."""
response = client.responses.create(
model="grok-4",
input=[
{"type": "input_text", "text": "AVANT :"},
{"type": "input_image", "image_url": url_avant, "detail": "high"},
{"type": "input_text", "text": "APRÈS :"},
{"type": "input_image", "image_url": url_apres, "detail": "high"},
{"type": "input_text", "text": prompt}
],
store=False
)
return response.output_textCas d’usage : suivi temporel
Suivre l’évolution d’un lieu, d’un produit ou d’un processus dans le temps :
def analyser_evolution(images_chronologiques):
"""images_chronologiques : liste de {"url": ..., "date": ...}"""
input_data = []
for img in images_chronologiques:
input_data.append({
"type": "input_text",
"text": f"Photo du {img['date']} :"
})
input_data.append({
"type": "input_image",
"image_url": img["url"],
"detail": "auto"
})
input_data.append({
"type": "input_text",
"text": """Analyse l'évolution chronologique visible dans
ces images. Identifie les changements progressifs, les tendances
et tout événement notable entre les différentes dates."""
})
response = client.responses.create(
model="grok-4",
input=input_data,
store=False
)
return response.output_textCas d’usage : contrôle qualité
Comparer un produit manufacturé à son modèle de référence :
def controle_qualite(url_reference, url_produit):
prompt = """Compare le produit photographié au modèle de référence.
Identifie :
1. Les conformités (ce qui correspond au modèle)
2. Les non-conformités (écarts, défauts, différences)
3. La sévérité de chaque non-conformité (mineure, majeure, critique)
Renvoie un JSON avec :
{
"conforme": true/false,
"score": 0-100,
"conformites": [...],
"non_conformites": [
{"description": "...", "severite": "mineure|majeure|critique"}
]
}"""
response = client.responses.create(
model="grok-4",
input=[
{"type": "input_text", "text": "RÉFÉRENCE (modèle attendu) :"},
{"type": "input_image", "image_url": url_reference, "detail": "high"},
{"type": "input_text", "text": "PRODUIT à vérifier :"},
{"type": "input_image", "image_url": url_produit, "detail": "high"},
{"type": "input_text", "text": prompt}
],
store=False
)
return response.output_textCas d’usage : analyse concurrentielle
Comparer les interfaces, les emballages ou les présentations de produits concurrents :
def analyser_concurrence(images_concurrents):
"""images_concurrents : [{"marque": "...", "url": "..."}]"""
input_data = []
for concurrent in images_concurrents:
input_data.append({
"type": "input_text",
"text": f"{concurrent['marque']} :"
})
input_data.append({
"type": "input_image",
"image_url": concurrent["url"],
"detail": "auto"
})
input_data.append({
"type": "input_text",
"text": """Compare ces produits/interfaces concurrents.
Pour chacun, identifie les forces et faiblesses visuelles.
Donne une recommandation de positionnement."""
})
response = client.responses.create(
model="grok-4",
input=input_data,
store=False
)
return response.output_textOptimisation des requêtes multi-images
Quand vous envoyez beaucoup d’images, la consommation de tokens augmente rapidement. Quelques stratégies d’optimisation :
Adapter le niveau de détail
Utilisez low pour les comparaisons générales et high uniquement quand vous analysez des détails fins :
# Comparaison globale : low suffit
detail = "low" # ~256 tokens par image
# Analyse de défauts : high nécessaire
detail = "high" # ~1024-1792 tokens par imageLimiter le nombre d’images par requête
Même si la limite est illimitée, au-delà de 10-15 images la qualité d’analyse peut diminuer. Le modèle dispose d’un contexte fini et doit le répartir entre toutes les images :
# Si plus de 10 images, traiter par lots
def analyser_par_lots(images, taille_lot=10):
resultats = []
for i in range(0, len(images), taille_lot):
lot = images[i:i + taille_lot]
resultat = analyser_lot(lot)
resultats.append(resultat)
return fusionner_resultats(resultats)Redimensionner les images
Si vous comparez des photos haute résolution pour une analyse générale, redimensionnez-les avant l’envoi pour réduire les tokens :
def preparer_pour_comparaison(chemin, taille_max=(800, 800)):
img = Image.open(chemin)
img.thumbnail(taille_max)
# ... encoder en base64Points clés à retenir
- Le nombre d’images par requête est illimité — c’est un avantage clé de l’API xAI
- Labellisez chaque image avec du texte pour structurer l’analyse
- Adaptez le paramètre
detailau type de comparaison - Au-delà de 10-15 images, traitez par lots pour maintenir la qualité
- Les cas d’usage incluent : avant/après, suivi temporel, contrôle qualité, analyse concurrentielle