Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Több kép küldése egyetlen üzenetben

6. lecke 12 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Több kép elemzése egyszerre
  2. Többképes üzenet felépítése
  3. Példa: Két kép összehasonlítása
  4. Szöveg és képek váltakoztatása
  5. Köteges feldolgozás Base64-kódolással
  6. A többképes hívások korlátai
  7. Stratégia nagy mennyiségek esetén
  8. Főbb megállapítások

Több kép elemzése egyszerre

A Mistral Vision API nem korlátozódik üzenetenként egyetlen képre. Több képet is küldhetsz egyetlen hívásban, hogy összehasonlítsd, szintetizáld vagy együtt elemeztesd őket a modellel. A különbség e és két külön hívás között kritikus: egyetlen hívás esetén a modell mindkét képet egyszerre látja, és képes következtetni a közöttük lévő kapcsolatokra – erre pedig az egyes válaszok bármilyen aggregálása nem lenne képes.

Ez a lehetőség olyan eseteket nyit meg, ahol a kérdés nem a tartalomra, hanem a különbségekre fókuszál: előtte/utána összehasonlítások, dokumentumsorozatok elemzése vagy vizuális megfelelőség-ellenőrzések.

Többképes üzenet felépítése

Az elv egyszerű: adj hozzá több image_url elemet a content tömbhöz:

message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Hasonlítsd össze ezt a két képet, és írd le a különbségeket."},
        {"type": "image_url", "image_url": "https://example.com/image1.jpg"},
        {"type": "image_url", "image_url": "https://example.com/image2.jpg"}
    ]
}

Nincs szükség homogenitásra: ugyanabban az üzenetben keverheted az URL-címekkel és Base64-kódolással megadott képeket. Ez akkor gyakori, amikor egy hosztolt referenciaképet kell összehasonlítanod egy frissen generált helyi fájllal.

Példa: Két kép összehasonlítása

Vegyünk egy raktári átvételi ellenőrzést. Összehasonlítod a megfelelős termékről készült referenciafotót az átvett mintáról készült fotóval, egy olyan rendszerpromptot használva, amely meghatározza az ellenőr szerepét:

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": "Te minőségellenőrző szakértő vagy. Pontosan hasonlítsd össze a megadott képeket."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Íme ugyanannak a terméknek két fotója. Az első a referencia, a második az átvett minta. Azonosítsd az összes különbséget."
                },
                {"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)

A szöveg kifejezetten tisztázza a sorrendet – „az első a referencia“ –, mert a modell nem tudja ezt kitalálni.

Szöveg és képek váltakoztatása

Ez a sorrendezési megközelítés gyorsan eléri a határait, ha kettőnél több képről van szó. Egy robusztusabb módszer, ha minden képet címkével látsz el közvetlenül a megadása előtt, váltakozva text és image_url elemekkel:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Íme az eredeti építészeti terv:"},
                {"type": "image_url", "image_url": "https://example.com/plan-original.png"},
                {"type": "text", "text": "És itt látható a megépült épület fotója:"},
                {"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
                {"type": "text", "text": "Megfelel az épület a tervnek? Sorold fel az eltéréseket."}
            ]
        }
    ]
)

Így minden kép megkapja a saját címkéjét, és a végső kérdés csak az összes anyag bemutatása után érkezik. Ez a formátum jelentősen javítja a modell megértését: tudja, hogy a terv a szabvány, a fotó pedig az értékelendő tárgy. Ha felcserélnéd őket, fordított eltérésjelentést kapnál.

Köteges feldolgozás Base64-kódolással

Helyi képeket tartalmazó mappa esetén a content felépítése programozottá válik. Egy ciklusban állítod össze a listát, menet közben kódolva minden fájlt:

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

# Összes kép betöltése egy mappából
folder = Path("captures/")
images = sorted(folder.glob("*.png"))

# Az üzenet tartalmának felépítése
content = [{"type": "text", "text": f"Elemezd ezt a {len(images)} képernyőképet, és foglald össze a közös elemeket."}]
for img in images[:5]:  # Limitálás maximum 5 képre
    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)

Az images[:5] szeletelés a script biztonsági őre. Enélkül egy kétszáz képernyőképet tartalmazó mappa teljes egésze egyetlen hívásba kerülne – a lentebb leírt következményekkel.

A többképes hívások korlátai

Nincs szigorúan dokumentált korlát a képek számára vonatkozóan, de öt-tíz kép felett két hatás kombinálódik: az elemzés minősége romlik, ahogy a modell figyelme szétoszlik a képek között, és a tokenköltségek meredeken emelkednek. Emlékezz vissza a 2. leckében tárgyalt nagyságrendre: minden kép 800–1500 tokent fogyaszt, így öt kép már 5000–7500 prompt tokent jelent, mielőtt még a kérdésed elkezdődne. A teljes mennyiségnek – képek, szöveg és válasz – bele kell férnie a modell kontextusablakába is; ezt a plafont egy képköteg sokkal gyorsabban eléri, mint egy szöveges dokumentum.

Ez a függvény még a hívás előtt kiszámolja a számlát, nem utána:

def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
    """Becsült teljes tokenmennyiség egy többképes híváshoz."""
    total_input = (num_images * tokens_per_image) + text_tokens
    total = total_input + response_tokens

    print(f"Képek: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} token")
    print(f"Prompt szöveg: {text_tokens} token")
    print(f"Becsült válasz: {response_tokens} token")
    print(f"Becsült összesen: {total} token")
    return total

estimate_multi_image_cost(3)
# Képek: 3 x 1000 = 3000 token
# Prompt szöveg: 100 token
# Becsült válasz: 500 token
# Becsült összesen: 3600 token

Stratégia nagy mennyiségek esetén

Öt képen túl változtass a megközelítéseden, ahelyett, hogy erőltetnéd a dolgot. Három út létezik, amelyeket gyakran kombinálnak. A szekvenciális elemzés egyesével dolgozza fel a képeket, majd aggregálja az eredményeket – a költség lineáris marad, és a képenkénti pontosság maximális. A köteges csoportosítás három-öt képes csomagokat küld, megőrizve bizonyos mértékű csomagon belüli összehasonlítást. Az előszűrés végül egy könnyebb modellt, például a Smallot használja a lényegtelen képek kiszűrésére, mielőtt a fontos eseteket a Large modellhez továbbítaná.

Az első út így néz ki, egy végső szintézissel, amely csak szöveget kezel:

# Szekvenciális elemzés aggregálással
results = []
for img_path in images:
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Röviden írd le ennek a képnek a tartalmát."},
                {"type": "image_url", "image_url": encode_image(img_path)}
            ]
        }]
    )
    results.append(response.choices[0].message.content)

# Végső szintézis (csak szöveg)
synthesis = client.chat.complete(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": f"Íme {len(results)} kép leírása:\n\n" +
                   "\n---\n".join(results) +
                   "\n\nKészíts egy globális szintézist."
    }]
)

A trükk a második hívásban rejlik: ez nem tartalmaz képeket, tehát nincsenek vizuális tokenek. Így ötven képet szintetizálsz néhány száz szöveges token áráért.

Főbb megállapítások

  • Több képet is küldhetsz egyetlen üzenetben több image_url elem hozzáadásával
  • Váltogass szöveget a képek között, hogy kontextust adj a modellnek
  • Minden kép 800–1500 tokent ad hozzá – becsld meg a költségeidet hívás előtt
  • 5 kép felett részesítsd előnyben a szekvenciális vagy köteges stratégiát
  • URL-címek és Base64 kódolás keverhető ugyanabban az üzenetben