Ir al contenido principal
Español— Elegir un idioma
Menú

Optimizar los tokens de imagen

Lección 10 de 12 Actualizado el 30 de julio de 2026 Principiante
En esta página
  1. Controla tus costes en producción
  2. Estrategia 1: Elige el nivel de detalle adecuado
  3. Estrategia 2: Redimensionar antes de enviar
  4. Estrategia 3: Canalización de dos pasadas
  5. Estrategia 4: Caché
  6. Supervisión y alertas
  7. Puntos clave

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 detail adecuado para la tarea; usa low cuando 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