Meerdere afbeeldingen in één bericht verzenden
Op deze pagina
Meerdere afbeeldingen tegelijk analyseren
De Vision API van Mistral is niet beperkt tot één afbeelding per bericht. U kunt meerdere afbeeldingen in één enkele call verzenden om het model te vragen ze te vergelijken, samen te vatten of gezamenlijk te analyseren. Het verschil tussen deze aanpak en twee aparte calls is cruciaal: bij één enkele call ziet het model beide afbeeldingen simultaan en kan het redeneren over hun onderlinge relaties—iets wat geen aggregatie van individuele responsen kan bereiken.
Deze mogelijkheid ontsluit use cases waarbij de vraag zich richt op het verschil in plaats van op de inhoud: vergelijkingen van voor/na, analyse van documentreeksen of visuele compliance-checks.
Structuur van een bericht met meerdere afbeeldingen
Het principe is eenvoudig: voeg meerdere image_url-items toe aan de content-array:
message = {
"role": "user",
"content": [
{"type": "text", "text": "Vergelijk deze twee afbeeldingen en beschrijf de verschillen."},
{"type": "image_url", "image_url": "https://example.com/image1.jpg"},
{"type": "image_url", "image_url": "https://example.com/image2.jpg"}
]
}
Homogeniteit is niet vereist: u kunt in hetzelfde bericht afbeeldingen via URL en Base64 mixen. Dit komt vaak voor wanneer u een gehoste referentieafbeelding moet vergelijken met een lokaal gegenereerd bestand.
Voorbeeld: twee afbeeldingen vergelijken
Stel u een inspectie bij ontvangst in een magazijn voor. U vergelijkt een referentiefoto van het conforme product met een foto van het ontvangen monster, gebruikmakend van een systeemprompt die de rol van inspecteur vastlegt:
from mistralai.client 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": "U bent een kwaliteitscontrole-expert. Vergelijk de verstrekte afbeeldingen met precisie."
},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Hier zijn twee foto's van hetzelfde product. De eerste is de referentie, de tweede is het ontvangen monster. Identificeer alle verschillen."
},
{"type": "image_url", "image_url": "https://example.com/reference.jpg"},
{"type": "image_url", "image_url": "https://example.com/sample.jpg"}
]
}
]
)
print(response.choices[0].message.content)
De tekst vermeldt expliciet de volgorde—“de eerste is de referentie”—omdat het model deze niet kan raden.
Tekst en afbeeldingen afwisselen
Deze benadering van ordening stoot snel op zijn grenzen bij meer dan twee afbeeldingen. Een robuustere methode is om elke afbeelding te labelen vlak voordat u deze verstrekt, door text- en image_url-elementen af te wisselen:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Hier is het oorspronkelijke architectonische plan:"},
{"type": "image_url", "image_url": "https://example.com/plan-original.png"},
{"type": "text", "text": "En hier is de foto van het gebouwde pand:"},
{"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
{"type": "text", "text": "Komt het gebouw overeen met het plan? Som de afwijkingen op."}
]
}
]
)
Elke afbeelding heeft nu zijn eigen label en de laatste vraag komt pas nadat al het materiaal is gepresenteerd. Dit formaat verbetert het begrip van het model aanzienlijk: het weet dat het plan de standaard is en de foto het object dat geëvalueerd moet worden. Het omdraaien ervan zou een omgekeerd afwijkingsrapport opleveren.
Batchverwerking met Base64
Voor een map met lokale afbeeldingen wordt het bouwen van de content programmatisch. U stelt de lijst samen in een lus en codeert elk bestand ter plekke:
import base64
import os
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def encode_image(path):
with open(path, "rb") as f:
b64 = base64.standard_b64encode(f.read()).decode("utf-8")
ext = Path(path).suffix.lower()
mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", "webp": "webp"}.get(ext.lstrip("."), "jpeg")
return f"data:image/{mime};base64,{b64}"
# Laad alle afbeeldingen uit een map
folder = Path("captures/")
images = sorted(folder.glob("*.png"))
# Bouw de inhoud van het bericht
content = [{"type": "text", "text": f"Analyseer deze {len(images)} screenshots en vat gemeenschappelijke elementen samen."}]
for img in images[:5]: # Beperk tot maximaal 5 afbeeldingen
content.append({"type": "image_url", "image_url": encode_image(img)})
response = client.chat.complete(
model="mistral-small-latest",
messages=[{"role": "user", "content": content}]
)
print(response.choices[0].message.content)
De slice images[:5] is de veiligheidsrem van het script. Zonder dit zou een map met tweehonderd screenshots volledig in één enkele call terechtkomen—met de gevolgen die hieronder worden beschreven.
Grenzen van calls met meerdere afbeeldingen
Er is geen strikt gedocumenteerde limiet voor het aantal afbeeldingen, maar twee effecten treden op bij meer dan vijf tot tien: de analysekwaliteit neemt af naarmate de aandacht van het model over de afbeeldingen verspreidt, en de tokenkosten stijgen scherp. Denk terug aan de orde van grootte uit Les 2: elke afbeelding verbruikt 800 tot 1.500 tokens, dus vijf afbeeldingen vertegenwoordigen al 5.000 tot 7.500 prompt-tokens voordat uw vraag überhaupt begint. Het totaal—afbeeldingen, tekst en respons—moet ook binnen het contextvenster van het model passen, een plafond dat een batch afbeeldingen veel sneller bereikt dan een tekstdocument.
Deze functie berekent de kosten vóór de call in plaats van erna:
def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
"""Schat het totale aantal tokens voor een call met meerdere afbeeldingen."""
total_input = (num_images * tokens_per_image) + text_tokens
total = total_input + response_tokens
print(f"Afbeeldingen: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokens")
print(f"Prompt-tekst: {text_tokens} tokens")
print(f"Geschatte respons: {response_tokens} tokens")
print(f"Geschat totaal: {total} tokens")
return total
estimate_multi_image_cost(3)
# Afbeeldingen: 3 x 1000 = 3000 tokens
# Prompt-tekst: 100 tokens
# Geschatte respons: 500 tokens
# Geschat totaal: 3600 tokens
Strategie voor grote volumes
Bij meer dan vijf afbeeldingen wijzigt u uw aanpak in plaats van door te zetten. Er bestaan drie paden, vaak gecombineerd. Sequentiële analyse verwerkt afbeeldingen één voor één en aggregeert vervolgens de resultaten—de kosten blijven lineair en de precisie per afbeelding is maximaal. Batchgroepering verzendt pakketten van drie tot vijf afbeeldingen, waardoor enige vergelijking binnen de batch behouden blijft. Pre-filtering ten slotte gebruikt een lichter model zoals Small om irrelevante afbeeldingen te verwijderen voordat belangrijke gevallen aan Large worden doorgegeven.
Het eerste pad ziet er als volgt uit, met een finale synthese die alleen tekst verwerkt:
# Sequentiële analyse met aggregatie
results = []
for img_path in images:
response = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Beschrijf kort de inhoud van deze afbeelding."},
{"type": "image_url", "image_url": encode_image(img_path)}
]
}]
)
results.append(response.choices[0].message.content)
# Finale synthese (alleen tekst)
synthesis = client.chat.complete(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": f"Hier zijn beschrijvingen van {len(results)} afbeeldingen:\n\n" +
"\n---\n".join(results) +
"\n\nVerstrek een globale synthese."
}]
)
De truc zit in de tweede call: deze bevat geen afbeeldingen, dus geen visuele tokens. U synthetiseert vijftig afbeeldingen voor de prijs van een paar honderd tekst-tokens.
Belangrijkste punten
- U kunt meerdere afbeeldingen in één bericht verzenden door meerdere
image_url-elementen toe te voegen - Wissel tekst af tussen afbeeldingen om context aan het model te bieden
- Elke afbeelding voegt 800-1500 tokens toe—schat uw kosten voordat u de call doet
- Bij meer dan 5 afbeeldingen geeft u de voorkeur aan een sequentiële of gebatchte strategie
- URL’s en Base64 kunnen in hetzelfde bericht worden gemixt