Otimizar tokens de imagem
Nesta página
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
detailadequado à tarefa —lowquando 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