Przejdź do głównej treści
Polski— Wybierz język
Menu

Wysyłanie wielu obrazów w jednej wiadomości

Lekcja 6 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Analiza wielu obrazów jednocześnie
  2. Struktura wiadomości wieloobrazowej
  3. Przykład: Porównanie dwóch obrazów
  4. Przeplatanie tekstu i obrazów
  5. Przetwarzanie wsadowe z Base64
  6. Ograniczenia wywołań wieloobrazowych
  7. Strategia dla dużych wolumenów
  8. Kluczowe wnioski

Analiza wielu obrazów jednocześnie

API Vision od Mistral nie ogranicza się do jednego obrazu na wiadomość. Możesz wysłać wiele obrazów w jednym wywołaniu, aby poprosić model o ich porównanie, syntezę lub wspólną analizę. Różnica między tym podejściem a dwoma osobnymi wywołaniami jest kluczowa: w ramach jednego wywołania model widzi oba obrazy jednocześnie i może wnioskować o relacjach między nimi – czego nie da się osiągnąć poprzez agregację indywidualnych odpowiedzi.

Możliwość ta otwiera scenariusze użycia, w których pytanie koncentruje się na różnicach, a nie na samej treści: porównania „przed i po“, analiza serii dokumentów czy wizualne kontrole zgodności.

Struktura wiadomości wieloobrazowej

Zasada jest prosta: dodaj wiele elementów image_url do tablicy content:

message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Porównaj te dwa obrazy i opisz różnice."},
        {"type": "image_url", "image_url": "https://example.com/image1.jpg"},
        {"type": "image_url", "image_url": "https://example.com/image2.jpg"}
    ]
}

Jednorodność nie jest wymagana: możesz mieszać obrazy podawane jako URL i Base64 w tej samej wiadomości. Jest to powszechne, gdy musisz porównać hostowany obraz referencyjny z nowo wygenerowanym plikiem lokalnym.

Przykład: Porównanie dwóch obrazów

Rozważmy kontrolę odbiorczą w magazynie. Porównujesz zdjęcie referencyjne produktu zgodnego ze zdjęciem otrzymanej próbki, używając monitu systemowego, który ustanawia rolę inspektora:

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": "Jesteś ekspertem ds. kontroli jakości. Porównaj dostarczone obrazy z precyzją."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Oto dwa zdjęcia tego samego produktu. Pierwsze to wzorzec, drugie to otrzymana próbka. Zidentyfikuj wszystkie różnice."
                },
                {"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)

Tekst wyraźnie określa kolejność – „pierwsze to wzorzec“ – ponieważ model nie może jej odgadnąć.

Przeplatanie tekstu i obrazów

To podejście oparte na kolejności szybko osiąga swoje granice przy więcej niż dwóch obrazach. Bardziej solidną metodą jest opisanie każdego obrazu tuż przed jego dostarczeniem, naprzemiennie umieszczając elementy text i image_url:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Oto oryginalny plan architektoniczny:"},
                {"type": "image_url", "image_url": "https://example.com/plan-original.png"},
                {"type": "text", "text": "A oto zdjęcie wybudowanego budynku:"},
                {"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
                {"type": "text", "text": "Czy budynek jest zgodny z planem? Wymień rozbieżności."}
            ]
        }
    ]
)

Każdy obraz ma teraz własną etykietę, a końcowe pytanie pojawia się dopiero po przedstawieniu całego materiału. Ten format znacząco poprawia zrozumienie przez model: wie, że plan jest standardem, a zdjęcie obiektem podlegającym ocenie. Odwrócenie ich kolejności skutkowałoby odwróconym raportem rozbieżności.

Przetwarzanie wsadowe z Base64

W przypadku folderu z lokalnymi obrazami budowanie zawartości content staje się procesem programistycznym. Składasz listę w pętli, kodując każdy plik w locie:

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

# Załaduj wszystkie obrazy z folderu
folder = Path("captures/")
images = sorted(folder.glob("*.png"))

# Zbuduj zawartość wiadomości
content = [{"type": "text", "text": f"Przeanalizuj te {len(images)} zrzuty ekranu i podsumuj wspólne elementy."}]
for img in images[:5]:  # Ogranicz do maksymalnie 5 obrazów
    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)

Wycinek images[:5] pełni funkcję zabezpieczenia skryptu. Bez niego folder zawierający dwieście zrzutów ekranu zostałby w całości przekazany w jednym wywołaniu – z konsekwencjami opisanymi poniżej.

Ograniczenia wywołań wieloobrazowych

Nie ma sztywnego, udokumentowanego limitu liczby obrazów, ale powyżej pięciu do dziesięciu łączą się dwa efekty: jakość analizy spada, ponieważ uwaga modelu rozprasza się na wiele obrazów, a koszty tokenów gwałtownie rosną. Przypomnij sobie rzędy wielkości z Lekcji 2: każdy obraz zużywa od 800 do 1500 tokenów, więc pięć obrazów to już od 5000 do 7500 tokenów promptu, zanim jeszcze zaczniesz zadawać pytanie. Całość – obrazy, tekst i odpowiedź – musi również zmieścić się w oknie kontekstowym modelu, którego limit w przypadku partii obrazów osiągany jest znacznie szybciej niż w przypadku dokumentu tekstowego.

Poniższa funkcja oblicza koszt przed wywołaniem, a nie po nim:

def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
    """Oszacuj całkowitą liczbę tokenów dla wywołania wieloobrazowego."""
    total_input = (num_images * tokens_per_image) + text_tokens
    total = total_input + response_tokens

    print(f"Obrazy: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokenów")
    print(f"Tekst promptu: {text_tokens} tokenów")
    print(f"Szacowana odpowiedź: {response_tokens} tokenów")
    print(f"Szacowana łączna liczba: {total} tokenów")
    return total

estimate_multi_image_cost(3)
# Obrazy: 3 x 1000 = 3000 tokenów
# Tekst promptu: 100 tokenów
# Szacowana odpowiedź: 500 tokenów
# Szacowana łączna liczba: 3600 tokenów

Strategia dla dużych wolumenów

Powyżej pięciu obrazów zmień podejście, zamiast forsować rozwiązanie. Istnieją trzy ścieżki, często łączone ze sobą. Analiza sekwencyjna przetwarza obrazy jeden po drugim, a następnie agreguje wyniki – koszt pozostaje liniowy, a precyzja dla każdego obrazu jest maksymalna. Grupowanie wsadowe wysyła pakiety od trzech do pięciu obrazów, zachowując możliwość porównania wewnątrz grupy. Filtrowanie wstępne wykorzystuje z kolei lżejszy model, taki jak Small, aby odrzucić nieistotne obrazy przed przekazaniem ważnych przypadków do modelu Large.

Pierwsza ścieżka wygląda następująco, z finalną syntezą obsługującą wyłącznie tekst:

# Analiza sekwencyjna z agregacją
results = []
for img_path in images:
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Krótko opisz zawartość tego obrazu."},
                {"type": "image_url", "image_url": encode_image(img_path)}
            ]
        }]
    )
    results.append(response.choices[0].message.content)

# Finalna synteza (tylko tekst)
synthesis = client.chat.complete(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": f"Oto opisy {len(results)} obrazów:\n\n" +
                   "\n---\n".join(results) +
                   "\n\nPrzedstaw globalną syntezę."
    }]
)

Sztuczka polega na drugim wywołaniu: nie zawiera ono żadnych obrazów, więc nie generuje tokenów wizualnych. Syntezujesz pięćdziesiąt obrazów za cenę kilkuset tokenów tekstowych.

Kluczowe wnioski

  • Możesz wysłać wiele obrazów w jednej wiadomości, dodając wiele elementów image_url
  • Przeplataj tekst między obrazami, aby dostarczyć modelowi kontekstu
  • Każdy obraz dodaje 800–1500 tokenów – oszacuj koszty przed wywołaniem
  • Powyżej 5 obrazów preferuj strategię sekwencyjną lub wsadową
  • URL-e i Base64 mogą być mieszane w tej samej wiadomości