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

Comparación de múltiples imágenes

Lección 8 de 12 Actualizado el 30 de julio de 2026 Principiante
En esta página
  1. Analizar múltiples imágenes en una única solicitud
  2. Estructura de la solicitud de múltiples imágenes
  3. Caso de uso: Comparación antes/después
  4. Caso de uso: Seguimiento temporal
  5. Caso de uso: Control de calidad
  6. Caso de uso: Análisis competitivo
  7. Optimización de solicitudes de múltiples imágenes
  8. Puntos clave

Analizar múltiples imágenes en una única solicitud

Una de las principales ventajas de Grok Vision es la capacidad de enviar un número ilimitado de imágenes en una sola solicitud. Esto abre posibilidades únicas de comparación, seguimiento temporal y análisis cruzado que las API de imagen única no pueden ofrecer.

Estructura de la solicitud de múltiples imágenes

El formato es sencillo: añade tantos objetos input_image como necesites al array input, intercalándolos con texto para guiar el análisis:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {"type": "input_text", "text": "Imagen A:"},
        {"type": "input_image", "image_url": url_image_a},
        {"type": "input_text", "text": "Imagen B:"},
        {"type": "input_image", "image_url": url_image_b},
        {"type": "input_text", "text": "Compara estas dos imágenes en detalle."}
    ]
)

Etiquetar cada imagen con texto («Imagen A», «Imagen B») ayuda al modelo a estructurar su respuesta y hacer referencia clara a cada imagen.

Caso de uso: Comparación antes/después

Ideal para el seguimiento de proyectos, reformas, diseño o control de calidad:

def comparer_avant_apres(url_avant, url_apres):
    prompt = """Compara estas dos imágenes (antes y después) e identifica:

1. Los cambios principales
2. Los elementos que no han cambiado
3. Las mejoras visibles
4. Cualquier problema potencial introducido

Presenta tu respuesta como una lista estructurada."""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "ANTES:"},
            {"type": "input_image", "image_url": url_avant, "detail": "high"},
            {"type": "input_text", "text": "DESPUÉS:"},
            {"type": "input_image", "image_url": url_apres, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Caso de uso: Seguimiento temporal

Rastrea la evolución de una ubicación, producto o proceso a lo largo del tiempo:

def analyser_evolution(images_chronologiques):
    """images_chronologiques: lista de {"url": ..., "date": ...}"""
    input_data = []

    for img in images_chronologiques:
        input_data.append({
            "type": "input_text",
            "text": f"Foto del {img['date']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": img["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Analiza la evolución cronológica visible en
estas imágenes. Identifica cambios progresivos, tendencias
y cualquier evento notable entre las diferentes fechas."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Caso de uso: Control de calidad

Compara un producto fabricado con su modelo de referencia:

def controle_qualite(url_reference, url_produit):
    prompt = """Compara el producto fotografiado con el modelo de referencia.

Identifica:
1. Conformidad (qué coincide con el modelo)
2. No conformidad (desviaciones, defectos, diferencias)
3. Gravedad de cada no conformidad (leve, grave, crítica)

Devuelve un JSON con:
{
  "compliant": true/false,
  "score": 0-100,
  "compliances": [...],
  "non_compliances": [
    {"description": "...", "severity": "minor|major|critical"}
  ]
}"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "REFERENCIA (modelo esperado):"},
            {"type": "input_image", "image_url": url_reference, "detail": "high"},
            {"type": "input_text", "text": "PRODUCTO a verificar:"},
            {"type": "input_image", "image_url": url_produit, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Caso de uso: Análisis competitivo

Compara interfaces, embalajes o presentaciones de productos de la competencia:

def analyser_concurrence(images_concurrents):
    """images_concurrents: [{"brand": "...", "url": "..."}]"""
    input_data = []

    for concurrent in images_concurrents:
        input_data.append({
            "type": "input_text",
            "text": f"{concurrent['brand']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": concurrent["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Compara estos productos/interfaces de la competencia.
Para cada uno, identifica los puntos fuertes y débiles visuales.
Proporciona una recomendación de posicionamiento."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Optimización de solicitudes de múltiples imágenes

Cuando envías muchas imágenes, el consumo de tokens aumenta rápidamente. Aquí tienes algunas estrategias de optimización:

Ajustar el nivel de detalle

Usa low para comparaciones generales y high solo cuando analices detalles finos:

# Comparación global: low es suficiente
detail = "low"  # ~256 tokens por imagen

# Análisis de defectos: high necesario
detail = "high"  # ~1024-1792 tokens por imagen

Limitar el número de imágenes por solicitud

Aunque no existe un límite estricto, con más de 10-15 imágenes la calidad del análisis puede disminuir. El modelo tiene un contexto finito y debe distribuirlo entre todas las imágenes:

# Si hay más de 10 imágenes, procesar por lotes
def analyser_par_lots(images, taille_lot=10):
    resultats = []
    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]
        resultat = analyser_lot(lot)
        resultats.append(resultat)
    return fusionner_resultats(resultats)

Redimensionar imágenes

Si comparas fotos de alta resolución para un análisis general, redimensiónalas antes de enviarlas para reducir los tokens:

def preparer_pour_comparaison(chemin, taille_max=(800, 800)):
    img = Image.open(chemin)
    img.thumbnail(taille_max)
    # ... codificar a base64

Puntos clave

  • El número de imágenes por solicitud es ilimitado: esta es una ventaja clave de la API de xAI
  • Etiqueta cada imagen con texto para estructurar el análisis
  • Ajusta el parámetro detail al tipo de comparación
  • Más allá de 10-15 imágenes, procesa por lotes para mantener la calidad
  • Los casos de uso incluyen: antes/después, seguimiento temporal, control de calidad y análisis competitivo