Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Comparar Imagens com a API Vision

Aula 10 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Análise Visual Comparativa
  2. Comparação Antes/Depois
  3. Controlo de Qualidade de Produtos
  4. Acompanhamento da Evolução ao Longo do Tempo
  5. Comparação de Interfaces de Utilizador
  6. Melhores Práticas de Comparação
  7. Pontos-chave

Análise Visual Comparativa

A comparação de imagens é um caso de uso poderoso que aproveita a capacidade de processamento de múltiplas imagens abordada na Lição 6. A questão deixa de ser «O que mostra esta imagem?» para passar a ser «O que mudou?» — uma operação que um modelo semântico trata de forma fundamentalmente diferente de um comparador de píxeis. Enquanto uma diferença de píxeis sinaliza uma divergência sem a qualificar, o modelo pode afirmar que um rótulo se deslocou dois milímetros e que um logótipo desapareceu, julgando depois qual dos dois factos é relevante.

Controlo de qualidade, acompanhamento da evolução, deteção de regressão visual: esta lição demonstra como estruturar prompts de comparação e aproveitar os resultados.

Comparação Antes/Depois

O cenário mais comum envolve verificar o que mudou entre dois estados. A mensagem do sistema define o método de comparação, enquanto a mensagem do utilizador identifica as imagens:

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)

Intercalar texto («BEFORE Image», «AFTER Image») ajuda o modelo a identificar a função de cada imagem. O terceiro passo no prompt do sistema é o que torna o relatório acionável: sem priorização, recebe uma lista onde uma mudança de sombra pesa tanto quanto uma peça em falta.

Controlo de Qualidade de Produtos

No final da cadeia de produção, este relatório deve ser lido por um programa, não por um humano. Combinamos, portanto, a comparação com o modo JSON da Lição 9: o modelo devolve um veredito, uma pontuação e uma lista de defeitos qualificados que o código pode explorar imediatamente.

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):
    """Compares a sample to its reference and detects defects."""
    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)

# Usage
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']}")

O campo recommendation é mais interessante do que parece: ao distinguir «review» de «reject», reserva a intervenção humana para casos ambíguos, em vez de a impor sistematicamente ou nunca a utilizar.

Acompanhamento da Evolução ao Longo do Tempo

Uma série temporal — canteiro de obras, crescimento de culturas, degradação de estruturas — é tratada como uma comparação alargada, desde que rotule cada imagem com a sua data. O modelo dispõe então do eixo temporal e pode qualificar um ritmo, não apenas uma lacuna.

def analyze_evolution(chronological_images, context=""):
    """Analyzes visible evolution across a series of ordered images."""
    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

# Construction site tracking
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)

A pergunta final é adicionada apenas depois de todas as imagens, uma vez que o ficheiro completo esteja estruturado.

Comparação de Interfaces de Utilizador

O desenvolvimento web oferece um caso de uso imediato: confrontar o mockup aprovado com o renderizado realmente produzido. Enquanto um teste de regressão de píxeis falha num deslocamento de um píxel sem importância, o modelo qualifica o impacto de cada discrepância.

def compare_interfaces(expected_screenshot, actual_screenshot):
    """Compares two interface screenshots to detect visual regressions."""
    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)

Integrada no seu pipeline de integração contínua, esta verificação bloqueia a entrega apenas mediante um veredito de regression.

Melhores Práticas de Comparação

Estes exemplos partilham alguns princípios que vale a pena explicitar. Nomeie sempre as suas imagens com um rótulo intercalado — «Reference», «Sample», «Before», «After» — porque, sem isso, o modelo atribui funções com base na aleatoriedade da ordem. Garanta a comparabilidade das capturas: com ângulos e iluminação diferentes, o modelo sinalizará discrepâncias que decorrem apenas das condições fotográficas. Utilize o Mistral Large 3, pois a comparação mobiliza um raciocínio de grande precisão que os modelos mais pequenos nem sempre dominam. Limite-se a duas ou três imagens por chamada; além disso, a precisão comparativa dilui-se. E solicite sistematicamente um formato estruturado, com uma pontuação, diferenças listadas e um veredito, caso o resultado deva ser processado automaticamente.

Pontos-chave

  • A comparação de imagens aproveita a capacidade de múltiplas imagens da API
  • Intercale texto explicativo entre as imagens para clarificar as suas funções
  • O modo JSON (response_format) é ideal para relatórios de comparação automatizados
  • Casos de uso principais: controlo de qualidade, acompanhamento de locais, QA visual, antes/depois
  • Utilize sempre o Mistral Large 3 para tarefas de comparação exigentes