Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Send flere billeder i én besked

Lektion 6 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Analysér flere billeder på én gang
  2. Struktur for en besked med flere billeder
  3. Eksempel: Sammenligning af to billeder
  4. Fletning af tekst og billeder
  5. Batch-behandling med Base64
  6. Grænser for kald med flere billeder
  7. Strategi for store mængder
  8. Vigtige pointer

Analysér flere billeder på én gang

Mistrals Vision-API er ikke begrænset til ét billede pr. besked. Du kan sende flere billeder i et enkelt kald for at bede modellen om at sammenligne, syntetisere eller analysere dem samlet. Forskellen mellem dette og to separate kald er afgørende: I et enkelt kald ser modellen begge billeder samtidigt og kan ræsonnere over deres indbyrdes forhold – noget ingen aggregering af individuelle svar kan opnå.

Denne funktion åbner op for anvendelsestilfælde, hvor spørgsmålet fokuserer på forskellen snarere end indholdet: før/efter-sammenligninger, analyse af dokumentserier eller visuelle overholdelseskontroller.

Struktur for en besked med flere billeder

Princippet er simpelt: Tilføj flere image_url-elementer til content-arrayet:

message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Sammenlign disse to billeder og beskriv forskellene."},
        {"type": "image_url", "image_url": "https://example.com/image1.jpg"},
        {"type": "image_url", "image_url": "https://example.com/image2.jpg"}
    ]
}

Homogenitet er ikke påkrævet: Du kan blande billeder via URL og Base64 i samme besked. Dette er almindeligt, når du skal sammenligne et hostet referencebillede med en nygenereret lokal fil.

Eksempel: Sammenligning af to billeder

Overvej en modtagekontrol i et lager. Du sammenligner et referencefoto af det godkendte produkt med et foto af den modtagne prøve ved hjælp af en system-prompt, der definerer inspektørens rolle:

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": "Du er en kvalitetskontrolsekspert. Sammenlign de leverede billeder med præcision."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Her er to fotos af samme produkt. Det første er referencen, det andet er den modtagne prøve. Identificér alle forskelle."
                },
                {"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)

Teksten angiver eksplicit rækkefølgen – „det første er referencen” – fordi modellen ikke kan gætte sig til det.

Fletning af tekst og billeder

Denne tilgang med rækkefølge stød hurtigt på sine grænser, når der er flere end to billeder. En mere robust metode er at mærke hvert billede lige før det leveres ved at alternerne mellem text- og image_url-elementer:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Her er den oprindelige arkitekttegning:"},
                {"type": "image_url", "image_url": "https://example.com/plan-original.png"},
                {"type": "text", "text": "Og her er fotoet af den opførte bygning:"},
                {"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
                {"type": "text", "text": "Matcher bygningen tegningen? Oplist afvigelserne."}
            ]
        }
    ]
)

Hvert billede har nu sin egen etiket, og det endelige spørgsmål kommer først, efter alt materiale er præsenteret. Dette format forbedrer modellens forståelse markant: Den ved, at tegningen er standarden, og at fotoet er objektet, der skal evalueres. At vende om på dem ville producere en inverteret afvigelsesrapport.

Batch-behandling med Base64

For en mappe med lokale billeder bliver opbygningen af content-delen programmatisk. Du samler listen i en løkke og encoder hver fil løbende:

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}"

# Indlæs alle billeder fra en mappe
folder = Path("captures/")
images = sorted(folder.glob("*.png"))

# Opbyg beskedens indhold
content = [{"type": "text", "text": f"Analysér disse {len(images)} skærmbilleder og opsummer fælles elementer."}]
for img in images[:5]:  # Begræns til maks. 5 billeder
    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)

Slicet images[:5] er scriptets sikkerhedsnet. Uden det ville en mappe med to hundrede skærmbilleder blive sendt i ét enkelt kald – med de konsekvenser, der beskrives lige nedenfor.

Grænser for kald med flere billeder

Der er ingen strengt dokumenteret grænse for antallet af billeder, men to effekter kombineres, når man overstiger fem til ti: Analyse kvaliteten forringes, efterhånden som modellens opmærksomhed udvandes på tværs af billederne, og token-omkostningerne stiger kraftigt. Husk størrelsesordenen fra lektion 2: Hvert billede bruger 800 til 1.500 tokens, så fem billeder repræsenterer allerede 5.000 til 7.500 prompt-tokens, før dit spørgsmål overhovedet starter. Totalen – billeder, tekst og svar – skal også passe inden for modellens kontekstvindue, et loft som en batch af billeder når meget hurtigere end et tekstdokument.

Denne funktion beregner regningen før kaldet i stedet for efter:

def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
    """Estimér samlede tokens for et kald med flere billeder."""
    total_input = (num_images * tokens_per_image) + text_tokens
    total = total_input + response_tokens

    print(f"Billeder: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokens")
    print(f"Prompt-tekst: {text_tokens} tokens")
    print(f"Estimeret svar: {response_tokens} tokens")
    print(f"Estimeret total: {total} tokens")
    return total

estimate_multi_image_cost(3)
# Billeder: 3 x 1000 = 3000 tokens
# Prompt-tekst: 100 tokens
# Estimeret svar: 500 tokens
# Estimeret total: 3600 tokens

Strategi for store mængder

Ved mere end fem billeder bør du ændre din tilgang i stedet for at presse på. Der findes tre veje, som ofte kombineres. Sekventiel analyse behandler billeder ét ad gangen og aggregerer derefter resultaterne – omkostningerne forbliver lineære, og præcisionen pr. billede er maksimal. Batch-gruppering sender pakker på tre til fem billeder, hvilket bevarer en vis sammenligning inden for batchen. Pre-filtering bruger endelig en lettere model som Small til at frasortere irrelevante billeder, før vigtige tilfælde overdrages til Large.

Den første vej ser sådan ud, med en endelig syntese, der kun håndterer tekst:

# Sekventiel analyse med aggregering
results = []
for img_path in images:
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Beskriv kort indholdet af dette billede."},
                {"type": "image_url", "image_url": encode_image(img_path)}
            ]
        }]
    )
    results.append(response.choices[0].message.content)

# Endelig syntese (kun tekst)
synthesis = client.chat.complete(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": f"Her er beskrivelser af {len(results)} billeder:\n\n" +
                   "\n---\n".join(results) +
                   "\n\nGiv en global syntese."
    }]
)

Tricket ligger i det andet kald: Det indeholder ingen billeder, så ingen visuelle tokens. Du syntetiserer halvtreds billeder for prisen af et par hundrede tekst-tokens.

Vigtige pointer

  • Du kan sende flere billeder i én besked ved at tilføje flere image_url-elementer
  • Flet tekst mellem billeder for at give modellen kontekst
  • Hvert billede tilføjer 800-1500 tokens – estimér dine omkostninger før kaldet
  • Ved mere end 5 billeder bør du foretrække en sekventiel eller batch-strategi
  • URLs og Base64 kan blandes i samme besked