Límites y optimización de la Vision API
En esta página
Conoce los límites para sortearlos
Las diez lecciones anteriores han cubierto lo que la Vision API hace bien. Esta trata donde flaquea. No se trata de un ejercicio de humildad: la diferencia entre un prototipo de demostración que impresiona y una aplicación que resiste en producción reside exactamente en esto. Aquí aprenderás sobre las restricciones técnicas, los errores comunes —siendo las alucinaciones visuales el principal de ellos— y las estrategias para optimizar el coste y la latencia.
Límites técnicos
Ya hemos tocado las restricciones de formato antes, pero vamos a reunirlas. Cada imagen tiene un límite de aproximadamente 20 MB y, de todos modos, se redimensionará internamente, típicamente a 768x768 o equivalente: una imagen 4K no mejorará los resultados. Los formatos aceptados son JPEG, PNG, GIF (solo el primer fotograma) y WebP. La Vision API no admite PDF directamente; necesitas llamar a Document AI para ello, como se discutió en la Lección 8.
La restricción más estructural sigue siendo el consumo de tokens. Cada imagen consume un número significativo de tokens, y esta función traduce esa estimación a dólares en lugar de unidades abstractas:
# Estima el coste de una llamada a vision
def estimate_cost(num_images=1, text_tokens=100, response_tokens=500,
tokens_per_image=1000, input_price=0.10, output_price=0.30):
"""Estima el coste en dólares para una llamada a vision (Small 3.2)."""
input_tokens = (num_images * tokens_per_image) + text_tokens
output_tokens = response_tokens
input_cost = (input_tokens / 1_000_000) * input_price
output_cost = (output_tokens / 1_000_000) * output_price
total_cost = input_cost + output_cost
print(f"Tokens de entrada: {input_tokens} (${input_cost:.4f})")
print(f"Tokens de salida: {output_tokens} (${output_cost:.4f})")
print(f"Coste total: ${total_cost:.4f}")
return total_cost
# 1 imagen con Small 3.2
estimate_cost(num_images=1)
# 5 imágenes con Large 3
estimate_cost(num_images=5, input_price=2.00, output_price=6.00)
Compara las dos llamadas al final del script: la segunda cuesta decenas de veces más que la primera. Multiplica eso por tu volumen diario antes de tomar una decisión. Además, está el límite de la ventana de contexto, que la suma de imágenes + prompt + respuesta no debe superar; un techo que múltiples imágenes alcanzan mucho más rápido que un texto largo.
Alucinaciones visuales
El modelo puede «inventar» detalles ausentes en la imagen. Este es el problema más crítico en producción porque es silencioso: la respuesta está bien formada, es plausible y es errónea.
Cuatro patrones se repiten. Texto inventado, donde el modelo lee una palabra que no existe en la imagen. Números aproximados, donde los valores leídos de un gráfico pueden desviarse un 5–15 % de la realidad. Detalles añadidos, donde el modelo rellena lo que no ve claramente con información plausible: un número SIRET borroso se convierte en un SIRET perfectamente formateado pero falso. Finalmente, confusión de elementos, donde dos objetos cercanos se fusionan en uno.
Existen tres contramedidas; combínalas según la criticidad. Primero, obliga al modelo a calificar su propia certeza. Segundo, haz que relea la imagen después de transcribir. Tercero, enfrenta a dos modelos a la misma pregunta y conserva solo aquello en lo que coincidan.
# 1. Pide un nivel de confianza
prompt_confiance = """Analiza esta imagen. Para cada dato extraído, indica tu nivel de confianza:
- [SEGURO]: claramente visible
- [PROBABLE]: parcialmente visible o inferido
- [INSEGURO]: apenas legible, estimado
Si un elemento es ilegible, márcalo [ILEGIBLE] en lugar de adivinar."""
# 2. Pide una verificación cruzada
prompt_verification = """Lee el texto de este documento. Después de transcribir, vuelve a leer la imagen y verifica cada número y nombre propio. Corrige cualquier error detectado."""
# 3. Doble lectura con dos modelos
def double_verification(image_uri, question):
"""Envía la misma imagen a dos modelos y compara los resultados."""
resultats = {}
for modele in ["mistral-small-latest", "mistral-large-latest"]:
response = client.chat.complete(
model=modele,
messages=[{
"role": "user",
"content": [
{"type": "text", "text": question},
{"type": "image_url", "image_url": image_uri}
]
}]
)
resultats[modele] = response.choices[0].message.content
return resultats
La doble lectura duplica el coste: resérvala para importes, identificadores y cualquier cosa que desencadene una acción irreversible.
Optimiza los costes
La optimización más rentable se cubrió en la Lección 5, y es la más simple: reduce el tamaño de la imagen antes de enviarla. Una foto de 6 MB redimensionada a 1024 píxeles no pierde nada a efectos de análisis y aligera toda la cadena.
from PIL import Image
from io import BytesIO
import base64
def optimiser_image(chemin, taille_max=1024, qualite=80):
"""Redimensiona y comprime una imagen para la Vision API."""
img = Image.open(chemin)
taille_originale = img.size
# Redimensionar
if max(img.size) > taille_max:
img.thumbnail((taille_max, taille_max))
# Comprimir como JPEG
buffer = BytesIO()
img.convert("RGB").save(buffer, format="JPEG", quality=qualite)
taille_fichier = buffer.tell()
b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
print(f"Original: {taille_originale} | Optimizada: {img.size} | Tamaño: {taille_fichier/1024:.0f} KB")
return f"data:image/jpeg;base64,{b64}"
Lo siguiente es el enrutamiento por complejidad: no toda tarea merece el modelo más caro. Una función de tres líneas basta para decidir, siempre que hayas clasificado tus tareas con antelación.
def choose_model(task):
"""Selecciona el modelo óptimo según la tarea."""
simple_tasks = ["classification", "ocr_simple", "description", "triage"]
complex_tasks = ["extraction_json", "comparaison", "analyse_graphique", "raisonnement"]
if task in simple_tasks:
return "mistral-small-latest" # ~0,10 $/M tokens
else:
return "mistral-large-latest" # ~2,00 $/M tokens
La tercera palanca es la que se olvida con más frecuencia: no pagues dos veces por el mismo análisis. En producción, la misma imagen vuelve con más frecuencia de lo que crees: volver a ejecutar un proceso, envíos duplicados o reintentos tras un incidente. Una caché en disco indexada por el hash del archivo y el prompt elimina estas llamadas redundantes.
import hashlib
import json
from pathlib import Path
CACHE_DIR = Path("cache_vision/")
CACHE_DIR.mkdir(exist_ok=True)
def analyser_avec_cache(image_path, prompt, modele="mistral-small-latest"):
"""Analiza una imagen con caché en disco."""
# Generar una clave de caché
with open(image_path, "rb") as f:
image_hash = hashlib.md5(f.read()).hexdigest()
cache_key = hashlib.md5(f"{image_hash}{prompt}{modele}".encode()).hexdigest()
cache_file = CACHE_DIR / f"{cache_key}.json"
# Comprobar caché
if cache_file.exists():
return json.loads(cache_file.read_text())
# Llamada a la API
response = client.chat.complete(
model=modele,
messages=[{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{"type": "image_url", "image_url": encoder_image(image_path)}
]
}]
)
resultat = response.choices[0].message.content
# Guardar en caché
cache_file.write_text(json.dumps(resultat, ensure_ascii=False))
return resultat
La clave incluye el prompt y el modelo, no solo la imagen: cambiar la pregunta sobre la misma foto debe, efectivamente, desencadenar una nueva llamada.
Optimiza la latencia
Para una aplicación interactiva, cuatro ajustes afectan al tiempo de respuesta percibido. Redimensiona las imágenes en el lado del cliente a un máximo de 1024 píxeles, lo que acorta el tiempo de subida. Elige Small o Ministral, ya que su generación es significativamente más rápida. Pasa las imágenes por URL cuando ya estén alojadas para evitar enviar un cuerpo de solicitud Base64 grande. Por último, habilita el streaming, que no reduce el tiempo total pero muestra la respuesta a medida que se construye:
# Streaming para una respuesta progresiva
stream = client.chat.stream(
model="mistral-small-latest",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Describe esta imagen."},
{"type": "image_url", "image_url": image_url}
]
}]
)
for chunk in stream:
if chunk.data.choices[0].delta.content:
print(chunk.data.choices[0].delta.content, end="", flush=True)
Es chat.stream reemplazando a chat.complete; el resto del mensaje es exactamente igual.
Lista de comprobación para producción
Antes de desplegar una aplicación de Vision en producción, verifica cada uno de estos puntos:
- Redimensionado automático de imágenes (máx. 1024 px)
- Validación de formato y tamaño antes del envío
- Gestión de errores de la API (reintento, tiempo de espera, alternativa)
- Caché de resultados para imágenes idénticas
- Enrutamiento inteligente (Small para simple, Large para complejo)
- Monitorización de costes y latencia
- Pruebas con imágenes de baja calidad (borrosas, baja resolución, rotadas)
- Estrategia anti-alucinaciones (niveles de confianza, doble verificación)
El penúltimo punto es el que se omite con más frecuencia y el que causa más daños: construye un conjunto de datos de imágenes deliberadamente malas y ejecútalo antes de cada despliegue.
Puntos clave
- Las imágenes se redimensionan internamente; no hace falta enviar una resolución muy alta
- Las alucinaciones visuales son el riesgo principal; pide niveles de confianza
- El redimensionado en el cliente es la optimización más rentable
- El enrutamiento por complejidad (Small frente a Large) reduce los costes un 90 % en tareas simples
- La caché en disco evita llamadas redundantes a la API sobre las mismas imágenes