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

Imagens Ilimitadas por Pedido

Aula 11 de 12 Atualizada a 30 de julho de 2026 Iniciante
Nesta página
  1. Uma Vantagem Competitiva da API xAI
  2. O Que “Ilimitado” Significa Realmente
  3. Recomendações Práticas por Volume
  4. Arquiteturas de Múltiplas Imagens em Produção
  5. Gestão de Erros com Grandes Conjuntos de Imagens
  6. Pontos-chave

Uma Vantagem Competitiva da API xAI

A API xAI destaca-se da concorrência num ponto técnico fundamental: não impõe qualquer limite ao número de imagens enviadas num único pedido. Enquanto outras APIs o limitam a 4, 10 ou 20 imagens, o Grok aceita quantas quiser.

Esta flexibilidade desbloqueia casos de uso impossíveis noutros locais, mas exige também uma compreensão sólida das implicações práticas.

O Que “Ilimitado” Significa Realmente

Não haver limite na contagem de imagens não significa ausência de restrições. Vários fatores limitam naturalmente quantas imagens pode enviar de forma eficaz:

Janela de Contexto

O modelo possui uma janela de contexto fixa. Cada imagem consome entre 256 e 1792 tokens. Se enviar 50 imagens no modo high, potencialmente utiliza 89.600 tokens apenas para as imagens, restando pouco espaço para texto e para a resposta.

Qualidade da Análise

Acima de determinado número de imagens, a qualidade da análise diminui. O modelo deve distribuir a sua atenção por todas as imagens, o que pode levar a descrições superficiais ou omissões.

Latência e Tempo Limite (Timeout)

Quanto mais imagens enviar, mais demorado será o processamento. Com um tempo limite recomendado de 3600 segundos para modelos de raciocínio, pedidos muito grandes podem aproximar-se deste limite.

Recomendações Práticas por Volume

Número de Imagens Recomendação Detalhe Sugerido
1-3 Análise detalhada possível high
4-10 Comparação eficiente auto
11-20 Classificação em lote low
20+ Dividir em subpedidos low

Arquiteturas de Múltiplas Imagens em Produção

Padrão: Processamento Sequencial com Agregação

Para analisar um grande número de imagens, processe-as em lotes e agregue depois os resultados:

import json

def analyser_catalogue(images, taille_lot=8):
    """Analyzes an image catalogue in batches."""
    tous_resultats = []

    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]

        input_data = []
        for j, img in enumerate(lot, 1):
            input_data.append({
                "type": "input_text",
                "text": f"Image {i + j}:"
            })
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })

        input_data.append({
            "type": "input_text",
            "text": """For each image, identify in JSON:
{"number": N, "category": "...", "short_description": "..."}
Return a JSON array."""
        })

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

        try:
            resultats_lot = json.loads(response.output_text)
            tous_resultats.extend(resultats_lot)
        except json.JSONDecodeError:
            tous_resultats.append({"batch": i, "raw": response.output_text})

    return tous_resultats

Padrão: Filtragem em Funil

Comece por uma triagem rápida em todas as imagens e depois aprofunde apenas as que são relevantes:

def entonnoir_analyse(images, critere):
    """Filters then analyzes in depth."""
    # Step 1: Quick filtering
    input_data = []
    for i, img in enumerate(images):
        input_data.append({"type": "input_image", "image_url": img, "detail": "low"})

    input_data.append({
        "type": "input_text",
        "text": f"""Among these {len(images)} images, which ones
match the criteria: "{critere}"?
Return only the numbers (0-based index) in JSON: [0, 3, 7]"""
    })

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

    indices = json.loads(response.output_text)

    # Step 2: In-depth analysis of filtered images
    resultats = []
    for idx in indices:
        response_detail = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": images[idx], "detail": "high"},
                {"type": "input_text", "text": "Detailed analysis of this image."}
            ],
            store=False
        )
        resultats.append({"index": idx, "analysis": response_detail.output_text})

    return resultats

Gestão de Erros com Grandes Conjuntos de Imagens

Ao trabalhar com um grande número de imagens, os erros são mais prováveis. Implemente uma gestão robusta:

import time

def requete_avec_retry(input_data, max_retries=3):
    for tentative in range(max_retries):
        try:
            response = client.responses.create(
                model="grok-4.5",
                input=input_data,
                store=False
            )
            return response
        except Exception as e:
            if tentative < max_retries - 1:
                delai = 2 ** tentative  # Exponential backoff
                time.sleep(delai)
            else:
                raise e

Pontos-chave

  • A API xAI aceita um número ilimitado de imagens, mas a janela de contexto permanece finita
  • Acima de 10 imagens, utilize detail: "low" para preservar a qualidade da análise
  • Acima de 20 imagens, divida em subpedidos para garantir fiabilidade
  • O padrão de «funil» (filtragem rápida seguida de análise detalhada) é o mais eficaz para grandes volumes
  • Implemente novas tentativas com recuo exponencial para pedidos de grande dimensão