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

Porównywanie wielu obrazów

Lekcja 8 z 12 Zaktualizowano 30 lipca 2026 Początkujący
Na tej stronie
  1. Analiza wielu obrazów w jednym żądaniu
  2. Struktura żądania wieloobrazowego
  3. Przypadek użycia: Porównanie przed i po
  4. Przypadek użycia: Śledzenie zmian w czasie
  5. Przypadek użycia: Kontrola jakości
  6. Przypadek użycia: Analiza konkurencji
  7. Optymalizacja żądań wieloobrazowych
  8. Kluczowe wnioski

Analiza wielu obrazów w jednym żądaniu

Jedną z kluczowych zalet Grok Vision jest możliwość wysłania nieograniczonej liczby obrazów w ramach jednego żądania. Otwiera to unikalne możliwości porównań, śledzenia zmian w czasie oraz analizy krzyżowej, których nie oferują interfejsy API obsługujące pojedyncze obrazy.

Struktura żądania wieloobrazowego

Format jest prosty: dodaj do tablicy input tyle obiektów input_image, ile potrzebujesz, przeplatając je tekstem kierującym analizą:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {"type": "input_text", "text": "Obraz A:"},
        {"type": "input_image", "image_url": url_image_a},
        {"type": "input_text", "text": "Obraz B:"},
        {"type": "input_image", "image_url": url_image_b},
        {"type": "input_text", "text": "Porównaj szczegółowo te dwa obrazy."}
    ]
)

Opisanie każdego obrazu etykietą tekstową („Obraz A“, „Obraz B“) pomaga modelowi ustrukturyzować odpowiedź i jednoznacznie odnosić się do poszczególnych grafik.

Przypadek użycia: Porównanie przed i po

Idealne rozwiązanie do śledzenia postępów projektów, remontów, prac projektowych lub kontroli jakości:

def comparer_avant_apres(url_avant, url_apres):
    prompt = """Porównaj te dwa obrazy (przed i po) i zidentyfikuj:

1. Główne zmiany
2. Elementy, które pozostały bez zmian
3. Widoczne ulepszenia
4. Wszelkie potencjalne problemy, które mogły powstać

Przedstaw odpowiedź w formie ustrukturyzowanej listy."""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "PRZED:"},
            {"type": "input_image", "image_url": url_avant, "detail": "high"},
            {"type": "input_text", "text": "PO:"},
            {"type": "input_image", "image_url": url_apres, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Przypadek użycia: Śledzenie zmian w czasie

Śledź ewolucję lokalizacji, produktu lub procesu na przestrzeni czasu:

def analyser_evolution(images_chronologiques):
    """images_chronologiques: lista {"url": ..., "date": ...}"""
    input_data = []

    for img in images_chronologiques:
        input_data.append({
            "type": "input_text",
            "text": f"Zdjęcie z dnia {img['date']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": img["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Przeanalizuj chronologiczną ewolucję widoczną na
tych obrazach. Zidentyfikuj zmiany postępujące, trendy
oraz wszelkie istotne wydarzenia między poszczególnymi datami."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Przypadek użycia: Kontrola jakości

Porównaj wyprodukowany wyrób z jego modelem referencyjnym:

def controle_qualite(url_reference, url_produit):
    prompt = """Porównaj sfotografowany produkt z modelem referencyjnym.

Zidentyfikuj:
1. Zgodność (co odpowiada modelowi)
2. Niezgodności (odchylenia, wady, różnice)
3. Wagę każdej niezgodności (drobna, poważna, krytyczna)

Zwróć wynik w formacie JSON:
{
  "compliant": true/false,
  "score": 0-100,
  "compliances": [...],
  "non_compliances": [
    {"description": "...", "severity": "minor|major|critical"}
  ]
}"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "REFERENCJA (oczekiwany model):"},
            {"type": "input_image", "image_url": url_reference, "detail": "high"},
            {"type": "input_text", "text": "PRODUKT do sprawdzenia:"},
            {"type": "input_image", "image_url": url_produit, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Przypadek użycia: Analiza konkurencji

Porównaj interfejsy, opakowania lub prezentacje produktów konkurencji:

def analyser_concurrence(images_concurrents):
    """images_concurrents: [{"brand": "...", "url": "..."}]"""
    input_data = []

    for concurrent in images_concurrents:
        input_data.append({
            "type": "input_text",
            "text": f"{concurrent['brand']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": concurrent["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Porównaj te produkty/interfejsy konkurencji.
Dla każdego z nich zidentyfikuj wizualne mocne i słabe strony.
Przedstaw rekomendację dotyczącą pozycjonowania."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Optymalizacja żądań wieloobrazowych

Gdy wysyłasz wiele obrazów, zużycie tokenów rośnie bardzo szybko. Oto kilka strategii optymalizacji:

Dostosowanie poziomu szczegółowości

Używaj wartości low do ogólnych porównań, a high tylko wtedy, gdy analizujesz drobne detale:

# Porównanie ogólne: low wystarczy
detail = "low"  # ~256 tokenów na obraz

# Analiza wad: wymagane high
detail = "high"  # ~1024-1792 tokenów na obraz

Ograniczenie liczby obrazów na żądanie

Mimo że nie istnieje sztywny limit, przy więcej niż 10–15 obrazach jakość analizy może spaść. Model ma skończony kontekst i musi go rozdzielić między wszystkie obrazy:

# Jeśli więcej niż 10 obrazów, przetwarzaj partiami
def analyser_par_lots(images, taille_lot=10):
    resultats = []
    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]
        resultat = analyser_lot(lot)
        resultats.append(resultat)
    return fusionner_resultats(resultats)

Zmiana rozmiaru obrazów

Jeśli porównujesz zdjęcia o wysokiej rozdzielczości w celu ogólnej analizy, zmniejsz ich rozmiar przed wysłaniem, aby zredukować liczbę tokenów:

def preparer_pour_comparaison(chemin, taille_max=(800, 800)):
    img = Image.open(chemin)
    img.thumbnail(taille_max)
    # ... kodowanie do base64

Kluczowe wnioski

  • Liczba obrazów na żądanie jest nieograniczona – to kluczowa zaleta interfejsu API xAI
  • Opisuj każdy obraz tekstem, aby ustrukturyzować analizę
  • Dostosuj parametr detail do rodzaju przeprowadzanego porównania
  • Przy więcej niż 10–15 obrazach przetwarzaj dane partiami, aby utrzymać wysoką jakość
  • Do przypadków użycia należą: porównanie przed i po, śledzenie zmian w czasie, kontrola jakości oraz analiza konkurencji