Optimizar los tokens de imagen
En esta página
Controla tus costes en producción
En entornos de producción, los tokens de imagen pueden representar una parte significativa de tu factura de API. Una sola imagen en modo high consume hasta 1.792 tokens, lo que equivale a varios párrafos de texto. Si multiplicas esa cifra por cientos o miles de solicitudes diarias, la optimización se convierte en una necesidad.
Estrategia 1: Elige el nivel de detalle adecuado
El parámetro detail es tu principal palanca de optimización. El error más común es utilizar high por defecto cuando low o auto son suficientes en la mayoría de los casos.
Matriz de decisión
| Tarea | Detalle recomendado | Tokens estimados |
|---|---|---|
| Clasificación de imágenes | low | ~256 |
| Descripción general | auto | ~512-768 |
| Texto alternativo / accesibilidad | low | ~256 |
| Moderación de contenido | auto | ~512-768 |
| OCR / extracción de texto | high | ~1024-1792 |
| Análisis de gráficos | high | ~1024-1792 |
| Detección de defectos | high | ~1024-1792 |
Estrategia 2: Redimensionar antes de enviar
Las imágenes de alta resolución (4K, 8K) rara vez son necesarias para el análisis con IA. Redimensionar sistemáticamente tus imágenes antes de enviarlas reduce los tokens sin un impacto perceptible en la calidad del análisis.
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)
# No ampliar imágenes pequeñas
if img.width <= taille_max[0] and img.height <= taille_max[1]:
pass
else:
img.thumbnail(taille_max)
# Convertir a JPEG para reducir el tamaño
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}"
Estrategia 3: Canalización de dos pasadas
Para grandes volúmenes, utiliza una canalización de dos pasadas: una primera pasada rápida en low para clasificar y, a continuación, una segunda pasada en high solo para las imágenes que lo requieran:
def pipeline_deux_passes(images):
# Pasada 1: clasificación rápida (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": "Clasifica: documento, foto, gráfico, otro. Una sola palabra."}
],
store=False
)
classifications.append({
"url": img,
"type": response.output_text.strip().lower()
})
# Pasada 2: análisis detallado (high) solo si es necesario
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": "Análisis detallado de esta imagen."}
],
store=False
)
resultats.append(response.output_text)
return resultats
Estrategia 4: Caché
Si analizas las mismas imágenes varias veces (pruebas, desarrollo, demostraciones), almacena los resultados en caché:
import hashlib
import json
cache = {}
def vision_avec_cache(image_url, prompt, detail="auto"):
# Crear una clave única
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
Supervisión y alertas
Configura el seguimiento de costes para detectar excesos:
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"ALERTA: {image_tokens} tokens de imagen (umbral: {seuil_alerte})")
return {
"image_tokens": image_tokens,
"text_tokens": usage.prompt_tokens_details.text_tokens,
"total": usage.total_tokens
}
Puntos clave
- Elige el nivel de
detailadecuado para la tarea; usalowcuando sea suficiente - Redimensiona las imágenes antes de enviarlas para reducir el consumo
- Utiliza una canalización de dos pasadas para grandes volúmenes
- Almacena los resultados en caché para evitar llamadas redundantes
- Supervisa los tokens de imagen en producción para anticipar los costes