Wysyłanie wielu obrazów w jednej wiadomości
Na tej stronie
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