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

Otimizar tokens de imagem

Aula 10 de 12 Atualizada a 30 de julho de 2026 Iniciante
Nesta página
  1. Controle os seus custos em produção
  2. Estratégia 1: Escolha o nível de detalhe adequado
  3. Estratégia 2: Redimensionar antes do envio
  4. Estratégia 3: Pipeline de duas passagens
  5. Estratégia 4: Cache
  6. Monitorização e alertas
  7. Pontos-chave

Controle os seus custos em produção

Em produção, os tokens de imagem podem representar uma parte significativa da sua fatura de API. Uma única imagem no modo high consome até 1.792 tokens — o equivalente a vários parágrafos de texto. Multiplique isso por centenas ou milhares de pedidos diários e a otimização torna-se uma necessidade.

Estratégia 1: Escolha o nível de detalhe adequado

O parâmetro detail é a sua principal alavanca de otimização. O erro mais comum é utilizar high por predefinição, quando low ou auto são suficientes na maioria dos casos.

Matriz de decisão

Tarefa Detalhe recomendado Tokens estimados
Classificação de imagem low ~256
Descrição geral auto ~512-768
Texto alternativo / acessibilidade low ~256
Moderação de conteúdo auto ~512-768
OCR / extração de texto high ~1024-1792
Análise de gráficos high ~1024-1792
Deteção de defeitos high ~1024-1792

Estratégia 2: Redimensionar antes do envio

Imagens de alta resolução (4K, 8K) raramente são necessárias para análise por IA. Redimensionar consistentemente as suas imagens antes de as enviar reduz os tokens sem impacto percetível na qualidade da análise.

from PIL import Image
import io
import base64

class OptimiseurImage:
    TAILLES_PAR_TACHE = {
        "classification": (512, 512),
        "description": (1024, 1024),
        "ocr": (2048, 2048),
        "comparison": (800, 800),
    }

    @staticmethod
    def optimiser(chemin, tache="description", qualite=85):
        taille_max = OptimiseurImage.TAILLES_PAR_TACHE.get(
            tache, (1024, 1024)
        )

        img = Image.open(chemin)

        # Do not enlarge small images
        if img.width <= taille_max[0] and img.height <= taille_max[1]:
            pass
        else:
            img.thumbnail(taille_max)

        # Convert to JPEG to reduce size
        if img.mode in ("RGBA", "P"):
            img = img.convert("RGB")

        buffer = io.BytesIO()
        img.save(buffer, "JPEG", quality=qualite)
        buffer.seek(0)

        encoded = base64.standard_b64encode(buffer.read()).decode()
        return f"data:image/jpeg;base64,{encoded}"

Estratégia 3: Pipeline de duas passagens

Para grandes volumes, utilize um pipeline de duas passagens: uma primeira passagem rápida em low para triagem e, em seguida, uma segunda passagem em high apenas para as imagens que o exigem:

def pipeline_deux_passes(images):
    # Pass 1: fast classification (low)
    classifications = []
    for img in images:
        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": img, "detail": "low"},
                {"type": "input_text", "text": "Classify: document, photo, chart, other. One word."}
            ],
            store=False
        )
        classifications.append({
            "url": img,
            "type": response.output_text.strip().lower()
        })

    # Pass 2: detailed analysis (high) only if necessary
    resultats = []
    for item in classifications:
        if item["type"] in ("document", "chart"):
            detail = "high"
        else:
            detail = "auto"

        response = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": item["url"], "detail": detail},
                {"type": "input_text", "text": "Detailed analysis of this image."}
            ],
            store=False
        )
        resultats.append(response.output_text)

    return resultats

Estratégia 4: Cache

Se analisar as mesmas imagens várias vezes (testes, desenvolvimento, demonstração), coloque os resultados em cache:

import hashlib
import json

cache = {}

def vision_avec_cache(image_url, prompt, detail="auto"):
    # Create a unique key
    cle = hashlib.sha256(
        f"{image_url}:{prompt}:{detail}".encode()
    ).hexdigest()

    if cle in cache:
        return cache[cle]

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

    cache[cle] = response.output_text
    return response.output_text

Monitorização e alertas

Configure o rastreio de custos para detetar excedentes:

def monitorer_tokens(response, seuil_alerte=5000):
    usage = response.usage
    image_tokens = usage.prompt_tokens_details.image_tokens

    if image_tokens > seuil_alerte:
        print(f"ALERT: {image_tokens} image tokens (threshold: {seuil_alerte})")

    return {
        "image_tokens": image_tokens,
        "text_tokens": usage.prompt_tokens_details.text_tokens,
        "total": usage.total_tokens
    }

Pontos-chave

  • Escolha o nível de detail adequado à tarefa — low quando for suficiente
  • Redimensione as imagens antes do envio para reduzir o consumo
  • Utilize um pipeline de duas passagens para grandes volumes
  • Coloque os resultados em cache para evitar chamadas redundantes
  • Monitore os tokens de imagem em produção para antecipar custos