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

Comparação de Múltiplas Imagens

Aula 8 de 12 Atualizada a 30 de julho de 2026 Iniciante
Nesta página
  1. Analisar Múltiplas Imagens num Único Pedido
  2. Estrutura do Pedido de Múltiplas Imagens
  3. Caso de Uso: Comparação Antes/Depois
  4. Caso de Uso: Acompanhamento Temporal
  5. Caso de Uso: Controlo de Qualidade
  6. Caso de Uso: Análise da Concorrência
  7. Otimização de Pedidos de Múltiplas Imagens
  8. Pontos-chave

Analisar Múltiplas Imagens num Único Pedido

Uma das principais vantagens do Grok Vision é a capacidade de enviar um número ilimitado de imagens num único pedido. Isto abre possibilidades únicas de comparação, acompanhamento temporal e análise cruzada que as APIs de imagem única não conseguem oferecer.

Estrutura do Pedido de Múltiplas Imagens

O formato é simples: adicione tantos objetos input_image quantos forem necessários ao array input, intercalando-os com texto para orientar a análise:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {"type": "input_text", "text": "Image A:"},
        {"type": "input_image", "image_url": url_image_a},
        {"type": "input_text", "text": "Image B:"},
        {"type": "input_image", "image_url": url_image_b},
        {"type": "input_text", "text": "Compare these two images in detail."}
    ]
)

Rotular cada imagem com texto (“Imagem A”, “Imagem B”) ajuda o modelo a estruturar a sua resposta e a referenciar claramente cada imagem.

Caso de Uso: Comparação Antes/Depois

Ideal para acompanhamento de projetos, renovações, design ou controlo de qualidade:

def comparer_avant_apres(url_avant, url_apres):
    prompt = """Compare these two images (before and after) and identify:

1. The main changes
2. Elements that have not changed
3. Visible improvements
4. Any potential issues introduced

Present your response as a structured list."""

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

Caso de Uso: Acompanhamento Temporal

Acompanhe a evolução de um local, produto ou processo ao longo do tempo:

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

    for img in images_chronologiques:
        input_data.append({
            "type": "input_text",
            "text": f"Photo from {img['date']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": img["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Analyze the chronological evolution visible in
these images. Identify progressive changes, trends,
and any notable events between the different dates."""
    })

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

Caso de Uso: Controlo de Qualidade

Compare um produto fabricado com o seu modelo de referência:

def controle_qualite(url_reference, url_produit):
    prompt = """Compare the photographed product to the reference model.

Identify:
1. Compliance (what matches the model)
2. Non-compliance (deviations, defects, differences)
3. Severity of each non-compliance (minor, major, critical)

Return a JSON with:
{
  "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": "REFERENCE (expected model):"},
            {"type": "input_image", "image_url": url_reference, "detail": "high"},
            {"type": "input_text", "text": "PRODUCT to check:"},
            {"type": "input_image", "image_url": url_produit, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Caso de Uso: Análise da Concorrência

Compare interfaces, embalagens ou apresentações de produtos de concorrentes:

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": """Compare these competitor products/interfaces.
For each, identify visual strengths and weaknesses.
Provide a positioning recommendation."""
    })

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

Otimização de Pedidos de Múltiplas Imagens

Quando envia muitas imagens, o consumo de tokens aumenta rapidamente. Eis algumas estratégias de otimização:

Ajustar o Nível de Detalhe

Utilize low para comparações gerais e high apenas quando analisar detalhes finos:

# Comparação global: low é suficiente
detail = "low"  # ~256 tokens per image

# Análise de defeitos: high necessário
detail = "high"  # ~1024-1792 tokens per image

Limitar o Número de Imagens por Pedido

Embora não exista um limite rígido, com mais de 10 a 15 imagens a qualidade da análise pode diminuir. O modelo tem um contexto finito e deve distribuí-lo por todas as imagens:

# Se mais de 10 imagens, processar em lotes
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)

Redimensionar Imagens

Se estiver a comparar fotografias de alta resolução para uma análise geral, redimensione-as antes de as enviar para reduzir os tokens:

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

Pontos-chave

  • O número de imagens por pedido é ilimitado — esta é uma vantagem chave da API xAI
  • Rotule cada imagem com texto para estruturar a análise
  • Ajuste o parâmetro detail ao tipo de comparação
  • Para mais de 10-15 imagens, processe em lotes para manter a qualidade
  • Os casos de uso incluem: antes/depois, acompanhamento temporal, controlo de qualidade e análise da concorrência