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

Porównywanie obrazów za pomocą Vision API

Lekcja 10 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Wizualna analiza porównawcza
  2. Porównanie przed i po
  3. Kontrola jakości produktu
  4. Śledzenie ewolucji w czasie
  5. Porównywanie interfejsów użytkownika
  6. Najlepsze praktyki porównywania
  7. Kluczowe wnioski

Wizualna analiza porównawcza

Porównywanie obrazów to potężny przypadek użycia, który wykorzystuje możliwość obsługi wielu obrazów omówioną w Lekcji 6. Pytanie zmienia się z „Co przedstawia ten obraz?“ na „Co się zmieniło?“ – operacja, którą model semantyczny wykonuje fundamentalnie inaczej niż komparator pikseli. Podczas gdy różnica pikseli sygnalizuje rozbieżność bez jej kwalifikowania, model może stwierdzić, że etykieta przesunęła się o dwa milimetry, a logo zniknęło, a następnie ocenić, które z tych zdarzeń ma znaczenie.

Kontrola jakości, śledzenie ewolucji, wykrywanie regresji wizualnych: ta lekcja pokazuje, jak strukturyzować polecenia porównawcze i wykorzystywać uzyskane wyniki.

Porównanie przed i po

Najczęstszym scenariuszem jest weryfikacja zmian między dwoma stanami. Wiadomość systemowa definiuje metodę porównania, podczas gdy wiadomość użytkownika identyfikuje obrazy:

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": """You are an expert in comparative image analysis. When presented with two images:
1. Briefly describe each image
2. List identified differences (with location)
3. Assess the significance of each difference (minor/major)
4. Provide an overall similarity score (0-100%)"""
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "BEFORE Image (reference):"},
                {"type": "image_url", "image_url": "https://exemple.com/avant.jpg"},
                {"type": "text", "text": "AFTER Image (current state):"},
                {"type": "image_url", "image_url": "https://exemple.com/apres.jpg"},
                {"type": "text", "text": "Identify all differences between these two images."}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Przeplatanie tekstu („BEFORE Image“, „AFTER Image“) pomaga modelowi zidentyfikować rolę każdego obrazu. Trzeci krok w poleceniu systemowym sprawia, że raport jest użyteczny: bez priorytetyzacji otrzymujesz listę, w której zmiana cienia waży tyle samo, co brakująca część.

Kontrola jakości produktu

Na końcu procesu ten raport musi zostać odczytany przez program, a nie przez człowieka. Łączymy więc porównywanie z trybem JSON z Lekcji 9: model zwraca werdykt, wynik oraz listę zakwalifikowanych дефекtów, które kod może natychmiast wykorzystać.

import base64
import json

def encode_image(path):
    with open(path, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/jpeg;base64,{b64}"

def quality_control(reference_image, sample_image):
    """Porównuje próbkę z wzorcem i wykrywa дефекty."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "You are a quality inspector. Compare the sample to the reference and return a JSON report."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Reference (compliant product):"},
                    {"type": "image_url", "image_url": encode_image(reference_image)},
                    {"type": "text", "text": "Sample to inspect:"},
                    {"type": "image_url", "image_url": encode_image(sample_image)},
                    {
                        "type": "text",
                        "text": """Compare and return:
{
  "compliant": true/false,
  "compliance_score": 0-100,
  "defects": [
    {"description": "...", "severity": "minor/major/critical", "location": "..."}
  ],
  "recommendation": "accept/review/reject"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

# Użycie
result = quality_control("reference/product-ok.jpg", "batch-42/sample-7.jpg")

if result["compliant"]:
    print(f"COMPLIANT - Score: {result['compliance_score']}%")
else:
    print(f"NON-COMPLIANT - {len(result['defects'])} defect(s) detected")
    for defect in result["defects"]:
        print(f"  - [{defect['severity']}] {defect['description']}")

Pole recommendation jest bardziej interesujące, niż się wydaje: rozróżniając „review“ od „reject“, rezerwuje interwencję człowieka dla przypadków niejednoznacznych, zamiast narzucać ją wszędzie lub nigdzie.

Śledzenie ewolucji w czasie

Szereg czasowy – plac budowy, wzrost roślin, degradacja konstrukcji – traktuje się jako rozszerzone porównanie, pod warunkiem oznaczenia każdego obrazu datą. Model otrzymuje wówczas oś czasu i może zakwalifikować tempo zmian, a nie tylko lukę między stanami.

def analyze_evolution(chronological_images, context=""):
    """Analizuje widoczną ewolucję w serii uporządkowanych obrazów."""
    content = [
        {
            "type": "text",
            "text": f"Here are {len(chronological_images)} images taken at different times, in chronological order. {context}"
        }
    ]

    for i, (date, path) in enumerate(chronological_images):
        content.append({"type": "text", "text": f"Image {i+1} ({date}):"})
        content.append({"type": "image_url", "image_url": encode_image(path)})

    content.append({
        "type": "text",
        "text": "Describe the evolution observed between each step. Identify major changes and the general trend."
    })

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": content}]
    )

    return response.choices[0].message.content

# Śledzenie placu budowy
images = [
    ("2025-01", "site/jan-2025.jpg"),
    ("2025-06", "site/jun-2025.jpg"),
    ("2026-01", "site/jan-2026.jpg"),
]

evolution = analyze_evolution(images, context="Tracking a construction site.")
print(evolution)

Ostatnie pytanie dodajemy dopiero po wszystkich obrazach, gdy cały zestaw jest już przygotowany.

Porównywanie interfejsów użytkownika

Tworzenie stron internetowych oferuje natychmiastowe zastosowanie: skonfrontowanie zatwierdzonej makiety z faktycznie wygenerowanym renderem. Tam, gdzie test regresji pikseli zawodzi przy przesunięciu o jeden piksel bez znaczenia, model kwalifikuje wpływ każdej rozbieżności.

def compare_interfaces(expected_screenshot, actual_screenshot):
    """Porównuje dwa zrzuty ekranu interfejsu w celu wykrycia regresji wizualnych."""
    response = client.chat.complete(
        model="mistral-large-latest",
        response_format={"type": "json_object"},
        messages=[
            {
                "role": "system",
                "content": "You are a QA tester specializing in visual testing of web interfaces."
            },
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Expected design (mockup):"},
                    {"type": "image_url", "image_url": encode_image(expected_screenshot)},
                    {"type": "text", "text": "Current render (screenshot):"},
                    {"type": "image_url", "image_url": encode_image(actual_screenshot)},
                    {
                        "type": "text",
                        "text": """Compare and return:
{
  "pixel_perfect": true/false,
  "differences": [
    {"element": "...", "expected": "...", "actual": "...", "impact": "minor/moderate/major"}
  ],
  "fidelity_score": 0-100,
  "verdict": "compliant/minor_adjustments/regression"
}"""
                    }
                ]
            }
        ]
    )

    return json.loads(response.choices[0].message.content)

Wpięte w potok ciągłej integracji (CI), to sprawdzenie blokuje dostawę tylko w przypadku werdyktu regression.

Najlepsze praktyki porównywania

Te przykłady dzielą kilka zasad, które warto wyraźnie podkreślić. Zawsze nazywaj swoje obrazy przeplatanymi etykietami – „Reference“, „Sample“, „Before“, „After“ – ponieważ bez nich model przypisuje role w sposób losowy, zależny od kolejności. Zapewnij porównywalność ujęć: przy różnych kątach i oświetleniu model zgłosi rozbieżności wynikające wyłącznie z warunków fotograficznych. Używaj Mistral Large 3, ponieważ porównywanie wymaga wnioskowania o wysokiej precyzji, którego mniejsze modele nie zawsze opanowują. Ogranicz się do dwóch lub trzech obrazów na wywołanie; powyżej tej liczby precyzja porównawcza maleje. I systematycznie żądaj formatu strukturalnego, zawierającego wynik, listę różnic i werdykt, jeśli wynik ma być przetwarzany automatycznie.

Kluczowe wnioski

  • Porównywanie obrazów wykorzystuje możliwość obsługi wielu obrazów przez API
  • Przeplataj tekst wyjaśniający między obrazami, aby wyjaśnić ich role
  • Tryb JSON (response_format) jest idealny do automatycznych raportów porównawczych
  • Główne przypadki użycia: kontrola jakości, śledzenie placów budowy, wizualne QA, porównanie przed i po
  • Do wymagających zadań porównawczych zawsze używaj Mistral Large 3